Allow specifying the type of params

lib/__tests__/custom-params.factory.test.ts

@@ -0,0 +1,48 @@
+import { Factory, DeepPartial, HookFn } from 'fishery';
+
+class DateTime {
+  private constructor(public date: Date) {}
+
+  toISO(): string {
+    return this.date.toISOString();
+  }
+
+  static fromISO(iso: string): DateTime {
+    return new DateTime(new Date(iso));
+  }
+}
+
+type User = {
+  id: string;
+  createdAt: DateTime;
+};
+
+type UserWithOptionalCreatedAt = DeepPartial<User> & {
+  createdAt?: DateTime;
+};
+
+const userFactory = Factory.define<User, {}, User, UserWithOptionalCreatedAt>(
+  ({ params }) => {
+    const created =
+      params.createdAt ?? DateTime.fromISO(new Date().toISOString());
+    return {
+      id: '3',
+      createdAt: created,
+    };
+  },
+);
+
+describe('factory.build', () => {
+  it('builds the object without params', () => {
+    const user = userFactory.build();
+    expect(user.id).not.toBeNull();
+    expect(user.createdAt).not.toBeNull();
+  });
+
+  it('builds the object with a custom params', () => {
+    const date = DateTime.fromISO('2022');
+    const user = userFactory.build({ createdAt: date });
+    expect(user.id).not.toBeNull();
+    expect(user.createdAt.toISO()).toEqual(date.toISO());
+  });
+});

lib/builder.ts

@@ -8,11 +8,11 @@ import {
 } from './types';
 import { merge, mergeCustomizer } from './merge';
 
-export class FactoryBuilder<T, I, C> {
+export class FactoryBuilder<T, I, C, P> {
   constructor(
-    private generator: GeneratorFn<T, I, C>,
+    private generator: GeneratorFn<T, I, C, P>,
     private sequence: number,
-    private params: DeepPartial<T>,
+    private params: P,
     private transientParams: Partial<I>,
     private associations: Partial<T>,
     private afterBuilds: HookFn<T>[],
@@ -21,7 +21,7 @@ export class FactoryBuilder<T, I, C> {
   ) {}
 
   build() {
-    const generatorOptions: GeneratorFnOptions<T, I, C> = {
+    const generatorOptions: GeneratorFnOptions<T, I, C, P> = {
       sequence: this.sequence,
       afterBuild: this.setAfterBuild,
       afterCreate: this.setAfterCreate,

lib/factory.ts

@@ -12,19 +12,19 @@ import { merge, mergeCustomizer } from './merge';
 
 const SEQUENCE_START_VALUE = 1;
 
-export class Factory<T, I = any, C = T> {
+export class Factory<T, I = any, C = T, P = DeepPartial<T>> {
   // id is an object so it is shared between extended factories
   private id: { value: number } = { value: SEQUENCE_START_VALUE };
 
   private _afterBuilds: HookFn<T>[] = [];
   private _afterCreates: AfterCreateFn<C>[] = [];
   private _onCreate?: OnCreateFn<T, C>;
   private _associations?: Partial<T>;
-  private _params?: DeepPartial<T>;
+  private _params?: P;
   private _transient?: Partial<I>;
 
   constructor(
-    private readonly generator: (opts: GeneratorFnOptions<T, I, C>) => T,
+    private readonly generator: (opts: GeneratorFnOptions<T, I, C, P>) => T,
   ) {}
 
   /**
@@ -34,9 +34,9 @@ export class Factory<T, I = any, C = T> {
    * @template C The class of the factory object being created.
    * @param generator - your factory function
    */
-  static define<T, I = any, C = T, F = Factory<T, I, C>>(
-    this: new (generator: GeneratorFn<T, I, C>) => F,
-    generator: GeneratorFn<T, I, C>,
+  static define<T, I = any, C = T, P = DeepPartial<T>, F = Factory<T, I, C, P>>(
+    this: new (generator: GeneratorFn<T, I, C, P>) => F,
+    generator: GeneratorFn<T, I, C, P>,
   ): F {
     return new this(generator);
   }
@@ -46,15 +46,11 @@ export class Factory<T, I = any, C = T> {
    * @param params
    * @param options
    */
-  build(params?: DeepPartial<T>, options: BuildOptions<T, I> = {}): T {
+  build(params?: P, options: BuildOptions<T, I> = {}): T {
     return this.builder(params, options).build();
   }
 
-  buildList(
-    number: number,
-    params?: DeepPartial<T>,
-    options: BuildOptions<T, I> = {},
-  ): T[] {
+  buildList(number: number, params?: P, options: BuildOptions<T, I> = {}): T[] {
     let list: T[] = [];
     for (let i = 0; i < number; i++) {
       list.push(this.build(params, options));
@@ -68,16 +64,13 @@ export class Factory<T, I = any, C = T> {
    * @param params
    * @param options
    */
-  async create(
-    params?: DeepPartial<T>,
-    options: BuildOptions<T, I> = {},
-  ): Promise<C> {
+  async create(params?: P, options: BuildOptions<T, I> = {}): Promise<C> {
     return this.builder(params, options).create();
   }
 
   async createList(
     number: number,
-    params?: DeepPartial<T>,
+    params?: P,
     options: BuildOptions<T, I> = {},
   ): Promise<C[]> {
     let list: Promise<C>[] = [];
@@ -141,7 +134,7 @@ export class Factory<T, I = any, C = T> {
    * @param params
    * @returns a new factory
    */
-  params(params: DeepPartial<T>): this {
+  params(params: P): this {
     const factory = this.clone();
     factory._params = merge({}, this._params, params, mergeCustomizer);
     return factory;
@@ -165,9 +158,9 @@ export class Factory<T, I = any, C = T> {
     this.id.value = SEQUENCE_START_VALUE;
   }
 
-  protected clone<F extends Factory<T, I, C>>(this: F): F {
+  protected clone<F extends Factory<T, I, C, P>>(this: F): F {
     const copy = new (this.constructor as {
-      new (generator: GeneratorFn<T, I, C>): F;
+      new (generator: GeneratorFn<T, I, C, P>): F;
     })(this.generator);
     Object.assign(copy, this);
     copy._afterCreates = [...this._afterCreates];
@@ -179,8 +172,8 @@ export class Factory<T, I = any, C = T> {
     return this.id.value++;
   }
 
-  protected builder(params?: DeepPartial<T>, options: BuildOptions<T, I> = {}) {
-    return new FactoryBuilder<T, I, C>(
+  protected builder(params?: P, options: BuildOptions<T, I> = {}) {
+    return new FactoryBuilder<T, I, C, P>(
       this.generator,
       this.sequence(),
       merge({}, this._params, params, mergeCustomizer),

lib/types/types.ts

@@ -1,15 +1,17 @@
 import { DeepPartial } from './deepPartial';
 
-export type GeneratorFnOptions<T, I, C> = {
+export type GeneratorFnOptions<T, I, C, P> = {
   sequence: number;
   afterBuild: (fn: HookFn<T>) => any;
   afterCreate: (fn: AfterCreateFn<C>) => any;
   onCreate: (fn: OnCreateFn<T, C>) => any;
-  params: DeepPartial<T>;
+  params: P;
   associations: Partial<T>;
   transientParams: Partial<I>;
 };
-export type GeneratorFn<T, I, C> = (opts: GeneratorFnOptions<T, I, C>) => T;
+export type GeneratorFn<T, I, C, P> = (
+  opts: GeneratorFnOptions<T, I, C, P>,
+) => T;
 export type HookFn<T> = (object: T) => any;
 export type OnCreateFn<T, C = T> = (object: T) => C | Promise<C>;
 export type AfterCreateFn<C> = (object: C) => C | Promise<C>;