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

package/dist/mailbox.d.cts

@@ -0,0 +1,58 @@
+//#region src/mailbox.d.ts
+/**
+ * The mail a test sent, read from Mailpit.
+ *
+ * Locally, mail goes over real SMTP to Mailpit — the same client, the same
+ * message, only the host differs. A test reads what arrived through Mailpit's
+ * HTTP API, so a magic link is signed in with by opening the email that was
+ * actually sent rather than a token pulled from somewhere else.
+ *
+ * Mailpit has one inbox for everything, and transactions do not reach it, so a
+ * test keeps to its own mail by address: a unique recipient per test, read by
+ * `to:`, and cleared afterwards.
+ */
+export interface MailboxOptions {
+  /** Mailpit's HTTP address — what `gkm test` injects as `<ID>_INBOX_URL`. */
+  inbox: string;
+  /** The `fetch` to read it with. Defaults to the global one. */
+  fetch?: typeof fetch;
+  /** How long `last()` waits for mail to arrive. */
+  timeout?: number;
+}
+/** One email, as it arrived. */
+export interface Email {
+  id: string;
+  from: string;
+  to: string[];
+  subject: string;
+  text: string;
+  html: string;
+  /** Every `http(s)` link in the email, in order. */
+  links: string[];
+  /** The first link — the one a sign-in or confirmation email is about. */
+  link: string | undefined;
+}
+export interface Mailbox {
+  /** The newest email to this address, waiting for one if none has arrived. */
+  last(): Promise<Email>;
+  /** Every email to this address, newest first. */
+  all(): Promise<Email[]>;
+  /** Delete every email to this address. */
+  clear(): Promise<void>;
+}
+/** A way to read the mail sent to one address. */
+export declare function createMailbox(options: MailboxOptions): (address: string) => Mailbox;
+/** No email to an address arrived in time. */
+export declare class NoMail extends Error {
+  readonly address: string;
+  readonly timeout: number;
+  constructor(address: string, timeout: number);
+}
+/** Mailpit did not answer. */
+export declare class InboxUnreachable extends Error {
+  readonly inbox: string;
+  readonly status: number;
+  constructor(inbox: string, status: number);
+}
+//#endregion
+//# sourceMappingURL=mailbox.d.cts.map

package/dist/mailbox.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mailbox.d.cts","names":[],"sources":["../src/mailbox.ts"],"mappings":";;;;;;;;;;;;;iBAiBiB;;EAEhB;;EAEA,eAAe;;EAEf;;;iBAIgB;EAChB;EACA;EACA;EACA;EACA;EACA;;EAEA;;EAEA;;iBAGgB;;EAEhB,QAAQ,QAAQ;;EAEhB,OAAO,QAAQ;;EAEf,SAAS;;;wBAIM,cACf,SAAS,kBACN,oBAAoB;;qBA0FX,eAAe;WAEjB;WACA;EAFV,YACU,iBACA;;;qBAWE,yBAAyB;WAE3B;WACA;EAFV,YACU,eACA"}

package/dist/mailbox.d.mts

@@ -0,0 +1,58 @@
+//#region src/mailbox.d.ts
+/**
+ * The mail a test sent, read from Mailpit.
+ *
+ * Locally, mail goes over real SMTP to Mailpit — the same client, the same
+ * message, only the host differs. A test reads what arrived through Mailpit's
+ * HTTP API, so a magic link is signed in with by opening the email that was
+ * actually sent rather than a token pulled from somewhere else.
+ *
+ * Mailpit has one inbox for everything, and transactions do not reach it, so a
+ * test keeps to its own mail by address: a unique recipient per test, read by
+ * `to:`, and cleared afterwards.
+ */
+export interface MailboxOptions {
+  /** Mailpit's HTTP address — what `gkm test` injects as `<ID>_INBOX_URL`. */
+  inbox: string;
+  /** The `fetch` to read it with. Defaults to the global one. */
+  fetch?: typeof fetch;
+  /** How long `last()` waits for mail to arrive. */
+  timeout?: number;
+}
+/** One email, as it arrived. */
+export interface Email {
+  id: string;
+  from: string;
+  to: string[];
+  subject: string;
+  text: string;
+  html: string;
+  /** Every `http(s)` link in the email, in order. */
+  links: string[];
+  /** The first link — the one a sign-in or confirmation email is about. */
+  link: string | undefined;
+}
+export interface Mailbox {
+  /** The newest email to this address, waiting for one if none has arrived. */
+  last(): Promise<Email>;
+  /** Every email to this address, newest first. */
+  all(): Promise<Email[]>;
+  /** Delete every email to this address. */
+  clear(): Promise<void>;
+}
+/** A way to read the mail sent to one address. */
+export declare function createMailbox(options: MailboxOptions): (address: string) => Mailbox;
+/** No email to an address arrived in time. */
+export declare class NoMail extends Error {
+  readonly address: string;
+  readonly timeout: number;
+  constructor(address: string, timeout: number);
+}
+/** Mailpit did not answer. */
+export declare class InboxUnreachable extends Error {
+  readonly inbox: string;
+  readonly status: number;
+  constructor(inbox: string, status: number);
+}
+//#endregion
+//# sourceMappingURL=mailbox.d.mts.map

package/dist/mailbox.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mailbox.d.mts","names":[],"sources":["../src/mailbox.ts"],"mappings":";;;;;;;;;;;;;iBAiBiB;;EAEhB;;EAEA,eAAe;;EAEf;;;iBAIgB;EAChB;EACA;EACA;EACA;EACA;EACA;;EAEA;;EAEA;;iBAGgB;;EAEhB,QAAQ,QAAQ;;EAEhB,OAAO,QAAQ;;EAEf,SAAS;;;wBAIM,cACf,SAAS,kBACN,oBAAoB;;qBA0FX,eAAe;WAEjB;WACA;EAFV,YACU,iBACA;;;qBAWE,yBAAyB;WAE3B;WACA;EAFV,YACU,eACA"}

package/dist/mailbox.mjs

@@ -0,0 +1,92 @@
+//#region src/mailbox.ts
+/**
+* The mail a test sent, read from Mailpit.
+*
+* Locally, mail goes over real SMTP to Mailpit — the same client, the same
+* message, only the host differs. A test reads what arrived through Mailpit's
+* HTTP API, so a magic link is signed in with by opening the email that was
+* actually sent rather than a token pulled from somewhere else.
+*
+* Mailpit has one inbox for everything, and transactions do not reach it, so a
+* test keeps to its own mail by address: a unique recipient per test, read by
+* `to:`, and cleared afterwards.
+*/
+/** How long `last()` waits for mail that is still on its way. */
+const DEFAULT_TIMEOUT = 5e3;
+const POLL_INTERVAL = 50;
+/** A way to read the mail sent to one address. */
+function createMailbox(options) {
+	const inbox = options.inbox.replace(/\/$/, "");
+	const timeout = options.timeout ?? DEFAULT_TIMEOUT;
+	const get = (path, init) => (options.fetch ?? globalThis.fetch)(`${inbox}${path}`, init);
+	return (address) => {
+		const query = `?query=${encodeURIComponent(`to:"${address}"`)}`;
+		const all = async () => {
+			const found = await json(await get(`/api/v1/search${query}`), inbox);
+			return Promise.all(found.messages.map(async ({ ID }) => email(await json(await get(`/api/v1/message/${ID}`), inbox))));
+		};
+		return {
+			all,
+			async last() {
+				const deadline = Date.now() + timeout;
+				for (;;) {
+					const [newest] = await all();
+					if (newest) return newest;
+					if (Date.now() >= deadline) throw new NoMail(address, timeout);
+					await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL));
+				}
+			},
+			async clear() {
+				const response = await get(`/api/v1/search${query}`, { method: "DELETE" });
+				if (!response.ok) throw new InboxUnreachable(inbox, response.status);
+			}
+		};
+	};
+}
+async function json(response, inbox) {
+	if (!response.ok) throw new InboxUnreachable(inbox, response.status);
+	return await response.json();
+}
+function email(message) {
+	const links = [...new Set([...(message.HTML ?? "").matchAll(/href="(https?:\/\/[^"]+)"/g), ...(message.Text ?? "").matchAll(/(https?:\/\/[^\s<>"]+)/g)].map(([, url]) => decodeEntities(url)))];
+	return {
+		id: message.ID,
+		from: message.From.Address,
+		to: message.To.map(({ Address }) => Address),
+		subject: message.Subject,
+		text: message.Text ?? "",
+		html: message.HTML ?? "",
+		links,
+		link: links[0]
+	};
+}
+/** `&amp;` in an HTML attribute is `&` in the URL it names. */
+function decodeEntities(url) {
+	return url.replaceAll("&amp;", "&");
+}
+/** No email to an address arrived in time. */
+var NoMail = class extends Error {
+	address;
+	timeout;
+	constructor(address, timeout) {
+		super(`No email to ${address} arrived within ${timeout}ms. Check that the code under test sends it, and to that address.`);
+		this.address = address;
+		this.timeout = timeout;
+		this.name = "NoMail";
+	}
+};
+/** Mailpit did not answer. */
+var InboxUnreachable = class extends Error {
+	inbox;
+	status;
+	constructor(inbox, status) {
+		super(`Mailpit at ${inbox} answered ${status}. Is it running? \`gkm test\` starts it when the app declares an Email construct.`);
+		this.inbox = inbox;
+		this.status = status;
+		this.name = "InboxUnreachable";
+	}
+};
+//#endregion
+export { InboxUnreachable, NoMail, createMailbox };
+
+//# sourceMappingURL=mailbox.mjs.map

package/dist/mailbox.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mailbox.mjs","names":[],"sources":["../src/mailbox.ts"],"sourcesContent":["/**\n * The mail a test sent, read from Mailpit.\n *\n * Locally, mail goes over real SMTP to Mailpit — the same client, the same\n * message, only the host differs. A test reads what arrived through Mailpit's\n * HTTP API, so a magic link is signed in with by opening the email that was\n * actually sent rather than a token pulled from somewhere else.\n *\n * Mailpit has one inbox for everything, and transactions do not reach it, so a\n * test keeps to its own mail by address: a unique recipient per test, read by\n * `to:`, and cleared afterwards.\n */\n\n/** How long `last()` waits for mail that is still on its way. */\nconst DEFAULT_TIMEOUT = 5_000;\nconst POLL_INTERVAL = 50;\n\nexport interface MailboxOptions {\n\t/** Mailpit's HTTP address — what `gkm test` injects as `<ID>_INBOX_URL`. */\n\tinbox: string;\n\t/** The `fetch` to read it with. Defaults to the global one. */\n\tfetch?: typeof fetch;\n\t/** How long `last()` waits for mail to arrive. */\n\ttimeout?: number;\n}\n\n/** One email, as it arrived. */\nexport interface Email {\n\tid: string;\n\tfrom: string;\n\tto: string[];\n\tsubject: string;\n\ttext: string;\n\thtml: string;\n\t/** Every `http(s)` link in the email, in order. */\n\tlinks: string[];\n\t/** The first link — the one a sign-in or confirmation email is about. */\n\tlink: string | undefined;\n}\n\nexport interface Mailbox {\n\t/** The newest email to this address, waiting for one if none has arrived. */\n\tlast(): Promise<Email>;\n\t/** Every email to this address, newest first. */\n\tall(): Promise<Email[]>;\n\t/** Delete every email to this address. */\n\tclear(): Promise<void>;\n}\n\n/** A way to read the mail sent to one address. */\nexport function createMailbox(\n\toptions: MailboxOptions,\n): (address: string) => Mailbox {\n\tconst inbox = options.inbox.replace(/\\/$/, '');\n\tconst timeout = options.timeout ?? DEFAULT_TIMEOUT;\n\tconst get = (path: string, init?: RequestInit) =>\n\t\t(options.fetch ?? globalThis.fetch)(`${inbox}${path}`, init);\n\n\treturn (address) => {\n\t\tconst query = `?query=${encodeURIComponent(`to:\"${address}\"`)}`;\n\n\t\tconst all = async (): Promise<Email[]> => {\n\t\t\tconst found = await json<SearchResult>(\n\t\t\t\tawait get(`/api/v1/search${query}`),\n\t\t\t\tinbox,\n\t\t\t);\n\t\t\treturn Promise.all(\n\t\t\t\tfound.messages.map(async ({ ID }) =>\n\t\t\t\t\temail(await json<Message>(await get(`/api/v1/message/${ID}`), inbox)),\n\t\t\t\t),\n\t\t\t);\n\t\t};\n\n\t\treturn {\n\t\t\tall,\n\t\t\tasync last() {\n\t\t\t\tconst deadline = Date.now() + timeout;\n\t\t\t\tfor (;;) {\n\t\t\t\t\tconst [newest] = await all();\n\t\t\t\t\tif (newest) return newest;\n\t\t\t\t\tif (Date.now() >= deadline) throw new NoMail(address, timeout);\n\t\t\t\t\tawait new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL));\n\t\t\t\t}\n\t\t\t},\n\t\t\tasync clear() {\n\t\t\t\tconst response = await get(`/api/v1/search${query}`, {\n\t\t\t\t\tmethod: 'DELETE',\n\t\t\t\t});\n\t\t\t\tif (!response.ok) {\n\t\t\t\t\tthrow new InboxUnreachable(inbox, response.status);\n\t\t\t\t}\n\t\t\t},\n\t\t};\n\t};\n}\n\ninterface SearchResult {\n\tmessages: { ID: string }[];\n}\n\ninterface Message {\n\tID: string;\n\tFrom: { Address: string };\n\tTo: { Address: string }[];\n\tSubject: string;\n\tText: string;\n\tHTML: string;\n}\n\nasync function json<T>(response: Response, inbox: string): Promise<T> {\n\tif (!response.ok) throw new InboxUnreachable(inbox, response.status);\n\treturn (await response.json()) as T;\n}\n\nfunction email(message: Message): Email {\n\tconst links = [\n\t\t...new Set(\n\t\t\t[\n\t\t\t\t...(message.HTML ?? '').matchAll(/href=\"(https?:\\/\\/[^\"]+)\"/g),\n\t\t\t\t...(message.Text ?? '').matchAll(/(https?:\\/\\/[^\\s<>\"]+)/g),\n\t\t\t].map(([, url]) => decodeEntities(url!)),\n\t\t),\n\t];\n\n\treturn {\n\t\tid: message.ID,\n\t\tfrom: message.From.Address,\n\t\tto: message.To.map(({ Address }) => Address),\n\t\tsubject: message.Subject,\n\t\ttext: message.Text ?? '',\n\t\thtml: message.HTML ?? '',\n\t\tlinks,\n\t\tlink: links[0],\n\t};\n}\n\n/** `&amp;` in an HTML attribute is `&` in the URL it names. */\nfunction decodeEntities(url: string): string {\n\treturn url.replaceAll('&amp;', '&');\n}\n\n/** No email to an address arrived in time. */\nexport class NoMail extends Error {\n\tconstructor(\n\t\treadonly address: string,\n\t\treadonly timeout: number,\n\t) {\n\t\tsuper(\n\t\t\t`No email to ${address} arrived within ${timeout}ms. Check that the ` +\n\t\t\t\t`code under test sends it, and to that address.`,\n\t\t);\n\t\tthis.name = 'NoMail';\n\t}\n}\n\n/** Mailpit did not answer. */\nexport class InboxUnreachable extends Error {\n\tconstructor(\n\t\treadonly inbox: string,\n\t\treadonly status: number,\n\t) {\n\t\tsuper(\n\t\t\t`Mailpit at ${inbox} answered ${status}. Is it running? \\`gkm test\\` ` +\n\t\t\t\t`starts it when the app declares an Email construct.`,\n\t\t);\n\t\tthis.name = 'InboxUnreachable';\n\t}\n}\n"],"mappings":";;;;;;;;;;;;;;AAcA,MAAM,kBAAkB;AACxB,MAAM,gBAAgB;;AAmCtB,SAAgB,cACf,SAC+B;CAC/B,MAAM,QAAQ,QAAQ,MAAM,QAAQ,OAAO,EAAE;CAC7C,MAAM,UAAU,QAAQ,WAAW;CACnC,MAAM,OAAO,MAAc,UACzB,QAAQ,SAAS,WAAW,MAAA,CAAO,GAAG,QAAQ,QAAQ,IAAI;CAE5D,QAAQ,YAAY;EACnB,MAAM,QAAQ,UAAU,mBAAmB,OAAO,QAAQ,EAAE;EAE5D,MAAM,MAAM,YAA8B;GACzC,MAAM,QAAQ,MAAM,KACnB,MAAM,IAAI,iBAAiB,OAAO,GAClC,KACD;GACA,OAAO,QAAQ,IACd,MAAM,SAAS,IAAI,OAAO,EAAE,SAC3B,MAAM,MAAM,KAAc,MAAM,IAAI,mBAAmB,IAAI,GAAG,KAAK,CAAC,CACrE,CACD;EACD;EAEA,OAAO;GACN;GACA,MAAM,OAAO;IACZ,MAAM,WAAW,KAAK,IAAI,IAAI;IAC9B,SAAS;KACR,MAAM,CAAC,UAAU,MAAM,IAAI;KAC3B,IAAI,QAAQ,OAAO;KACnB,IAAI,KAAK,IAAI,KAAK,UAAU,MAAM,IAAI,OAAO,SAAS,OAAO;KAC7D,MAAM,IAAI,SAAS,YAAY,WAAW,SAAS,aAAa,CAAC;IAClE;GACD;GACA,MAAM,QAAQ;IACb,MAAM,WAAW,MAAM,IAAI,iBAAiB,SAAS,EACpD,QAAQ,SACT,CAAC;IACD,IAAI,CAAC,SAAS,IACb,MAAM,IAAI,iBAAiB,OAAO,SAAS,MAAM;GAEnD;EACD;CACD;AACD;AAeA,eAAe,KAAQ,UAAoB,OAA2B;CACrE,IAAI,CAAC,SAAS,IAAI,MAAM,IAAI,iBAAiB,OAAO,SAAS,MAAM;CACnE,OAAQ,MAAM,SAAS,KAAK;AAC7B;AAEA,SAAS,MAAM,SAAyB;CACvC,MAAM,QAAQ,CACb,GAAG,IAAI,IACN,CACC,IAAI,QAAQ,QAAQ,GAAA,CAAI,SAAS,4BAA4B,GAC7D,IAAI,QAAQ,QAAQ,GAAA,CAAI,SAAS,yBAAyB,CAC3D,CAAC,CAAC,KAAK,GAAG,SAAS,eAAe,GAAI,CAAC,CACxC,CACD;CAEA,OAAO;EACN,IAAI,QAAQ;EACZ,MAAM,QAAQ,KAAK;EACnB,IAAI,QAAQ,GAAG,KAAK,EAAE,cAAc,OAAO;EAC3C,SAAS,QAAQ;EACjB,MAAM,QAAQ,QAAQ;EACtB,MAAM,QAAQ,QAAQ;EACtB;EACA,MAAM,MAAM;CACb;AACD;;AAGA,SAAS,eAAe,KAAqB;CAC5C,OAAO,IAAI,WAAW,SAAS,GAAG;AACnC;;AAGA,IAAa,SAAb,cAA4B,MAAM;CAEvB;CACA;CAFV,YACC,SACA,SACC;EACD,MACC,eAAe,QAAQ,kBAAkB,QAAQ,kEAElD;EANS,KAAA,UAAA;EACA,KAAA,UAAA;EAMT,KAAK,OAAO;CACb;AACD;;AAGA,IAAa,mBAAb,cAAsC,MAAM;CAEjC;CACA;CAFV,YACC,OACA,QACC;EACD,MACC,cAAc,MAAM,YAAY,OAAO,kFAExC;EANS,KAAA,QAAA;EACA,KAAA,SAAA;EAMT,KAAK,OAAO;CACb;AACD"}

package/dist/objection.cjs

@@ -1,11 +1,9 @@
-require('./Factory-BhjUOBWN.cjs');
-const require_faker = require('./faker-B14IEMIN.cjs');
-const require_ObjectionFactory = require('./ObjectionFactory-BeFBYcan.cjs');
-require('./PostgresMigrator-M9jpzOvN.cjs');
-const require_PostgresObjectionMigrator = require('./PostgresObjectionMigrator-DSaPhwjY.cjs');
-const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-DyiX-QtK.cjs');
-const require_VitestObjectionTransactionIsolator = require('./VitestObjectionTransactionIsolator-DDoJTu7e.cjs');
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_faker = require("./faker.cjs");
+const require_ObjectionFactory = require("./ObjectionFactory.cjs");
+const require_PostgresObjectionMigrator = require("./PostgresObjectionMigrator.cjs");
+const require_VitestTransactionIsolator = require("./VitestTransactionIsolator.cjs");
+const require_VitestObjectionTransactionIsolator = require("./VitestObjectionTransactionIsolator.cjs");
 //#region src/objection.ts
 /**
 * Creates a wrapped Vitest test API with automatic transaction rollback for Objection.js.
@@ -52,8 +50,7 @@ const require_VitestObjectionTransactionIsolator = require('./VitestObjectionTra
 * ```
 */
 function wrapVitestObjectionTransaction(api, options) {
-	const wrapper = new require_VitestObjectionTransactionIsolator.VitestObjectionTransactionIsolator(api);
-	return wrapper.wrapVitestWithTransaction(options);
+	return new require_VitestObjectionTransactionIsolator.VitestObjectionTransactionIsolator(api).wrapVitestWithTransaction(options);
 }
 /**
 * Extends an Objection.js transaction-wrapped test with additional fixtures.
@@ -103,16 +100,16 @@ function wrapVitestObjectionTransaction(api, options) {
 * });
 * ```
 */
-function extendWithFixtures$1(wrappedTest, fixtures) {
+function extendWithFixtures(wrappedTest, fixtures) {
 	return require_VitestTransactionIsolator.extendWithFixtures(wrappedTest, fixtures);
 }
-
 //#endregion
 exports.IsolationLevel = require_VitestTransactionIsolator.IsolationLevel;
 exports.ObjectionFactory = require_ObjectionFactory.ObjectionFactory;
 exports.PostgresObjectionMigrator = require_PostgresObjectionMigrator.PostgresObjectionMigrator;
 exports.VitestObjectionTransactionIsolator = require_VitestObjectionTransactionIsolator.VitestObjectionTransactionIsolator;
-exports.extendWithFixtures = extendWithFixtures$1;
+exports.extendWithFixtures = extendWithFixtures;
 exports.faker = require_faker.faker;
 exports.wrapVitestObjectionTransaction = wrapVitestObjectionTransaction;
+
 //# sourceMappingURL=objection.cjs.map

package/dist/objection.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"objection.cjs","names":["api: TestAPI","options: ObjectionTransactionOptions<Extended>","VitestObjectionTransactionIsolator","extendWithFixtures","wrappedTest: T","fixtures: FixtureCreators<Knex.Transaction, Extended>"],"sources":["../src/objection.ts"],"sourcesContent":["import type { Knex } from 'knex';\nimport type { TestAPI } from 'vitest';\nimport { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';\nimport {\n\textendWithFixtures as baseExtendWithFixtures,\n\ttype DatabaseConnection,\n\ttype FixtureCreators,\n\ttype IsolationLevel,\n} from './VitestTransactionIsolator';\n\n/**\n * Objection.js-specific exports for test utilities.\n * Provides factory implementation for creating test data with Objection.js ORM\n * and transaction isolation for test suites.\n */\n\nexport type { ExtractSeedAttrs, FactorySeed } from './Factory';\nexport { ObjectionFactory } from './ObjectionFactory';\nexport { PostgresObjectionMigrator } from './PostgresObjectionMigrator';\nexport { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';\nexport type {\n\tDatabaseFixtures,\n\tExtendedDatabaseFixtures,\n\tFixtureCreators,\n\tTestWithExtendedFixtures,\n\tTransactionWrapperOptions,\n} from './VitestTransactionIsolator';\nexport { IsolationLevel } from './VitestTransactionIsolator';\n\n/**\n * Objection.js-specific options for transaction wrapping.\n */\nexport interface ObjectionTransactionOptions<\n\tExtended extends Record<string, unknown> = {},\n> {\n\t/** Function that creates or returns a Knex database connection */\n\tconnection: DatabaseConnection<Knex>;\n\t/** Optional setup function to run within the transaction before each test */\n\tsetup?: (trx: Knex.Transaction) => Promise<void>;\n\t/** Transaction isolation level (defaults to REPEATABLE_READ) */\n\tisolationLevel?: IsolationLevel;\n\t/** Additional fixtures that depend on the transaction */\n\tfixtures?: FixtureCreators<Knex.Transaction, Extended>;\n}\n\n// Re-export faker and FakerFactory for type portability in declaration files\nexport { type FakerFactory, faker } from './faker';\n\n/**\n * Creates a wrapped Vitest test API with automatic transaction rollback for Objection.js.\n * Each test runs in an isolated database transaction that is rolled back after completion.\n * This ensures tests don't affect each other's data and run faster than truncating tables.\n *\n * @template Extended - Additional fixtures to provide\n * @param api - The Vitest test API (usually `test` from vitest)\n * @param options - Configuration options for transaction wrapping\n * @returns A wrapped test API that provides transaction isolation\n *\n * @example\n * ```typescript\n * import { test } from 'vitest';\n * import { wrapVitestObjectionTransaction } from '@geekmidas/testkit/objection';\n * import { knex } from './database';\n * import { User } from './models';\n *\n * // Create isolated test with automatic rollback\n * const isolatedTest = wrapVitestObjectionTransaction(test, {\n *   connection: knex,\n * });\n *\n * // Use in tests - each test gets its own transaction\n * isolatedTest('should create user', async ({ trx }) => {\n *   const user = await User.query(trx)\n *     .insert({ name: 'Test User', email: 'test@example.com' });\n *\n *   expect(user).toBeDefined();\n * });\n *\n * // With fixtures for factories\n * const it = wrapVitestObjectionTransaction<{ factory: Factory }>(test, {\n *   connection: knex,\n *   fixtures: {\n *     factory: (trx) => new Factory(trx),\n *   },\n * });\n *\n * it('should create user with factory', async ({ trx, factory }) => {\n *   const user = await factory.insert('user', { name: 'Test' });\n *   expect(user.id).toBeDefined();\n * });\n * ```\n */\nexport function wrapVitestObjectionTransaction<\n\tExtended extends Record<string, unknown> = {},\n>(api: TestAPI, options: ObjectionTransactionOptions<Extended>) {\n\tconst wrapper = new VitestObjectionTransactionIsolator(api);\n\n\treturn wrapper.wrapVitestWithTransaction(options);\n}\n\n/**\n * Extends an Objection.js transaction-wrapped test with additional fixtures.\n * Each fixture receives the transaction and can create dependencies like factories or repositories.\n *\n * @template Extended - The type of additional fixtures to provide\n * @param wrappedTest - The base wrapped test from wrapVitestObjectionTransaction\n * @param fixtures - Object mapping fixture names to creator functions\n * @returns An extended test API with both trx and the additional fixtures\n *\n * @example\n * ```typescript\n * import { test } from 'vitest';\n * import { wrapVitestObjectionTransaction, extendWithFixtures, ObjectionFactory } from '@geekmidas/testkit/objection';\n * import { User } from './models';\n *\n * // Define your builders\n * const builders = {\n *   user: ObjectionFactory.createBuilder(User, ({ faker }) => ({\n *     name: faker.person.fullName(),\n *     email: faker.internet.email(),\n *   })),\n * };\n *\n * // Create base wrapped test\n * const baseTest = wrapVitestObjectionTransaction(test, {\n *   connection: knex,\n *   setup: createTestTables,\n * });\n *\n * // Extend with fixtures - each fixture receives the transaction\n * const it = extendWithFixtures<{ factory: ObjectionFactory<typeof builders, {}> }>(\n *   baseTest,\n *   {\n *     factory: (trx) => new ObjectionFactory(builders, {}, trx),\n *   }\n * );\n *\n * // Use in tests - both trx and factory are available\n * it('should create user with factory', async ({ trx, factory }) => {\n *   const user = await factory.insert('user', { name: 'Test User' });\n *   expect(user.id).toBeDefined();\n *\n *   // Verify in database\n *   const found = await User.query(trx).findById(user.id);\n *   expect(found?.name).toBe('Test User');\n * });\n * ```\n */\nexport function extendWithFixtures<\n\tExtended extends Record<string, unknown>,\n\tT extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>,\n>(wrappedTest: T, fixtures: FixtureCreators<Knex.Transaction, Extended>) {\n\treturn baseExtendWithFixtures<Knex.Transaction, Extended, T>(\n\t\twrappedTest,\n\t\tfixtures,\n\t);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4FA,SAAgB,+BAEdA,KAAcC,SAAgD;CAC/D,MAAM,UAAU,IAAIC,8EAAmC;AAEvD,QAAO,QAAQ,0BAA0B,QAAQ;AACjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDD,SAAgBC,qBAGdC,aAAgBC,UAAuD;AACxE,QAAO,qDACN,aACA,SACA;AACD"}
+{"version":3,"file":"objection.cjs","names":["VitestObjectionTransactionIsolator","baseExtendWithFixtures"],"sources":["../src/objection.ts"],"sourcesContent":["import type { Knex } from 'knex';\nimport type { TestAPI } from 'vitest';\nimport { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';\nimport {\n\textendWithFixtures as baseExtendWithFixtures,\n\ttype DatabaseConnection,\n\ttype FixtureCreators,\n\ttype IsolationLevel,\n} from './VitestTransactionIsolator';\n\n/**\n * Objection.js-specific exports for test utilities.\n * Provides factory implementation for creating test data with Objection.js ORM\n * and transaction isolation for test suites.\n */\n\nexport type { ExtractSeedAttrs, FactorySeed } from './Factory';\nexport { ObjectionFactory } from './ObjectionFactory';\nexport { PostgresObjectionMigrator } from './PostgresObjectionMigrator';\nexport { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';\nexport type {\n\tDatabaseFixtures,\n\tExtendedDatabaseFixtures,\n\tFixtureCreators,\n\tTestWithExtendedFixtures,\n\tTransactionWrapperOptions,\n} from './VitestTransactionIsolator';\nexport { IsolationLevel } from './VitestTransactionIsolator';\n\n/**\n * Objection.js-specific options for transaction wrapping.\n */\nexport interface ObjectionTransactionOptions<\n\tExtended extends Record<string, unknown> = {},\n> {\n\t/** Function that creates or returns a Knex database connection */\n\tconnection: DatabaseConnection<Knex>;\n\t/** Optional setup function to run within the transaction before each test */\n\tsetup?: (trx: Knex.Transaction) => Promise<void>;\n\t/** Transaction isolation level (defaults to REPEATABLE_READ) */\n\tisolationLevel?: IsolationLevel;\n\t/** Additional fixtures that depend on the transaction */\n\tfixtures?: FixtureCreators<Knex.Transaction, Extended>;\n}\n\n// Re-export faker and FakerFactory for type portability in declaration files\nexport { type FakerFactory, faker } from './faker';\n\n/**\n * Creates a wrapped Vitest test API with automatic transaction rollback for Objection.js.\n * Each test runs in an isolated database transaction that is rolled back after completion.\n * This ensures tests don't affect each other's data and run faster than truncating tables.\n *\n * @template Extended - Additional fixtures to provide\n * @param api - The Vitest test API (usually `test` from vitest)\n * @param options - Configuration options for transaction wrapping\n * @returns A wrapped test API that provides transaction isolation\n *\n * @example\n * ```typescript\n * import { test } from 'vitest';\n * import { wrapVitestObjectionTransaction } from '@geekmidas/testkit/objection';\n * import { knex } from './database';\n * import { User } from './models';\n *\n * // Create isolated test with automatic rollback\n * const isolatedTest = wrapVitestObjectionTransaction(test, {\n *   connection: knex,\n * });\n *\n * // Use in tests - each test gets its own transaction\n * isolatedTest('should create user', async ({ trx }) => {\n *   const user = await User.query(trx)\n *     .insert({ name: 'Test User', email: 'test@example.com' });\n *\n *   expect(user).toBeDefined();\n * });\n *\n * // With fixtures for factories\n * const it = wrapVitestObjectionTransaction<{ factory: Factory }>(test, {\n *   connection: knex,\n *   fixtures: {\n *     factory: (trx) => new Factory(trx),\n *   },\n * });\n *\n * it('should create user with factory', async ({ trx, factory }) => {\n *   const user = await factory.insert('user', { name: 'Test' });\n *   expect(user.id).toBeDefined();\n * });\n * ```\n */\nexport function wrapVitestObjectionTransaction<\n\tExtended extends Record<string, unknown> = {},\n>(api: TestAPI, options: ObjectionTransactionOptions<Extended>) {\n\tconst wrapper = new VitestObjectionTransactionIsolator(api);\n\n\treturn wrapper.wrapVitestWithTransaction(options);\n}\n\n/**\n * Extends an Objection.js transaction-wrapped test with additional fixtures.\n * Each fixture receives the transaction and can create dependencies like factories or repositories.\n *\n * @template Extended - The type of additional fixtures to provide\n * @param wrappedTest - The base wrapped test from wrapVitestObjectionTransaction\n * @param fixtures - Object mapping fixture names to creator functions\n * @returns An extended test API with both trx and the additional fixtures\n *\n * @example\n * ```typescript\n * import { test } from 'vitest';\n * import { wrapVitestObjectionTransaction, extendWithFixtures, ObjectionFactory } from '@geekmidas/testkit/objection';\n * import { User } from './models';\n *\n * // Define your builders\n * const builders = {\n *   user: ObjectionFactory.createBuilder(User, ({ faker }) => ({\n *     name: faker.person.fullName(),\n *     email: faker.internet.email(),\n *   })),\n * };\n *\n * // Create base wrapped test\n * const baseTest = wrapVitestObjectionTransaction(test, {\n *   connection: knex,\n *   setup: createTestTables,\n * });\n *\n * // Extend with fixtures - each fixture receives the transaction\n * const it = extendWithFixtures<{ factory: ObjectionFactory<typeof builders, {}> }>(\n *   baseTest,\n *   {\n *     factory: (trx) => new ObjectionFactory(builders, {}, trx),\n *   }\n * );\n *\n * // Use in tests - both trx and factory are available\n * it('should create user with factory', async ({ trx, factory }) => {\n *   const user = await factory.insert('user', { name: 'Test User' });\n *   expect(user.id).toBeDefined();\n *\n *   // Verify in database\n *   const found = await User.query(trx).findById(user.id);\n *   expect(found?.name).toBe('Test User');\n * });\n * ```\n */\nexport function extendWithFixtures<\n\tExtended extends Record<string, unknown>,\n\tT extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>,\n>(wrappedTest: T, fixtures: FixtureCreators<Knex.Transaction, Extended>) {\n\treturn baseExtendWithFixtures<Knex.Transaction, Extended, T>(\n\t\twrappedTest,\n\t\tfixtures,\n\t);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4FA,SAAgB,+BAEd,KAAc,SAAgD;CAG/D,OAAO,IAFaA,2CAAAA,mCAAmC,GAE1C,CAAC,CAAC,0BAA0B,OAAO;AACjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDA,SAAgB,mBAGd,aAAgB,UAAuD;CACxE,OAAOC,kCAAAA,mBACN,aACA,QACD;AACD"}

package/dist/objection.d.cts

@@ -1,19 +1,16 @@
-import { FakerFactory, faker } from "./faker-DvxiCtxc.cjs";
-import { ExtractSeedAttrs, FactorySeed } from "./Factory-AWn1IulI.cjs";
-import { ObjectionFactory } from "./ObjectionFactory-CYvaa0kU.cjs";
-import "./PostgresMigrator-CeYy-eHF.cjs";
-import { PostgresObjectionMigrator } from "./PostgresObjectionMigrator-DHVC9h_P.cjs";
-import { DatabaseConnection, DatabaseFixtures, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures, TransactionWrapperOptions } from "./VitestTransactionIsolator-glcxyS_R.cjs";
-import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-CTTjvTPO.cjs";
+import { FakerFactory, faker } from "./faker.cjs";
+import { ExtractSeedAttrs, FactorySeed } from "./Factory.cjs";
+import { ObjectionFactory } from "./ObjectionFactory.cjs";
+import { PostgresObjectionMigrator } from "./PostgresObjectionMigrator.cjs";
+import { DatabaseConnection, DatabaseFixtures, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures, TransactionWrapperOptions } from "./VitestTransactionIsolator.cjs";
+import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator.cjs";
 import { Knex } from "knex";
 import { TestAPI } from "vitest";
-
 //#region src/objection.d.ts
-
 /**
  * Objection.js-specific options for transaction wrapping.
  */
-interface ObjectionTransactionOptions<Extended extends Record<string, unknown> = {}> {
+export interface ObjectionTransactionOptions<Extended extends Record<string, unknown> = {}> {
   /** Function that creates or returns a Knex database connection */
   connection: DatabaseConnection<Knex>;
   /** Optional setup function to run within the transaction before each test */
@@ -67,7 +64,7 @@ interface ObjectionTransactionOptions<Extended extends Record<string, unknown> =
  * });
  * ```
  */
-declare function wrapVitestObjectionTransaction<Extended extends Record<string, unknown> = {}>(api: TestAPI, options: ObjectionTransactionOptions<Extended>): TestAPI<DatabaseFixtures<Knex.Transaction<any, any[]>, object> & Extended>;
+export declare function wrapVitestObjectionTransaction<Extended extends Record<string, unknown> = {}>(api: TestAPI, options: ObjectionTransactionOptions<Extended>): TestAPI<DatabaseFixtures<Knex.Transaction<any, any[]>, object> & Extended>;
 /**
  * Extends an Objection.js transaction-wrapped test with additional fixtures.
  * Each fixture receives the transaction and can create dependencies like factories or repositories.
@@ -116,8 +113,7 @@ declare function wrapVitestObjectionTransaction<Extended extends Record<string,
  * });
  * ```
  */
-declare function extendWithFixtures<Extended extends Record<string, unknown>, T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>>(wrappedTest: T, fixtures: FixtureCreators<Knex.Transaction, Extended>): TestWithExtendedFixtures<Knex.Transaction<any, any[]>, Extended, T>;
-//# sourceMappingURL=objection.d.ts.map
+export declare function extendWithFixtures<Extended extends Record<string, unknown>, T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>>(wrappedTest: T, fixtures: FixtureCreators<Knex.Transaction, Extended>): TestWithExtendedFixtures<Knex.Transaction<any, any[]>, Extended, T>;
 //#endregion
-export { DatabaseFixtures, ExtendedDatabaseFixtures, ExtractSeedAttrs, FactorySeed, FakerFactory, FixtureCreators, IsolationLevel, ObjectionFactory, ObjectionTransactionOptions, PostgresObjectionMigrator, TestWithExtendedFixtures, TransactionWrapperOptions, VitestObjectionTransactionIsolator, extendWithFixtures, faker, wrapVitestObjectionTransaction };
+export { type DatabaseFixtures, type ExtendedDatabaseFixtures, type ExtractSeedAttrs, type FactorySeed, type FakerFactory, type FixtureCreators, IsolationLevel, ObjectionFactory, PostgresObjectionMigrator, type TestWithExtendedFixtures, type TransactionWrapperOptions, VitestObjectionTransactionIsolator, faker };
 //# sourceMappingURL=objection.d.cts.map

package/dist/objection.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"objection.d.cts","names":[],"sources":["../src/objection.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;AAsCoC,UANnB,2BAMmB,CAAA,iBALlB,MAKkB,CAAA,MAAA,EAAA,OAAA,CAAA,GAAA,CAAA,CAAA,CAAA,CAAA;EAAO;EAEX,UAEC,EANpB,kBAMoB,CAND,IAMC,CAAA;EAAW;EAAU,KAA1C,CAAA,EAAA,CAAA,GAAA,EAJG,IAAA,CAAK,WAIR,EAAA,GAJwB,OAIxB,CAAA,IAAA,CAAA;EAAe;EAkDX,cAAA,CAAA,EApDE,cAoDF;EAA8B;EAAA,QAC5B,CAAA,EAnDN,eAmDM,CAnDU,IAAA,CAAK,WAmDf,EAnD4B,QAmD5B,CAAA;;;;;;;AAC4C;AAsD9D;;;;;;;;;;;;;;;AAGuE;;;;;;;;;;;;;;;;;;;;;;;iBA3DvD,gDACE,mCACX,kBAAkB,4BAA4B,YAAS,QAAA,iBAAA,IAAA,CAAA,mCAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsD9C,oCACE,mCACP,WAAW,qBAAqB,WAAW,iCACvC,aAAa,gBAAgB,IAAA,CAAK,aAAa,YAAS,yBAAA,IAAA,CAAA,yBAAA,UAAA"}
+{"version":3,"file":"objection.d.cts","names":["_$__VitestTransactionIsolator0.DatabaseFixtures","_$__VitestTransactionIsolator0.TestWithExtendedFixtures"],"sources":["../src/objection.ts"],"mappings":";;;;;;;;;;;;iBAgCiB,4BAChB,iBAAiB;;EAGjB,YAAY,mBAAmB;;EAE/B,SAAS,KAAK,KAAK,gBAAgB;;EAEnC,iBAAiB;;EAEjB,WAAW,gBAAgB,KAAK,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAkD9B,+BACf,iBAAiB,8BAChB,KAAK,SAAS,SAAS,4BAA4B,YAAS,QAAAA,iBAAA,KAAA,mCAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAsD9C,mBACf,iBAAiB,yBACjB,UAAU,WAAW,qBAAqB,WAAW,oBACpD,aAAa,GAAG,UAAU,gBAAgB,KAAK,aAAa,YAASC,yBAAA,KAAA,yBAAA,UAAA"}

package/dist/objection.d.mts

@@ -1,19 +1,16 @@
-import { FakerFactory, faker } from "./faker-B6bmbGCM.mjs";
-import { ExtractSeedAttrs, FactorySeed } from "./Factory-C15SSK8_.mjs";
-import { ObjectionFactory } from "./ObjectionFactory-Cf2WI4o_.mjs";
-import "./PostgresMigrator-C_QQ6q35.mjs";
-import { PostgresObjectionMigrator } from "./PostgresObjectionMigrator-1j6YIB1c.mjs";
-import { DatabaseConnection, DatabaseFixtures, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures, TransactionWrapperOptions } from "./VitestTransactionIsolator-BLaw80cx.mjs";
-import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-CyZG6nq4.mjs";
+import { FakerFactory, faker } from "./faker.mjs";
+import { ExtractSeedAttrs, FactorySeed } from "./Factory.mjs";
+import { ObjectionFactory } from "./ObjectionFactory.mjs";
+import { PostgresObjectionMigrator } from "./PostgresObjectionMigrator.mjs";
+import { DatabaseConnection, DatabaseFixtures, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures, TransactionWrapperOptions } from "./VitestTransactionIsolator.mjs";
+import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator.mjs";
 import { TestAPI } from "vitest";
 import { Knex } from "knex";
-
 //#region src/objection.d.ts
-
 /**
  * Objection.js-specific options for transaction wrapping.
  */
-interface ObjectionTransactionOptions<Extended extends Record<string, unknown> = {}> {
+export interface ObjectionTransactionOptions<Extended extends Record<string, unknown> = {}> {
   /** Function that creates or returns a Knex database connection */
   connection: DatabaseConnection<Knex>;
   /** Optional setup function to run within the transaction before each test */
@@ -67,7 +64,7 @@ interface ObjectionTransactionOptions<Extended extends Record<string, unknown> =
  * });
  * ```
  */
-declare function wrapVitestObjectionTransaction<Extended extends Record<string, unknown> = {}>(api: TestAPI, options: ObjectionTransactionOptions<Extended>): TestAPI<DatabaseFixtures<Knex.Transaction<any, any[]>, object> & Extended>;
+export declare function wrapVitestObjectionTransaction<Extended extends Record<string, unknown> = {}>(api: TestAPI, options: ObjectionTransactionOptions<Extended>): TestAPI<DatabaseFixtures<Knex.Transaction<any, any[]>, object> & Extended>;
 /**
  * Extends an Objection.js transaction-wrapped test with additional fixtures.
  * Each fixture receives the transaction and can create dependencies like factories or repositories.
@@ -116,8 +113,7 @@ declare function wrapVitestObjectionTransaction<Extended extends Record<string,
  * });
  * ```
  */
-declare function extendWithFixtures<Extended extends Record<string, unknown>, T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>>(wrappedTest: T, fixtures: FixtureCreators<Knex.Transaction, Extended>): TestWithExtendedFixtures<Knex.Transaction<any, any[]>, Extended, T>;
-//# sourceMappingURL=objection.d.ts.map
+export declare function extendWithFixtures<Extended extends Record<string, unknown>, T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>>(wrappedTest: T, fixtures: FixtureCreators<Knex.Transaction, Extended>): TestWithExtendedFixtures<Knex.Transaction<any, any[]>, Extended, T>;
 //#endregion
-export { DatabaseFixtures, ExtendedDatabaseFixtures, ExtractSeedAttrs, FactorySeed, FakerFactory, FixtureCreators, IsolationLevel, ObjectionFactory, ObjectionTransactionOptions, PostgresObjectionMigrator, TestWithExtendedFixtures, TransactionWrapperOptions, VitestObjectionTransactionIsolator, extendWithFixtures, faker, wrapVitestObjectionTransaction };
+export { type DatabaseFixtures, type ExtendedDatabaseFixtures, type ExtractSeedAttrs, type FactorySeed, type FakerFactory, type FixtureCreators, IsolationLevel, ObjectionFactory, PostgresObjectionMigrator, type TestWithExtendedFixtures, type TransactionWrapperOptions, VitestObjectionTransactionIsolator, faker };
 //# sourceMappingURL=objection.d.mts.map

package/dist/objection.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"objection.d.mts","names":[],"sources":["../src/objection.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;AAsCoC,UANnB,2BAMmB,CAAA,iBALlB,MAKkB,CAAA,MAAA,EAAA,OAAA,CAAA,GAAA,CAAA,CAAA,CAAA,CAAA;EAAO;EAEX,UAEC,EANpB,kBAMoB,CAND,IAMC,CAAA;EAAW;EAAU,KAA1C,CAAA,EAAA,CAAA,GAAA,EAJG,IAAA,CAAK,WAIR,EAAA,GAJwB,OAIxB,CAAA,IAAA,CAAA;EAAe;EAkDX,cAAA,CAAA,EApDE,cAoDF;EAA8B;EAAA,QAC5B,CAAA,EAnDN,eAmDM,CAnDU,IAAA,CAAK,WAmDf,EAnD4B,QAmD5B,CAAA;;;;;;;AAC4C;AAsD9D;;;;;;;;;;;;;;;AAGuE;;;;;;;;;;;;;;;;;;;;;;;iBA3DvD,gDACE,mCACX,kBAAkB,4BAA4B,YAAS,QAAA,iBAAA,IAAA,CAAA,mCAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsD9C,oCACE,mCACP,WAAW,qBAAqB,WAAW,iCACvC,aAAa,gBAAgB,IAAA,CAAK,aAAa,YAAS,yBAAA,IAAA,CAAA,yBAAA,UAAA"}
+{"version":3,"file":"objection.d.mts","names":["_$__VitestTransactionIsolator0.DatabaseFixtures","_$__VitestTransactionIsolator0.TestWithExtendedFixtures"],"sources":["../src/objection.ts"],"mappings":";;;;;;;;;;;;iBAgCiB,4BAChB,iBAAiB;;EAGjB,YAAY,mBAAmB;;EAE/B,SAAS,KAAK,KAAK,gBAAgB;;EAEnC,iBAAiB;;EAEjB,WAAW,gBAAgB,KAAK,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAkD9B,+BACf,iBAAiB,8BAChB,KAAK,SAAS,SAAS,4BAA4B,YAAS,QAAAA,iBAAA,KAAA,mCAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAsD9C,mBACf,iBAAiB,yBACjB,UAAU,WAAW,qBAAqB,WAAW,oBACpD,aAAa,GAAG,UAAU,gBAAgB,KAAK,aAAa,YAASC,yBAAA,KAAA,yBAAA,UAAA"}

package/dist/objection.mjs

@@ -1,11 +1,8 @@
-import "./Factory-BFVnMMCC.mjs";
-import { faker } from "./faker-BGKYFoCT.mjs";
-import { ObjectionFactory } from "./ObjectionFactory-QCJ7u0Ql.mjs";
-import "./PostgresMigrator-DVAY04qN.mjs";
-import { PostgresObjectionMigrator } from "./PostgresObjectionMigrator-DjPKdUbm.mjs";
-import { IsolationLevel, extendWithFixtures } from "./VitestTransactionIsolator-CvwPecpl.mjs";
-import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-B_VSWFum.mjs";
-
+import { faker } from "./faker.mjs";
+import { ObjectionFactory } from "./ObjectionFactory.mjs";
+import { PostgresObjectionMigrator } from "./PostgresObjectionMigrator.mjs";
+import { IsolationLevel, extendWithFixtures as extendWithFixtures$1 } from "./VitestTransactionIsolator.mjs";
+import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator.mjs";
 //#region src/objection.ts
 /**
 * Creates a wrapped Vitest test API with automatic transaction rollback for Objection.js.
@@ -52,8 +49,7 @@ import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransaction
 * ```
 */
 function wrapVitestObjectionTransaction(api, options) {
-	const wrapper = new VitestObjectionTransactionIsolator(api);
-	return wrapper.wrapVitestWithTransaction(options);
+	return new VitestObjectionTransactionIsolator(api).wrapVitestWithTransaction(options);
 }
 /**
 * Extends an Objection.js transaction-wrapped test with additional fixtures.
@@ -103,10 +99,10 @@ function wrapVitestObjectionTransaction(api, options) {
 * });
 * ```
 */
-function extendWithFixtures$1(wrappedTest, fixtures) {
-	return extendWithFixtures(wrappedTest, fixtures);
+function extendWithFixtures(wrappedTest, fixtures) {
+	return extendWithFixtures$1(wrappedTest, fixtures);
 }
-
 //#endregion
-export { IsolationLevel, ObjectionFactory, PostgresObjectionMigrator, VitestObjectionTransactionIsolator, extendWithFixtures$1 as extendWithFixtures, faker, wrapVitestObjectionTransaction };
+export { IsolationLevel, ObjectionFactory, PostgresObjectionMigrator, VitestObjectionTransactionIsolator, extendWithFixtures, faker, wrapVitestObjectionTransaction };
+
 //# sourceMappingURL=objection.mjs.map

package/dist/objection.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"objection.mjs","names":["api: TestAPI","options: ObjectionTransactionOptions<Extended>","extendWithFixtures","wrappedTest: T","fixtures: FixtureCreators<Knex.Transaction, Extended>"],"sources":["../src/objection.ts"],"sourcesContent":["import type { Knex } from 'knex';\nimport type { TestAPI } from 'vitest';\nimport { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';\nimport {\n\textendWithFixtures as baseExtendWithFixtures,\n\ttype DatabaseConnection,\n\ttype FixtureCreators,\n\ttype IsolationLevel,\n} from './VitestTransactionIsolator';\n\n/**\n * Objection.js-specific exports for test utilities.\n * Provides factory implementation for creating test data with Objection.js ORM\n * and transaction isolation for test suites.\n */\n\nexport type { ExtractSeedAttrs, FactorySeed } from './Factory';\nexport { ObjectionFactory } from './ObjectionFactory';\nexport { PostgresObjectionMigrator } from './PostgresObjectionMigrator';\nexport { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';\nexport type {\n\tDatabaseFixtures,\n\tExtendedDatabaseFixtures,\n\tFixtureCreators,\n\tTestWithExtendedFixtures,\n\tTransactionWrapperOptions,\n} from './VitestTransactionIsolator';\nexport { IsolationLevel } from './VitestTransactionIsolator';\n\n/**\n * Objection.js-specific options for transaction wrapping.\n */\nexport interface ObjectionTransactionOptions<\n\tExtended extends Record<string, unknown> = {},\n> {\n\t/** Function that creates or returns a Knex database connection */\n\tconnection: DatabaseConnection<Knex>;\n\t/** Optional setup function to run within the transaction before each test */\n\tsetup?: (trx: Knex.Transaction) => Promise<void>;\n\t/** Transaction isolation level (defaults to REPEATABLE_READ) */\n\tisolationLevel?: IsolationLevel;\n\t/** Additional fixtures that depend on the transaction */\n\tfixtures?: FixtureCreators<Knex.Transaction, Extended>;\n}\n\n// Re-export faker and FakerFactory for type portability in declaration files\nexport { type FakerFactory, faker } from './faker';\n\n/**\n * Creates a wrapped Vitest test API with automatic transaction rollback for Objection.js.\n * Each test runs in an isolated database transaction that is rolled back after completion.\n * This ensures tests don't affect each other's data and run faster than truncating tables.\n *\n * @template Extended - Additional fixtures to provide\n * @param api - The Vitest test API (usually `test` from vitest)\n * @param options - Configuration options for transaction wrapping\n * @returns A wrapped test API that provides transaction isolation\n *\n * @example\n * ```typescript\n * import { test } from 'vitest';\n * import { wrapVitestObjectionTransaction } from '@geekmidas/testkit/objection';\n * import { knex } from './database';\n * import { User } from './models';\n *\n * // Create isolated test with automatic rollback\n * const isolatedTest = wrapVitestObjectionTransaction(test, {\n *   connection: knex,\n * });\n *\n * // Use in tests - each test gets its own transaction\n * isolatedTest('should create user', async ({ trx }) => {\n *   const user = await User.query(trx)\n *     .insert({ name: 'Test User', email: 'test@example.com' });\n *\n *   expect(user).toBeDefined();\n * });\n *\n * // With fixtures for factories\n * const it = wrapVitestObjectionTransaction<{ factory: Factory }>(test, {\n *   connection: knex,\n *   fixtures: {\n *     factory: (trx) => new Factory(trx),\n *   },\n * });\n *\n * it('should create user with factory', async ({ trx, factory }) => {\n *   const user = await factory.insert('user', { name: 'Test' });\n *   expect(user.id).toBeDefined();\n * });\n * ```\n */\nexport function wrapVitestObjectionTransaction<\n\tExtended extends Record<string, unknown> = {},\n>(api: TestAPI, options: ObjectionTransactionOptions<Extended>) {\n\tconst wrapper = new VitestObjectionTransactionIsolator(api);\n\n\treturn wrapper.wrapVitestWithTransaction(options);\n}\n\n/**\n * Extends an Objection.js transaction-wrapped test with additional fixtures.\n * Each fixture receives the transaction and can create dependencies like factories or repositories.\n *\n * @template Extended - The type of additional fixtures to provide\n * @param wrappedTest - The base wrapped test from wrapVitestObjectionTransaction\n * @param fixtures - Object mapping fixture names to creator functions\n * @returns An extended test API with both trx and the additional fixtures\n *\n * @example\n * ```typescript\n * import { test } from 'vitest';\n * import { wrapVitestObjectionTransaction, extendWithFixtures, ObjectionFactory } from '@geekmidas/testkit/objection';\n * import { User } from './models';\n *\n * // Define your builders\n * const builders = {\n *   user: ObjectionFactory.createBuilder(User, ({ faker }) => ({\n *     name: faker.person.fullName(),\n *     email: faker.internet.email(),\n *   })),\n * };\n *\n * // Create base wrapped test\n * const baseTest = wrapVitestObjectionTransaction(test, {\n *   connection: knex,\n *   setup: createTestTables,\n * });\n *\n * // Extend with fixtures - each fixture receives the transaction\n * const it = extendWithFixtures<{ factory: ObjectionFactory<typeof builders, {}> }>(\n *   baseTest,\n *   {\n *     factory: (trx) => new ObjectionFactory(builders, {}, trx),\n *   }\n * );\n *\n * // Use in tests - both trx and factory are available\n * it('should create user with factory', async ({ trx, factory }) => {\n *   const user = await factory.insert('user', { name: 'Test User' });\n *   expect(user.id).toBeDefined();\n *\n *   // Verify in database\n *   const found = await User.query(trx).findById(user.id);\n *   expect(found?.name).toBe('Test User');\n * });\n * ```\n */\nexport function extendWithFixtures<\n\tExtended extends Record<string, unknown>,\n\tT extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>,\n>(wrappedTest: T, fixtures: FixtureCreators<Knex.Transaction, Extended>) {\n\treturn baseExtendWithFixtures<Knex.Transaction, Extended, T>(\n\t\twrappedTest,\n\t\tfixtures,\n\t);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4FA,SAAgB,+BAEdA,KAAcC,SAAgD;CAC/D,MAAM,UAAU,IAAI,mCAAmC;AAEvD,QAAO,QAAQ,0BAA0B,QAAQ;AACjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDD,SAAgBC,qBAGdC,aAAgBC,UAAuD;AACxE,QAAO,mBACN,aACA,SACA;AACD"}
+{"version":3,"file":"objection.mjs","names":["baseExtendWithFixtures"],"sources":["../src/objection.ts"],"sourcesContent":["import type { Knex } from 'knex';\nimport type { TestAPI } from 'vitest';\nimport { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';\nimport {\n\textendWithFixtures as baseExtendWithFixtures,\n\ttype DatabaseConnection,\n\ttype FixtureCreators,\n\ttype IsolationLevel,\n} from './VitestTransactionIsolator';\n\n/**\n * Objection.js-specific exports for test utilities.\n * Provides factory implementation for creating test data with Objection.js ORM\n * and transaction isolation for test suites.\n */\n\nexport type { ExtractSeedAttrs, FactorySeed } from './Factory';\nexport { ObjectionFactory } from './ObjectionFactory';\nexport { PostgresObjectionMigrator } from './PostgresObjectionMigrator';\nexport { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';\nexport type {\n\tDatabaseFixtures,\n\tExtendedDatabaseFixtures,\n\tFixtureCreators,\n\tTestWithExtendedFixtures,\n\tTransactionWrapperOptions,\n} from './VitestTransactionIsolator';\nexport { IsolationLevel } from './VitestTransactionIsolator';\n\n/**\n * Objection.js-specific options for transaction wrapping.\n */\nexport interface ObjectionTransactionOptions<\n\tExtended extends Record<string, unknown> = {},\n> {\n\t/** Function that creates or returns a Knex database connection */\n\tconnection: DatabaseConnection<Knex>;\n\t/** Optional setup function to run within the transaction before each test */\n\tsetup?: (trx: Knex.Transaction) => Promise<void>;\n\t/** Transaction isolation level (defaults to REPEATABLE_READ) */\n\tisolationLevel?: IsolationLevel;\n\t/** Additional fixtures that depend on the transaction */\n\tfixtures?: FixtureCreators<Knex.Transaction, Extended>;\n}\n\n// Re-export faker and FakerFactory for type portability in declaration files\nexport { type FakerFactory, faker } from './faker';\n\n/**\n * Creates a wrapped Vitest test API with automatic transaction rollback for Objection.js.\n * Each test runs in an isolated database transaction that is rolled back after completion.\n * This ensures tests don't affect each other's data and run faster than truncating tables.\n *\n * @template Extended - Additional fixtures to provide\n * @param api - The Vitest test API (usually `test` from vitest)\n * @param options - Configuration options for transaction wrapping\n * @returns A wrapped test API that provides transaction isolation\n *\n * @example\n * ```typescript\n * import { test } from 'vitest';\n * import { wrapVitestObjectionTransaction } from '@geekmidas/testkit/objection';\n * import { knex } from './database';\n * import { User } from './models';\n *\n * // Create isolated test with automatic rollback\n * const isolatedTest = wrapVitestObjectionTransaction(test, {\n *   connection: knex,\n * });\n *\n * // Use in tests - each test gets its own transaction\n * isolatedTest('should create user', async ({ trx }) => {\n *   const user = await User.query(trx)\n *     .insert({ name: 'Test User', email: 'test@example.com' });\n *\n *   expect(user).toBeDefined();\n * });\n *\n * // With fixtures for factories\n * const it = wrapVitestObjectionTransaction<{ factory: Factory }>(test, {\n *   connection: knex,\n *   fixtures: {\n *     factory: (trx) => new Factory(trx),\n *   },\n * });\n *\n * it('should create user with factory', async ({ trx, factory }) => {\n *   const user = await factory.insert('user', { name: 'Test' });\n *   expect(user.id).toBeDefined();\n * });\n * ```\n */\nexport function wrapVitestObjectionTransaction<\n\tExtended extends Record<string, unknown> = {},\n>(api: TestAPI, options: ObjectionTransactionOptions<Extended>) {\n\tconst wrapper = new VitestObjectionTransactionIsolator(api);\n\n\treturn wrapper.wrapVitestWithTransaction(options);\n}\n\n/**\n * Extends an Objection.js transaction-wrapped test with additional fixtures.\n * Each fixture receives the transaction and can create dependencies like factories or repositories.\n *\n * @template Extended - The type of additional fixtures to provide\n * @param wrappedTest - The base wrapped test from wrapVitestObjectionTransaction\n * @param fixtures - Object mapping fixture names to creator functions\n * @returns An extended test API with both trx and the additional fixtures\n *\n * @example\n * ```typescript\n * import { test } from 'vitest';\n * import { wrapVitestObjectionTransaction, extendWithFixtures, ObjectionFactory } from '@geekmidas/testkit/objection';\n * import { User } from './models';\n *\n * // Define your builders\n * const builders = {\n *   user: ObjectionFactory.createBuilder(User, ({ faker }) => ({\n *     name: faker.person.fullName(),\n *     email: faker.internet.email(),\n *   })),\n * };\n *\n * // Create base wrapped test\n * const baseTest = wrapVitestObjectionTransaction(test, {\n *   connection: knex,\n *   setup: createTestTables,\n * });\n *\n * // Extend with fixtures - each fixture receives the transaction\n * const it = extendWithFixtures<{ factory: ObjectionFactory<typeof builders, {}> }>(\n *   baseTest,\n *   {\n *     factory: (trx) => new ObjectionFactory(builders, {}, trx),\n *   }\n * );\n *\n * // Use in tests - both trx and factory are available\n * it('should create user with factory', async ({ trx, factory }) => {\n *   const user = await factory.insert('user', { name: 'Test User' });\n *   expect(user.id).toBeDefined();\n *\n *   // Verify in database\n *   const found = await User.query(trx).findById(user.id);\n *   expect(found?.name).toBe('Test User');\n * });\n * ```\n */\nexport function extendWithFixtures<\n\tExtended extends Record<string, unknown>,\n\tT extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>,\n>(wrappedTest: T, fixtures: FixtureCreators<Knex.Transaction, Extended>) {\n\treturn baseExtendWithFixtures<Knex.Transaction, Extended, T>(\n\t\twrappedTest,\n\t\tfixtures,\n\t);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4FA,SAAgB,+BAEd,KAAc,SAAgD;CAG/D,OAAO,IAFa,mCAAmC,GAE1C,CAAC,CAAC,0BAA0B,OAAO;AACjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDA,SAAgB,mBAGd,aAAgB,UAAuD;CACxE,OAAOA,qBACN,aACA,QACD;AACD"}

package/dist/os/directory.cjs

@@ -1,3 +1,32 @@
-const require_directory = require('../directory-DD_xQoSh.cjs');
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_rolldown_runtime = require("../rolldown-runtime-VH7oDXx4.cjs");
+let vitest = require("vitest");
+let node_crypto = require("node:crypto");
+node_crypto = require_rolldown_runtime.__toESM(node_crypto, 1);
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = require_rolldown_runtime.__toESM(node_fs_promises, 1);
+let node_os = require("node:os");
+node_os = require_rolldown_runtime.__toESM(node_os, 1);
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path, 1);
+//#region src/os/directory.ts
+const itWithDir = vitest.it.extend({ dir: async ({}, use) => {
+	const tempDir = node_os.default.tmpdir();
+	const directoryName = node_crypto.default.randomUUID().replace(/-/g, "").toUpperCase();
+	const dir = node_path.default.join(tempDir, directoryName);
+	await node_fs_promises.default.mkdir(dir, { recursive: true });
+	await use(dir);
+	await node_fs_promises.default.rm(dir, {
+		recursive: true,
+		force: true
+	});
+	const keystoreDir = node_path.default.join(node_os.default.homedir(), ".gkm", directoryName);
+	await node_fs_promises.default.rm(keystoreDir, {
+		recursive: true,
+		force: true
+	});
+} });
+//#endregion
+exports.itWithDir = itWithDir;
 
-exports.itWithDir = require_directory.itWithDir;
+//# sourceMappingURL=directory.cjs.map

package/dist/os/directory.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"directory.cjs","names":["it","os","crypto","path","fs"],"sources":["../../src/os/directory.ts"],"sourcesContent":["import crypto from 'node:crypto';\nimport fs from 'node:fs/promises';\nimport os from 'node:os';\nimport path from 'node:path';\nimport { it } from 'vitest';\n\nexport const itWithDir = it.extend<DirectoryFixtures>({\n\t// This fixture automatically provides a transaction to each test\n\t// biome-ignore lint/correctness/noEmptyPattern: this has to be like this to satisfy Biome\n\tdir: async ({}, use) => {\n\t\tconst tempDir = os.tmpdir();\n\t\tconst directoryName = crypto.randomUUID().replace(/-/g, '').toUpperCase();\n\t\tconst dir = path.join(tempDir, directoryName);\n\t\tawait fs.mkdir(dir, { recursive: true });\n\t\tawait use(dir);\n\t\tawait fs.rm(dir, { recursive: true, force: true });\n\n\t\t// Clean up keystore directory that may have been created at ~/.gkm/{directoryName}\n\t\tconst keystoreDir = path.join(os.homedir(), '.gkm', directoryName);\n\t\tawait fs.rm(keystoreDir, { recursive: true, force: true });\n\t},\n});\n\nexport interface DirectoryFixtures {\n\tdir: string;\n}\n"],"mappings":";;;;;;;;;;;;AAMA,MAAa,YAAYA,OAAAA,GAAG,OAA0B,EAGrD,KAAK,OAAO,IAAI,QAAQ;CACvB,MAAM,UAAUC,QAAAA,QAAG,OAAO;CAC1B,MAAM,gBAAgBC,YAAAA,QAAO,WAAW,CAAC,CAAC,QAAQ,MAAM,EAAE,CAAC,CAAC,YAAY;CACxE,MAAM,MAAMC,UAAAA,QAAK,KAAK,SAAS,aAAa;CAC5C,MAAMC,iBAAAA,QAAG,MAAM,KAAK,EAAE,WAAW,KAAK,CAAC;CACvC,MAAM,IAAI,GAAG;CACb,MAAMA,iBAAAA,QAAG,GAAG,KAAK;EAAE,WAAW;EAAM,OAAO;CAAK,CAAC;CAGjD,MAAM,cAAcD,UAAAA,QAAK,KAAKF,QAAAA,QAAG,QAAQ,GAAG,QAAQ,aAAa;CACjE,MAAMG,iBAAAA,QAAG,GAAG,aAAa;EAAE,WAAW;EAAM,OAAO;CAAK,CAAC;AAC1D,EACD,CAAC"}

package/dist/os/directory.d.cts

@@ -1,2 +1,9 @@
-import { DirectoryFixtures, itWithDir } from "../directory-zIEh5ZPl.cjs";
-export { DirectoryFixtures, itWithDir };
+//#region src/os/directory.d.ts
+export declare const itWithDir: import("vitest").TestAPI<{
+  dir: string;
+}>;
+export interface DirectoryFixtures {
+  dir: string;
+}
+//#endregion
+//# sourceMappingURL=directory.d.cts.map

package/dist/os/directory.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"directory.d.cts","names":[],"sources":["../../src/os/directory.ts"],"mappings":";qBAMa,4BAAS;EAAA;;iBAiBL;EAChB"}

package/dist/os/directory.d.mts

@@ -1,2 +1,9 @@
-import { DirectoryFixtures, itWithDir } from "../directory-DiQ_DkaF.mjs";
-export { DirectoryFixtures, itWithDir };
+//#region src/os/directory.d.ts
+export declare const itWithDir: import("vitest").TestAPI<{
+  dir: string;
+}>;
+export interface DirectoryFixtures {
+  dir: string;
+}
+//#endregion
+//# sourceMappingURL=directory.d.mts.map

package/dist/os/directory.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"directory.d.mts","names":[],"sources":["../../src/os/directory.ts"],"mappings":";qBAMa,4BAAS;EAAA;;iBAiBL;EAChB"}

package/dist/os/directory.mjs

@@ -1,3 +1,26 @@
-import { itWithDir } from "../directory-BxjqmtCT.mjs";
+import { it } from "vitest";
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+//#region src/os/directory.ts
+const itWithDir = it.extend({ dir: async ({}, use) => {
+	const tempDir = os.tmpdir();
+	const directoryName = crypto.randomUUID().replace(/-/g, "").toUpperCase();
+	const dir = path.join(tempDir, directoryName);
+	await fs.mkdir(dir, { recursive: true });
+	await use(dir);
+	await fs.rm(dir, {
+		recursive: true,
+		force: true
+	});
+	const keystoreDir = path.join(os.homedir(), ".gkm", directoryName);
+	await fs.rm(keystoreDir, {
+		recursive: true,
+		force: true
+	});
+} });
+//#endregion
+export { itWithDir };
 
-export { itWithDir };
+//# sourceMappingURL=directory.mjs.map

package/dist/os/directory.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"directory.mjs","names":[],"sources":["../../src/os/directory.ts"],"sourcesContent":["import crypto from 'node:crypto';\nimport fs from 'node:fs/promises';\nimport os from 'node:os';\nimport path from 'node:path';\nimport { it } from 'vitest';\n\nexport const itWithDir = it.extend<DirectoryFixtures>({\n\t// This fixture automatically provides a transaction to each test\n\t// biome-ignore lint/correctness/noEmptyPattern: this has to be like this to satisfy Biome\n\tdir: async ({}, use) => {\n\t\tconst tempDir = os.tmpdir();\n\t\tconst directoryName = crypto.randomUUID().replace(/-/g, '').toUpperCase();\n\t\tconst dir = path.join(tempDir, directoryName);\n\t\tawait fs.mkdir(dir, { recursive: true });\n\t\tawait use(dir);\n\t\tawait fs.rm(dir, { recursive: true, force: true });\n\n\t\t// Clean up keystore directory that may have been created at ~/.gkm/{directoryName}\n\t\tconst keystoreDir = path.join(os.homedir(), '.gkm', directoryName);\n\t\tawait fs.rm(keystoreDir, { recursive: true, force: true });\n\t},\n});\n\nexport interface DirectoryFixtures {\n\tdir: string;\n}\n"],"mappings":";;;;;;AAMA,MAAa,YAAY,GAAG,OAA0B,EAGrD,KAAK,OAAO,IAAI,QAAQ;CACvB,MAAM,UAAU,GAAG,OAAO;CAC1B,MAAM,gBAAgB,OAAO,WAAW,CAAC,CAAC,QAAQ,MAAM,EAAE,CAAC,CAAC,YAAY;CACxE,MAAM,MAAM,KAAK,KAAK,SAAS,aAAa;CAC5C,MAAM,GAAG,MAAM,KAAK,EAAE,WAAW,KAAK,CAAC;CACvC,MAAM,IAAI,GAAG;CACb,MAAM,GAAG,GAAG,KAAK;EAAE,WAAW;EAAM,OAAO;CAAK,CAAC;CAGjD,MAAM,cAAc,KAAK,KAAK,GAAG,QAAQ,GAAG,QAAQ,aAAa;CACjE,MAAM,GAAG,GAAG,aAAa;EAAE,WAAW;EAAM,OAAO;CAAK,CAAC;AAC1D,EACD,CAAC"}