@mikro-orm/seeder 7.0.3 → 7.0.4-dev.0

package/Factory.d.ts

@@ -1,42 +1,42 @@
 import type { EntityData, EntityManager, Constructor } from '@mikro-orm/core';
 /** Base class for entity factories used in seeding. Provides methods to create and persist test entities. */
 export declare abstract class Factory<TEntity extends object, TInput = EntityData<TEntity>> {
-  protected readonly em: EntityManager;
-  abstract readonly model: Constructor<TEntity>;
-  private eachFunction?;
-  constructor(em: EntityManager);
-  protected abstract definition(input?: TInput): EntityData<TEntity>;
-  /**
-   * Make a single entity instance, without persisting it.
-   * @param input Object specifying what default attributes of the entity factory should be overridden
-   */
-  makeEntity(input?: TInput, index?: number): TEntity;
-  /**
-   * Make a single entity and persist (not flush)
-   * @param input Object specifying what default attributes of the entity factory should be overridden
-   */
-  makeOne(input?: TInput): TEntity;
-  /**
-   * Make multiple entities and then persist them (not flush)
-   * @param amount Number of entities that should be generated
-   * @param input Object specifying what default attributes of the entity factory should be overridden
-   */
-  make(amount: number, input?: TInput): TEntity[];
-  /**
-   * Create (and flush) a single entity
-   * @param input Object specifying what default attributes of the entity factory should be overridden
-   */
-  createOne(input?: TInput): Promise<TEntity>;
-  /**
-   * Create (and flush) multiple entities
-   * @param amount Number of entities that should be generated
-   * @param input Object specifying what default attributes of the entity factory should be overridden
-   */
-  create(amount: number, input?: TInput): Promise<TEntity[]>;
-  /**
-   * Set a function that is applied to each entity before it is returned
-   * In case of `createOne` or `create` it is applied before the entity is persisted
-   * @param eachFunction The function that is applied on every entity
-   */
-  each(eachFunction: (entity: TEntity, index: number) => void): this;
+    protected readonly em: EntityManager;
+    abstract readonly model: Constructor<TEntity>;
+    private eachFunction?;
+    constructor(em: EntityManager);
+    protected abstract definition(input?: TInput): EntityData<TEntity>;
+    /**
+     * Make a single entity instance, without persisting it.
+     * @param input Object specifying what default attributes of the entity factory should be overridden
+     */
+    makeEntity(input?: TInput, index?: number): TEntity;
+    /**
+     * Make a single entity and persist (not flush)
+     * @param input Object specifying what default attributes of the entity factory should be overridden
+     */
+    makeOne(input?: TInput): TEntity;
+    /**
+     * Make multiple entities and then persist them (not flush)
+     * @param amount Number of entities that should be generated
+     * @param input Object specifying what default attributes of the entity factory should be overridden
+     */
+    make(amount: number, input?: TInput): TEntity[];
+    /**
+     * Create (and flush) a single entity
+     * @param input Object specifying what default attributes of the entity factory should be overridden
+     */
+    createOne(input?: TInput): Promise<TEntity>;
+    /**
+     * Create (and flush) multiple entities
+     * @param amount Number of entities that should be generated
+     * @param input Object specifying what default attributes of the entity factory should be overridden
+     */
+    create(amount: number, input?: TInput): Promise<TEntity[]>;
+    /**
+     * Set a function that is applied to each entity before it is returned
+     * In case of `createOne` or `create` it is applied before the entity is persisted
+     * @param eachFunction The function that is applied on every entity
+     */
+    each(eachFunction: (entity: TEntity, index: number) => void): this;
 }

package/Factory.js

@@ -1,73 +1,72 @@
 /** Base class for entity factories used in seeding. Provides methods to create and persist test entities. */
 export class Factory {
-  em;
-  eachFunction;
-  constructor(em) {
-    this.em = em;
-  }
-  /**
-   * Make a single entity instance, without persisting it.
-   * @param input Object specifying what default attributes of the entity factory should be overridden
-   */
-  makeEntity(input, index = 0) {
-    const data =
-      this.definition.length === 0
-        ? {
-            ...this.definition(),
-            ...input,
-          }
-        : this.definition(input);
-    const entity = this.em.create(this.model, data, { persist: false });
-    this.eachFunction?.(entity, index);
-    return entity;
-  }
-  /**
-   * Make a single entity and persist (not flush)
-   * @param input Object specifying what default attributes of the entity factory should be overridden
-   */
-  makeOne(input) {
-    const entity = this.makeEntity(input);
-    this.em.persist(entity);
-    return entity;
-  }
-  /**
-   * Make multiple entities and then persist them (not flush)
-   * @param amount Number of entities that should be generated
-   * @param input Object specifying what default attributes of the entity factory should be overridden
-   */
-  make(amount, input) {
-    const entities = [...Array(amount)].map((_, index) => {
-      return this.makeEntity(input, index);
-    });
-    this.em.persist(entities);
-    return entities;
-  }
-  /**
-   * Create (and flush) a single entity
-   * @param input Object specifying what default attributes of the entity factory should be overridden
-   */
-  async createOne(input) {
-    const entity = this.makeOne(input);
-    await this.em.flush();
-    return entity;
-  }
-  /**
-   * Create (and flush) multiple entities
-   * @param amount Number of entities that should be generated
-   * @param input Object specifying what default attributes of the entity factory should be overridden
-   */
-  async create(amount, input) {
-    const entities = this.make(amount, input);
-    await this.em.flush();
-    return entities;
-  }
-  /**
-   * Set a function that is applied to each entity before it is returned
-   * In case of `createOne` or `create` it is applied before the entity is persisted
-   * @param eachFunction The function that is applied on every entity
-   */
-  each(eachFunction) {
-    this.eachFunction = eachFunction;
-    return this;
-  }
+    em;
+    eachFunction;
+    constructor(em) {
+        this.em = em;
+    }
+    /**
+     * Make a single entity instance, without persisting it.
+     * @param input Object specifying what default attributes of the entity factory should be overridden
+     */
+    makeEntity(input, index = 0) {
+        const data = this.definition.length === 0
+            ? {
+                ...this.definition(),
+                ...input,
+            }
+            : this.definition(input);
+        const entity = this.em.create(this.model, data, { persist: false });
+        this.eachFunction?.(entity, index);
+        return entity;
+    }
+    /**
+     * Make a single entity and persist (not flush)
+     * @param input Object specifying what default attributes of the entity factory should be overridden
+     */
+    makeOne(input) {
+        const entity = this.makeEntity(input);
+        this.em.persist(entity);
+        return entity;
+    }
+    /**
+     * Make multiple entities and then persist them (not flush)
+     * @param amount Number of entities that should be generated
+     * @param input Object specifying what default attributes of the entity factory should be overridden
+     */
+    make(amount, input) {
+        const entities = [...Array(amount)].map((_, index) => {
+            return this.makeEntity(input, index);
+        });
+        this.em.persist(entities);
+        return entities;
+    }
+    /**
+     * Create (and flush) a single entity
+     * @param input Object specifying what default attributes of the entity factory should be overridden
+     */
+    async createOne(input) {
+        const entity = this.makeOne(input);
+        await this.em.flush();
+        return entity;
+    }
+    /**
+     * Create (and flush) multiple entities
+     * @param amount Number of entities that should be generated
+     * @param input Object specifying what default attributes of the entity factory should be overridden
+     */
+    async create(amount, input) {
+        const entities = this.make(amount, input);
+        await this.em.flush();
+        return entities;
+    }
+    /**
+     * Set a function that is applied to each entity before it is returned
+     * In case of `createOne` or `create` it is applied before the entity is persisted
+     * @param eachFunction The function that is applied on every entity
+     */
+    each(eachFunction) {
+        this.eachFunction = eachFunction;
+        return this;
+    }
 }

package/README.md

@@ -133,7 +133,7 @@ const author = await em.findOneOrFail(Author, 1, {
   populate: ['books'],
 });
 author.name = 'Jon Snow II';
-author.books.getItems().forEach(book => (book.title += ' (2nd ed.)'));
+author.books.getItems().forEach(book => book.title += ' (2nd ed.)');
 author.books.add(orm.em.create(Book, { title: 'New Book', author }));
 
 // Flush computes change sets and executes them in a single transaction

package/SeedManager.d.ts

@@ -2,24 +2,24 @@ import { type Constructor, type EntityManager, type ISeedManager, type MikroORM
 import type { Seeder } from './Seeder.js';
 /** Manages discovery and execution of database seeders. */
 export declare class SeedManager implements ISeedManager {
-  #private;
-  constructor(em: EntityManager);
-  private init;
-  static register(orm: MikroORM): void;
-  /**
-   * Checks if `src` folder exists, it so, tries to adjust the migrations and seeders paths automatically to use it.
-   * If there is a `dist` or `build` folder, it will be used for the JS variant (`path` option), while the `src` folder will be
-   * used for the TS variant (`pathTs` option).
-   *
-   * If the default folder exists (e.g. `/migrations`), the config will respect that, so this auto-detection should not
-   * break existing projects, only help with the new ones.
-   */
-  private detectSourceFolder;
-  seed(...classNames: Constructor<Seeder>[]): Promise<void>;
-  /**
-   * @internal
-   */
-  seedString(...classNames: string[]): Promise<void>;
-  create(className: string): Promise<string>;
-  private generate;
+    #private;
+    constructor(em: EntityManager);
+    private init;
+    static register(orm: MikroORM): void;
+    /**
+     * Checks if `src` folder exists, it so, tries to adjust the migrations and seeders paths automatically to use it.
+     * If there is a `dist` or `build` folder, it will be used for the JS variant (`path` option), while the `src` folder will be
+     * used for the TS variant (`pathTs` option).
+     *
+     * If the default folder exists (e.g. `/migrations`), the config will respect that, so this auto-detection should not
+     * break existing projects, only help with the new ones.
+     */
+    private detectSourceFolder;
+    seed(...classNames: Constructor<Seeder>[]): Promise<void>;
+    /**
+     * @internal
+     */
+    seedString(...classNames: string[]): Promise<void>;
+    create(className: string): Promise<string>;
+    private generate;
 }

package/SeedManager.js

@@ -1,136 +1,137 @@
-import { Utils } from '@mikro-orm/core';
+import { Utils, } from '@mikro-orm/core';
 /** Manages discovery and execution of database seeders. */
 export class SeedManager {
-  #config;
-  #options;
-  #absolutePath;
-  #initialized = false;
-  #em;
-  constructor(em) {
-    this.#em = em;
-    this.#config = this.#em.config;
-    this.#options = this.#config.get('seeder');
-    this.#em = this.#em.fork();
-    this.#config.set('persistOnCreate', true);
-  }
-  async init() {
-    if (this.#initialized) {
-      return;
+    #config;
+    #options;
+    #absolutePath;
+    #initialized = false;
+    #em;
+    constructor(em) {
+        this.#em = em;
+        this.#config = this.#em.config;
+        this.#options = this.#config.get('seeder');
+        this.#em = this.#em.fork();
+        this.#config.set('persistOnCreate', true);
     }
-    this.#initialized = true;
-    if (!this.#options.seedersList) {
-      const { fs } = await import('@mikro-orm/core/fs-utils');
-      this.detectSourceFolder(fs);
-      /* v8 ignore next */
-      const key =
-        this.#config.get('preferTs', Utils.detectTypeScriptSupport()) && this.#options.pathTs ? 'pathTs' : 'path';
-      this.#absolutePath = fs.absolutePath(this.#options[key], this.#config.get('baseDir'));
+    async init() {
+        if (this.#initialized) {
+            return;
+        }
+        this.#initialized = true;
+        if (!this.#options.seedersList) {
+            const { fs } = await import('@mikro-orm/core/fs-utils');
+            this.detectSourceFolder(fs);
+            /* v8 ignore next */
+            const key = this.#config.get('preferTs', Utils.detectTypeScriptSupport()) && this.#options.pathTs ? 'pathTs' : 'path';
+            this.#absolutePath = fs.absolutePath(this.#options[key], this.#config.get('baseDir'));
+        }
     }
-  }
-  static register(orm) {
-    orm.config.registerExtension('@mikro-orm/seeder', () => new SeedManager(orm.em));
-  }
-  /**
-   * Checks if `src` folder exists, it so, tries to adjust the migrations and seeders paths automatically to use it.
-   * If there is a `dist` or `build` folder, it will be used for the JS variant (`path` option), while the `src` folder will be
-   * used for the TS variant (`pathTs` option).
-   *
-   * If the default folder exists (e.g. `/migrations`), the config will respect that, so this auto-detection should not
-   * break existing projects, only help with the new ones.
-   */
-  detectSourceFolder(fs) {
-    const baseDir = this.#config.get('baseDir');
-    const defaultPath = './seeders';
-    if (!fs.pathExists(baseDir + '/src')) {
-      this.#options.path ??= defaultPath;
-      return;
+    static register(orm) {
+        orm.config.registerExtension('@mikro-orm/seeder', () => new SeedManager(orm.em));
     }
-    const exists = fs.pathExists(`${baseDir}/${defaultPath}`);
-    const distDir = fs.pathExists(baseDir + '/dist');
-    const buildDir = fs.pathExists(baseDir + '/build');
-    // if neither `dist` nor `build` exist, we use the `src` folder as it might be a JS project without building, but with `src` folder
-    const path = distDir ? './dist' : buildDir ? './build' : './src';
-    // only if the user did not provide any values and if the default path does not exist
-    if (!this.#options.path && !this.#options.pathTs && !exists) {
-      this.#options.path = `${path}/seeders`;
-      this.#options.pathTs = './src/seeders';
+    /**
+     * Checks if `src` folder exists, it so, tries to adjust the migrations and seeders paths automatically to use it.
+     * If there is a `dist` or `build` folder, it will be used for the JS variant (`path` option), while the `src` folder will be
+     * used for the TS variant (`pathTs` option).
+     *
+     * If the default folder exists (e.g. `/migrations`), the config will respect that, so this auto-detection should not
+     * break existing projects, only help with the new ones.
+     */
+    detectSourceFolder(fs) {
+        const baseDir = this.#config.get('baseDir');
+        const defaultPath = './seeders';
+        if (!fs.pathExists(baseDir + '/src')) {
+            this.#options.path ??= defaultPath;
+            return;
+        }
+        const exists = fs.pathExists(`${baseDir}/${defaultPath}`);
+        const distDir = fs.pathExists(baseDir + '/dist');
+        const buildDir = fs.pathExists(baseDir + '/build');
+        // if neither `dist` nor `build` exist, we use the `src` folder as it might be a JS project without building, but with `src` folder
+        const path = distDir ? './dist' : buildDir ? './build' : './src';
+        // only if the user did not provide any values and if the default path does not exist
+        if (!this.#options.path && !this.#options.pathTs && !exists) {
+            this.#options.path = `${path}/seeders`;
+            this.#options.pathTs = './src/seeders';
+        }
     }
-  }
-  async seed(...classNames) {
-    for (const SeederClass of classNames) {
-      const seeder = new SeederClass();
-      await seeder.run(this.#em);
-      await this.#em.flush();
-      this.#em.clear();
+    async seed(...classNames) {
+        for (const SeederClass of classNames) {
+            const seeder = new SeederClass();
+            await seeder.run(this.#em);
+            await this.#em.flush();
+            this.#em.clear();
+        }
     }
-  }
-  /**
-   * @internal
-   */
-  async seedString(...classNames) {
-    if (this.#options.seedersList) {
-      const classMap = new Map();
-      for (const entry of this.#options.seedersList) {
-        if (typeof entry === 'function') {
-          classMap.set(entry.name, entry);
-        } else {
-          classMap.set(entry.name, entry.class);
+    /**
+     * @internal
+     */
+    async seedString(...classNames) {
+        if (this.#options.seedersList) {
+            const classMap = new Map();
+            for (const entry of this.#options.seedersList) {
+                if (typeof entry === 'function') {
+                    classMap.set(entry.name, entry);
+                }
+                else {
+                    classMap.set(entry.name, entry.class);
+                }
+            }
+            for (const className of classNames) {
+                const seederClass = classMap.get(className);
+                if (!seederClass) {
+                    throw new Error(`Seeder class ${className} not found in seedersList`);
+                }
+                await this.seed(seederClass);
+            }
+            return;
         }
-      }
-      for (const className of classNames) {
-        const seederClass = classMap.get(className);
-        if (!seederClass) {
-          throw new Error(`Seeder class ${className} not found in seedersList`);
+        await this.init();
+        const { fs } = await import('@mikro-orm/core/fs-utils');
+        const path = fs.normalizePath(this.#absolutePath, this.#options.glob);
+        const files = fs.glob(path).sort();
+        const classMap = new Map();
+        for (const filePath of files) {
+            const exports = await fs.dynamicImport(filePath);
+            for (const name of Object.keys(exports)) {
+                classMap.set(name, exports[name]);
+            }
+        }
+        for (const className of classNames) {
+            const seederClass = classMap.get(className);
+            if (!seederClass) {
+                throw new Error(`Seeder class ${className} not found in ${fs.relativePath(path, process.cwd())}`);
+            }
+            await this.seed(seederClass);
         }
-        await this.seed(seederClass);
-      }
-      return;
-    }
-    await this.init();
-    const { fs } = await import('@mikro-orm/core/fs-utils');
-    const path = fs.normalizePath(this.#absolutePath, this.#options.glob);
-    const files = fs.glob(path).sort();
-    const classMap = new Map();
-    for (const filePath of files) {
-      const exports = await fs.dynamicImport(filePath);
-      for (const name of Object.keys(exports)) {
-        classMap.set(name, exports[name]);
-      }
     }
-    for (const className of classNames) {
-      const seederClass = classMap.get(className);
-      if (!seederClass) {
-        throw new Error(`Seeder class ${className} not found in ${fs.relativePath(path, process.cwd())}`);
-      }
-      await this.seed(seederClass);
+    async create(className) {
+        await this.init();
+        const { fs } = await import('@mikro-orm/core/fs-utils');
+        fs.ensureDir(this.#absolutePath);
+        return this.generate(fs, className);
     }
-  }
-  async create(className) {
-    await this.init();
-    const { fs } = await import('@mikro-orm/core/fs-utils');
-    fs.ensureDir(this.#absolutePath);
-    return this.generate(fs, className);
-  }
-  async generate(fs, className) {
-    const fileName = `${this.#options.fileName(className)}.${this.#options.emit}`;
-    const filePath = `${this.#absolutePath}/${fileName}`;
-    let ret = '';
-    if (this.#options.emit === 'ts') {
-      ret += `import type { EntityManager } from '@mikro-orm/core';\n`;
-      ret += `import { Seeder } from '@mikro-orm/seeder';\n\n`;
-      ret += `export class ${className} extends Seeder {\n\n`;
-      ret += `  async run(em: EntityManager): Promise<void> {}\n\n`;
-      ret += `}\n`;
-    } else {
-      ret += `'use strict';\n`;
-      ret += `Object.defineProperty(exports, '__esModule', { value: true });\n`;
-      ret += `const { Seeder } = require('@mikro-orm/seeder');\n\n`;
-      ret += `class ${className} extends Seeder {\n\n`;
-      ret += `  async run(em: EntityManager): Promise<void> {}\n\n`;
-      ret += `}\n`;
-      ret += `exports.${className} = ${className};\n`;
+    async generate(fs, className) {
+        const fileName = `${this.#options.fileName(className)}.${this.#options.emit}`;
+        const filePath = `${this.#absolutePath}/${fileName}`;
+        let ret = '';
+        if (this.#options.emit === 'ts') {
+            ret += `import type { EntityManager } from '@mikro-orm/core';\n`;
+            ret += `import { Seeder } from '@mikro-orm/seeder';\n\n`;
+            ret += `export class ${className} extends Seeder {\n\n`;
+            ret += `  async run(em: EntityManager): Promise<void> {}\n\n`;
+            ret += `}\n`;
+        }
+        else {
+            ret += `'use strict';\n`;
+            ret += `Object.defineProperty(exports, '__esModule', { value: true });\n`;
+            ret += `const { Seeder } = require('@mikro-orm/seeder');\n\n`;
+            ret += `class ${className} extends Seeder {\n\n`;
+            ret += `  async run(em: EntityManager): Promise<void> {}\n\n`;
+            ret += `}\n`;
+            ret += `exports.${className} = ${className};\n`;
+        }
+        await fs.writeFile(filePath, ret, { flush: true });
+        return filePath;
     }
-    await fs.writeFile(filePath, ret, { flush: true });
-    return filePath;
-  }
 }

package/Seeder.d.ts

@@ -1,12 +1,8 @@
 import type { Dictionary, EntityManager } from '@mikro-orm/core';
 /** Base class for database seeders. Extend this class and implement `run()` to populate the database with data. */
 export declare abstract class Seeder<T extends Dictionary = Dictionary> {
-  abstract run(em: EntityManager, context?: T): void | Promise<void>;
-  protected call(
-    em: EntityManager,
-    seeders: {
-      new (): Seeder;
-    }[],
-    context?: T,
-  ): Promise<void>;
+    abstract run(em: EntityManager, context?: T): void | Promise<void>;
+    protected call(em: EntityManager, seeders: {
+        new (): Seeder;
+    }[], context?: T): Promise<void>;
 }

package/Seeder.js

@@ -1,11 +1,11 @@
 /** Base class for database seeders. Extend this class and implement `run()` to populate the database with data. */
 export class Seeder {
-  async call(em, seeders, context = {}) {
-    for (const Seeder of seeders) {
-      const fork = em.fork();
-      const instance = new Seeder();
-      await instance.run(fork, context);
-      await fork.flush();
+    async call(em, seeders, context = {}) {
+        for (const Seeder of seeders) {
+            const fork = em.fork();
+            const instance = new Seeder();
+            await instance.run(fork, context);
+            await fork.flush();
+        }
     }
-  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/seeder",
-  "version": "7.0.3",
+  "version": "7.0.4-dev.0",
   "description": "Seeder package for MikroORM.",
   "keywords": [
     "data-mapper",
@@ -51,7 +51,7 @@
     "@mikro-orm/core": "^7.0.3"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.3"
+    "@mikro-orm/core": "7.0.4-dev.0"
   },
   "engines": {
     "node": ">= 22.17.0"