@joakimbugge/nest-typeorm-seeder 0.2.0

package/README.md

@@ -0,0 +1,145 @@
+# @joakimbugge/nest-typeorm-seeder
+
+NestJS module for [@joakimbugge/typeorm-seeder](../typeorm-seeder). Runs your `@Seeder` classes automatically on application bootstrap — once per seeder by default, tracked in a database table so watch-mode restarts do not re-seed.
+
+> [!TIP]
+> This package handles the NestJS integration. The seeding itself — `@Seed()`, `@Seeder`, `seed()`, entity factories — is all defined in [@joakimbugge/typeorm-seeder](../typeorm-seeder/README.md). Familiarity with that package will make this one much easier to use.
+
+---
+
+## Installation
+
+```bash
+npm install @joakimbugge/nest-typeorm-seeder @joakimbugge/typeorm-seeder
+```
+
+The peer dependencies (`@nestjs/common`, `@nestjs/core`, `typeorm`, `reflect-metadata`) are required, but if you are adding this to an existing NestJS + TypeORM project they are already present.
+
+---
+
+## Basic usage
+
+Import `SeederModule` in your root module. It auto-detects the `DataSource` registered by `TypeOrmModule`, so no extra wiring is needed in the common case:
+
+```ts
+import { Module } from '@nestjs/common'
+import { TypeOrmModule } from '@nestjs/typeorm'
+import { SeederModule } from '@joakimbugge/nest-typeorm-seeder'
+import { UserSeeder } from './seeders/UserSeeder.js'
+
+@Module({
+  imports: [
+    TypeOrmModule.forRoot({ ... }),
+    SeederModule.forRoot({ seeders: [UserSeeder] }),
+  ],
+})
+export class AppModule {}
+```
+
+If your seeders declare dependencies on each other via the `@Seeder` decorator, they are sorted and executed in the correct order automatically — see [@joakimbugge/typeorm-seeder](../typeorm-seeder#seeder-suites) for details.
+
+### Providing a DataSource explicitly
+
+If you manage the `DataSource` yourself rather than through `TypeOrmModule`, pass it directly:
+
+```ts
+SeederModule.forRoot({
+  seeders: [UserSeeder],
+  dataSource: myDataSource,
+})
+```
+
+> [!IMPORTANT]
+> A DataSource passed this way must already be initialized before the app bootstraps. The module does not call `initialize()` on it.
+
+### Async configuration
+
+Use `forRootAsync` to resolve options from the DI container — useful when the `DataSource` or environment config is injected:
+
+```ts
+import { ConfigService } from '@nestjs/config'
+
+SeederModule.forRootAsync({
+  imports: [ConfigModule],
+  inject: [ConfigService],
+  useFactory: (config: ConfigService) => ({
+    seeders: [UserSeeder],
+    enabled: config.get('SEED') === 'true',
+  }),
+})
+```
+
+---
+
+## Running once
+
+By default (`runOnce: true`) each seeder is tracked in a `seeders` table — similar to how TypeORM tracks migrations. On the next boot — including watch-mode restarts — seeders already recorded in that table are skipped.
+
+### In combination with `dropSchema`
+
+When TypeORM's `dropSchema: true` is set, the entire schema — including the `seeders` table — is dropped on every start, so all seeders run regardless of `runOnce`.
+
+| `dropSchema` | `runOnce` | What happens |
+|---|---|---|
+| `true` | `true` | Tracking table dropped → all seeders run (fresh schema needs fresh seeds) |
+| `true` | `false` | Always runs |
+| `false` | `true` | Tracking table persists → already-run seeders are skipped |
+| `false` | `false` | Always runs (tracking disabled) |
+
+`dropSchema: true` is typical in development when you want a clean slate on every restart — seeding every run is exactly what you want in that scenario. `runOnce: true` with a persistent schema is the right default for staging and production, where duplicate data is the concern.
+
+### Re-seeding
+
+To force a seeder to run again, delete its row from the `seeders` table:
+
+```sql
+DELETE FROM "seeders" WHERE name = 'UserSeeder';
+```
+
+To reset everything and re-run all seeders on next boot:
+
+```sql
+DELETE FROM "seeders";
+```
+
+> [!NOTE]
+> If your factories use random data (e.g. via Faker), setting `runOnce: false` means you will get a completely different dataset on every restart. This can be useful in some development setups, but is usually not what you want.
+
+---
+
+## API reference
+
+### `SeederModule.forRoot(options)`
+
+Registers the module with static options.
+
+### `SeederModule.forRootAsync(options)`
+
+Registers the module with options resolved from the DI container.
+
+**`SeederModuleAsyncOptions`**
+
+| Property | Type | Description |
+|---|---|---|
+| `imports` | `any[]?` | Modules to import for the factory's dependencies. |
+| `inject` | `any[]?` | Providers to inject into the factory. |
+| `useFactory` | `(...args) => SeederModuleOptions \| Promise<SeederModuleOptions>` | Factory that returns the module options. |
+
+---
+
+### `SeederModuleOptions`
+
+| Property | Type | Default | Description |
+|---|---|---|---|
+| `seeders` | `SeederCtor[]` | — | Seeder classes to run. Transitive dependencies are resolved automatically. |
+| `dataSource` | `DataSource?` | — | Explicit DataSource. When omitted, the module resolves the DataSource registered by `TypeOrmModule`. |
+| `relations` | `boolean?` | `true` | Passed through to `runSeeders`. Set to `false` to skip relation seeding. |
+| `enabled` | `boolean?` | `true` | When `false`, seeding is skipped entirely. Useful for gating on an environment variable. |
+| `runOnce` | `boolean?` | `true` | Track executed seeders in the database and skip them on subsequent boots. |
+| `historyTableName` | `string?` | `'seeders'` | Name of the table used to track which seeders have run. |
+
+---
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,122 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _nestjs_common = require("@nestjs/common");
+let _nestjs_core = require("@nestjs/core");
+let _joakimbugge_typeorm_seeder = require("@joakimbugge/typeorm-seeder");
+let typeorm = require("typeorm");
+//#region \0@oxc-project+runtime@0.121.0/helpers/decorateMetadata.js
+function __decorateMetadata(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.121.0/helpers/decorateParam.js
+function __decorateParam(paramIndex, decorator) {
+	return function(target, key) {
+		decorator(target, key, paramIndex);
+	};
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.121.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+//#endregion
+//#region src/SeederRunnerService.ts
+var _ref, _SeederRunnerService;
+const SEEDER_MODULE_OPTIONS = Symbol("SEEDER_MODULE_OPTIONS");
+const DEFAULT_HISTORY_TABLE = "seeders";
+let SeederRunnerService = _SeederRunnerService = class SeederRunnerService {
+	constructor(options, moduleRef) {
+		this.options = options;
+		this.moduleRef = moduleRef;
+		this.logger = new _nestjs_common.Logger(_SeederRunnerService.name);
+	}
+	async onApplicationBootstrap() {
+		if (this.options.enabled === false) return;
+		const dataSource = await this.resolveDataSource();
+		const runOnce = this.options.runOnce ?? true;
+		const tableName = this.options.historyTableName ?? DEFAULT_HISTORY_TABLE;
+		let executedSeeders = /* @__PURE__ */ new Set();
+		if (runOnce) {
+			await this.ensureHistoryTable(dataSource, tableName);
+			executedSeeders = await this.getExecutedSeeders(dataSource, tableName);
+		}
+		await (0, _joakimbugge_typeorm_seeder.runSeeders)(this.options.seeders, {
+			dataSource,
+			relations: this.options.relations,
+			logging: false,
+			skip: (seeder) => {
+				const shouldSkip = executedSeeders.has(seeder.name);
+				if (shouldSkip) this.logger.log(`[${seeder.name}] Skipping (already run)`);
+				return shouldSkip;
+			},
+			onBefore: (seeder) => this.logger.log(`[${seeder.name}] Starting...`),
+			onAfter: async (seeder, durationMs) => {
+				if (runOnce) await this.recordRun(dataSource, tableName, seeder.name);
+				this.logger.log(`[${seeder.name}] Done in ${durationMs}ms`);
+			},
+			onError: (seeder, error) => this.logger.error(`[${seeder.name}] Failed`, error instanceof Error ? error.stack : String(error))
+		});
+	}
+	async ensureHistoryTable(dataSource, tableName) {
+		await dataSource.query(`CREATE TABLE IF NOT EXISTS "${tableName}" (name VARCHAR(255) PRIMARY KEY NOT NULL, executed_at VARCHAR(32) NOT NULL)`);
+	}
+	async getExecutedSeeders(dataSource, tableName) {
+		const rows = await dataSource.query(`SELECT name FROM "${tableName}"`);
+		return new Set(rows.map((r) => r.name));
+	}
+	async recordRun(dataSource, tableName, name) {
+		const executedAt = (/* @__PURE__ */ new Date()).toISOString();
+		await dataSource.query(`INSERT INTO "${tableName}" (name, executed_at) VALUES ('${name}', '${executedAt}')`);
+	}
+	async resolveDataSource() {
+		if (this.options.dataSource) return this.options.dataSource;
+		try {
+			return this.moduleRef.get(typeorm.DataSource, { strict: false });
+		} catch {
+			throw new Error("SeederModule could not resolve a DataSource. Either import TypeOrmModule or provide a dataSource in SeederModule options.");
+		}
+	}
+};
+SeederRunnerService = _SeederRunnerService = __decorate([
+	(0, _nestjs_common.Injectable)(),
+	__decorateParam(0, (0, _nestjs_common.Inject)(SEEDER_MODULE_OPTIONS)),
+	__decorateMetadata("design:paramtypes", [Object, typeof (_ref = typeof _nestjs_core.ModuleRef !== "undefined" && _nestjs_core.ModuleRef) === "function" ? _ref : Object])
+], SeederRunnerService);
+//#endregion
+//#region src/SeederModule.ts
+var _SeederModule;
+let SeederModule = _SeederModule = class SeederModule {
+	static forRoot(options) {
+		return {
+			module: _SeederModule,
+			providers: [{
+				provide: SEEDER_MODULE_OPTIONS,
+				useValue: options
+			}, SeederRunnerService]
+		};
+	}
+	static forRootAsync(options) {
+		return {
+			module: _SeederModule,
+			imports: options.imports ?? [],
+			providers: [{
+				provide: SEEDER_MODULE_OPTIONS,
+				inject: options.inject ?? [],
+				useFactory: options.useFactory
+			}, SeederRunnerService]
+		};
+	}
+};
+SeederModule = _SeederModule = __decorate([(0, _nestjs_common.Module)({})], SeederModule);
+//#endregion
+Object.defineProperty(exports, "SeederModule", {
+	enumerable: true,
+	get: function() {
+		return SeederModule;
+	}
+});
+
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["Logger","DataSource"],"sources":["../src/SeederRunnerService.ts","../src/SeederModule.ts"],"sourcesContent":["import { Inject, Injectable, Logger, type OnApplicationBootstrap } from '@nestjs/common';\nimport { ModuleRef } from '@nestjs/core';\nimport { runSeeders } from '@joakimbugge/typeorm-seeder';\nimport { DataSource } from 'typeorm';\nimport type { SeederModuleOptions } from './SeederModule.js';\n\nexport const SEEDER_MODULE_OPTIONS = Symbol('SEEDER_MODULE_OPTIONS');\n\nconst DEFAULT_HISTORY_TABLE = 'seeders';\n\n@Injectable()\nexport class SeederRunnerService implements OnApplicationBootstrap {\n  private readonly logger = new Logger(SeederRunnerService.name);\n\n  constructor(\n    @Inject(SEEDER_MODULE_OPTIONS) private readonly options: SeederModuleOptions,\n    private readonly moduleRef: ModuleRef,\n  ) {}\n\n  async onApplicationBootstrap(): Promise<void> {\n    if (this.options.enabled === false) {\n      return;\n    }\n\n    const dataSource = await this.resolveDataSource();\n    const runOnce = this.options.runOnce ?? true;\n    const tableName = this.options.historyTableName ?? DEFAULT_HISTORY_TABLE;\n\n    let executedSeeders = new Set<string>();\n\n    if (runOnce) {\n      await this.ensureHistoryTable(dataSource, tableName);\n      executedSeeders = await this.getExecutedSeeders(dataSource, tableName);\n    }\n\n    await runSeeders(this.options.seeders, {\n      dataSource,\n      relations: this.options.relations,\n      logging: false,\n      skip: (seeder) => {\n        const shouldSkip = executedSeeders.has(seeder.name);\n\n        if (shouldSkip) {\n          this.logger.log(`[${seeder.name}] Skipping (already run)`);\n        }\n\n        return shouldSkip;\n      },\n      onBefore: (seeder) => this.logger.log(`[${seeder.name}] Starting...`),\n      onAfter: async (seeder, durationMs) => {\n        if (runOnce) {\n          await this.recordRun(dataSource, tableName, seeder.name);\n        }\n\n        this.logger.log(`[${seeder.name}] Done in ${durationMs}ms`);\n      },\n      onError: (seeder, error) =>\n        this.logger.error(\n          `[${seeder.name}] Failed`,\n          error instanceof Error ? error.stack : String(error),\n        ),\n    });\n  }\n\n  private async ensureHistoryTable(dataSource: DataSource, tableName: string): Promise<void> {\n    await dataSource.query(\n      `CREATE TABLE IF NOT EXISTS \"${tableName}\" (name VARCHAR(255) PRIMARY KEY NOT NULL, executed_at VARCHAR(32) NOT NULL)`,\n    );\n  }\n\n  private async getExecutedSeeders(\n    dataSource: DataSource,\n    tableName: string,\n  ): Promise<Set<string>> {\n    const rows: { name: string }[] = await dataSource.query(`SELECT name FROM \"${tableName}\"`);\n\n    return new Set(rows.map((r) => r.name));\n  }\n\n  private async recordRun(dataSource: DataSource, tableName: string, name: string): Promise<void> {\n    const executedAt = new Date().toISOString();\n\n    await dataSource.query(\n      `INSERT INTO \"${tableName}\" (name, executed_at) VALUES ('${name}', '${executedAt}')`,\n    );\n  }\n\n  private async resolveDataSource(): Promise<DataSource> {\n    if (this.options.dataSource) {\n      return this.options.dataSource;\n    }\n\n    try {\n      return this.moduleRef.get(DataSource, { strict: false });\n    } catch {\n      throw new Error(\n        'SeederModule could not resolve a DataSource. Either import TypeOrmModule or provide a dataSource in SeederModule options.',\n      );\n    }\n  }\n}\n","import { type DynamicModule, Module } from '@nestjs/common';\nimport type { SeederInterface } from '@joakimbugge/typeorm-seeder';\nimport type { DataSource } from 'typeorm';\nimport { SeederRunnerService, SEEDER_MODULE_OPTIONS } from './SeederRunnerService.js';\n\nexport type SeederCtor = new () => SeederInterface;\n\nexport interface SeederModuleOptions {\n  seeders: SeederCtor[];\n  dataSource?: DataSource;\n  relations?: boolean;\n  /**\n   * When `false`, seeding is skipped entirely. Useful for gating on an env var.\n   *\n   * @default true\n   */\n  enabled?: boolean;\n  /**\n   * Track executed seeders in a database table and skip them on subsequent boots.\n   * Set to `false` to always run every seeder regardless.\n   *\n   * When TypeORM's `dropSchema` is `true`, the history table is dropped with the\n   * rest of the schema on every start, so all seeders run regardless of this setting.\n   *\n   * @default true\n   */\n  runOnce?: boolean;\n  /**\n   * Name of the table used to track which seeders have run.\n   *\n   * @default 'seeders'\n   */\n  historyTableName?: string;\n}\n\nexport interface SeederModuleAsyncOptions {\n  imports?: any[];\n  inject?: any[];\n  useFactory: (...args: any[]) => SeederModuleOptions | Promise<SeederModuleOptions>;\n}\n\n@Module({})\nexport class SeederModule {\n  static forRoot(options: SeederModuleOptions): DynamicModule {\n    return {\n      module: SeederModule,\n      providers: [{ provide: SEEDER_MODULE_OPTIONS, useValue: options }, SeederRunnerService],\n    };\n  }\n\n  static forRootAsync(options: SeederModuleAsyncOptions): DynamicModule {\n    return {\n      module: SeederModule,\n      imports: options.imports ?? [],\n      providers: [\n        {\n          provide: SEEDER_MODULE_OPTIONS,\n          inject: options.inject ?? [],\n          useFactory: options.useFactory,\n        },\n        SeederRunnerService,\n      ],\n    };\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAMA,MAAa,wBAAwB,OAAO,wBAAwB;AAEpE,MAAM,wBAAwB;AAGvB,IAAA,sBAAA,uBAAA,MAAM,oBAAsD;CAGjE,YACE,SACA,WACA;AAFgD,OAAA,UAAA;AAC/B,OAAA,YAAA;gBAJO,IAAIA,eAAAA,OAAAA,qBAA2B,KAAK;;CAO9D,MAAM,yBAAwC;AAC5C,MAAI,KAAK,QAAQ,YAAY,MAC3B;EAGF,MAAM,aAAa,MAAM,KAAK,mBAAmB;EACjD,MAAM,UAAU,KAAK,QAAQ,WAAW;EACxC,MAAM,YAAY,KAAK,QAAQ,oBAAoB;EAEnD,IAAI,kCAAkB,IAAI,KAAa;AAEvC,MAAI,SAAS;AACX,SAAM,KAAK,mBAAmB,YAAY,UAAU;AACpD,qBAAkB,MAAM,KAAK,mBAAmB,YAAY,UAAU;;AAGxE,SAAA,GAAA,4BAAA,YAAiB,KAAK,QAAQ,SAAS;GACrC;GACA,WAAW,KAAK,QAAQ;GACxB,SAAS;GACT,OAAO,WAAW;IAChB,MAAM,aAAa,gBAAgB,IAAI,OAAO,KAAK;AAEnD,QAAI,WACF,MAAK,OAAO,IAAI,IAAI,OAAO,KAAK,0BAA0B;AAG5D,WAAO;;GAET,WAAW,WAAW,KAAK,OAAO,IAAI,IAAI,OAAO,KAAK,eAAe;GACrE,SAAS,OAAO,QAAQ,eAAe;AACrC,QAAI,QACF,OAAM,KAAK,UAAU,YAAY,WAAW,OAAO,KAAK;AAG1D,SAAK,OAAO,IAAI,IAAI,OAAO,KAAK,YAAY,WAAW,IAAI;;GAE7D,UAAU,QAAQ,UAChB,KAAK,OAAO,MACV,IAAI,OAAO,KAAK,WAChB,iBAAiB,QAAQ,MAAM,QAAQ,OAAO,MAAM,CACrD;GACJ,CAAC;;CAGJ,MAAc,mBAAmB,YAAwB,WAAkC;AACzF,QAAM,WAAW,MACf,+BAA+B,UAAU,8EAC1C;;CAGH,MAAc,mBACZ,YACA,WACsB;EACtB,MAAM,OAA2B,MAAM,WAAW,MAAM,qBAAqB,UAAU,GAAG;AAE1F,SAAO,IAAI,IAAI,KAAK,KAAK,MAAM,EAAE,KAAK,CAAC;;CAGzC,MAAc,UAAU,YAAwB,WAAmB,MAA6B;EAC9F,MAAM,8BAAa,IAAI,MAAM,EAAC,aAAa;AAE3C,QAAM,WAAW,MACf,gBAAgB,UAAU,iCAAiC,KAAK,MAAM,WAAW,IAClF;;CAGH,MAAc,oBAAyC;AACrD,MAAI,KAAK,QAAQ,WACf,QAAO,KAAK,QAAQ;AAGtB,MAAI;AACF,UAAO,KAAK,UAAU,IAAIC,QAAAA,YAAY,EAAE,QAAQ,OAAO,CAAC;UAClD;AACN,SAAM,IAAI,MACR,4HACD;;;;;iCAvFM;+CAKD,sBAAsB,CAAA;;;;;;AC2B3B,IAAA,eAAA,gBAAA,MAAM,aAAa;CACxB,OAAO,QAAQ,SAA6C;AAC1D,SAAO;GACL,QAAA;GACA,WAAW,CAAC;IAAE,SAAS;IAAuB,UAAU;IAAS,EAAE,oBAAoB;GACxF;;CAGH,OAAO,aAAa,SAAkD;AACpE,SAAO;GACL,QAAA;GACA,SAAS,QAAQ,WAAW,EAAE;GAC9B,WAAW,CACT;IACE,SAAS;IACT,QAAQ,QAAQ,UAAU,EAAE;IAC5B,YAAY,QAAQ;IACrB,EACD,oBACD;GACF;;;sEArBG,EAAE,CAAC,CAAA,EAAA,aAAA"}

package/dist/index.d.cts

@@ -0,0 +1,45 @@
+import { DynamicModule } from "@nestjs/common";
+import { SeederInterface } from "@joakimbugge/typeorm-seeder";
+import { DataSource } from "typeorm";
+
+//#region src/SeederModule.d.ts
+type SeederCtor = new () => SeederInterface;
+interface SeederModuleOptions {
+  seeders: SeederCtor[];
+  dataSource?: DataSource;
+  relations?: boolean;
+  /**
+   * When `false`, seeding is skipped entirely. Useful for gating on an env var.
+   *
+   * @default true
+   */
+  enabled?: boolean;
+  /**
+   * Track executed seeders in a database table and skip them on subsequent boots.
+   * Set to `false` to always run every seeder regardless.
+   *
+   * When TypeORM's `dropSchema` is `true`, the history table is dropped with the
+   * rest of the schema on every start, so all seeders run regardless of this setting.
+   *
+   * @default true
+   */
+  runOnce?: boolean;
+  /**
+   * Name of the table used to track which seeders have run.
+   *
+   * @default 'seeders'
+   */
+  historyTableName?: string;
+}
+interface SeederModuleAsyncOptions {
+  imports?: any[];
+  inject?: any[];
+  useFactory: (...args: any[]) => SeederModuleOptions | Promise<SeederModuleOptions>;
+}
+declare class SeederModule {
+  static forRoot(options: SeederModuleOptions): DynamicModule;
+  static forRootAsync(options: SeederModuleAsyncOptions): DynamicModule;
+}
+//#endregion
+export { type SeederCtor, SeederModule, type SeederModuleAsyncOptions, type SeederModuleOptions };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/SeederModule.ts"],"mappings":";;;;;KAKY,UAAA,aAAuB,eAAA;AAAA,UAElB,mBAAA;EACf,OAAA,EAAS,UAAA;EACT,UAAA,GAAa,UAAA;EACb,SAAA;EALiC;;AAEnC;;;EASE,OAAA;EARA;;;;;;;;;EAkBA,OAAA;EASe;;;;;EAHf,gBAAA;AAAA;AAAA,UAGe,wBAAA;EACf,OAAA;EACA,MAAA;EACA,UAAA,MAAgB,IAAA,YAAgB,mBAAA,GAAsB,OAAA,CAAQ,mBAAA;AAAA;AAAA,cAInD,YAAA;EAAA,OACJ,OAAA,CAAQ,OAAA,EAAS,mBAAA,GAAsB,aAAA;EAAA,OAOvC,YAAA,CAAa,OAAA,EAAS,wBAAA,GAA2B,aAAA;AAAA"}

package/dist/index.d.mts

@@ -0,0 +1,45 @@
+import { DynamicModule } from "@nestjs/common";
+import { SeederInterface } from "@joakimbugge/typeorm-seeder";
+import { DataSource } from "typeorm";
+
+//#region src/SeederModule.d.ts
+type SeederCtor = new () => SeederInterface;
+interface SeederModuleOptions {
+  seeders: SeederCtor[];
+  dataSource?: DataSource;
+  relations?: boolean;
+  /**
+   * When `false`, seeding is skipped entirely. Useful for gating on an env var.
+   *
+   * @default true
+   */
+  enabled?: boolean;
+  /**
+   * Track executed seeders in a database table and skip them on subsequent boots.
+   * Set to `false` to always run every seeder regardless.
+   *
+   * When TypeORM's `dropSchema` is `true`, the history table is dropped with the
+   * rest of the schema on every start, so all seeders run regardless of this setting.
+   *
+   * @default true
+   */
+  runOnce?: boolean;
+  /**
+   * Name of the table used to track which seeders have run.
+   *
+   * @default 'seeders'
+   */
+  historyTableName?: string;
+}
+interface SeederModuleAsyncOptions {
+  imports?: any[];
+  inject?: any[];
+  useFactory: (...args: any[]) => SeederModuleOptions | Promise<SeederModuleOptions>;
+}
+declare class SeederModule {
+  static forRoot(options: SeederModuleOptions): DynamicModule;
+  static forRootAsync(options: SeederModuleAsyncOptions): DynamicModule;
+}
+//#endregion
+export { type SeederCtor, SeederModule, type SeederModuleAsyncOptions, type SeederModuleOptions };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/SeederModule.ts"],"mappings":";;;;;KAKY,UAAA,aAAuB,eAAA;AAAA,UAElB,mBAAA;EACf,OAAA,EAAS,UAAA;EACT,UAAA,GAAa,UAAA;EACb,SAAA;EALiC;;AAEnC;;;EASE,OAAA;EARA;;;;;;;;;EAkBA,OAAA;EASe;;;;;EAHf,gBAAA;AAAA;AAAA,UAGe,wBAAA;EACf,OAAA;EACA,MAAA;EACA,UAAA,MAAgB,IAAA,YAAgB,mBAAA,GAAsB,OAAA,CAAQ,mBAAA;AAAA;AAAA,cAInD,YAAA;EAAA,OACJ,OAAA,CAAQ,OAAA,EAAS,mBAAA,GAAsB,aAAA;EAAA,OAOvC,YAAA,CAAa,OAAA,EAAS,wBAAA,GAA2B,aAAA;AAAA"}

package/dist/index.mjs

@@ -0,0 +1,116 @@
+import { Inject, Injectable, Logger, Module } from "@nestjs/common";
+import { ModuleRef } from "@nestjs/core";
+import { runSeeders } from "@joakimbugge/typeorm-seeder";
+import { DataSource } from "typeorm";
+//#region \0@oxc-project+runtime@0.121.0/helpers/decorateMetadata.js
+function __decorateMetadata(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.121.0/helpers/decorateParam.js
+function __decorateParam(paramIndex, decorator) {
+	return function(target, key) {
+		decorator(target, key, paramIndex);
+	};
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.121.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+//#endregion
+//#region src/SeederRunnerService.ts
+var _ref, _SeederRunnerService;
+const SEEDER_MODULE_OPTIONS = Symbol("SEEDER_MODULE_OPTIONS");
+const DEFAULT_HISTORY_TABLE = "seeders";
+let SeederRunnerService = _SeederRunnerService = class SeederRunnerService {
+	constructor(options, moduleRef) {
+		this.options = options;
+		this.moduleRef = moduleRef;
+		this.logger = new Logger(_SeederRunnerService.name);
+	}
+	async onApplicationBootstrap() {
+		if (this.options.enabled === false) return;
+		const dataSource = await this.resolveDataSource();
+		const runOnce = this.options.runOnce ?? true;
+		const tableName = this.options.historyTableName ?? DEFAULT_HISTORY_TABLE;
+		let executedSeeders = /* @__PURE__ */ new Set();
+		if (runOnce) {
+			await this.ensureHistoryTable(dataSource, tableName);
+			executedSeeders = await this.getExecutedSeeders(dataSource, tableName);
+		}
+		await runSeeders(this.options.seeders, {
+			dataSource,
+			relations: this.options.relations,
+			logging: false,
+			skip: (seeder) => {
+				const shouldSkip = executedSeeders.has(seeder.name);
+				if (shouldSkip) this.logger.log(`[${seeder.name}] Skipping (already run)`);
+				return shouldSkip;
+			},
+			onBefore: (seeder) => this.logger.log(`[${seeder.name}] Starting...`),
+			onAfter: async (seeder, durationMs) => {
+				if (runOnce) await this.recordRun(dataSource, tableName, seeder.name);
+				this.logger.log(`[${seeder.name}] Done in ${durationMs}ms`);
+			},
+			onError: (seeder, error) => this.logger.error(`[${seeder.name}] Failed`, error instanceof Error ? error.stack : String(error))
+		});
+	}
+	async ensureHistoryTable(dataSource, tableName) {
+		await dataSource.query(`CREATE TABLE IF NOT EXISTS "${tableName}" (name VARCHAR(255) PRIMARY KEY NOT NULL, executed_at VARCHAR(32) NOT NULL)`);
+	}
+	async getExecutedSeeders(dataSource, tableName) {
+		const rows = await dataSource.query(`SELECT name FROM "${tableName}"`);
+		return new Set(rows.map((r) => r.name));
+	}
+	async recordRun(dataSource, tableName, name) {
+		const executedAt = (/* @__PURE__ */ new Date()).toISOString();
+		await dataSource.query(`INSERT INTO "${tableName}" (name, executed_at) VALUES ('${name}', '${executedAt}')`);
+	}
+	async resolveDataSource() {
+		if (this.options.dataSource) return this.options.dataSource;
+		try {
+			return this.moduleRef.get(DataSource, { strict: false });
+		} catch {
+			throw new Error("SeederModule could not resolve a DataSource. Either import TypeOrmModule or provide a dataSource in SeederModule options.");
+		}
+	}
+};
+SeederRunnerService = _SeederRunnerService = __decorate([
+	Injectable(),
+	__decorateParam(0, Inject(SEEDER_MODULE_OPTIONS)),
+	__decorateMetadata("design:paramtypes", [Object, typeof (_ref = typeof ModuleRef !== "undefined" && ModuleRef) === "function" ? _ref : Object])
+], SeederRunnerService);
+//#endregion
+//#region src/SeederModule.ts
+var _SeederModule;
+let SeederModule = _SeederModule = class SeederModule {
+	static forRoot(options) {
+		return {
+			module: _SeederModule,
+			providers: [{
+				provide: SEEDER_MODULE_OPTIONS,
+				useValue: options
+			}, SeederRunnerService]
+		};
+	}
+	static forRootAsync(options) {
+		return {
+			module: _SeederModule,
+			imports: options.imports ?? [],
+			providers: [{
+				provide: SEEDER_MODULE_OPTIONS,
+				inject: options.inject ?? [],
+				useFactory: options.useFactory
+			}, SeederRunnerService]
+		};
+	}
+};
+SeederModule = _SeederModule = __decorate([Module({})], SeederModule);
+//#endregion
+export { SeederModule };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/SeederRunnerService.ts","../src/SeederModule.ts"],"sourcesContent":["import { Inject, Injectable, Logger, type OnApplicationBootstrap } from '@nestjs/common';\nimport { ModuleRef } from '@nestjs/core';\nimport { runSeeders } from '@joakimbugge/typeorm-seeder';\nimport { DataSource } from 'typeorm';\nimport type { SeederModuleOptions } from './SeederModule.js';\n\nexport const SEEDER_MODULE_OPTIONS = Symbol('SEEDER_MODULE_OPTIONS');\n\nconst DEFAULT_HISTORY_TABLE = 'seeders';\n\n@Injectable()\nexport class SeederRunnerService implements OnApplicationBootstrap {\n  private readonly logger = new Logger(SeederRunnerService.name);\n\n  constructor(\n    @Inject(SEEDER_MODULE_OPTIONS) private readonly options: SeederModuleOptions,\n    private readonly moduleRef: ModuleRef,\n  ) {}\n\n  async onApplicationBootstrap(): Promise<void> {\n    if (this.options.enabled === false) {\n      return;\n    }\n\n    const dataSource = await this.resolveDataSource();\n    const runOnce = this.options.runOnce ?? true;\n    const tableName = this.options.historyTableName ?? DEFAULT_HISTORY_TABLE;\n\n    let executedSeeders = new Set<string>();\n\n    if (runOnce) {\n      await this.ensureHistoryTable(dataSource, tableName);\n      executedSeeders = await this.getExecutedSeeders(dataSource, tableName);\n    }\n\n    await runSeeders(this.options.seeders, {\n      dataSource,\n      relations: this.options.relations,\n      logging: false,\n      skip: (seeder) => {\n        const shouldSkip = executedSeeders.has(seeder.name);\n\n        if (shouldSkip) {\n          this.logger.log(`[${seeder.name}] Skipping (already run)`);\n        }\n\n        return shouldSkip;\n      },\n      onBefore: (seeder) => this.logger.log(`[${seeder.name}] Starting...`),\n      onAfter: async (seeder, durationMs) => {\n        if (runOnce) {\n          await this.recordRun(dataSource, tableName, seeder.name);\n        }\n\n        this.logger.log(`[${seeder.name}] Done in ${durationMs}ms`);\n      },\n      onError: (seeder, error) =>\n        this.logger.error(\n          `[${seeder.name}] Failed`,\n          error instanceof Error ? error.stack : String(error),\n        ),\n    });\n  }\n\n  private async ensureHistoryTable(dataSource: DataSource, tableName: string): Promise<void> {\n    await dataSource.query(\n      `CREATE TABLE IF NOT EXISTS \"${tableName}\" (name VARCHAR(255) PRIMARY KEY NOT NULL, executed_at VARCHAR(32) NOT NULL)`,\n    );\n  }\n\n  private async getExecutedSeeders(\n    dataSource: DataSource,\n    tableName: string,\n  ): Promise<Set<string>> {\n    const rows: { name: string }[] = await dataSource.query(`SELECT name FROM \"${tableName}\"`);\n\n    return new Set(rows.map((r) => r.name));\n  }\n\n  private async recordRun(dataSource: DataSource, tableName: string, name: string): Promise<void> {\n    const executedAt = new Date().toISOString();\n\n    await dataSource.query(\n      `INSERT INTO \"${tableName}\" (name, executed_at) VALUES ('${name}', '${executedAt}')`,\n    );\n  }\n\n  private async resolveDataSource(): Promise<DataSource> {\n    if (this.options.dataSource) {\n      return this.options.dataSource;\n    }\n\n    try {\n      return this.moduleRef.get(DataSource, { strict: false });\n    } catch {\n      throw new Error(\n        'SeederModule could not resolve a DataSource. Either import TypeOrmModule or provide a dataSource in SeederModule options.',\n      );\n    }\n  }\n}\n","import { type DynamicModule, Module } from '@nestjs/common';\nimport type { SeederInterface } from '@joakimbugge/typeorm-seeder';\nimport type { DataSource } from 'typeorm';\nimport { SeederRunnerService, SEEDER_MODULE_OPTIONS } from './SeederRunnerService.js';\n\nexport type SeederCtor = new () => SeederInterface;\n\nexport interface SeederModuleOptions {\n  seeders: SeederCtor[];\n  dataSource?: DataSource;\n  relations?: boolean;\n  /**\n   * When `false`, seeding is skipped entirely. Useful for gating on an env var.\n   *\n   * @default true\n   */\n  enabled?: boolean;\n  /**\n   * Track executed seeders in a database table and skip them on subsequent boots.\n   * Set to `false` to always run every seeder regardless.\n   *\n   * When TypeORM's `dropSchema` is `true`, the history table is dropped with the\n   * rest of the schema on every start, so all seeders run regardless of this setting.\n   *\n   * @default true\n   */\n  runOnce?: boolean;\n  /**\n   * Name of the table used to track which seeders have run.\n   *\n   * @default 'seeders'\n   */\n  historyTableName?: string;\n}\n\nexport interface SeederModuleAsyncOptions {\n  imports?: any[];\n  inject?: any[];\n  useFactory: (...args: any[]) => SeederModuleOptions | Promise<SeederModuleOptions>;\n}\n\n@Module({})\nexport class SeederModule {\n  static forRoot(options: SeederModuleOptions): DynamicModule {\n    return {\n      module: SeederModule,\n      providers: [{ provide: SEEDER_MODULE_OPTIONS, useValue: options }, SeederRunnerService],\n    };\n  }\n\n  static forRootAsync(options: SeederModuleAsyncOptions): DynamicModule {\n    return {\n      module: SeederModule,\n      imports: options.imports ?? [],\n      providers: [\n        {\n          provide: SEEDER_MODULE_OPTIONS,\n          inject: options.inject ?? [],\n          useFactory: options.useFactory,\n        },\n        SeederRunnerService,\n      ],\n    };\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAMA,MAAa,wBAAwB,OAAO,wBAAwB;AAEpE,MAAM,wBAAwB;AAGvB,IAAA,sBAAA,uBAAA,MAAM,oBAAsD;CAGjE,YACE,SACA,WACA;AAFgD,OAAA,UAAA;AAC/B,OAAA,YAAA;gBAJO,IAAI,OAAA,qBAA2B,KAAK;;CAO9D,MAAM,yBAAwC;AAC5C,MAAI,KAAK,QAAQ,YAAY,MAC3B;EAGF,MAAM,aAAa,MAAM,KAAK,mBAAmB;EACjD,MAAM,UAAU,KAAK,QAAQ,WAAW;EACxC,MAAM,YAAY,KAAK,QAAQ,oBAAoB;EAEnD,IAAI,kCAAkB,IAAI,KAAa;AAEvC,MAAI,SAAS;AACX,SAAM,KAAK,mBAAmB,YAAY,UAAU;AACpD,qBAAkB,MAAM,KAAK,mBAAmB,YAAY,UAAU;;AAGxE,QAAM,WAAW,KAAK,QAAQ,SAAS;GACrC;GACA,WAAW,KAAK,QAAQ;GACxB,SAAS;GACT,OAAO,WAAW;IAChB,MAAM,aAAa,gBAAgB,IAAI,OAAO,KAAK;AAEnD,QAAI,WACF,MAAK,OAAO,IAAI,IAAI,OAAO,KAAK,0BAA0B;AAG5D,WAAO;;GAET,WAAW,WAAW,KAAK,OAAO,IAAI,IAAI,OAAO,KAAK,eAAe;GACrE,SAAS,OAAO,QAAQ,eAAe;AACrC,QAAI,QACF,OAAM,KAAK,UAAU,YAAY,WAAW,OAAO,KAAK;AAG1D,SAAK,OAAO,IAAI,IAAI,OAAO,KAAK,YAAY,WAAW,IAAI;;GAE7D,UAAU,QAAQ,UAChB,KAAK,OAAO,MACV,IAAI,OAAO,KAAK,WAChB,iBAAiB,QAAQ,MAAM,QAAQ,OAAO,MAAM,CACrD;GACJ,CAAC;;CAGJ,MAAc,mBAAmB,YAAwB,WAAkC;AACzF,QAAM,WAAW,MACf,+BAA+B,UAAU,8EAC1C;;CAGH,MAAc,mBACZ,YACA,WACsB;EACtB,MAAM,OAA2B,MAAM,WAAW,MAAM,qBAAqB,UAAU,GAAG;AAE1F,SAAO,IAAI,IAAI,KAAK,KAAK,MAAM,EAAE,KAAK,CAAC;;CAGzC,MAAc,UAAU,YAAwB,WAAmB,MAA6B;EAC9F,MAAM,8BAAa,IAAI,MAAM,EAAC,aAAa;AAE3C,QAAM,WAAW,MACf,gBAAgB,UAAU,iCAAiC,KAAK,MAAM,WAAW,IAClF;;CAGH,MAAc,oBAAyC;AACrD,MAAI,KAAK,QAAQ,WACf,QAAO,KAAK,QAAQ;AAGtB,MAAI;AACF,UAAO,KAAK,UAAU,IAAI,YAAY,EAAE,QAAQ,OAAO,CAAC;UAClD;AACN,SAAM,IAAI,MACR,4HACD;;;;;CAvFN,YAAY;oBAKR,OAAO,sBAAsB,CAAA;;;;;;AC2B3B,IAAA,eAAA,gBAAA,MAAM,aAAa;CACxB,OAAO,QAAQ,SAA6C;AAC1D,SAAO;GACL,QAAA;GACA,WAAW,CAAC;IAAE,SAAS;IAAuB,UAAU;IAAS,EAAE,oBAAoB;GACxF;;CAGH,OAAO,aAAa,SAAkD;AACpE,SAAO;GACL,QAAA;GACA,SAAS,QAAQ,WAAW,EAAE;GAC9B,WAAW,CACT;IACE,SAAS;IACT,QAAQ,QAAQ,UAAU,EAAE;IAC5B,YAAY,QAAQ;IACrB,EACD,oBACD;GACF;;;2CArBJ,OAAO,EAAE,CAAC,CAAA,EAAA,aAAA"}

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@joakimbugge/nest-typeorm-seeder",
+  "version": "0.2.0",
+  "description": "NestJS module for @joakimbugge/typeorm-seeder",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/joakimbugge/to-seeder.git"
+  },
+  "homepage": "https://github.com/joakimbugge/to-seeder#readme",
+  "bugs": "https://github.com/joakimbugge/to-seeder/issues",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "prepublishOnly": "pnpm run build",
+    "dev": "tsdown --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "lint": "oxlint src tests",
+    "lint:fix": "oxlint --fix src tests",
+    "fmt": "oxfmt src tests",
+    "fmt:check": "oxfmt --check src tests"
+  },
+  "keywords": [
+    "typeorm",
+    "seeder",
+    "decorator",
+    "database",
+    "seed",
+    "nestjs"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=16.13.0"
+  },
+  "peerDependencies": {
+    "@nestjs/common": ">=10.0.0",
+    "@nestjs/core": ">=10.0.0",
+    "reflect-metadata": ">=0.1.0",
+    "typeorm": ">=0.3.0"
+  },
+  "devDependencies": {
+    "@faker-js/faker": "^10.4.0",
+    "@nestjs/common": "^11.0.0",
+    "@nestjs/core": "^11.0.0",
+    "@nestjs/testing": "^11.0.0",
+    "@types/better-sqlite3": "^7.6.13",
+    "better-sqlite3": "^12.8.0",
+    "reflect-metadata": "^0.2.2",
+    "typeorm": "1.0.0-beta.1"
+  },
+  "dependencies": {
+    "@joakimbugge/typeorm-seeder": "workspace:*"
+  }
+}