@geekmidas/testkit 10.0.0-alpha.2 → 10.0.0-alpha.20

package/dist/objection.d.cts

@@ -1,19 +1,16 @@
-import { FakerFactory, faker } from "./faker-Dg3trU4a.cjs";
-import { ExtractSeedAttrs, FactorySeed } from "./Factory-Cwzho3c8.cjs";
-import { ObjectionFactory } from "./ObjectionFactory-DW-qwnqO.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-DsYCplsG.mjs";
-import { ExtractSeedAttrs, FactorySeed } from "./Factory-CVR3GdkW.mjs";
-import { ObjectionFactory } from "./ObjectionFactory-DkJUf-uM.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-C6DuuNyc.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"}

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-C6DuuNyc.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"}