pg-seed-kit 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kulcsár Rudolf
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,132 @@
+# pg-seed-kit
+
+[![npm version](https://img.shields.io/npm/v/pg-seed-kit)](https://www.npmjs.com/package/pg-seed-kit)
+[![license](https://badgen.net/npm/license/pg-seed-kit)](https://github.com/kulcsarrudolf/pg-seed-kit/blob/main/LICENSE)
+[![downloads](https://img.shields.io/npm/dt/pg-seed-kit)](https://www.npmjs.com/package/pg-seed-kit)
+[![GitHub Stars](https://badgen.net/github/stars/kulcsarrudolf/pg-seed-kit)](https://github.com/kulcsarrudolf/pg-seed-kit)
+
+A lightweight, zero-dependency seeder toolkit for Postgres that works with **Prisma**, **Drizzle**, **TypeORM**, and **Sequelize**. Run one-time seed scripts on startup, track execution status, and manage seeders via a small CLI.
+
+The package ships **no runtime dependencies**: instead of opening its own connection, it runs its tracking SQL through a tiny adapter built on the connection your ORM already owns.
+
+> Docs with copy-paste examples for every ORM: **https://kulcsarrudolf.github.io/pg-seed-kit/**
+
+## Installation
+
+```bash
+npm install pg-seed-kit
+```
+
+Your ORM is an optional peer dependency: install whichever one you already use (`@prisma/client`, `drizzle-orm`, `typeorm`, or `sequelize`).
+
+## Quick Start (Drizzle)
+
+Point pg-seed-kit at your seeders and tell it how to connect. Create `pg-seed-kit.config.js`:
+
+```javascript
+import { drizzleAdapter } from "pg-seed-kit/drizzle";
+import { db, pool } from "./db.js"; // your drizzle db + pg Pool
+
+export default {
+  seedersPath: "./src/db/seeders",
+  connect: async () => drizzleAdapter(db, { close: () => pool.end() }),
+};
+```
+
+Scaffold a seeder:
+
+```bash
+npx pg-seed-kit create add-admin
+```
+
+Implement the generated `src/db/seeders/20260320120000-add-admin.seeder.ts`:
+
+```typescript
+import { db } from "../../db.js";
+import { users } from "../schema.js";
+
+const seed = async (): Promise<void> => {
+  await db
+    .insert(users)
+    .values({ email: "admin@example.com", role: "admin" })
+    .onConflictDoNothing();
+};
+
+export default seed;
+```
+
+Run pending seeders, either from your app (after the ORM is connected) or via the CLI:
+
+```typescript
+import { runPendingSeeders } from "pg-seed-kit";
+import { drizzleAdapter } from "pg-seed-kit/drizzle";
+import { db } from "./db.js";
+
+await runPendingSeeders({ adapter: drizzleAdapter(db) });
+```
+
+```bash
+npx pg-seed-kit run
+```
+
+Using **Prisma**, **TypeORM**, or **Sequelize**? The same three steps, with that ORM's adapter and idiom: see the [website](https://kulcsarrudolf.github.io/pg-seed-kit/).
+
+## How It Works
+
+1. Seeder files are sorted alphabetically; the timestamp prefix (`20260320120000-`) keeps them in chronological order.
+2. On each run, only seeders without a `success` record in the tracking table are executed. The table (`seeders` by default) is auto-created on first run.
+3. If a seeder fails it is recorded as `failed` and retried on the next run; execution continues with the remaining seeders.
+
+## API
+
+All functions take an options object with a live `adapter` and assume your ORM is already connected.
+
+| Function                         | Description                                        | Returns             |
+| -------------------------------- | -------------------------------------------------- | ------------------- |
+| `runPendingSeeders(options?)`    | Runs seeders without a successful tracking record  | `SeederRunResult[]` |
+| `runSeederByName(name, options?)`| Force-runs one seeder, even if already executed    | `SeederRunResult[]` |
+| `getSeederStatuses(options?)`    | Lists `pending`, `success`, and `failed` seeders   | `SeederStatus[]`    |
+| `resetSeeder(name, options?)`    | Deletes the tracking record so a seeder can rerun  | `Promise<void>`     |
+
+## Adapters
+
+Import an adapter from its subpath and build it from your ORM's connection.
+
+| ORM       | Import                   | Factory                                  |
+| --------- | ------------------------ | ---------------------------------------- |
+| Prisma    | `pg-seed-kit/prisma`     | `prismaAdapter(prisma)`                  |
+| Drizzle   | `pg-seed-kit/drizzle`    | `drizzleAdapter(db, { close? })`         |
+| TypeORM   | `pg-seed-kit/typeorm`    | `typeormAdapter(dataSource)`             |
+| Sequelize | `pg-seed-kit/sequelize`  | `sequelizeAdapter(sequelize)`            |
+
+## Config
+
+Config is loaded from `pg-seed-kit.config.js` (or `.cjs`/`.mjs`), the `"pg-seed-kit"` key in `package.json`, or inline options.
+
+| Option        | Type                       | Default        | Description                                          |
+| ------------- | -------------------------- | -------------- | ---------------------------------------------------- |
+| `seedersPath` | `string \| () => string`   | (required)     | Directory containing seeder files                    |
+| `tableName`   | `string`                   | `"seeders"`    | Table used to track execution                        |
+| `filePattern` | `RegExp`                   | `/^\d{14}-.+\.seeder\.(ts\|js\|mjs\|cjs)$/` | Pattern that matches seeder files    |
+| `adapter`     | `Adapter`                  | (none)         | A live adapter, for calling the API from your app    |
+| `connect`     | `() => Promise<Adapter>`   | (none)         | Used by the CLI to open a connection and adapter     |
+
+## CLI
+
+```bash
+npx pg-seed-kit create <name>    # Scaffold a new seeder file
+npx pg-seed-kit status           # List seeders and statuses
+npx pg-seed-kit run              # Run all pending seeders
+npx pg-seed-kit run <name>       # Force-run one seeder by name
+npx pg-seed-kit reset <name>     # Mark a seeder as pending
+```
+
+`status`, `run`, and `reset` use your config's async `connect()` to open a connection, then close it when done. `run` exits non-zero if any seeder fails.
+
+## Contributing
+
+Submit a pull request or open an issue on GitHub.
+
+## License
+
+MIT

package/bin/pg-seed-kit.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/cli/index.js';

package/dist/adapters/drizzle.cjs

@@ -0,0 +1,53 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/adapters/drizzle.ts
+var drizzle_exports = {};
+__export(drizzle_exports, {
+  drizzleAdapter: () => drizzleAdapter
+});
+module.exports = __toCommonJS(drizzle_exports);
+var import_drizzle_orm = require("drizzle-orm");
+function toDrizzleSql(text, params) {
+  const chunks = [];
+  const placeholder = /\$(\d+)/g;
+  let lastIndex = 0;
+  let match;
+  while ((match = placeholder.exec(text)) !== null) {
+    chunks.push(import_drizzle_orm.sql.raw(text.slice(lastIndex, match.index)));
+    chunks.push(import_drizzle_orm.sql`${params[Number(match[1]) - 1]}`);
+    lastIndex = placeholder.lastIndex;
+  }
+  chunks.push(import_drizzle_orm.sql.raw(text.slice(lastIndex)));
+  return import_drizzle_orm.sql.join(chunks);
+}
+function drizzleAdapter(db, options) {
+  return {
+    async query(sqlText, params) {
+      const result = await db.execute(toDrizzleSql(sqlText, params ?? []));
+      const rows = Array.isArray(result) ? result : result.rows;
+      return rows ?? [];
+    },
+    close: options?.close
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  drizzleAdapter
+});

package/dist/adapters/drizzle.d.cts

@@ -0,0 +1,25 @@
+import { SQL } from 'drizzle-orm';
+import { A as Adapter } from '../types-CCBHgrLA.cjs';
+
+/** The subset of a Drizzle database this adapter relies on. */
+interface DrizzleLike {
+    execute(query: SQL): Promise<unknown>;
+}
+/**
+ * Build an {@link Adapter} from a Drizzle database. Tracking SQL is bound through
+ * Drizzle's `sql` template and run with `db.execute`. Because closing the
+ * connection is driver-specific (the pool lives outside the Drizzle instance),
+ * pass `close` to end it from the CLI.
+ *
+ * Targets the `drizzle-orm/node-postgres` driver (result exposes `rows`);
+ * postgres-js returns the rows array directly, which is handled too.
+ *
+ * @example
+ * import { drizzleAdapter } from 'pg-seed-kit/drizzle';
+ * const adapter = drizzleAdapter(db, { close: () => pool.end() });
+ */
+declare function drizzleAdapter(db: DrizzleLike, options?: {
+    close?: () => Promise<void>;
+}): Adapter;
+
+export { type DrizzleLike, drizzleAdapter };

package/dist/adapters/drizzle.d.ts

@@ -0,0 +1,25 @@
+import { SQL } from 'drizzle-orm';
+import { A as Adapter } from '../types-CCBHgrLA.js';
+
+/** The subset of a Drizzle database this adapter relies on. */
+interface DrizzleLike {
+    execute(query: SQL): Promise<unknown>;
+}
+/**
+ * Build an {@link Adapter} from a Drizzle database. Tracking SQL is bound through
+ * Drizzle's `sql` template and run with `db.execute`. Because closing the
+ * connection is driver-specific (the pool lives outside the Drizzle instance),
+ * pass `close` to end it from the CLI.
+ *
+ * Targets the `drizzle-orm/node-postgres` driver (result exposes `rows`);
+ * postgres-js returns the rows array directly, which is handled too.
+ *
+ * @example
+ * import { drizzleAdapter } from 'pg-seed-kit/drizzle';
+ * const adapter = drizzleAdapter(db, { close: () => pool.end() });
+ */
+declare function drizzleAdapter(db: DrizzleLike, options?: {
+    close?: () => Promise<void>;
+}): Adapter;
+
+export { type DrizzleLike, drizzleAdapter };

package/dist/adapters/drizzle.js

@@ -0,0 +1,28 @@
+// src/adapters/drizzle.ts
+import { sql } from "drizzle-orm";
+function toDrizzleSql(text, params) {
+  const chunks = [];
+  const placeholder = /\$(\d+)/g;
+  let lastIndex = 0;
+  let match;
+  while ((match = placeholder.exec(text)) !== null) {
+    chunks.push(sql.raw(text.slice(lastIndex, match.index)));
+    chunks.push(sql`${params[Number(match[1]) - 1]}`);
+    lastIndex = placeholder.lastIndex;
+  }
+  chunks.push(sql.raw(text.slice(lastIndex)));
+  return sql.join(chunks);
+}
+function drizzleAdapter(db, options) {
+  return {
+    async query(sqlText, params) {
+      const result = await db.execute(toDrizzleSql(sqlText, params ?? []));
+      const rows = Array.isArray(result) ? result : result.rows;
+      return rows ?? [];
+    },
+    close: options?.close
+  };
+}
+export {
+  drizzleAdapter
+};

package/dist/adapters/prisma.cjs

@@ -0,0 +1,45 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/adapters/prisma.ts
+var prisma_exports = {};
+__export(prisma_exports, {
+  prismaAdapter: () => prismaAdapter
+});
+module.exports = __toCommonJS(prisma_exports);
+function prismaAdapter(prisma) {
+  return {
+    async query(sql, params) {
+      const values = params ?? [];
+      if (/^\s*(select|with)\b/i.test(sql)) {
+        const rows = await prisma.$queryRawUnsafe(sql, ...values);
+        return rows ?? [];
+      }
+      await prisma.$executeRawUnsafe(sql, ...values);
+      return [];
+    },
+    async close() {
+      await prisma.$disconnect();
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  prismaAdapter
+});

package/dist/adapters/prisma.d.cts

@@ -0,0 +1,22 @@
+import { A as Adapter } from '../types-CCBHgrLA.cjs';
+
+/** The subset of a Prisma client this adapter relies on. */
+interface PrismaClientLike {
+    $queryRawUnsafe(query: string, ...values: unknown[]): Promise<unknown>;
+    $executeRawUnsafe(query: string, ...values: unknown[]): Promise<unknown>;
+    $disconnect(): Promise<unknown>;
+}
+/**
+ * Build an {@link Adapter} from a Prisma client. Prisma splits raw access into
+ * two methods: `$queryRawUnsafe` returns rows (for `SELECT`), `$executeRawUnsafe`
+ * returns an affected-row count (for `INSERT`/`DELETE`/DDL). We route by the
+ * leading keyword so both read and write tracking statements work. Both use
+ * Postgres `$1` positional parameters.
+ *
+ * @example
+ * import { prismaAdapter } from 'pg-seed-kit/prisma';
+ * const adapter = prismaAdapter(prisma);
+ */
+declare function prismaAdapter(prisma: PrismaClientLike): Adapter;
+
+export { type PrismaClientLike, prismaAdapter };

package/dist/adapters/prisma.d.ts

@@ -0,0 +1,22 @@
+import { A as Adapter } from '../types-CCBHgrLA.js';
+
+/** The subset of a Prisma client this adapter relies on. */
+interface PrismaClientLike {
+    $queryRawUnsafe(query: string, ...values: unknown[]): Promise<unknown>;
+    $executeRawUnsafe(query: string, ...values: unknown[]): Promise<unknown>;
+    $disconnect(): Promise<unknown>;
+}
+/**
+ * Build an {@link Adapter} from a Prisma client. Prisma splits raw access into
+ * two methods: `$queryRawUnsafe` returns rows (for `SELECT`), `$executeRawUnsafe`
+ * returns an affected-row count (for `INSERT`/`DELETE`/DDL). We route by the
+ * leading keyword so both read and write tracking statements work. Both use
+ * Postgres `$1` positional parameters.
+ *
+ * @example
+ * import { prismaAdapter } from 'pg-seed-kit/prisma';
+ * const adapter = prismaAdapter(prisma);
+ */
+declare function prismaAdapter(prisma: PrismaClientLike): Adapter;
+
+export { type PrismaClientLike, prismaAdapter };

package/dist/adapters/prisma.js

@@ -0,0 +1,20 @@
+// src/adapters/prisma.ts
+function prismaAdapter(prisma) {
+  return {
+    async query(sql, params) {
+      const values = params ?? [];
+      if (/^\s*(select|with)\b/i.test(sql)) {
+        const rows = await prisma.$queryRawUnsafe(sql, ...values);
+        return rows ?? [];
+      }
+      await prisma.$executeRawUnsafe(sql, ...values);
+      return [];
+    },
+    async close() {
+      await prisma.$disconnect();
+    }
+  };
+}
+export {
+  prismaAdapter
+};

package/dist/adapters/sequelize.cjs

@@ -0,0 +1,41 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/adapters/sequelize.ts
+var sequelize_exports = {};
+__export(sequelize_exports, {
+  sequelizeAdapter: () => sequelizeAdapter
+});
+module.exports = __toCommonJS(sequelize_exports);
+function sequelizeAdapter(sequelize) {
+  return {
+    async query(sql, params) {
+      const result = await sequelize.query(sql, { bind: params });
+      const rows = Array.isArray(result) ? result[0] : result;
+      return rows ?? [];
+    },
+    async close() {
+      await sequelize.close();
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sequelizeAdapter
+});

package/dist/adapters/sequelize.d.cts

@@ -0,0 +1,21 @@
+import { A as Adapter } from '../types-CCBHgrLA.cjs';
+
+/** The subset of a Sequelize instance this adapter relies on. */
+interface SequelizeLike {
+    query(sql: string, options: {
+        bind?: unknown[];
+    }): Promise<unknown>;
+    close(): Promise<unknown>;
+}
+/**
+ * Build an {@link Adapter} from a Sequelize instance. Tracking SQL runs through
+ * `sequelize.query` with `bind`, which uses Postgres `$1` positional parameters.
+ * Sequelize resolves to a `[rows, metadata]` tuple; we return the rows.
+ *
+ * @example
+ * import { sequelizeAdapter } from 'pg-seed-kit/sequelize';
+ * const adapter = sequelizeAdapter(sequelize);
+ */
+declare function sequelizeAdapter(sequelize: SequelizeLike): Adapter;
+
+export { type SequelizeLike, sequelizeAdapter };

package/dist/adapters/sequelize.d.ts

@@ -0,0 +1,21 @@
+import { A as Adapter } from '../types-CCBHgrLA.js';
+
+/** The subset of a Sequelize instance this adapter relies on. */
+interface SequelizeLike {
+    query(sql: string, options: {
+        bind?: unknown[];
+    }): Promise<unknown>;
+    close(): Promise<unknown>;
+}
+/**
+ * Build an {@link Adapter} from a Sequelize instance. Tracking SQL runs through
+ * `sequelize.query` with `bind`, which uses Postgres `$1` positional parameters.
+ * Sequelize resolves to a `[rows, metadata]` tuple; we return the rows.
+ *
+ * @example
+ * import { sequelizeAdapter } from 'pg-seed-kit/sequelize';
+ * const adapter = sequelizeAdapter(sequelize);
+ */
+declare function sequelizeAdapter(sequelize: SequelizeLike): Adapter;
+
+export { type SequelizeLike, sequelizeAdapter };

package/dist/adapters/sequelize.js

@@ -0,0 +1,16 @@
+// src/adapters/sequelize.ts
+function sequelizeAdapter(sequelize) {
+  return {
+    async query(sql, params) {
+      const result = await sequelize.query(sql, { bind: params });
+      const rows = Array.isArray(result) ? result[0] : result;
+      return rows ?? [];
+    },
+    async close() {
+      await sequelize.close();
+    }
+  };
+}
+export {
+  sequelizeAdapter
+};

package/dist/adapters/typeorm.cjs

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/adapters/typeorm.ts
+var typeorm_exports = {};
+__export(typeorm_exports, {
+  typeormAdapter: () => typeormAdapter
+});
+module.exports = __toCommonJS(typeorm_exports);
+function typeormAdapter(dataSource) {
+  return {
+    async query(sql, params) {
+      const rows = await dataSource.query(sql, params);
+      return rows ?? [];
+    },
+    async close() {
+      await dataSource.destroy();
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  typeormAdapter
+});

package/dist/adapters/typeorm.d.cts

@@ -0,0 +1,18 @@
+import { A as Adapter } from '../types-CCBHgrLA.cjs';
+
+/** The subset of a TypeORM `DataSource` this adapter relies on. */
+interface TypeOrmDataSourceLike {
+    query(query: string, parameters?: unknown[]): Promise<unknown>;
+    destroy(): Promise<unknown>;
+}
+/**
+ * Build an {@link Adapter} from a TypeORM `DataSource`. Tracking SQL runs through
+ * `dataSource.query`, which uses Postgres `$1` positional parameters.
+ *
+ * @example
+ * import { typeormAdapter } from 'pg-seed-kit/typeorm';
+ * const adapter = typeormAdapter(dataSource);
+ */
+declare function typeormAdapter(dataSource: TypeOrmDataSourceLike): Adapter;
+
+export { type TypeOrmDataSourceLike, typeormAdapter };

package/dist/adapters/typeorm.d.ts

@@ -0,0 +1,18 @@
+import { A as Adapter } from '../types-CCBHgrLA.js';
+
+/** The subset of a TypeORM `DataSource` this adapter relies on. */
+interface TypeOrmDataSourceLike {
+    query(query: string, parameters?: unknown[]): Promise<unknown>;
+    destroy(): Promise<unknown>;
+}
+/**
+ * Build an {@link Adapter} from a TypeORM `DataSource`. Tracking SQL runs through
+ * `dataSource.query`, which uses Postgres `$1` positional parameters.
+ *
+ * @example
+ * import { typeormAdapter } from 'pg-seed-kit/typeorm';
+ * const adapter = typeormAdapter(dataSource);
+ */
+declare function typeormAdapter(dataSource: TypeOrmDataSourceLike): Adapter;
+
+export { type TypeOrmDataSourceLike, typeormAdapter };

package/dist/adapters/typeorm.js

@@ -0,0 +1,15 @@
+// src/adapters/typeorm.ts
+function typeormAdapter(dataSource) {
+  return {
+    async query(sql, params) {
+      const rows = await dataSource.query(sql, params);
+      return rows ?? [];
+    },
+    async close() {
+      await dataSource.destroy();
+    }
+  };
+}
+export {
+  typeormAdapter
+};