@mikro-orm/seeder 7.0.4-dev.9 → 7.0.4

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,72 +1,73 @@
 /** 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,137 +1,136 @@
-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);
+  #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;
     }
-    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'));
-        }
+    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));
+  }
+  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;
     }
-    /**
-     * 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';
-        }
+    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);
-                }
-            }
-            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;
+  }
+  /**
+   * @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);
         }
-        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);
+      }
+      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;
     }
-    async create(className) {
-        await this.init();
-        const { fs } = await import('@mikro-orm/core/fs-utils');
-        fs.ensureDir(this.#absolutePath);
-        return this.generate(fs, className);
+    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]);
+      }
     }
-    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;
+    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 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;
+  }
 }

package/Seeder.d.ts

@@ -1,8 +1,12 @@
 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.4-dev.9",
+  "version": "7.0.4",
   "description": "Seeder package for MikroORM.",
   "keywords": [
     "data-mapper",
@@ -48,10 +48,10 @@
     "copy": "node ../../scripts/copy.mjs"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^7.0.3"
+    "@mikro-orm/core": "^7.0.4"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.4-dev.9"
+    "@mikro-orm/core": "7.0.4"
   },
   "engines": {
     "node": ">= 22.17.0"