More explicit types

Batterii · Jan 19, 2021 · 9be41c7 · 9be41c7
1 parent 11cbe7a
commit 9be41c7
Show file tree

Hide file tree

Showing 14 changed files with 126 additions and 81 deletions.
diff --git a/lib/assembler.ts b/lib/assembler.ts
@@ -3,9 +3,9 @@ import {Callback} from "./callback";
 
 export class Assembler<T> {
 	attributeAssigner: AttributeAssigner<T>;
-	callbacks: Callback[];
+	callbacks: Callback<T>[];
 
-	constructor(attributeAssigner: AttributeAssigner<T>, callbacks: Callback[]) {
+	constructor(attributeAssigner: AttributeAssigner<T>, callbacks: Callback<T>[]) {
 		this.attributeAssigner = attributeAssigner;
 		this.callbacks = callbacks;
 	}

diff --git a/lib/callback-handler.ts b/lib/callback-handler.ts
@@ -7,36 +7,36 @@ import {FixtureRiveter} from "./fixture-riveter";
 import {isFunction} from "lodash";
 
 export class CallbackHandler {
-	callbacks: Callback[];
+	callbacks: Callback<any>[];
 	fixtureRiveter: FixtureRiveter;
 
 	constructor(fixtureRiveter: FixtureRiveter) {
 		this.callbacks = [];
 		this.fixtureRiveter = fixtureRiveter;
 	}
 
-	addCallback(names: string[], block: callbackFunction): void {
+	addCallback<T>(names: string[], block: callbackFunction<T>): void {
 		for (const name of names) {
 			this.callbacks.push(new Callback(this.fixtureRiveter, name, block));
 		}
 	}
 
-	before(...rest: any[]): void {
+	before<T>(...rest: any[]): void {
 		const block = extractCallbackFunction(rest);
 		const names = rest.map((n: string) => {
 			const string = n.charAt(0).toUpperCase() + n.slice(1);
 			return `before${string}`;
 		});
-		this.addCallback(names, block);
+		this.addCallback<T>(names, block);
 	}
 
-	after(...rest: any[]): void {
+	after<T>(...rest: any[]): void {
 		const block = extractCallbackFunction(rest);
 		const names = rest.map((n: string) => {
 			const string = n.charAt(0).toUpperCase() + n.slice(1);
 			return `after${string}`;
 		});
-		this.addCallback(names, block);
+		this.addCallback<T>(names, block);
 	}
 }
 

diff --git a/lib/callback.ts b/lib/callback.ts
@@ -1,20 +1,20 @@
 import {Evaluator} from "./evaluator";
 import {FixtureRiveter} from "./fixture-riveter";
 
-export type callbackFunction = (instance: any, evaluator: Evaluator) => any;
+export type callbackFunction<T> = (instance: T, evaluator: Evaluator) => any;
 
-export class Callback {
+export class Callback<T> {
 	fixtureRiveter: FixtureRiveter;
 	name: string;
-	block: callbackFunction;
+	block: callbackFunction<T>;
 
-	constructor(fixtureRiveter: FixtureRiveter, name: string, block: callbackFunction) {
+	constructor(fixtureRiveter: FixtureRiveter, name: string, block: callbackFunction<T>) {
 		this.fixtureRiveter = fixtureRiveter;
 		this.name = name;
 		this.block = block;
 	}
 
-	async run(instance: any, evaluator: Evaluator): Promise<any> {
+	async run(instance: T, evaluator: Evaluator): Promise<any> {
 		return this.block.call(this.fixtureRiveter, instance, evaluator);
 	}
 }
diff --git a/lib/definition-proxy.ts b/lib/definition-proxy.ts
@@ -118,17 +118,16 @@ export class DefinitionProxy<T> {
 		block(addMethodMissing(proxy));
 	}
 
-	before(name: string, name2: string, name3: string, block: callbackFunction): void;
-	before(name: string, name2: string, block: callbackFunction): void;
-	before(name: string, block: callbackFunction): void;
+	before(name: string, block: callbackFunction<T>): void;
+	before(name: string, name2: string, block: callbackFunction<T>): void;
+	before(name: string, name2: string, name3: string, block: callbackFunction<T>): void;
 	before(...rest: any[]): void {
 		this.definition.before(...rest);
 	}
 
-	after(name: string, name2: string, name3: string, block: callbackFunction): void;
-	after(name: string, name2: string, block: callbackFunction): void;
-	after(name: string, block: callbackFunction): void;
-	after(name: string, ...block: any[]): void;
+	after(name: string, block: callbackFunction<T>): void;
+	after(name: string, name2: string, block: callbackFunction<T>): void;
+	after(name: string, name2: string, name3: string, block: callbackFunction<T>): void;
 	after(...rest: any[]): void {
 		this.definition.after(...rest);
 	}

diff --git a/lib/definition.ts b/lib/definition.ts
@@ -118,11 +118,11 @@ export class Definition<T> {
 		this.callbackHandler.after(...rest);
 	}
 
-	addCallback(names: string[], block: callbackFunction): void {
+	addCallback(names: string[], block: callbackFunction<T>): void {
 		this.callbackHandler.addCallback(names, block);
 	}
 
-	getCallbacks(): Callback[] {
+	getCallbacks(): Callback<T>[] {
 		this.compile();
 
 		return [

diff --git a/lib/fixture-options-parser.ts b/lib/fixture-options-parser.ts
@@ -1,5 +1,6 @@
 import {DefinitionProxy} from "./definition-proxy";
 import {Evaluator} from "./evaluator";
+import {Instance} from "./fixture-riveter";
 
 import {first, isFunction, isPlainObject, last} from "lodash";
 
@@ -9,11 +10,17 @@ export interface FixtureOptions {
 	parent?: string;
 }
 
-type ConvertToFn<T, FN = () => Promise<any>> = {
-	[P in keyof T]: (fn: FN) => Promise<T[P]>;
+type ConvertToFn<T, FN = () => any> = {
+	[P in keyof T]-?: <Q = undefined>(
+		fn: FN,
+		overrides?: Partial<Q extends undefined ? T extends Instance ? T : Instance : Q>,
+	) => Promise<T[P]>;
 };
 
-type EvaluatorFn<T> = (evaluator: ConvertToFn<T> & Evaluator) => Promise<any> | any;
+type EvaluatorFn<T> =
+	((evaluator: ConvertToFn<T> & Evaluator) => Promise<any> | any) |
+	string[] |
+	Partial<T extends Instance ? T : Instance>;
 
 export type AttrFunction<T> = (f: ConvertToFn<T, EvaluatorFn<T>> & Evaluator) => Promise<any> | any;
 

diff --git a/lib/fixture-riveter.ts b/lib/fixture-riveter.ts
@@ -74,7 +74,7 @@ export class FixtureRiveter {
 		return fixture;
 	}
 
-	registerFixture(fixture: Fixture<any>): void {
+	registerFixture<T>(fixture: Fixture<T>): void {
 		for (const name of fixture.names()) {
 			this.fixtures[name] = fixture;
 		}
@@ -201,25 +201,25 @@ export class FixtureRiveter {
 		this.strategyHandler.registerStrategy(strategyName, strategyClass);
 	}
 
-	before(name: string, name2: string, name3: string, block: callbackFunction): void;
-	before(name: string, name2: string, block: callbackFunction): void;
-	before(name: string, block?: callbackFunction): void;
+	before<T>(name: string, block?: callbackFunction<T>): void;
+	before<T>(name: string, name2: string, block: callbackFunction<T>): void;
+	before<T>(name: string, name2: string, name3: string, block: callbackFunction<T>): void;
 	before(...rest: any[]): void {
 		this.callbackHandler.before(...rest);
 	}
 
-	after(name: string, name2: string, name3: string, block: callbackFunction): void;
-	after(name: string, name2: string, block: callbackFunction): void;
-	after(name: string, block?: callbackFunction): void;
+	after<T>(name: string, block?: callbackFunction<T>): void;
+	after<T>(name: string, name2: string, block: callbackFunction<T>): void;
+	after<T>(name: string, name2: string, name3: string, block: callbackFunction<T>): void;
 	after(...rest: any[]): void {
 		this.callbackHandler.after(...rest);
 	}
 
-	addCallback(names: string[], block: callbackFunction): void {
+	addCallback<T>(names: string[], block: callbackFunction<T>): void {
 		this.callbackHandler.addCallback(names, block);
 	}
 
-	getCallbacks(): Callback[] {
+	getCallbacks<T>(): Callback<T>[] {
 		return this.callbackHandler.callbacks;
 	}
 
@@ -380,7 +380,7 @@ export class FixtureRiveter {
 	/* eslint-enable */
 }
 
-type Instance = Record<string, any>;
+export type Instance = Record<string, any>;
 
 type Pair<T> = [T, T];
 type List<T> = T[];

diff --git a/lib/fixture.ts b/lib/fixture.ts
@@ -114,7 +114,7 @@ export class Fixture<T> extends Definition<T> {
 		return attributesToKeep.concat(this.attributes);
 	}
 
-	getCallbacks(): Callback[] {
+	getCallbacks(): Callback<T>[] {
 		const globalCallbacks = this.fixtureRiveter.getCallbacks();
 		const parentCallbacks = this.parentFixture().getCallbacks();
 		const definedCallbacks = super.getCallbacks();

diff --git a/lib/null-fixture.ts b/lib/null-fixture.ts
@@ -18,7 +18,7 @@ export class NullFixture<T> extends Definition<T> {
 		return [];
 	}
 
-	getCallbacks(): Callback[] {
+	getCallbacks(): Callback<T>[] {
 		return [];
 	}
 }
diff --git a/test/acceptance/associations.ts b/test/acceptance/associations.ts
@@ -14,6 +14,7 @@ describe("simple associations", function() {
 		id: number;
 		name: string;
 		age: number;
+		admin: boolean;
 	}
 
 	class Post extends ObjectionModel {
@@ -38,6 +39,7 @@ describe("simple associations", function() {
 		await createTable(User, {
 			name: "string",
 			age: "integer",
+			admin: "boolean",
 		});
 
 		await createTable(Post, {
@@ -48,13 +50,26 @@ describe("simple associations", function() {
 		fr = new FixtureRiveter();
 		fr.setAdapter(new ObjectionAdapter());
 
-		fr.fixture("user", User, (f: any) => {
+		fr.fixture("user", User, (f) => {
 			f.attr("name", () => "Noah");
 			f.attr("age", () => 32);
+
+			f.trait("admin", (t) => {
+				t.admin(() => true);
+			});
 		});
-		fr.fixture("post", Post, (f: any) => {
+
+		fr.fixture("post", Post, (f) => {
 			f.association("user");
 			f.attr("body", () => "Post body");
+
+			f.trait("admin", (t) => {
+				t.user(["admin"]);
+			});
+
+			f.trait("old admin", (t) => {
+				t.user<User>(["admin"], {age: 100});
+			});
 		});
 	});
 
@@ -86,6 +101,13 @@ describe("simple associations", function() {
 		expect(model.id).to.equal(post.userId);
 		expect(model.id).to.equal(post.user.id);
 	});
+
+	it("can handle traits and overrides", async function() {
+		const post = await fr.build("post", ["old admin"]);
+
+		expect(post.user.age).to.equal(100);
+		expect(post.user.admin).to.be.true;
+	});
 });
 
 describe("Complex associations", function() {
@@ -149,20 +171,20 @@ describe("Complex associations", function() {
 				fr = new FixtureRiveter();
 				fr.setAdapter(new ObjectionAdapter());
 
-				fr.fixture("user", User, (f: any) => {
+				fr.fixture("user", User, (f) => {
 					f.attr("name", () => "Noah");
-					f.fixture("userWithPosts", User, (ff: any) => {
+					f.fixture("userWithPosts", User, (ff) => {
 						ff.transient((t) => {
 							t.attr("postCount", () => 5);
 						});
 
 						ff.after("create", async(user, evaluator) => {
-							const posts = await fr.createList(
+							const posts = await fr.createList<Post>(
 								"post",
 								await evaluator.attr("postCount"),
 								{user},
 							);
-							await user.$appendRelated("posts", posts);
+							user.$appendRelated("posts", posts);
 						});
 					});
 				});