@geekmidas/testkit 10.0.0-alpha.3 → 10.0.0-alpha.30

package/dist/os/index.cjs

@@ -1,3 +1,3 @@
-const require_directory = require('../directory-DD_xQoSh.cjs');
-
-exports.itWithDir = require_directory.itWithDir;
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_os_directory = require("./directory.cjs");
+exports.itWithDir = require_os_directory.itWithDir;

package/dist/os/index.d.cts

@@ -1,2 +1,2 @@
-import { itWithDir } from "../directory-DGOcVlKD.cjs";
+import { itWithDir } from "./directory.cjs";
 export { itWithDir };

package/dist/os/index.d.mts

@@ -1,2 +1,2 @@
-import { itWithDir } from "../directory-DiQ_DkaF.mjs";
+import { itWithDir } from "./directory.mjs";
 export { itWithDir };

package/dist/os/index.mjs

@@ -1,3 +1,2 @@
-import { itWithDir } from "../directory-BxjqmtCT.mjs";
-
-export { itWithDir };
+import { itWithDir } from "./directory.mjs";
+export { itWithDir };

package/dist/requestContext.cjs

@@ -1,12 +1,11 @@
-const require_chunk = require('./chunk-CUT6urMc.cjs');
-const __geekmidas_services = require_chunk.__toESM(require("@geekmidas/services"));
-const node_crypto = require_chunk.__toESM(require("node:crypto"));
-const __geekmidas_logger_console = require_chunk.__toESM(require("@geekmidas/logger/console"));
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _geekmidas_services = require("@geekmidas/services");
+let node_crypto = require("node:crypto");
+let _geekmidas_logger_console = require("@geekmidas/logger/console");
 //#region src/requestContext.ts
 function resolveContext(opts = {}) {
 	return {
-		logger: opts.logger ?? new __geekmidas_logger_console.ConsoleLogger({ app: "test" }),
+		logger: opts.logger ?? new _geekmidas_logger_console.ConsoleLogger({ app: "test" }),
 		requestId: opts.requestId ?? (0, node_crypto.randomUUID)(),
 		startTime: opts.startTime ?? Date.now()
 	};
@@ -24,7 +23,7 @@ function resolveContext(opts = {}) {
 * ```
 */
 function runInRequestContext(fn, opts = {}) {
-	return (0, __geekmidas_services.runWithRequestContext)(resolveContext(opts), fn);
+	return (0, _geekmidas_services.runWithRequestContext)(resolveContext(opts), fn);
 }
 /**
 * Vitest fixture creator. Spread the result into `.extend()` and every test
@@ -43,11 +42,11 @@ function runInRequestContext(fn, opts = {}) {
 */
 function requestContextFixture(opts = {}) {
 	return { requestContext: [async ({}, use) => {
-		(0, __geekmidas_services.enterRequestContext)(resolveContext(opts));
+		(0, _geekmidas_services.enterRequestContext)(resolveContext(opts));
 		try {
-			await use(__geekmidas_services.serviceContext);
+			await use(_geekmidas_services.serviceContext);
 		} finally {
-			(0, __geekmidas_services.exitRequestContext)();
+			(0, _geekmidas_services.exitRequestContext)();
 		}
 	}, { auto: true }] };
 }
@@ -72,9 +71,9 @@ function requestContextFixture(opts = {}) {
 function withRequestContext(testApi, opts = {}) {
 	return testApi.extend(requestContextFixture(opts));
 }
-
 //#endregion
 exports.requestContextFixture = requestContextFixture;
 exports.runInRequestContext = runInRequestContext;
 exports.withRequestContext = withRequestContext;
+
 //# sourceMappingURL=requestContext.cjs.map

package/dist/requestContext.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"requestContext.cjs","names":["opts: RequestContextOptions","ConsoleLogger","fn: () => T | Promise<T>","use: (value: ServiceContext) => Promise<void>","serviceContext","testApi: T"],"sources":["../src/requestContext.ts"],"sourcesContent":["import { randomUUID } from 'node:crypto';\nimport type { Logger } from '@geekmidas/logger';\nimport { ConsoleLogger } from '@geekmidas/logger/console';\nimport {\n\tenterRequestContext,\n\texitRequestContext,\n\trunWithRequestContext,\n\ttype ServiceContext,\n\tserviceContext,\n} from '@geekmidas/services';\nimport type { TestAPI } from 'vitest';\n\n/**\n * Options for setting up a request context in tests. Any field omitted\n * is filled with a test-friendly default (ConsoleLogger, random UUID,\n * Date.now()).\n */\nexport interface RequestContextOptions {\n\t/** Logger exposed via serviceContext.getLogger(). */\n\tlogger?: Logger;\n\t/** Request id exposed via serviceContext.getRequestId(). */\n\trequestId?: string;\n\t/** Start time exposed via serviceContext.getRequestStartTime(). */\n\tstartTime?: number;\n}\n\nfunction resolveContext(opts: RequestContextOptions = {}) {\n\treturn {\n\t\tlogger: opts.logger ?? new ConsoleLogger({ app: 'test' }),\n\t\trequestId: opts.requestId ?? randomUUID(),\n\t\tstartTime: opts.startTime ?? Date.now(),\n\t};\n}\n\n/**\n * Run a function inside a request context with test-friendly defaults.\n * Useful when you need `serviceContext` to be available for a single call\n * (e.g. invoking `Service.register({ context })` outside a wrapped test).\n *\n * @example\n * ```ts\n * await runInRequestContext(() =>\n *   discovery.register([databaseService]),\n * );\n * ```\n */\nexport function runInRequestContext<T>(\n\tfn: () => T | Promise<T>,\n\topts: RequestContextOptions = {},\n): T | Promise<T> {\n\treturn runWithRequestContext(resolveContext(opts), fn);\n}\n\n/**\n * Vitest fixture creator. Spread the result into `.extend()` and every test\n * runs inside `runWithRequestContext`, even tests that don't destructure\n * `requestContext` directly (the fixture is registered as `auto`).\n *\n * @example\n * ```ts\n * const it = test.extend({ ...requestContextFixture() });\n *\n * it('registers services with context', async ({ requestContext }) => {\n *   await discovery.register([databaseService]);\n *   expect(requestContext.getRequestId()).toBeDefined();\n * });\n * ```\n */\nexport function requestContextFixture(opts: RequestContextOptions = {}) {\n\treturn {\n\t\trequestContext: [\n\t\t\tasync (\n\t\t\t\t// biome-ignore lint/correctness/noEmptyPattern: vitest fixture signature\n\t\t\t\t{}: {},\n\t\t\t\tuse: (value: ServiceContext) => Promise<void>,\n\t\t\t) => {\n\t\t\t\t// Vitest suspends the fixture on `await use(...)` and runs the test\n\t\t\t\t// body in a continuation of the runner's async context. A scoped\n\t\t\t\t// `runWithRequestContext` callback ends as soon as we hand control\n\t\t\t\t// to the runner, so the test body would see no context. Instead,\n\t\t\t\t// mutate the current task's store with `enterRequestContext` —\n\t\t\t\t// async/await preserves that store across the suspension, so the\n\t\t\t\t// test body sees it. We restore on the way out so subsequent tests\n\t\t\t\t// don't inherit the value.\n\t\t\t\tenterRequestContext(resolveContext(opts));\n\t\t\t\ttry {\n\t\t\t\t\tawait use(serviceContext);\n\t\t\t\t} finally {\n\t\t\t\t\texitRequestContext();\n\t\t\t\t}\n\t\t\t},\n\t\t\t{ auto: true },\n\t\t] as const,\n\t};\n}\n\n/**\n * Wrap any Vitest `TestAPI` (including the one returned by\n * `wrapVitestKyselyTransaction`) so every test runs inside\n * `runWithRequestContext`. Compose with the transaction wrappers:\n *\n * @example\n * ```ts\n * import { wrapVitestKyselyTransaction } from '@geekmidas/testkit/kysely';\n * import { withRequestContext } from '@geekmidas/testkit/request-context';\n *\n * const baseIt = wrapVitestKyselyTransaction<DB>(it, { connection: db });\n * const itWithCtx = withRequestContext(baseIt);\n *\n * itWithCtx('runs inside trx + context', async ({ trx, requestContext }) => {\n *   // serviceContext is set up; Service.register({ context }) works here.\n * });\n * ```\n */\nexport function withRequestContext<\n\tT extends TestAPI | ReturnType<TestAPI['extend']>,\n>(testApi: T, opts: RequestContextOptions = {}): T {\n\treturn (testApi as any).extend(requestContextFixture(opts));\n}\n"],"mappings":";;;;;;AA0BA,SAAS,eAAeA,OAA8B,CAAE,GAAE;AACzD,QAAO;EACN,QAAQ,KAAK,UAAU,IAAIC,yCAAc,EAAE,KAAK,OAAQ;EACxD,WAAW,KAAK,aAAa,6BAAY;EACzC,WAAW,KAAK,aAAa,KAAK,KAAK;CACvC;AACD;;;;;;;;;;;;;AAcD,SAAgB,oBACfC,IACAF,OAA8B,CAAE,GACf;AACjB,QAAO,gDAAsB,eAAe,KAAK,EAAE,GAAG;AACtD;;;;;;;;;;;;;;;;AAiBD,SAAgB,sBAAsBA,OAA8B,CAAE,GAAE;AACvE,QAAO,EACN,gBAAgB,CACf,OAEC,EAAM,EACNG,QACI;AASJ,gDAAoB,eAAe,KAAK,CAAC;AACzC,MAAI;AACH,SAAM,IAAIC,oCAAe;EACzB,UAAS;AACT,iDAAoB;EACpB;CACD,GACD,EAAE,MAAM,KAAM,CACd,EACD;AACD;;;;;;;;;;;;;;;;;;;AAoBD,SAAgB,mBAEdC,SAAYL,OAA8B,CAAE,GAAK;AAClD,QAAO,AAAC,QAAgB,OAAO,sBAAsB,KAAK,CAAC;AAC3D"}
+{"version":3,"file":"requestContext.cjs","names":["ConsoleLogger","randomUUID","runWithRequestContext","serviceContext"],"sources":["../src/requestContext.ts"],"sourcesContent":["import { randomUUID } from 'node:crypto';\nimport type { Logger } from '@geekmidas/logger';\nimport { ConsoleLogger } from '@geekmidas/logger/console';\nimport {\n\tenterRequestContext,\n\texitRequestContext,\n\trunWithRequestContext,\n\ttype ServiceContext,\n\tserviceContext,\n} from '@geekmidas/services';\nimport type { TestAPI } from 'vitest';\n\n/**\n * Options for setting up a request context in tests. Any field omitted\n * is filled with a test-friendly default (ConsoleLogger, random UUID,\n * Date.now()).\n */\nexport interface RequestContextOptions {\n\t/** Logger exposed via serviceContext.getLogger(). */\n\tlogger?: Logger;\n\t/** Request id exposed via serviceContext.getRequestId(). */\n\trequestId?: string;\n\t/** Start time exposed via serviceContext.getRequestStartTime(). */\n\tstartTime?: number;\n}\n\nfunction resolveContext(opts: RequestContextOptions = {}) {\n\treturn {\n\t\tlogger: opts.logger ?? new ConsoleLogger({ app: 'test' }),\n\t\trequestId: opts.requestId ?? randomUUID(),\n\t\tstartTime: opts.startTime ?? Date.now(),\n\t};\n}\n\n/**\n * Run a function inside a request context with test-friendly defaults.\n * Useful when you need `serviceContext` to be available for a single call\n * (e.g. invoking `Service.register({ context })` outside a wrapped test).\n *\n * @example\n * ```ts\n * await runInRequestContext(() =>\n *   discovery.register([databaseService]),\n * );\n * ```\n */\nexport function runInRequestContext<T>(\n\tfn: () => T | Promise<T>,\n\topts: RequestContextOptions = {},\n): T | Promise<T> {\n\treturn runWithRequestContext(resolveContext(opts), fn);\n}\n\n/**\n * Vitest fixture creator. Spread the result into `.extend()` and every test\n * runs inside `runWithRequestContext`, even tests that don't destructure\n * `requestContext` directly (the fixture is registered as `auto`).\n *\n * @example\n * ```ts\n * const it = test.extend({ ...requestContextFixture() });\n *\n * it('registers services with context', async ({ requestContext }) => {\n *   await discovery.register([databaseService]);\n *   expect(requestContext.getRequestId()).toBeDefined();\n * });\n * ```\n */\nexport function requestContextFixture(opts: RequestContextOptions = {}) {\n\treturn {\n\t\trequestContext: [\n\t\t\tasync (\n\t\t\t\t// biome-ignore lint/correctness/noEmptyPattern: vitest fixture signature\n\t\t\t\t{}: {},\n\t\t\t\tuse: (value: ServiceContext) => Promise<void>,\n\t\t\t) => {\n\t\t\t\t// Vitest suspends the fixture on `await use(...)` and runs the test\n\t\t\t\t// body in a continuation of the runner's async context. A scoped\n\t\t\t\t// `runWithRequestContext` callback ends as soon as we hand control\n\t\t\t\t// to the runner, so the test body would see no context. Instead,\n\t\t\t\t// mutate the current task's store with `enterRequestContext` —\n\t\t\t\t// async/await preserves that store across the suspension, so the\n\t\t\t\t// test body sees it. We restore on the way out so subsequent tests\n\t\t\t\t// don't inherit the value.\n\t\t\t\tenterRequestContext(resolveContext(opts));\n\t\t\t\ttry {\n\t\t\t\t\tawait use(serviceContext);\n\t\t\t\t} finally {\n\t\t\t\t\texitRequestContext();\n\t\t\t\t}\n\t\t\t},\n\t\t\t{ auto: true },\n\t\t] as const,\n\t};\n}\n\n/**\n * Wrap any Vitest `TestAPI` (including the one returned by\n * `wrapVitestKyselyTransaction`) so every test runs inside\n * `runWithRequestContext`. Compose with the transaction wrappers:\n *\n * @example\n * ```ts\n * import { wrapVitestKyselyTransaction } from '@geekmidas/testkit/kysely';\n * import { withRequestContext } from '@geekmidas/testkit/request-context';\n *\n * const baseIt = wrapVitestKyselyTransaction<DB>(it, { connection: db });\n * const itWithCtx = withRequestContext(baseIt);\n *\n * itWithCtx('runs inside trx + context', async ({ trx, requestContext }) => {\n *   // serviceContext is set up; Service.register({ context }) works here.\n * });\n * ```\n */\nexport function withRequestContext<\n\tT extends TestAPI | ReturnType<TestAPI['extend']>,\n>(testApi: T, opts: RequestContextOptions = {}): T {\n\treturn (testApi as any).extend(requestContextFixture(opts));\n}\n"],"mappings":";;;;;AA0BA,SAAS,eAAe,OAA8B,CAAC,GAAG;CACzD,OAAO;EACN,QAAQ,KAAK,UAAU,IAAIA,0BAAAA,cAAc,EAAE,KAAK,OAAO,CAAC;EACxD,WAAW,KAAK,cAAA,GAAaC,YAAAA,WAAAA,CAAW;EACxC,WAAW,KAAK,aAAa,KAAK,IAAI;CACvC;AACD;;;;;;;;;;;;;AAcA,SAAgB,oBACf,IACA,OAA8B,CAAC,GACd;CACjB,QAAA,GAAOC,oBAAAA,sBAAAA,CAAsB,eAAe,IAAI,GAAG,EAAE;AACtD;;;;;;;;;;;;;;;;AAiBA,SAAgB,sBAAsB,OAA8B,CAAC,GAAG;CACvE,OAAO,EACN,gBAAgB,CACf,OAEC,IACA,QACI;EASJ,CAAA,GAAA,oBAAA,oBAAA,CAAoB,eAAe,IAAI,CAAC;EACxC,IAAI;GACH,MAAM,IAAIC,oBAAAA,cAAc;EACzB,UAAU;GACT,CAAA,GAAA,oBAAA,mBAAA,CAAmB;EACpB;CACD,GACA,EAAE,MAAM,KAAK,CACd,EACD;AACD;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,mBAEd,SAAY,OAA8B,CAAC,GAAM;CAClD,OAAQ,QAAgB,OAAO,sBAAsB,IAAI,CAAC;AAC3D"}

package/dist/requestContext.d.cts

@@ -1,15 +1,13 @@
 import { ServiceContext } from "@geekmidas/services";
 import { TestAPI } from "vitest";
 import { Logger } from "@geekmidas/logger";
-
 //#region src/requestContext.d.ts
-
 /**
  * Options for setting up a request context in tests. Any field omitted
  * is filled with a test-friendly default (ConsoleLogger, random UUID,
  * Date.now()).
  */
-interface RequestContextOptions {
+export interface RequestContextOptions {
   /** Logger exposed via serviceContext.getLogger(). */
   logger?: Logger;
   /** Request id exposed via serviceContext.getRequestId(). */
@@ -29,7 +27,7 @@ interface RequestContextOptions {
  * );
  * ```
  */
-declare function runInRequestContext<T>(fn: () => T | Promise<T>, opts?: RequestContextOptions): T | Promise<T>;
+export declare function runInRequestContext<T>(fn: () => T | Promise<T>, opts?: RequestContextOptions): T | Promise<T>;
 /**
  * Vitest fixture creator. Spread the result into `.extend()` and every test
  * runs inside `runWithRequestContext`, even tests that don't destructure
@@ -45,7 +43,7 @@ declare function runInRequestContext<T>(fn: () => T | Promise<T>, opts?: Request
  * });
  * ```
  */
-declare function requestContextFixture(opts?: RequestContextOptions): {
+export declare function requestContextFixture(opts?: RequestContextOptions): {
   requestContext: readonly [({}: {}, use: (value: ServiceContext) => Promise<void>) => Promise<void>, {
     readonly auto: true;
   }];
@@ -68,8 +66,6 @@ declare function requestContextFixture(opts?: RequestContextOptions): {
  * });
  * ```
  */
-declare function withRequestContext<T extends TestAPI | ReturnType<TestAPI['extend']>>(testApi: T, opts?: RequestContextOptions): T;
-//# sourceMappingURL=requestContext.d.ts.map
+export declare function withRequestContext<T extends TestAPI | ReturnType<TestAPI['extend']>>(testApi: T, opts?: RequestContextOptions): T;
 //#endregion
-export { RequestContextOptions, requestContextFixture, runInRequestContext, withRequestContext };
 //# sourceMappingURL=requestContext.d.cts.map

package/dist/requestContext.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"requestContext.d.cts","names":[],"sources":["../src/requestContext.ts"],"sourcesContent":[],"mappings":";;;;;;;;AAiBA;AA6BA;;AACW,UA9BM,qBAAA,CA8BN;EAAC;EAAY,MAAT,CAAA,EA5BL,MA4BK;EAAO;EACW,SAC9B,CAAA,EAAA,MAAA;EAAC;EAAY,SAAT,CAAA,EAAA,MAAA;AAAO;AAmBd;;;;;;AAMiD;AAwCjD;;;;;AAEW,iBAtEK,mBAsEL,CAAA,CAAA,CAAA,CAAA,EAAA,EAAA,GAAA,GArEA,CAqEA,GArEI,OAqEJ,CArEY,CAqEZ,CAAA,EAAA,IAAA,CAAA,EApEJ,qBAoEI,CAAA,EAnER,CAmEQ,GAnEJ,OAmEI,CAnEI,CAmEJ,CAAA;;;AAAuC;;;;;;;;;;;;;iBAhDlC,qBAAA,QAA4B;kDAM3B,mBAAmB,kBAAa;;;;;;;;;;;;;;;;;;;;;;iBAwCjC,6BACL,UAAU,WAAW,6BACrB,UAAS,wBAA6B"}
+{"version":3,"file":"requestContext.d.cts","names":[],"sources":["../src/requestContext.ts"],"mappings":";;;;;;;;;iBAiBiB;;EAEhB,SAAS;;EAET;;EAEA;;;;;;;;;;;;;;wBAuBe,oBAAoB,GACnC,UAAU,IAAI,QAAQ,IACtB,OAAM,wBACJ,IAAI,QAAQ;;;;;;;;;;;;;;;;wBAmBC,sBAAsB,OAAM;EAE1C,mCAGQ,MACA,OAAO,mBAAmB,kBAAa;aAiB5C;;;;;;;;;;;;;;;;;;;;;wBAuBW,mBACf,UAAU,UAAU,WAAW,oBAC9B,SAAS,GAAG,OAAM,wBAA6B"}

package/dist/requestContext.d.mts

@@ -1,15 +1,13 @@
 import { ServiceContext } from "@geekmidas/services";
 import { TestAPI } from "vitest";
 import { Logger } from "@geekmidas/logger";
-
 //#region src/requestContext.d.ts
-
 /**
  * Options for setting up a request context in tests. Any field omitted
  * is filled with a test-friendly default (ConsoleLogger, random UUID,
  * Date.now()).
  */
-interface RequestContextOptions {
+export interface RequestContextOptions {
   /** Logger exposed via serviceContext.getLogger(). */
   logger?: Logger;
   /** Request id exposed via serviceContext.getRequestId(). */
@@ -29,7 +27,7 @@ interface RequestContextOptions {
  * );
  * ```
  */
-declare function runInRequestContext<T>(fn: () => T | Promise<T>, opts?: RequestContextOptions): T | Promise<T>;
+export declare function runInRequestContext<T>(fn: () => T | Promise<T>, opts?: RequestContextOptions): T | Promise<T>;
 /**
  * Vitest fixture creator. Spread the result into `.extend()` and every test
  * runs inside `runWithRequestContext`, even tests that don't destructure
@@ -45,7 +43,7 @@ declare function runInRequestContext<T>(fn: () => T | Promise<T>, opts?: Request
  * });
  * ```
  */
-declare function requestContextFixture(opts?: RequestContextOptions): {
+export declare function requestContextFixture(opts?: RequestContextOptions): {
   requestContext: readonly [({}: {}, use: (value: ServiceContext) => Promise<void>) => Promise<void>, {
     readonly auto: true;
   }];
@@ -68,8 +66,6 @@ declare function requestContextFixture(opts?: RequestContextOptions): {
  * });
  * ```
  */
-declare function withRequestContext<T extends TestAPI | ReturnType<TestAPI['extend']>>(testApi: T, opts?: RequestContextOptions): T;
-//# sourceMappingURL=requestContext.d.ts.map
+export declare function withRequestContext<T extends TestAPI | ReturnType<TestAPI['extend']>>(testApi: T, opts?: RequestContextOptions): T;
 //#endregion
-export { RequestContextOptions, requestContextFixture, runInRequestContext, withRequestContext };
 //# sourceMappingURL=requestContext.d.mts.map

package/dist/requestContext.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"requestContext.d.mts","names":[],"sources":["../src/requestContext.ts"],"sourcesContent":[],"mappings":";;;;;;;;AAiBA;AA6BA;;AACW,UA9BM,qBAAA,CA8BN;EAAC;EAAY,MAAT,CAAA,EA5BL,MA4BK;EAAO;EACW,SAC9B,CAAA,EAAA,MAAA;EAAC;EAAY,SAAT,CAAA,EAAA,MAAA;AAAO;AAmBd;;;;;;AAMiD;AAwCjD;;;;;AAEW,iBAtEK,mBAsEL,CAAA,CAAA,CAAA,CAAA,EAAA,EAAA,GAAA,GArEA,CAqEA,GArEI,OAqEJ,CArEY,CAqEZ,CAAA,EAAA,IAAA,CAAA,EApEJ,qBAoEI,CAAA,EAnER,CAmEQ,GAnEJ,OAmEI,CAnEI,CAmEJ,CAAA;;;AAAuC;;;;;;;;;;;;;iBAhDlC,qBAAA,QAA4B;kDAM3B,mBAAmB,kBAAa;;;;;;;;;;;;;;;;;;;;;;iBAwCjC,6BACL,UAAU,WAAW,6BACrB,UAAS,wBAA6B"}
+{"version":3,"file":"requestContext.d.mts","names":[],"sources":["../src/requestContext.ts"],"mappings":";;;;;;;;;iBAiBiB;;EAEhB,SAAS;;EAET;;EAEA;;;;;;;;;;;;;;wBAuBe,oBAAoB,GACnC,UAAU,IAAI,QAAQ,IACtB,OAAM,wBACJ,IAAI,QAAQ;;;;;;;;;;;;;;;;wBAmBC,sBAAsB,OAAM;EAE1C,mCAGQ,MACA,OAAO,mBAAmB,kBAAa;aAiB5C;;;;;;;;;;;;;;;;;;;;;wBAuBW,mBACf,UAAU,UAAU,WAAW,oBAC9B,SAAS,GAAG,OAAM,wBAA6B"}

package/dist/requestContext.mjs

@@ -1,7 +1,6 @@
 import { enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext } from "@geekmidas/services";
 import { randomUUID } from "node:crypto";
 import { ConsoleLogger } from "@geekmidas/logger/console";
-
 //#region src/requestContext.ts
 function resolveContext(opts = {}) {
 	return {
@@ -71,7 +70,7 @@ function requestContextFixture(opts = {}) {
 function withRequestContext(testApi, opts = {}) {
 	return testApi.extend(requestContextFixture(opts));
 }
-
 //#endregion
 export { requestContextFixture, runInRequestContext, withRequestContext };
+
 //# sourceMappingURL=requestContext.mjs.map

package/dist/requestContext.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"requestContext.mjs","names":["opts: RequestContextOptions","fn: () => T | Promise<T>","use: (value: ServiceContext) => Promise<void>","testApi: T"],"sources":["../src/requestContext.ts"],"sourcesContent":["import { randomUUID } from 'node:crypto';\nimport type { Logger } from '@geekmidas/logger';\nimport { ConsoleLogger } from '@geekmidas/logger/console';\nimport {\n\tenterRequestContext,\n\texitRequestContext,\n\trunWithRequestContext,\n\ttype ServiceContext,\n\tserviceContext,\n} from '@geekmidas/services';\nimport type { TestAPI } from 'vitest';\n\n/**\n * Options for setting up a request context in tests. Any field omitted\n * is filled with a test-friendly default (ConsoleLogger, random UUID,\n * Date.now()).\n */\nexport interface RequestContextOptions {\n\t/** Logger exposed via serviceContext.getLogger(). */\n\tlogger?: Logger;\n\t/** Request id exposed via serviceContext.getRequestId(). */\n\trequestId?: string;\n\t/** Start time exposed via serviceContext.getRequestStartTime(). */\n\tstartTime?: number;\n}\n\nfunction resolveContext(opts: RequestContextOptions = {}) {\n\treturn {\n\t\tlogger: opts.logger ?? new ConsoleLogger({ app: 'test' }),\n\t\trequestId: opts.requestId ?? randomUUID(),\n\t\tstartTime: opts.startTime ?? Date.now(),\n\t};\n}\n\n/**\n * Run a function inside a request context with test-friendly defaults.\n * Useful when you need `serviceContext` to be available for a single call\n * (e.g. invoking `Service.register({ context })` outside a wrapped test).\n *\n * @example\n * ```ts\n * await runInRequestContext(() =>\n *   discovery.register([databaseService]),\n * );\n * ```\n */\nexport function runInRequestContext<T>(\n\tfn: () => T | Promise<T>,\n\topts: RequestContextOptions = {},\n): T | Promise<T> {\n\treturn runWithRequestContext(resolveContext(opts), fn);\n}\n\n/**\n * Vitest fixture creator. Spread the result into `.extend()` and every test\n * runs inside `runWithRequestContext`, even tests that don't destructure\n * `requestContext` directly (the fixture is registered as `auto`).\n *\n * @example\n * ```ts\n * const it = test.extend({ ...requestContextFixture() });\n *\n * it('registers services with context', async ({ requestContext }) => {\n *   await discovery.register([databaseService]);\n *   expect(requestContext.getRequestId()).toBeDefined();\n * });\n * ```\n */\nexport function requestContextFixture(opts: RequestContextOptions = {}) {\n\treturn {\n\t\trequestContext: [\n\t\t\tasync (\n\t\t\t\t// biome-ignore lint/correctness/noEmptyPattern: vitest fixture signature\n\t\t\t\t{}: {},\n\t\t\t\tuse: (value: ServiceContext) => Promise<void>,\n\t\t\t) => {\n\t\t\t\t// Vitest suspends the fixture on `await use(...)` and runs the test\n\t\t\t\t// body in a continuation of the runner's async context. A scoped\n\t\t\t\t// `runWithRequestContext` callback ends as soon as we hand control\n\t\t\t\t// to the runner, so the test body would see no context. Instead,\n\t\t\t\t// mutate the current task's store with `enterRequestContext` —\n\t\t\t\t// async/await preserves that store across the suspension, so the\n\t\t\t\t// test body sees it. We restore on the way out so subsequent tests\n\t\t\t\t// don't inherit the value.\n\t\t\t\tenterRequestContext(resolveContext(opts));\n\t\t\t\ttry {\n\t\t\t\t\tawait use(serviceContext);\n\t\t\t\t} finally {\n\t\t\t\t\texitRequestContext();\n\t\t\t\t}\n\t\t\t},\n\t\t\t{ auto: true },\n\t\t] as const,\n\t};\n}\n\n/**\n * Wrap any Vitest `TestAPI` (including the one returned by\n * `wrapVitestKyselyTransaction`) so every test runs inside\n * `runWithRequestContext`. Compose with the transaction wrappers:\n *\n * @example\n * ```ts\n * import { wrapVitestKyselyTransaction } from '@geekmidas/testkit/kysely';\n * import { withRequestContext } from '@geekmidas/testkit/request-context';\n *\n * const baseIt = wrapVitestKyselyTransaction<DB>(it, { connection: db });\n * const itWithCtx = withRequestContext(baseIt);\n *\n * itWithCtx('runs inside trx + context', async ({ trx, requestContext }) => {\n *   // serviceContext is set up; Service.register({ context }) works here.\n * });\n * ```\n */\nexport function withRequestContext<\n\tT extends TestAPI | ReturnType<TestAPI['extend']>,\n>(testApi: T, opts: RequestContextOptions = {}): T {\n\treturn (testApi as any).extend(requestContextFixture(opts));\n}\n"],"mappings":";;;;;AA0BA,SAAS,eAAeA,OAA8B,CAAE,GAAE;AACzD,QAAO;EACN,QAAQ,KAAK,UAAU,IAAI,cAAc,EAAE,KAAK,OAAQ;EACxD,WAAW,KAAK,aAAa,YAAY;EACzC,WAAW,KAAK,aAAa,KAAK,KAAK;CACvC;AACD;;;;;;;;;;;;;AAcD,SAAgB,oBACfC,IACAD,OAA8B,CAAE,GACf;AACjB,QAAO,sBAAsB,eAAe,KAAK,EAAE,GAAG;AACtD;;;;;;;;;;;;;;;;AAiBD,SAAgB,sBAAsBA,OAA8B,CAAE,GAAE;AACvE,QAAO,EACN,gBAAgB,CACf,OAEC,EAAM,EACNE,QACI;AASJ,sBAAoB,eAAe,KAAK,CAAC;AACzC,MAAI;AACH,SAAM,IAAI,eAAe;EACzB,UAAS;AACT,uBAAoB;EACpB;CACD,GACD,EAAE,MAAM,KAAM,CACd,EACD;AACD;;;;;;;;;;;;;;;;;;;AAoBD,SAAgB,mBAEdC,SAAYH,OAA8B,CAAE,GAAK;AAClD,QAAO,AAAC,QAAgB,OAAO,sBAAsB,KAAK,CAAC;AAC3D"}
+{"version":3,"file":"requestContext.mjs","names":[],"sources":["../src/requestContext.ts"],"sourcesContent":["import { randomUUID } from 'node:crypto';\nimport type { Logger } from '@geekmidas/logger';\nimport { ConsoleLogger } from '@geekmidas/logger/console';\nimport {\n\tenterRequestContext,\n\texitRequestContext,\n\trunWithRequestContext,\n\ttype ServiceContext,\n\tserviceContext,\n} from '@geekmidas/services';\nimport type { TestAPI } from 'vitest';\n\n/**\n * Options for setting up a request context in tests. Any field omitted\n * is filled with a test-friendly default (ConsoleLogger, random UUID,\n * Date.now()).\n */\nexport interface RequestContextOptions {\n\t/** Logger exposed via serviceContext.getLogger(). */\n\tlogger?: Logger;\n\t/** Request id exposed via serviceContext.getRequestId(). */\n\trequestId?: string;\n\t/** Start time exposed via serviceContext.getRequestStartTime(). */\n\tstartTime?: number;\n}\n\nfunction resolveContext(opts: RequestContextOptions = {}) {\n\treturn {\n\t\tlogger: opts.logger ?? new ConsoleLogger({ app: 'test' }),\n\t\trequestId: opts.requestId ?? randomUUID(),\n\t\tstartTime: opts.startTime ?? Date.now(),\n\t};\n}\n\n/**\n * Run a function inside a request context with test-friendly defaults.\n * Useful when you need `serviceContext` to be available for a single call\n * (e.g. invoking `Service.register({ context })` outside a wrapped test).\n *\n * @example\n * ```ts\n * await runInRequestContext(() =>\n *   discovery.register([databaseService]),\n * );\n * ```\n */\nexport function runInRequestContext<T>(\n\tfn: () => T | Promise<T>,\n\topts: RequestContextOptions = {},\n): T | Promise<T> {\n\treturn runWithRequestContext(resolveContext(opts), fn);\n}\n\n/**\n * Vitest fixture creator. Spread the result into `.extend()` and every test\n * runs inside `runWithRequestContext`, even tests that don't destructure\n * `requestContext` directly (the fixture is registered as `auto`).\n *\n * @example\n * ```ts\n * const it = test.extend({ ...requestContextFixture() });\n *\n * it('registers services with context', async ({ requestContext }) => {\n *   await discovery.register([databaseService]);\n *   expect(requestContext.getRequestId()).toBeDefined();\n * });\n * ```\n */\nexport function requestContextFixture(opts: RequestContextOptions = {}) {\n\treturn {\n\t\trequestContext: [\n\t\t\tasync (\n\t\t\t\t// biome-ignore lint/correctness/noEmptyPattern: vitest fixture signature\n\t\t\t\t{}: {},\n\t\t\t\tuse: (value: ServiceContext) => Promise<void>,\n\t\t\t) => {\n\t\t\t\t// Vitest suspends the fixture on `await use(...)` and runs the test\n\t\t\t\t// body in a continuation of the runner's async context. A scoped\n\t\t\t\t// `runWithRequestContext` callback ends as soon as we hand control\n\t\t\t\t// to the runner, so the test body would see no context. Instead,\n\t\t\t\t// mutate the current task's store with `enterRequestContext` —\n\t\t\t\t// async/await preserves that store across the suspension, so the\n\t\t\t\t// test body sees it. We restore on the way out so subsequent tests\n\t\t\t\t// don't inherit the value.\n\t\t\t\tenterRequestContext(resolveContext(opts));\n\t\t\t\ttry {\n\t\t\t\t\tawait use(serviceContext);\n\t\t\t\t} finally {\n\t\t\t\t\texitRequestContext();\n\t\t\t\t}\n\t\t\t},\n\t\t\t{ auto: true },\n\t\t] as const,\n\t};\n}\n\n/**\n * Wrap any Vitest `TestAPI` (including the one returned by\n * `wrapVitestKyselyTransaction`) so every test runs inside\n * `runWithRequestContext`. Compose with the transaction wrappers:\n *\n * @example\n * ```ts\n * import { wrapVitestKyselyTransaction } from '@geekmidas/testkit/kysely';\n * import { withRequestContext } from '@geekmidas/testkit/request-context';\n *\n * const baseIt = wrapVitestKyselyTransaction<DB>(it, { connection: db });\n * const itWithCtx = withRequestContext(baseIt);\n *\n * itWithCtx('runs inside trx + context', async ({ trx, requestContext }) => {\n *   // serviceContext is set up; Service.register({ context }) works here.\n * });\n * ```\n */\nexport function withRequestContext<\n\tT extends TestAPI | ReturnType<TestAPI['extend']>,\n>(testApi: T, opts: RequestContextOptions = {}): T {\n\treturn (testApi as any).extend(requestContextFixture(opts));\n}\n"],"mappings":";;;;AA0BA,SAAS,eAAe,OAA8B,CAAC,GAAG;CACzD,OAAO;EACN,QAAQ,KAAK,UAAU,IAAI,cAAc,EAAE,KAAK,OAAO,CAAC;EACxD,WAAW,KAAK,aAAa,WAAW;EACxC,WAAW,KAAK,aAAa,KAAK,IAAI;CACvC;AACD;;;;;;;;;;;;;AAcA,SAAgB,oBACf,IACA,OAA8B,CAAC,GACd;CACjB,OAAO,sBAAsB,eAAe,IAAI,GAAG,EAAE;AACtD;;;;;;;;;;;;;;;;AAiBA,SAAgB,sBAAsB,OAA8B,CAAC,GAAG;CACvE,OAAO,EACN,gBAAgB,CACf,OAEC,IACA,QACI;EASJ,oBAAoB,eAAe,IAAI,CAAC;EACxC,IAAI;GACH,MAAM,IAAI,cAAc;EACzB,UAAU;GACT,mBAAmB;EACpB;CACD,GACA,EAAE,MAAM,KAAK,CACd,EACD;AACD;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,mBAEd,SAAY,OAA8B,CAAC,GAAM;CAClD,OAAQ,QAAgB,OAAO,sBAAsB,IAAI,CAAC;AAC3D"}

package/dist/{chunk-CUT6urMc.cjs → rolldown-runtime-VH7oDXx4.cjs}

@@ -1,4 +1,4 @@
-//#region rolldown:runtime
+//#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -15,16 +15,14 @@ var __copyProps = (to, from, except, desc) => {
 	}
 	return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
 	value: mod,
 	enumerable: true
 }) : target, mod));
-
 //#endregion
-
-Object.defineProperty(exports, '__toESM', {
-  enumerable: true,
-  get: function () {
-    return __toESM;
-  }
-});
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});

package/dist/timer.cjs

@@ -1,9 +1,9 @@
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 //#region src/timer.ts
 function waitFor(ms) {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
-
 //#endregion
 exports.waitFor = waitFor;
+
 //# sourceMappingURL=timer.cjs.map

package/dist/timer.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"timer.cjs","names":["ms: number"],"sources":["../src/timer.ts"],"sourcesContent":["export function waitFor(ms: number) {\n\treturn new Promise((resolve) => setTimeout(resolve, ms));\n}\n"],"mappings":";;AAAA,SAAgB,QAAQA,IAAY;AACnC,QAAO,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,GAAG;AACvD"}
+{"version":3,"file":"timer.cjs","names":[],"sources":["../src/timer.ts"],"sourcesContent":["export function waitFor(ms: number) {\n\treturn new Promise((resolve) => setTimeout(resolve, ms));\n}\n"],"mappings":";;AAAA,SAAgB,QAAQ,IAAY;CACnC,OAAO,IAAI,SAAS,YAAY,WAAW,SAAS,EAAE,CAAC;AACxD"}

package/dist/timer.d.cts

@@ -1,7 +1,4 @@
 //#region src/timer.d.ts
-declare function waitFor(ms: number): Promise<unknown>;
-//# sourceMappingURL=timer.d.ts.map
-
+export declare function waitFor(ms: number): Promise<unknown>;
 //#endregion
-export { waitFor };
 //# sourceMappingURL=timer.d.cts.map

package/dist/timer.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"timer.d.cts","names":[],"sources":["../src/timer.ts"],"sourcesContent":[],"mappings":";iBAAgB,OAAA,cAAkB;AAAlC"}
+{"version":3,"file":"timer.d.cts","names":[],"sources":["../src/timer.ts"],"mappings":";wBAAgB,QAAQ,aAAU"}

package/dist/timer.d.mts

@@ -1,7 +1,4 @@
 //#region src/timer.d.ts
-declare function waitFor(ms: number): Promise<unknown>;
-//# sourceMappingURL=timer.d.ts.map
-
+export declare function waitFor(ms: number): Promise<unknown>;
 //#endregion
-export { waitFor };
 //# sourceMappingURL=timer.d.mts.map

package/dist/timer.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"timer.d.mts","names":[],"sources":["../src/timer.ts"],"sourcesContent":[],"mappings":";iBAAgB,OAAA,cAAkB;AAAlC"}
+{"version":3,"file":"timer.d.mts","names":[],"sources":["../src/timer.ts"],"mappings":";wBAAgB,QAAQ,aAAU"}

package/dist/timer.mjs

@@ -2,7 +2,7 @@
 function waitFor(ms) {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
-
 //#endregion
 export { waitFor };
+
 //# sourceMappingURL=timer.mjs.map

package/dist/timer.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"timer.mjs","names":["ms: number"],"sources":["../src/timer.ts"],"sourcesContent":["export function waitFor(ms: number) {\n\treturn new Promise((resolve) => setTimeout(resolve, ms));\n}\n"],"mappings":";AAAA,SAAgB,QAAQA,IAAY;AACnC,QAAO,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,GAAG;AACvD"}
+{"version":3,"file":"timer.mjs","names":[],"sources":["../src/timer.ts"],"sourcesContent":["export function waitFor(ms: number) {\n\treturn new Promise((resolve) => setTimeout(resolve, ms));\n}\n"],"mappings":";AAAA,SAAgB,QAAQ,IAAY;CACnC,OAAO,IAAI,SAAS,YAAY,WAAW,SAAS,EAAE,CAAC;AACxD"}

package/dist/transactions.cjs

@@ -0,0 +1,123 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
+let pg = require("pg");
+pg = require_rolldown_runtime.__toESM(pg, 1);
+let kysely = require("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.default.Client(connectionConfig(url));
+	await client.connect();
+	await client.query("BEGIN");
+	return {
+		db: new kysely.Kysely({
+			...config,
+			dialect: new kysely.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
+exports.TransactionRegistry = TransactionRegistry;
+exports.connectionConfig = connectionConfig;
+exports.openBoundTransaction = openBoundTransaction;
+
+//# sourceMappingURL=transactions.cjs.map

package/dist/transactions.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"transactions.cjs","names":["Kysely","PostgresDialect"],"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,GAAA,QAAG,OAAO,iBAAiB,GAAG,CAAC;CAClD,MAAM,OAAO,QAAQ;CACrB,MAAM,OAAO,MAAM,OAAO;CAE1B,OAAO;EACN,IAAI,IAAIA,OAAAA,OAAO;GACd,GAAG;GACH,SAAS,IAAIC,OAAAA,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/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"}