@geekmidas/testkit 10.0.0-alpha.4 → 10.0.0-alpha.41

package/dist/transactions.d.cts

@@ -0,0 +1,44 @@
+import { Kysely, KyselyConfig } from "kysely";
+//#region src/transactions.d.ts
+/** How to reach one database: a URL, and its search path as a startup option. */
+export interface ConnectionConfig {
+  connectionString: string;
+  options?: string;
+}
+/**
+ * The connection settings for a database URL.
+ *
+ * `?search_path=` is not a libpq parameter: a URL carrying it connects and then
+ * resolves every name against `public`. Postgres takes it as a startup option,
+ * which is what a schema tenant's URL needs to reach its own tables.
+ */
+export declare function connectionConfig(url: string): ConnectionConfig;
+/** One database's connection, inside a transaction the test will roll back. */
+export interface BoundTransaction {
+  /** Everything queried through this runs inside the test's transaction. */
+  readonly db: Kysely<any>;
+  /** Undo everything, and let the connection go. */
+  rollback(): Promise<void>;
+}
+/**
+ * Open a connection to `url` and begin the transaction a test will roll back.
+ *
+ * `config` is what the database's own clients are built with — its plugins
+ * above all. The code under test is handed this Kysely in place of its own, so
+ * one built without them runs different queries than production does.
+ */
+export declare function openBoundTransaction(url: string, config?: Omit<KyselyConfig, 'dialect'>): Promise<BoundTransaction>;
+/**
+ * The transactions one test has opened, by database.
+ *
+ * `get` opens a database's transaction the first time it is asked for and
+ * hands back the same one after that — including to a caller that asks while
+ * it is still opening. `rollbackAll` ends every one of them.
+ */
+export declare class TransactionRegistry<TKey = string> {
+  private readonly open;
+  get(key: TKey, url: string, config?: Omit<KyselyConfig, 'dialect'>): Promise<Kysely<any>>;
+  rollbackAll(): Promise<void>;
+}
+//#endregion
+//# sourceMappingURL=transactions.d.cts.map

package/dist/transactions.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transactions.d.cts","names":[],"sources":["../src/transactions.ts"],"mappings":";;;iBAqBiB;EAChB;EACA;;;;;;;;;wBAUe,iBAAiB,cAAc;;iBAa9B;;WAEP,IAAI;;EAEb,YAAY;;;;;;;;;wBAUS,qBACrB,aACA,SAAQ,KAAK,2BACX,QAAQ;;;;;;;;qBAoEE,oBAAoB;mBACf;EAEjB,IACC,KAAK,MACL,aACA,SAAS,KAAK,2BACZ,QAAQ;EASL,eAAe"}

package/dist/transactions.d.mts

@@ -0,0 +1,44 @@
+import { Kysely, KyselyConfig } from "kysely";
+//#region src/transactions.d.ts
+/** How to reach one database: a URL, and its search path as a startup option. */
+export interface ConnectionConfig {
+  connectionString: string;
+  options?: string;
+}
+/**
+ * The connection settings for a database URL.
+ *
+ * `?search_path=` is not a libpq parameter: a URL carrying it connects and then
+ * resolves every name against `public`. Postgres takes it as a startup option,
+ * which is what a schema tenant's URL needs to reach its own tables.
+ */
+export declare function connectionConfig(url: string): ConnectionConfig;
+/** One database's connection, inside a transaction the test will roll back. */
+export interface BoundTransaction {
+  /** Everything queried through this runs inside the test's transaction. */
+  readonly db: Kysely<any>;
+  /** Undo everything, and let the connection go. */
+  rollback(): Promise<void>;
+}
+/**
+ * Open a connection to `url` and begin the transaction a test will roll back.
+ *
+ * `config` is what the database's own clients are built with — its plugins
+ * above all. The code under test is handed this Kysely in place of its own, so
+ * one built without them runs different queries than production does.
+ */
+export declare function openBoundTransaction(url: string, config?: Omit<KyselyConfig, 'dialect'>): Promise<BoundTransaction>;
+/**
+ * The transactions one test has opened, by database.
+ *
+ * `get` opens a database's transaction the first time it is asked for and
+ * hands back the same one after that — including to a caller that asks while
+ * it is still opening. `rollbackAll` ends every one of them.
+ */
+export declare class TransactionRegistry<TKey = string> {
+  private readonly open;
+  get(key: TKey, url: string, config?: Omit<KyselyConfig, 'dialect'>): Promise<Kysely<any>>;
+  rollbackAll(): Promise<void>;
+}
+//#endregion
+//# sourceMappingURL=transactions.d.mts.map

package/dist/transactions.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transactions.d.mts","names":[],"sources":["../src/transactions.ts"],"mappings":";;;iBAqBiB;EAChB;EACA;;;;;;;;;wBAUe,iBAAiB,cAAc;;iBAa9B;;WAEP,IAAI;;EAEb,YAAY;;;;;;;;;wBAUS,qBACrB,aACA,SAAQ,KAAK,2BACX,QAAQ;;;;;;;;qBAoEE,oBAAoB;mBACf;EAEjB,IACC,KAAK,MACL,aACA,SAAS,KAAK,2BACZ,QAAQ;EASL,eAAe"}

package/dist/transactions.mjs

@@ -0,0 +1,118 @@
+import pg from "pg";
+import { Kysely, PostgresDialect } from "kysely";
+//#region src/transactions.ts
+/**
+* A transaction per database, per test — as each runs deployed.
+*
+* An app's database and a schema tenant such as the auth server's are separate
+* databases to the code using them: separate connections, credentials, roles
+* and search paths. A test keeps them that way. Each gets its own connection,
+* opened into a transaction the first time the test touches it, and every one
+* is rolled back when the test ends.
+*
+* Code under test must be free to use transactions itself, and better-auth
+* does — it also calls `db.connection()`, which Kysely refuses on a
+* `Transaction`. So what a test hands over is not a `Transaction` but a Kysely
+* over the one connection already inside the test's transaction, on which a
+* `BEGIN` becomes a savepoint and a `COMMIT` releases it. Nothing the code does
+* can end the transaction the test will roll back.
+*/
+/**
+* The connection settings for a database URL.
+*
+* `?search_path=` is not a libpq parameter: a URL carrying it connects and then
+* resolves every name against `public`. Postgres takes it as a startup option,
+* which is what a schema tenant's URL needs to reach its own tables.
+*/
+function connectionConfig(url) {
+	const parsed = new URL(url);
+	const searchPath = parsed.searchParams.get("search_path");
+	if (!searchPath) return { connectionString: url };
+	parsed.searchParams.delete("search_path");
+	return {
+		connectionString: parsed.toString(),
+		options: `-c search_path=${searchPath}`
+	};
+}
+/**
+* Open a connection to `url` and begin the transaction a test will roll back.
+*
+* `config` is what the database's own clients are built with — its plugins
+* above all. The code under test is handed this Kysely in place of its own, so
+* one built without them runs different queries than production does.
+*/
+async function openBoundTransaction(url, config = {}) {
+	const client = new pg.Client(connectionConfig(url));
+	await client.connect();
+	await client.query("BEGIN");
+	return {
+		db: new Kysely({
+			...config,
+			dialect: new PostgresDialect({ pool: {
+				connect: async () => savepointing(client),
+				end: async () => {}
+			} })
+		}),
+		async rollback() {
+			try {
+				await client.query("ROLLBACK");
+			} finally {
+				await client.end();
+			}
+		}
+	};
+}
+/**
+* The client, with transaction control turned into savepoints.
+*
+* Kysely issues `begin`/`commit`/`rollback` as plain statements; this is the
+* one place they can be caught. A depth counter names the savepoints, so
+* nested transactions nest.
+*/
+function savepointing(client) {
+	let depth = 0;
+	const query = client.query.bind(client);
+	const wrapped = Object.create(client);
+	Object.assign(wrapped, {
+		query: (text, ...rest) => {
+			const statement = typeof text === "string" ? text.trim().toLowerCase() : void 0;
+			if (statement === "begin" || statement?.startsWith("start transaction")) {
+				depth++;
+				return query(`SAVEPOINT test_sp_${depth}`);
+			}
+			if (statement === "commit") return query(`RELEASE SAVEPOINT test_sp_${depth--}`);
+			if (statement === "rollback") return query(`ROLLBACK TO SAVEPOINT test_sp_${depth--}`);
+			return query(text, ...rest);
+		},
+		release: () => {}
+	});
+	return wrapped;
+}
+/**
+* The transactions one test has opened, by database.
+*
+* `get` opens a database's transaction the first time it is asked for and
+* hands back the same one after that — including to a caller that asks while
+* it is still opening. `rollbackAll` ends every one of them.
+*/
+var TransactionRegistry = class {
+	open = /* @__PURE__ */ new Map();
+	get(key, url, config) {
+		let transaction = this.open.get(key);
+		if (!transaction) {
+			transaction = openBoundTransaction(url, config);
+			this.open.set(key, transaction);
+		}
+		return transaction.then(({ db }) => db);
+	}
+	async rollbackAll() {
+		const transactions = [...this.open.values()];
+		this.open.clear();
+		const failed = (await Promise.allSettled(transactions.map(async (transaction) => (await transaction).rollback()))).find((result) => result.status === "rejected");
+		if (failed) throw failed.reason;
+	}
+};
+//#endregion
+export { TransactionRegistry, connectionConfig, openBoundTransaction };
+
+//# sourceMappingURL=transactions.mjs.map

package/dist/transactions.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"transactions.mjs","names":[],"sources":["../src/transactions.ts"],"sourcesContent":["/**\n * A transaction per database, per test — as each runs deployed.\n *\n * An app's database and a schema tenant such as the auth server's are separate\n * databases to the code using them: separate connections, credentials, roles\n * and search paths. A test keeps them that way. Each gets its own connection,\n * opened into a transaction the first time the test touches it, and every one\n * is rolled back when the test ends.\n *\n * Code under test must be free to use transactions itself, and better-auth\n * does — it also calls `db.connection()`, which Kysely refuses on a\n * `Transaction`. So what a test hands over is not a `Transaction` but a Kysely\n * over the one connection already inside the test's transaction, on which a\n * `BEGIN` becomes a savepoint and a `COMMIT` releases it. Nothing the code does\n * can end the transaction the test will roll back.\n */\n\nimport { Kysely, type KyselyConfig, PostgresDialect } from 'kysely';\nimport pg from 'pg';\n\n/** How to reach one database: a URL, and its search path as a startup option. */\nexport interface ConnectionConfig {\n\tconnectionString: string;\n\toptions?: string;\n}\n\n/**\n * The connection settings for a database URL.\n *\n * `?search_path=` is not a libpq parameter: a URL carrying it connects and then\n * resolves every name against `public`. Postgres takes it as a startup option,\n * which is what a schema tenant's URL needs to reach its own tables.\n */\nexport function connectionConfig(url: string): ConnectionConfig {\n\tconst parsed = new URL(url);\n\tconst searchPath = parsed.searchParams.get('search_path');\n\tif (!searchPath) return { connectionString: url };\n\n\tparsed.searchParams.delete('search_path');\n\treturn {\n\t\tconnectionString: parsed.toString(),\n\t\toptions: `-c search_path=${searchPath}`,\n\t};\n}\n\n/** One database's connection, inside a transaction the test will roll back. */\nexport interface BoundTransaction {\n\t/** Everything queried through this runs inside the test's transaction. */\n\treadonly db: Kysely<any>;\n\t/** Undo everything, and let the connection go. */\n\trollback(): Promise<void>;\n}\n\n/**\n * Open a connection to `url` and begin the transaction a test will roll back.\n *\n * `config` is what the database's own clients are built with — its plugins\n * above all. The code under test is handed this Kysely in place of its own, so\n * one built without them runs different queries than production does.\n */\nexport async function openBoundTransaction(\n\turl: string,\n\tconfig: Omit<KyselyConfig, 'dialect'> = {},\n): Promise<BoundTransaction> {\n\tconst client = new pg.Client(connectionConfig(url));\n\tawait client.connect();\n\tawait client.query('BEGIN');\n\n\treturn {\n\t\tdb: new Kysely({\n\t\t\t...config,\n\t\t\tdialect: new PostgresDialect({\n\t\t\t\t// A \"pool\" of the one connection. Released never, ended never: the\n\t\t\t\t// test owns it, and it closes in `rollback`.\n\t\t\t\tpool: {\n\t\t\t\t\tconnect: async () => savepointing(client),\n\t\t\t\t\tend: async () => {},\n\t\t\t\t} as unknown as pg.Pool,\n\t\t\t}),\n\t\t}),\n\t\tasync rollback() {\n\t\t\ttry {\n\t\t\t\tawait client.query('ROLLBACK');\n\t\t\t} finally {\n\t\t\t\tawait client.end();\n\t\t\t}\n\t\t},\n\t};\n}\n\n/**\n * The client, with transaction control turned into savepoints.\n *\n * Kysely issues `begin`/`commit`/`rollback` as plain statements; this is the\n * one place they can be caught. A depth counter names the savepoints, so\n * nested transactions nest.\n */\nfunction savepointing(client: pg.Client): pg.PoolClient {\n\tlet depth = 0;\n\tconst query = client.query.bind(client) as (...args: unknown[]) => unknown;\n\n\tconst wrapped = Object.create(client) as pg.PoolClient;\n\tObject.assign(wrapped, {\n\t\tquery: (text: unknown, ...rest: unknown[]) => {\n\t\t\tconst statement =\n\t\t\t\ttypeof text === 'string' ? text.trim().toLowerCase() : undefined;\n\n\t\t\tif (statement === 'begin' || statement?.startsWith('start transaction')) {\n\t\t\t\tdepth++;\n\t\t\t\treturn query(`SAVEPOINT test_sp_${depth}`);\n\t\t\t}\n\t\t\tif (statement === 'commit') {\n\t\t\t\treturn query(`RELEASE SAVEPOINT test_sp_${depth--}`);\n\t\t\t}\n\t\t\tif (statement === 'rollback') {\n\t\t\t\treturn query(`ROLLBACK TO SAVEPOINT test_sp_${depth--}`);\n\t\t\t}\n\t\t\treturn query(text, ...rest);\n\t\t},\n\t\trelease: () => {},\n\t});\n\treturn wrapped;\n}\n\n/**\n * The transactions one test has opened, by database.\n *\n * `get` opens a database's transaction the first time it is asked for and\n * hands back the same one after that — including to a caller that asks while\n * it is still opening. `rollbackAll` ends every one of them.\n */\nexport class TransactionRegistry<TKey = string> {\n\tprivate readonly open = new Map<TKey, Promise<BoundTransaction>>();\n\n\tget(\n\t\tkey: TKey,\n\t\turl: string,\n\t\tconfig?: Omit<KyselyConfig, 'dialect'>,\n\t): Promise<Kysely<any>> {\n\t\tlet transaction = this.open.get(key);\n\t\tif (!transaction) {\n\t\t\ttransaction = openBoundTransaction(url, config);\n\t\t\tthis.open.set(key, transaction);\n\t\t}\n\t\treturn transaction.then(({ db }) => db);\n\t}\n\n\tasync rollbackAll(): Promise<void> {\n\t\tconst transactions = [...this.open.values()];\n\t\tthis.open.clear();\n\n\t\tconst results = await Promise.allSettled(\n\t\t\ttransactions.map(async (transaction) => (await transaction).rollback()),\n\t\t);\n\t\tconst failed = results.find(\n\t\t\t(result): result is PromiseRejectedResult => result.status === 'rejected',\n\t\t);\n\t\tif (failed) throw failed.reason;\n\t}\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,SAAgB,iBAAiB,KAA+B;CAC/D,MAAM,SAAS,IAAI,IAAI,GAAG;CAC1B,MAAM,aAAa,OAAO,aAAa,IAAI,aAAa;CACxD,IAAI,CAAC,YAAY,OAAO,EAAE,kBAAkB,IAAI;CAEhD,OAAO,aAAa,OAAO,aAAa;CACxC,OAAO;EACN,kBAAkB,OAAO,SAAS;EAClC,SAAS,kBAAkB;CAC5B;AACD;;;;;;;;AAiBA,eAAsB,qBACrB,KACA,SAAwC,CAAC,GACb;CAC5B,MAAM,SAAS,IAAI,GAAG,OAAO,iBAAiB,GAAG,CAAC;CAClD,MAAM,OAAO,QAAQ;CACrB,MAAM,OAAO,MAAM,OAAO;CAE1B,OAAO;EACN,IAAI,IAAI,OAAO;GACd,GAAG;GACH,SAAS,IAAI,gBAAgB,EAG5B,MAAM;IACL,SAAS,YAAY,aAAa,MAAM;IACxC,KAAK,YAAY,CAAC;GACnB,EACD,CAAC;EACF,CAAC;EACD,MAAM,WAAW;GAChB,IAAI;IACH,MAAM,OAAO,MAAM,UAAU;GAC9B,UAAU;IACT,MAAM,OAAO,IAAI;GAClB;EACD;CACD;AACD;;;;;;;;AASA,SAAS,aAAa,QAAkC;CACvD,IAAI,QAAQ;CACZ,MAAM,QAAQ,OAAO,MAAM,KAAK,MAAM;CAEtC,MAAM,UAAU,OAAO,OAAO,MAAM;CACpC,OAAO,OAAO,SAAS;EACtB,QAAQ,MAAe,GAAG,SAAoB;GAC7C,MAAM,YACL,OAAO,SAAS,WAAW,KAAK,KAAK,CAAC,CAAC,YAAY,IAAI,KAAA;GAExD,IAAI,cAAc,WAAW,WAAW,WAAW,mBAAmB,GAAG;IACxE;IACA,OAAO,MAAM,qBAAqB,OAAO;GAC1C;GACA,IAAI,cAAc,UACjB,OAAO,MAAM,6BAA6B,SAAS;GAEpD,IAAI,cAAc,YACjB,OAAO,MAAM,iCAAiC,SAAS;GAExD,OAAO,MAAM,MAAM,GAAG,IAAI;EAC3B;EACA,eAAe,CAAC;CACjB,CAAC;CACD,OAAO;AACR;;;;;;;;AASA,IAAa,sBAAb,MAAgD;CAC/C,uBAAwB,IAAI,IAAqC;CAEjE,IACC,KACA,KACA,QACuB;EACvB,IAAI,cAAc,KAAK,KAAK,IAAI,GAAG;EACnC,IAAI,CAAC,aAAa;GACjB,cAAc,qBAAqB,KAAK,MAAM;GAC9C,KAAK,KAAK,IAAI,KAAK,WAAW;EAC/B;EACA,OAAO,YAAY,MAAM,EAAE,SAAS,EAAE;CACvC;CAEA,MAAM,cAA6B;EAClC,MAAM,eAAe,CAAC,GAAG,KAAK,KAAK,OAAO,CAAC;EAC3C,KAAK,KAAK,MAAM;EAKhB,MAAM,UAAS,MAHO,QAAQ,WAC7B,aAAa,IAAI,OAAO,iBAAiB,MAAM,YAAA,CAAa,SAAS,CAAC,CACvE,EAAA,CACuB,MACrB,WAA4C,OAAO,WAAW,UAChE;EACA,IAAI,QAAQ,MAAM,OAAO;CAC1B;AACD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/testkit",
-  "version": "10.0.0-alpha.4",
+  "version": "10.0.0-alpha.41",
   "private": false,
   "type": "module",
   "exports": {
@@ -113,6 +113,46 @@
         "types": "./dist/requestContext.d.cts",
         "default": "./dist/requestContext.cjs"
       }
+    },
+    "./browser": {
+      "import": {
+        "types": "./dist/browser.d.mts",
+        "default": "./dist/browser.mjs"
+      },
+      "require": {
+        "types": "./dist/browser.d.cts",
+        "default": "./dist/browser.cjs"
+      }
+    },
+    "./context": {
+      "import": {
+        "types": "./dist/context.d.mts",
+        "default": "./dist/context.mjs"
+      },
+      "require": {
+        "types": "./dist/context.d.cts",
+        "default": "./dist/context.cjs"
+      }
+    },
+    "./mailbox": {
+      "import": {
+        "types": "./dist/mailbox.d.mts",
+        "default": "./dist/mailbox.mjs"
+      },
+      "require": {
+        "types": "./dist/mailbox.d.cts",
+        "default": "./dist/mailbox.cjs"
+      }
+    },
+    "./transactions": {
+      "import": {
+        "types": "./dist/transactions.d.mts",
+        "default": "./dist/transactions.mjs"
+      },
+      "require": {
+        "types": "./dist/transactions.d.cts",
+        "default": "./dist/transactions.cjs"
+      }
     }
   },
   "files": [
@@ -120,15 +160,18 @@
   ],
   "dependencies": {
     "@faker-js/faker": "~10.6.0",
-    "@geekmidas/envkit": "^10.0.0-alpha.4",
-    "@geekmidas/services": "^10.0.0-alpha.4",
-    "@geekmidas/logger": "^10.0.0-alpha.4"
+    "tough-cookie": "~6.0.2",
+    "@geekmidas/envkit": "^10.0.0-alpha.41",
+    "@geekmidas/logger": "^10.0.0-alpha.41",
+    "@geekmidas/services": "^10.0.0-alpha.41"
   },
   "devDependencies": {
+    "@better-auth/test-utils": "~1.7.6",
     "@types/pg": "~8.23.1",
-    "@geekmidas/envkit": "^10.0.0-alpha.4",
-    "@geekmidas/logger": "^10.0.0-alpha.4",
-    "@geekmidas/services": "^10.0.0-alpha.4"
+    "better-auth": "~1.7.6",
+    "@geekmidas/envkit": "^10.0.0-alpha.41",
+    "@geekmidas/logger": "^10.0.0-alpha.41",
+    "@geekmidas/services": "^10.0.0-alpha.41"
   },
   "repository": {
     "type": "git",
@@ -144,7 +187,7 @@
     "knex": ">=3.3.0",
     "objection": ">=3.1.5",
     "db-errors": "~0.2.3",
-    "vitest": "~3.2.4",
+    "vitest": "~5.0.2",
     "@types/aws-lambda": ">=8.10.163",
     "better-auth": ">=1.7.5"
   },

package/dist/Factory-AWn1IulI.d.cts

@@ -1,147 +0,0 @@
-import { FakerFactory } from "./faker-DvxiCtxc.cjs";
-
-//#region src/Factory.d.ts
-
-/**
- * Abstract base class for database factories used in testing.
- * Provides a standardized interface for creating test data using builder and seed patterns.
- *
- * @template Builders - Record of builder functions for creating individual entities
- * @template Seeds - Record of seed functions for creating complex test scenarios
- *
- * @example
- * ```typescript
- * // Define builders for creating individual records
- * const builders = {
- *   user: (attrs) => ({ name: 'Test User', email: 'test@example.com', ...attrs }),
- *   post: (attrs) => ({ title: 'Test Post', content: 'Content', ...attrs })
- * };
- *
- * // Define seeds for complex scenarios
- * const seeds = {
- *   userWithPosts: async (attrs, factory) => {
- *     const user = await factory.insert('user', attrs);
- *     await factory.insertMany(3, 'post', { userId: user.id });
- *     return user;
- *   }
- * };
- * ```
- */
-declare abstract class Factory<Builders extends Record<string, any>, Seeds extends Record<string, any>> {
-  /**
-   * Creates a typed seed function with proper type inference.
-   * This is a utility method to help with TypeScript type checking when defining seeds.
-   *
-   * @template Seed - The seed function type
-   * @param seedFn - The seed function to wrap
-   * @returns The same seed function with proper typing
-   *
-   * @example
-   * ```typescript
-   * const userWithPostsSeed = Factory.createSeed(async ({ attrs, factory, db }) => {
-   *   const user = await factory.insert('user', attrs);
-   *   return user;
-   * });
-   * ```
-   */
-  static createSeed<Seed extends FactorySeed>(seedFn: Seed): Seed;
-  /**
-   * Inserts an object into the database using a builder function.
-   *
-   * @param builderName - The name of the builder to use
-   * @param attrs - The attributes to insert
-   */
-  abstract insert<K extends keyof Builders>(builderName: K, attrs?: Parameters<Builders[K]>[0]): Promise<Awaited<ReturnType<Builders[K]>>>;
-  /**
-   * Inserts multiple objects into the database
-   *
-   * @param count -  Number of objects to insert
-   * @param builderName - The name of the builder to use
-   * @param attrs - The attributes to insert
-   */
-  abstract insertMany<K extends keyof Builders>(count: number, builderName: K, attrs?: Parameters<Builders[K]>[0] | ((idx: number, faker: FakerFactory) => Promise<Parameters<Builders[K]>[0]>)): Promise<Awaited<ReturnType<Builders[K]>>[]>;
-  /**
-   * Seeds the database using a seed function.
-   *
-   * @param seedName - The name of the seed to use
-   * @returns The result of the seed function
-   * @param attrs - The attributes to pass to the seed function
-   */
-  abstract seed<K extends keyof Seeds>(seedName: K, attrs?: ExtractSeedAttrs<Seeds[K]>): ReturnType<Seeds[K]>;
-}
-/**
- * Type definition for a factory builder function that can work with different database types.
- * Builders are responsible for creating individual database records with default values and relationships.
- *
- * @template Attrs - The attributes/input type for the builder
- * @template Factory - The factory instance type
- * @template Result - The type of object returned by the builder
- * @template DB - The database connection type (Kysely, Knex, etc.)
- *
- * @param attrs - Partial attributes to override defaults
- * @param factory - The factory instance for creating related records
- * @param db - The database connection
- * @returns The created record or a promise resolving to it
- *
- * @example
- * ```typescript
- * const userBuilder: MixedFactoryBuilder<UserAttrs, Factory, User, Kysely<DB>> =
- *   async (attrs, factory, db) => {
- *     return {
- *       id: faker.string.uuid(),
- *       name: faker.person.fullName(),
- *       email: faker.internet.email(),
- *       ...attrs
- *     };
- *   };
- * ```
- */
-type MixedFactoryBuilder<Attrs = any, Factory = any, Result = any, DB = any> = (attrs: Attrs, factory: Factory, db: DB) => Result | Promise<Result>;
-/**
- * Type definition for a factory seed function used to create complex test scenarios.
- * Seeds typically create multiple related records to set up a complete test environment.
- *
- * @template Attrs - The attributes/input type for the seed
- * @template Factory - The factory instance type
- * @template Result - The type of object returned by the seed
- * @template DB - The database connection type (Kysely, Knex, etc.)
- *
- * @param context - Object containing attrs, factory, and db
- * @param context.attrs - Configuration attributes for the seed
- * @param context.factory - The factory instance for creating records
- * @param context.db - The database connection
- * @returns A promise resolving to the seed result
- *
- * @example
- * ```typescript
- * const userWithPostsSeed: FactorySeed<{ postCount?: number }, Factory, User, DB> =
- *   async ({ attrs, factory, db }) => {
- *     const user = await factory.insert('user', attrs);
- *     const postCount = attrs.postCount || 3;
- *
- *     for (let i = 0; i < postCount; i++) {
- *       await factory.insert('post', { userId: user.id });
- *     }
- *
- *     return user;
- *   };
- * ```
- */
-type FactorySeed<Attrs = any, Factory = any, Result = any, DB = any> = (context: {
-  attrs: Attrs;
-  factory: Factory;
-  db: DB;
-}) => Promise<Result>;
-/**
- * Helper type to extract the Attrs type from a FactorySeed function.
- * Used internally by Factory implementations to correctly type the seed method parameters.
- */
-type ExtractSeedAttrs<T> = T extends ((context: {
-  attrs: infer A;
-  factory: any;
-  db: any;
-}) => any) ? A : never;
-//# sourceMappingURL=Factory.d.ts.map
-//#endregion
-export { ExtractSeedAttrs, Factory, FactorySeed, MixedFactoryBuilder };
-//# sourceMappingURL=Factory-AWn1IulI.d.cts.map

package/dist/Factory-AWn1IulI.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Factory-AWn1IulI.d.cts","names":[],"sources":["../src/Factory.ts"],"sourcesContent":[],"mappings":";;;;;;AA2BA;;;;;;;;;;;;;;;;;;;;;;;AAiD6B,uBAjDP,OAiDO,CAAA,iBAhDX,MAgDW,CAAA,MAAA,EAAA,GAAA,CAAA,EAAA,cA/Cd,MA+Cc,CAAA,MAAA,EAAA,GAAA,CAAA,CAAA,CAAA;EAAQ;;;;;;;;;;;;;;;;EAavB,OAAA,UAAA,CAAA,aA1CkB,WA0ClB,CAAA,CAAA,MAAA,EA1CuC,IA0CvC,CAAA,EA1C8C,IA0C9C;EA8BF;;;;;;EAK0C,SAAW,MAAA,CAAA,UAAA,MApEhC,QAoEgC,CAAA,CAAA,WAAA,EAnElD,CAmEkD,EAAA,KAAA,CAAA,EAlEvD,UAkEuD,CAlE5C,QAkE4C,CAlEnC,CAkEmC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EAjE7D,OAiE6D,CAjErD,OAiEqD,CAjE7C,UAiE6C,CAjElC,QAiEkC,CAjEzB,CAiEyB,CAAA,CAAA,CAAA,CAAA;EAAM;AAAP;AAgChE;;;;;EAKsD,SAAe,UAAA,CAAA,UAAA,MA7FhC,QA6FgC,CAAA,CAAA,KAAA,EAAA,MAAA,EAAA,WAAA,EA3FtD,CA2FsD,EAAA,KAAA,CAAA,EAzFhE,UAyFgE,CAzFrD,QAyFqD,CAzF5C,CAyF4C,CAAA,CAAA,CAAA,CAAA,CAAA,GAAA,CAAA,CAAA,GAAA,EAAA,MAAA,EAAA,KAAA,EAtFzD,YAsFyD,EAAA,GArF3D,OAqF2D,CArFnD,UAqFmD,CArFxC,QAqFwC,CArF/B,CAqF+B,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EApFjE,OAoFiE,CApFzD,OAoFyD,CApFjD,UAoFiD,CApFtC,QAoFsC,CApF7B,CAoF6B,CAAA,CAAA,CAAA,EAAA,CAAA;EAAM;AAAP;AAMpE;;;;AAKI;gCAtF2B,iBACnB,WACF,iBAAiB,MAAM,MAC7B,WAAW,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA8BT,kFAKA,gBAAgB,aAAa,OAAO,SAAS,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgCrD;SAKW;WAAgB;MAAa;MAAS,QAAQ;;;;;KAMzD,sBAAsB;;;;aAK/B"}

package/dist/Factory-BFVnMMCC.mjs

@@ -1,51 +0,0 @@
-//#region src/Factory.ts
-/**
-* Abstract base class for database factories used in testing.
-* Provides a standardized interface for creating test data using builder and seed patterns.
-*
-* @template Builders - Record of builder functions for creating individual entities
-* @template Seeds - Record of seed functions for creating complex test scenarios
-*
-* @example
-* ```typescript
-* // Define builders for creating individual records
-* const builders = {
-*   user: (attrs) => ({ name: 'Test User', email: 'test@example.com', ...attrs }),
-*   post: (attrs) => ({ title: 'Test Post', content: 'Content', ...attrs })
-* };
-*
-* // Define seeds for complex scenarios
-* const seeds = {
-*   userWithPosts: async (attrs, factory) => {
-*     const user = await factory.insert('user', attrs);
-*     await factory.insertMany(3, 'post', { userId: user.id });
-*     return user;
-*   }
-* };
-* ```
-*/
-var Factory = class {
-	/**
-	* Creates a typed seed function with proper type inference.
-	* This is a utility method to help with TypeScript type checking when defining seeds.
-	*
-	* @template Seed - The seed function type
-	* @param seedFn - The seed function to wrap
-	* @returns The same seed function with proper typing
-	*
-	* @example
-	* ```typescript
-	* const userWithPostsSeed = Factory.createSeed(async ({ attrs, factory, db }) => {
-	*   const user = await factory.insert('user', attrs);
-	*   return user;
-	* });
-	* ```
-	*/
-	static createSeed(seedFn) {
-		return seedFn;
-	}
-};
-
-//#endregion
-export { Factory };
-//# sourceMappingURL=Factory-BFVnMMCC.mjs.map

package/dist/Factory-BFVnMMCC.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"Factory-BFVnMMCC.mjs","names":["seedFn: Seed"],"sources":["../src/Factory.ts"],"sourcesContent":["import type { FakerFactory } from './faker';\n\n/**\n * Abstract base class for database factories used in testing.\n * Provides a standardized interface for creating test data using builder and seed patterns.\n *\n * @template Builders - Record of builder functions for creating individual entities\n * @template Seeds - Record of seed functions for creating complex test scenarios\n *\n * @example\n * ```typescript\n * // Define builders for creating individual records\n * const builders = {\n *   user: (attrs) => ({ name: 'Test User', email: 'test@example.com', ...attrs }),\n *   post: (attrs) => ({ title: 'Test Post', content: 'Content', ...attrs })\n * };\n *\n * // Define seeds for complex scenarios\n * const seeds = {\n *   userWithPosts: async (attrs, factory) => {\n *     const user = await factory.insert('user', attrs);\n *     await factory.insertMany(3, 'post', { userId: user.id });\n *     return user;\n *   }\n * };\n * ```\n */\nexport abstract class Factory<\n\tBuilders extends Record<string, any>,\n\tSeeds extends Record<string, any>,\n> {\n\t/**\n\t * Creates a typed seed function with proper type inference.\n\t * This is a utility method to help with TypeScript type checking when defining seeds.\n\t *\n\t * @template Seed - The seed function type\n\t * @param seedFn - The seed function to wrap\n\t * @returns The same seed function with proper typing\n\t *\n\t * @example\n\t * ```typescript\n\t * const userWithPostsSeed = Factory.createSeed(async ({ attrs, factory, db }) => {\n\t *   const user = await factory.insert('user', attrs);\n\t *   return user;\n\t * });\n\t * ```\n\t */\n\tstatic createSeed<Seed extends FactorySeed>(seedFn: Seed): Seed {\n\t\treturn seedFn;\n\t}\n\t/**\n\t * Inserts an object into the database using a builder function.\n\t *\n\t * @param builderName - The name of the builder to use\n\t * @param attrs - The attributes to insert\n\t */\n\tabstract insert<K extends keyof Builders>(\n\t\tbuilderName: K,\n\t\tattrs?: Parameters<Builders[K]>[0],\n\t): Promise<Awaited<ReturnType<Builders[K]>>>;\n\n\t/**\n\t * Inserts multiple objects into the database\n\t *\n\t * @param count -  Number of objects to insert\n\t * @param builderName - The name of the builder to use\n\t * @param attrs - The attributes to insert\n\t */\n\tabstract insertMany<K extends keyof Builders>(\n\t\tcount: number,\n\t\tbuilderName: K,\n\t\tattrs?:\n\t\t\t| Parameters<Builders[K]>[0]\n\t\t\t| ((\n\t\t\t\t\tidx: number,\n\t\t\t\t\tfaker: FakerFactory,\n\t\t\t  ) => Promise<Parameters<Builders[K]>[0]>),\n\t): Promise<Awaited<ReturnType<Builders[K]>>[]>;\n\n\t/**\n\t * Seeds the database using a seed function.\n\t *\n\t * @param seedName - The name of the seed to use\n\t * @returns The result of the seed function\n\t * @param attrs - The attributes to pass to the seed function\n\t */\n\tabstract seed<K extends keyof Seeds>(\n\t\tseedName: K,\n\t\tattrs?: ExtractSeedAttrs<Seeds[K]>,\n\t): ReturnType<Seeds[K]>;\n}\n\n/**\n * Type definition for a factory builder function that can work with different database types.\n * Builders are responsible for creating individual database records with default values and relationships.\n *\n * @template Attrs - The attributes/input type for the builder\n * @template Factory - The factory instance type\n * @template Result - The type of object returned by the builder\n * @template DB - The database connection type (Kysely, Knex, etc.)\n *\n * @param attrs - Partial attributes to override defaults\n * @param factory - The factory instance for creating related records\n * @param db - The database connection\n * @returns The created record or a promise resolving to it\n *\n * @example\n * ```typescript\n * const userBuilder: MixedFactoryBuilder<UserAttrs, Factory, User, Kysely<DB>> =\n *   async (attrs, factory, db) => {\n *     return {\n *       id: faker.string.uuid(),\n *       name: faker.person.fullName(),\n *       email: faker.internet.email(),\n *       ...attrs\n *     };\n *   };\n * ```\n */\nexport type MixedFactoryBuilder<\n\tAttrs = any,\n\tFactory = any,\n\tResult = any,\n\tDB = any,\n> = (attrs: Attrs, factory: Factory, db: DB) => Result | Promise<Result>;\n\n/**\n * Type definition for a factory seed function used to create complex test scenarios.\n * Seeds typically create multiple related records to set up a complete test environment.\n *\n * @template Attrs - The attributes/input type for the seed\n * @template Factory - The factory instance type\n * @template Result - The type of object returned by the seed\n * @template DB - The database connection type (Kysely, Knex, etc.)\n *\n * @param context - Object containing attrs, factory, and db\n * @param context.attrs - Configuration attributes for the seed\n * @param context.factory - The factory instance for creating records\n * @param context.db - The database connection\n * @returns A promise resolving to the seed result\n *\n * @example\n * ```typescript\n * const userWithPostsSeed: FactorySeed<{ postCount?: number }, Factory, User, DB> =\n *   async ({ attrs, factory, db }) => {\n *     const user = await factory.insert('user', attrs);\n *     const postCount = attrs.postCount || 3;\n *\n *     for (let i = 0; i < postCount; i++) {\n *       await factory.insert('post', { userId: user.id });\n *     }\n *\n *     return user;\n *   };\n * ```\n */\nexport type FactorySeed<\n\tAttrs = any,\n\tFactory = any,\n\tResult = any,\n\tDB = any,\n> = (context: { attrs: Attrs; factory: Factory; db: DB }) => Promise<Result>;\n\n/**\n * Helper type to extract the Attrs type from a FactorySeed function.\n * Used internally by Factory implementations to correctly type the seed method parameters.\n */\nexport type ExtractSeedAttrs<T> = T extends (context: {\n\tattrs: infer A;\n\tfactory: any;\n\tdb: any;\n}) => any\n\t? A\n\t: never;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,IAAsB,UAAtB,MAGE;;;;;;;;;;;;;;;;;CAiBD,OAAO,WAAqCA,QAAoB;AAC/D,SAAO;CACP;AAyCD"}

package/dist/Factory-BhjUOBWN.cjs

@@ -1,57 +0,0 @@
-
-//#region src/Factory.ts
-/**
-* Abstract base class for database factories used in testing.
-* Provides a standardized interface for creating test data using builder and seed patterns.
-*
-* @template Builders - Record of builder functions for creating individual entities
-* @template Seeds - Record of seed functions for creating complex test scenarios
-*
-* @example
-* ```typescript
-* // Define builders for creating individual records
-* const builders = {
-*   user: (attrs) => ({ name: 'Test User', email: 'test@example.com', ...attrs }),
-*   post: (attrs) => ({ title: 'Test Post', content: 'Content', ...attrs })
-* };
-*
-* // Define seeds for complex scenarios
-* const seeds = {
-*   userWithPosts: async (attrs, factory) => {
-*     const user = await factory.insert('user', attrs);
-*     await factory.insertMany(3, 'post', { userId: user.id });
-*     return user;
-*   }
-* };
-* ```
-*/
-var Factory = class {
-	/**
-	* Creates a typed seed function with proper type inference.
-	* This is a utility method to help with TypeScript type checking when defining seeds.
-	*
-	* @template Seed - The seed function type
-	* @param seedFn - The seed function to wrap
-	* @returns The same seed function with proper typing
-	*
-	* @example
-	* ```typescript
-	* const userWithPostsSeed = Factory.createSeed(async ({ attrs, factory, db }) => {
-	*   const user = await factory.insert('user', attrs);
-	*   return user;
-	* });
-	* ```
-	*/
-	static createSeed(seedFn) {
-		return seedFn;
-	}
-};
-
-//#endregion
-Object.defineProperty(exports, 'Factory', {
-  enumerable: true,
-  get: function () {
-    return Factory;
-  }
-});
-//# sourceMappingURL=Factory-BhjUOBWN.cjs.map

package/dist/Factory-BhjUOBWN.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"Factory-BhjUOBWN.cjs","names":["seedFn: Seed"],"sources":["../src/Factory.ts"],"sourcesContent":["import type { FakerFactory } from './faker';\n\n/**\n * Abstract base class for database factories used in testing.\n * Provides a standardized interface for creating test data using builder and seed patterns.\n *\n * @template Builders - Record of builder functions for creating individual entities\n * @template Seeds - Record of seed functions for creating complex test scenarios\n *\n * @example\n * ```typescript\n * // Define builders for creating individual records\n * const builders = {\n *   user: (attrs) => ({ name: 'Test User', email: 'test@example.com', ...attrs }),\n *   post: (attrs) => ({ title: 'Test Post', content: 'Content', ...attrs })\n * };\n *\n * // Define seeds for complex scenarios\n * const seeds = {\n *   userWithPosts: async (attrs, factory) => {\n *     const user = await factory.insert('user', attrs);\n *     await factory.insertMany(3, 'post', { userId: user.id });\n *     return user;\n *   }\n * };\n * ```\n */\nexport abstract class Factory<\n\tBuilders extends Record<string, any>,\n\tSeeds extends Record<string, any>,\n> {\n\t/**\n\t * Creates a typed seed function with proper type inference.\n\t * This is a utility method to help with TypeScript type checking when defining seeds.\n\t *\n\t * @template Seed - The seed function type\n\t * @param seedFn - The seed function to wrap\n\t * @returns The same seed function with proper typing\n\t *\n\t * @example\n\t * ```typescript\n\t * const userWithPostsSeed = Factory.createSeed(async ({ attrs, factory, db }) => {\n\t *   const user = await factory.insert('user', attrs);\n\t *   return user;\n\t * });\n\t * ```\n\t */\n\tstatic createSeed<Seed extends FactorySeed>(seedFn: Seed): Seed {\n\t\treturn seedFn;\n\t}\n\t/**\n\t * Inserts an object into the database using a builder function.\n\t *\n\t * @param builderName - The name of the builder to use\n\t * @param attrs - The attributes to insert\n\t */\n\tabstract insert<K extends keyof Builders>(\n\t\tbuilderName: K,\n\t\tattrs?: Parameters<Builders[K]>[0],\n\t): Promise<Awaited<ReturnType<Builders[K]>>>;\n\n\t/**\n\t * Inserts multiple objects into the database\n\t *\n\t * @param count -  Number of objects to insert\n\t * @param builderName - The name of the builder to use\n\t * @param attrs - The attributes to insert\n\t */\n\tabstract insertMany<K extends keyof Builders>(\n\t\tcount: number,\n\t\tbuilderName: K,\n\t\tattrs?:\n\t\t\t| Parameters<Builders[K]>[0]\n\t\t\t| ((\n\t\t\t\t\tidx: number,\n\t\t\t\t\tfaker: FakerFactory,\n\t\t\t  ) => Promise<Parameters<Builders[K]>[0]>),\n\t): Promise<Awaited<ReturnType<Builders[K]>>[]>;\n\n\t/**\n\t * Seeds the database using a seed function.\n\t *\n\t * @param seedName - The name of the seed to use\n\t * @returns The result of the seed function\n\t * @param attrs - The attributes to pass to the seed function\n\t */\n\tabstract seed<K extends keyof Seeds>(\n\t\tseedName: K,\n\t\tattrs?: ExtractSeedAttrs<Seeds[K]>,\n\t): ReturnType<Seeds[K]>;\n}\n\n/**\n * Type definition for a factory builder function that can work with different database types.\n * Builders are responsible for creating individual database records with default values and relationships.\n *\n * @template Attrs - The attributes/input type for the builder\n * @template Factory - The factory instance type\n * @template Result - The type of object returned by the builder\n * @template DB - The database connection type (Kysely, Knex, etc.)\n *\n * @param attrs - Partial attributes to override defaults\n * @param factory - The factory instance for creating related records\n * @param db - The database connection\n * @returns The created record or a promise resolving to it\n *\n * @example\n * ```typescript\n * const userBuilder: MixedFactoryBuilder<UserAttrs, Factory, User, Kysely<DB>> =\n *   async (attrs, factory, db) => {\n *     return {\n *       id: faker.string.uuid(),\n *       name: faker.person.fullName(),\n *       email: faker.internet.email(),\n *       ...attrs\n *     };\n *   };\n * ```\n */\nexport type MixedFactoryBuilder<\n\tAttrs = any,\n\tFactory = any,\n\tResult = any,\n\tDB = any,\n> = (attrs: Attrs, factory: Factory, db: DB) => Result | Promise<Result>;\n\n/**\n * Type definition for a factory seed function used to create complex test scenarios.\n * Seeds typically create multiple related records to set up a complete test environment.\n *\n * @template Attrs - The attributes/input type for the seed\n * @template Factory - The factory instance type\n * @template Result - The type of object returned by the seed\n * @template DB - The database connection type (Kysely, Knex, etc.)\n *\n * @param context - Object containing attrs, factory, and db\n * @param context.attrs - Configuration attributes for the seed\n * @param context.factory - The factory instance for creating records\n * @param context.db - The database connection\n * @returns A promise resolving to the seed result\n *\n * @example\n * ```typescript\n * const userWithPostsSeed: FactorySeed<{ postCount?: number }, Factory, User, DB> =\n *   async ({ attrs, factory, db }) => {\n *     const user = await factory.insert('user', attrs);\n *     const postCount = attrs.postCount || 3;\n *\n *     for (let i = 0; i < postCount; i++) {\n *       await factory.insert('post', { userId: user.id });\n *     }\n *\n *     return user;\n *   };\n * ```\n */\nexport type FactorySeed<\n\tAttrs = any,\n\tFactory = any,\n\tResult = any,\n\tDB = any,\n> = (context: { attrs: Attrs; factory: Factory; db: DB }) => Promise<Result>;\n\n/**\n * Helper type to extract the Attrs type from a FactorySeed function.\n * Used internally by Factory implementations to correctly type the seed method parameters.\n */\nexport type ExtractSeedAttrs<T> = T extends (context: {\n\tattrs: infer A;\n\tfactory: any;\n\tdb: any;\n}) => any\n\t? A\n\t: never;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,IAAsB,UAAtB,MAGE;;;;;;;;;;;;;;;;;CAiBD,OAAO,WAAqCA,QAAoB;AAC/D,SAAO;CACP;AAyCD"}