@geekmidas/testkit 1.0.7 → 1.0.8

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @geekmidas/testkit
 
+## 1.0.8
+
+### Patch Changes
+
+- ✨ [`351f73b`](https://github.com/geekmidas/toolbox/commit/351f73b032bc0742b7f611a9fbcdfc85bbfd69a8) Thanks [@geekmidas](https://github.com/geekmidas)! - Update request context and add support for trpc
+
+- Updated dependencies [[`351f73b`](https://github.com/geekmidas/toolbox/commit/351f73b032bc0742b7f611a9fbcdfc85bbfd69a8)]:
+  - @geekmidas/services@1.0.3
+
 ## 1.0.7
 
 ### Patch Changes

package/dist/{Factory-_w0_BN4J.d.mts → Factory-C6W78ulZ.d.mts}

@@ -1,4 +1,4 @@
-import { FakerFactory } from "./faker-Br8MzXil.mjs";
+import { FakerFactory } from "./faker-D9gz7KjY.mjs";
 
 //#region src/Factory.d.ts
 
@@ -144,4 +144,4 @@ type ExtractSeedAttrs<T> = T extends ((context: {
 //# sourceMappingURL=Factory.d.ts.map
 //#endregion
 export { ExtractSeedAttrs, Factory, FactorySeed, MixedFactoryBuilder };
-//# sourceMappingURL=Factory-_w0_BN4J.d.mts.map
+//# sourceMappingURL=Factory-C6W78ulZ.d.mts.map

package/dist/{Factory-_w0_BN4J.d.mts.map → Factory-C6W78ulZ.d.mts.map}

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

package/dist/Factory.d.mts

@@ -1,3 +1,3 @@
-import "./faker-Br8MzXil.mjs";
-import { ExtractSeedAttrs, Factory, FactorySeed, MixedFactoryBuilder } from "./Factory-_w0_BN4J.mjs";
+import "./faker-D9gz7KjY.mjs";
+import { ExtractSeedAttrs, Factory, FactorySeed, MixedFactoryBuilder } from "./Factory-C6W78ulZ.mjs";
 export { ExtractSeedAttrs, Factory, FactorySeed, MixedFactoryBuilder };

package/dist/{KyselyFactory-BFxq2hz5.d.mts → KyselyFactory-Cc2UmOJk.d.mts}

@@ -1,5 +1,5 @@
-import { FakerFactory } from "./faker-Br8MzXil.mjs";
-import { ExtractSeedAttrs, Factory, FactorySeed } from "./Factory-_w0_BN4J.mjs";
+import { FakerFactory } from "./faker-D9gz7KjY.mjs";
+import { ExtractSeedAttrs, Factory, FactorySeed } from "./Factory-C6W78ulZ.mjs";
 import { ControlledTransaction, Insertable, Kysely, Selectable } from "kysely";
 
 //#region src/KyselyFactory.d.ts
@@ -225,4 +225,4 @@ declare class KyselyFactory<DB, Builders extends Record<string, any>, Seeds exte
 //# sourceMappingURL=KyselyFactory.d.ts.map
 //#endregion
 export { KyselyFactory };
-//# sourceMappingURL=KyselyFactory-BFxq2hz5.d.mts.map
+//# sourceMappingURL=KyselyFactory-Cc2UmOJk.d.mts.map

package/dist/{KyselyFactory-BFxq2hz5.d.mts.map → KyselyFactory-Cc2UmOJk.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"KyselyFactory-BFxq2hz5.d.mts","names":[],"sources":["../src/KyselyFactory.ts"],"sourcesContent":[],"mappings":";;;;;;;;AA+CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4GK,cA5GQ,aA4GR,CAAA,EAAA,EAAA,iBA1Ga,MA0Gb,CAAA,MAAA,EAAA,GAAA,CAAA,EAAA,cAzGU,MAyGV,CAAA,MAAA,EAAA,GAAA,CAAA,CAAA,SAxGK,OAwGL,CAxGa,QAwGb,EAxGuB,KAwGvB,CAAA,CAAA;EAAO,QACoB,QAAA;EAAE,QAAC,KAAA;EAAS,QAAvB,EAAA;EAAU;;;;;;;;;;;;;;;;;;;;;EAwJf,OACK,UAAA,CAAA,aA5OoB,WA4OpB,CAAA,CAAA,MAAA,EA5OyC,IA4OzC,CAAA,EA5OgD,IA4OhD;EAAQ;;;;;;;EAClB,WACuB,CAAA,QAAA,EAlOd,QAkOc,EAAA,KAAA,EAjOjB,KAiOiB,EAAA,EAAA,EAhOpB,MAgOoB,CAhOb,EAgOa,CAAA,GAhOP,qBAgOO,CAhOe,EAgOf,EAAA,EAAA,CAAA;EAAQ;;;;;;;;;;;;;;;;;;;;;;;AApQzB;;;;;;;;;;;;;;;;;;;;;;;;mDA0FS,2BACV,QAAQ,WAAW,GAAG,eAAe,QAClD,WAAW,GAAG,sCAGN,WAAW,GAAG,oBAEhB;WAEC;aACE;QACL,OAAO;WACJ;QAEL,QAAQ,WAAW,GAAG,eACtB,QAAQ,QAAQ,WAAW,GAAG,8CAG1B,gBACE,aACL,OAAO,YACJ,iBACH,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAuEgB,uBACf,WACL,WAAW,SAAS,SAC1B,QAAQ,QAAQ,WAAW,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAqEN,sCAEnB,WACL,WAAW,SAAS,SAC1B,QAAQ,QAAQ,WAAW,SAAS;6BACN,sCAEnB,+BAGL,iBACH,WAAW,SAAS,SAAS,QAAQ,WAAW,SAAS,UAC5D,QAAQ,QAAQ,WAAW,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAsDlB,iBACV,WACF,iBAAiB,MAAM,MAC7B,WAAW,MAAM"}
+{"version":3,"file":"KyselyFactory-Cc2UmOJk.d.mts","names":[],"sources":["../src/KyselyFactory.ts"],"sourcesContent":[],"mappings":";;;;;;;;AA+CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4GK,cA5GQ,aA4GR,CAAA,EAAA,EAAA,iBA1Ga,MA0Gb,CAAA,MAAA,EAAA,GAAA,CAAA,EAAA,cAzGU,MAyGV,CAAA,MAAA,EAAA,GAAA,CAAA,CAAA,SAxGK,OAwGL,CAxGa,QAwGb,EAxGuB,KAwGvB,CAAA,CAAA;EAAO,QACoB,QAAA;EAAE,QAAC,KAAA;EAAS,QAAvB,EAAA;EAAU;;;;;;;;;;;;;;;;;;;;;EAwJf,OACK,UAAA,CAAA,aA5OoB,WA4OpB,CAAA,CAAA,MAAA,EA5OyC,IA4OzC,CAAA,EA5OgD,IA4OhD;EAAQ;;;;;;;EAClB,WACuB,CAAA,QAAA,EAlOd,QAkOc,EAAA,KAAA,EAjOjB,KAiOiB,EAAA,EAAA,EAhOpB,MAgOoB,CAhOb,EAgOa,CAAA,GAhOP,qBAgOO,CAhOe,EAgOf,EAAA,EAAA,CAAA;EAAQ;;;;;;;;;;;;;;;;;;;;;;;AApQzB;;;;;;;;;;;;;;;;;;;;;;;;mDA0FS,2BACV,QAAQ,WAAW,GAAG,eAAe,QAClD,WAAW,GAAG,sCAGN,WAAW,GAAG,oBAEhB;WAEC;aACE;QACL,OAAO;WACJ;QAEL,QAAQ,WAAW,GAAG,eACtB,QAAQ,QAAQ,WAAW,GAAG,8CAG1B,gBACE,aACL,OAAO,YACJ,iBACH,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAuEgB,uBACf,WACL,WAAW,SAAS,SAC1B,QAAQ,QAAQ,WAAW,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAqEN,sCAEnB,WACL,WAAW,SAAS,SAC1B,QAAQ,QAAQ,WAAW,SAAS;6BACN,sCAEnB,+BAGL,iBACH,WAAW,SAAS,SAAS,QAAQ,WAAW,SAAS,UAC5D,QAAQ,QAAQ,WAAW,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAsDlB,iBACV,WACF,iBAAiB,MAAM,MAC7B,WAAW,MAAM"}

package/dist/KyselyFactory.d.mts

@@ -1,4 +1,4 @@
-import "./faker-Br8MzXil.mjs";
-import "./Factory-_w0_BN4J.mjs";
-import { KyselyFactory } from "./KyselyFactory-BFxq2hz5.mjs";
+import "./faker-D9gz7KjY.mjs";
+import "./Factory-C6W78ulZ.mjs";
+import { KyselyFactory } from "./KyselyFactory-Cc2UmOJk.mjs";
 export { KyselyFactory };

package/dist/{ObjectionFactory-C4IsQ_wj.d.mts → ObjectionFactory-BYnPr9ZP.d.mts}

@@ -1,5 +1,5 @@
-import { FakerFactory } from "./faker-Br8MzXil.mjs";
-import { ExtractSeedAttrs, Factory, FactorySeed } from "./Factory-_w0_BN4J.mjs";
+import { FakerFactory } from "./faker-D9gz7KjY.mjs";
+import { ExtractSeedAttrs, Factory, FactorySeed } from "./Factory-C6W78ulZ.mjs";
 import { Knex } from "knex";
 import { Model } from "objection";
 
@@ -238,4 +238,4 @@ declare class ObjectionFactory<Builders extends Record<string, any>, Seeds exten
 //# sourceMappingURL=ObjectionFactory.d.ts.map
 //#endregion
 export { ObjectionFactory };
-//# sourceMappingURL=ObjectionFactory-C4IsQ_wj.d.mts.map
+//# sourceMappingURL=ObjectionFactory-BYnPr9ZP.d.mts.map

package/dist/{ObjectionFactory-C4IsQ_wj.d.mts.map → ObjectionFactory-BYnPr9ZP.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"ObjectionFactory-C4IsQ_wj.d.mts","names":[],"sources":["../src/ObjectionFactory.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAyCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0Gc,cA1GD,gBA0GC,CAAA,iBAzGI,MAyGJ,CAAA,MAAA,EAAA,GAAA,CAAA,EAAA,cAxGC,MAwGD,CAAA,MAAA,EAAA,GAAA,CAAA,CAAA,SAvGJ,OAuGI,CAvGI,QAuGJ,EAvGc,KAuGd,CAAA,CAAA;EAAM,QAAd,QAAA;EAAO,QAqDO,KAAA;EAAQ,QACX,EAAA;EAAK;;;;;;;;;;;;;;;;;;;;;EA2GX,OACuB,UAAA,CAAA,aAnPO,WAmPP,CAAA,CAAA,MAAA,EAnP4B,IAmP5B,CAAA,EAnPmC,IAmPnC;EAAQ;;;;;;;;;;;;;;;;;;;AAzQzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6CAmFO,qBACR,QAAQ,aAAa,WAAW,QAAQ,aAAa,kCAE1D,aAAa,qBAEV;WAEJ;aACE;QACL;WACG;QAEL,QAAQ,aAAa,WACrB,QAAQ,QAAQ,aAAa,0CAGzB,gBACE,aACL,aACG,iBACH,QAAQ;;;;;;;;wBAqDM,iBACH,WACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAoCgB,uBACf,WACL,WAAW,SAAS,SAC1B,QAAQ,QAAQ,WAAW,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BA+DN,sCAEnB,WACL,WAAW,SAAS,SAC1B,QAAQ,QAAQ,WAAW,SAAS;6BACN,sCAEnB,+BACe,iBAAiB,WAAW,SAAS,SAC/D,QAAQ,QAAQ,WAAW,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAgFlB,iBACV,WACF,iBAAiB,MAAM,MAC7B,WAAW,MAAM"}
+{"version":3,"file":"ObjectionFactory-BYnPr9ZP.d.mts","names":[],"sources":["../src/ObjectionFactory.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAyCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0Gc,cA1GD,gBA0GC,CAAA,iBAzGI,MAyGJ,CAAA,MAAA,EAAA,GAAA,CAAA,EAAA,cAxGC,MAwGD,CAAA,MAAA,EAAA,GAAA,CAAA,CAAA,SAvGJ,OAuGI,CAvGI,QAuGJ,EAvGc,KAuGd,CAAA,CAAA;EAAM,QAAd,QAAA;EAAO,QAqDO,KAAA;EAAQ,QACX,EAAA;EAAK;;;;;;;;;;;;;;;;;;;;;EA2GX,OACuB,UAAA,CAAA,aAnPO,WAmPP,CAAA,CAAA,MAAA,EAnP4B,IAmP5B,CAAA,EAnPmC,IAmPnC;EAAQ;;;;;;;;;;;;;;;;;;;AAzQzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6CAmFO,qBACR,QAAQ,aAAa,WAAW,QAAQ,aAAa,kCAE1D,aAAa,qBAEV;WAEJ;aACE;QACL;WACG;QAEL,QAAQ,aAAa,WACrB,QAAQ,QAAQ,aAAa,0CAGzB,gBACE,aACL,aACG,iBACH,QAAQ;;;;;;;;wBAqDM,iBACH,WACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAoCgB,uBACf,WACL,WAAW,SAAS,SAC1B,QAAQ,QAAQ,WAAW,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BA+DN,sCAEnB,WACL,WAAW,SAAS,SAC1B,QAAQ,QAAQ,WAAW,SAAS;6BACN,sCAEnB,+BACe,iBAAiB,WAAW,SAAS,SAC/D,QAAQ,QAAQ,WAAW,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAgFlB,iBACV,WACF,iBAAiB,MAAM,MAC7B,WAAW,MAAM"}

package/dist/ObjectionFactory.d.mts

@@ -1,4 +1,4 @@
-import "./faker-Br8MzXil.mjs";
-import "./Factory-_w0_BN4J.mjs";
-import { ObjectionFactory } from "./ObjectionFactory-C4IsQ_wj.mjs";
+import "./faker-D9gz7KjY.mjs";
+import "./Factory-C6W78ulZ.mjs";
+import { ObjectionFactory } from "./ObjectionFactory-BYnPr9ZP.mjs";
 export { ObjectionFactory };

package/dist/better-auth.d.mts

@@ -1,4 +1,4 @@
-import * as better_auth_adapters4 from "better-auth/adapters";
+import * as better_auth_adapters6 from "better-auth/adapters";
 import { DBAdapterDebugLogOption } from "better-auth/adapters";
 
 //#region src/better-auth.d.ts
@@ -7,7 +7,7 @@ interface MemoryAdapterConfig {
   usePlural?: boolean;
   initialData?: Record<string, any[]>;
 }
-declare const memoryAdapter: (config?: MemoryAdapterConfig, store?: Map<any, any>) => better_auth_adapters4.AdapterFactory & {
+declare const memoryAdapter: (config?: MemoryAdapterConfig, store?: Map<any, any>) => better_auth_adapters6.AdapterFactory & {
   clear: () => void;
   getAllData: () => Record<string, any[]>;
   getStore: () => Map<any, any>;

package/dist/{directory-DAVs0Yaq.d.mts → directory-DGOcVlKD.d.cts}

@@ -1,7 +1,7 @@
-import * as vitest3 from "vitest";
+import * as vitest6 from "vitest";
 
 //#region src/os/directory.d.ts
-declare const itWithDir: vitest3.TestAPI<{
+declare const itWithDir: vitest6.TestAPI<{
   dir: string;
 }>;
 interface DirectoryFixtures {
@@ -10,4 +10,4 @@ interface DirectoryFixtures {
 //# sourceMappingURL=directory.d.ts.map
 //#endregion
 export { DirectoryFixtures, itWithDir };
-//# sourceMappingURL=directory-DAVs0Yaq.d.mts.map
+//# sourceMappingURL=directory-DGOcVlKD.d.cts.map

package/dist/{directory-DAVs0Yaq.d.mts.map → directory-DGOcVlKD.d.cts.map}

@@ -1 +1 @@
-{"version":3,"file":"directory-DAVs0Yaq.d.mts","names":[],"sources":["../src/os/directory.ts"],"sourcesContent":[],"mappings":";;;cAMa,WAeX,OAAA,CAfoB;;;AAAT,UAiBI,iBAAA,CAjBK;EAiBL,GAAA,EAAA,MAAA"}
+{"version":3,"file":"directory-DGOcVlKD.d.cts","names":[],"sources":["../src/os/directory.ts"],"sourcesContent":[],"mappings":";;;cAMa,WAeX,OAAA,CAfoB;;;AAAT,UAiBI,iBAAA,CAjBK;EAiBL,GAAA,EAAA,MAAA"}

package/dist/{directory-DAnMWi50.d.cts → directory-DiQ_DkaF.d.mts}

@@ -1,7 +1,7 @@
-import * as vitest4 from "vitest";
+import * as vitest5 from "vitest";
 
 //#region src/os/directory.d.ts
-declare const itWithDir: vitest4.TestAPI<{
+declare const itWithDir: vitest5.TestAPI<{
   dir: string;
 }>;
 interface DirectoryFixtures {
@@ -10,4 +10,4 @@ interface DirectoryFixtures {
 //# sourceMappingURL=directory.d.ts.map
 //#endregion
 export { DirectoryFixtures, itWithDir };
-//# sourceMappingURL=directory-DAnMWi50.d.cts.map
+//# sourceMappingURL=directory-DiQ_DkaF.d.mts.map

package/dist/{directory-DAnMWi50.d.cts.map → directory-DiQ_DkaF.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"directory-DAnMWi50.d.cts","names":[],"sources":["../src/os/directory.ts"],"sourcesContent":[],"mappings":";;;cAMa,WAeX,OAAA,CAfoB;;;AAAT,UAiBI,iBAAA,CAjBK;EAiBL,GAAA,EAAA,MAAA"}
+{"version":3,"file":"directory-DiQ_DkaF.d.mts","names":[],"sources":["../src/os/directory.ts"],"sourcesContent":[],"mappings":";;;cAMa,WAeX,OAAA,CAfoB;;;AAAT,UAiBI,iBAAA,CAjBK;EAiBL,GAAA,EAAA,MAAA"}

package/dist/{faker-Br8MzXil.d.mts → faker-D9gz7KjY.d.mts}

@@ -1,4 +1,4 @@
-import * as _faker_js_faker2 from "@faker-js/faker";
+import * as _faker_js_faker0 from "@faker-js/faker";
 
 //#region src/faker.d.ts
 
@@ -134,7 +134,7 @@ declare function coordinateOutsideRadius(center: Coordinate, minRadiusMeters: nu
  * const productPrice = faker.price();
  * ```
  */
-declare const faker$1: Readonly<_faker_js_faker2.Faker & {
+declare const faker$1: Readonly<_faker_js_faker0.Faker & {
   timestamps: typeof timestamps;
   identifier: typeof identifier;
   sequence: typeof sequence;
@@ -163,4 +163,4 @@ type Timestamps = {
 type FakerFactory = typeof faker$1;
 //#endregion
 export { FakerFactory, Timestamps, coordinateInRadius, faker$1 as faker, identifier, resetAllSequences, resetSequence, sequence, timestamps };
-//# sourceMappingURL=faker-Br8MzXil.d.mts.map
+//# sourceMappingURL=faker-D9gz7KjY.d.mts.map

package/dist/{faker-Br8MzXil.d.mts.map → faker-D9gz7KjY.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"faker-Br8MzXil.d.mts","names":[],"sources":["../src/faker.ts"],"sourcesContent":[],"mappings":";;;;;;;AAkFA;AA2BA;AAmCA;AA2BA;AA0BA;AAEC;AAca;AASd;;;;AAGa;AA4BZ;;;;AAMY;AA2DA,iBA5OG,UAAA,CAAA,CAyPf,EAzP6B,UAyP7B;;;;;;;;;;;;AAbiB;AAmBlB;;AAEY,iBAtOI,UAAA,CAsOJ,MAAA,CAAA,EAAA,MAAA,CAAA,EAAA,MAAA;;AAEI;AAOhB;;;;;;;;;;;;;;;;;;iBA5MgB,QAAA;;;;;;;;;;;;;;;;;;;iBA2BA,aAAA;;;;;;;;;;;;;;;;;;iBA0BA,iBAAA,CAAA;;;;;;;;;;;;;iBAgBP,KAAA,CAAA;KAIJ,UAAA;;;;iBAKW,kBAAA,SACP,6BAEN;iBA8BM,uBAAA,SACA,+DAGN;;;;;;;;;;;;;;;;;;;;cA2DU,SAAK,SAajB,gBAAA,CAbiB,KAAA;qBAAA;;;;;;;;;;;;;;;KAmBN,UAAA;;aAEA;;aAEA;;;;;;KAOA,YAAA,UAAsB"}
+{"version":3,"file":"faker-D9gz7KjY.d.mts","names":[],"sources":["../src/faker.ts"],"sourcesContent":[],"mappings":";;;;;;;AAkFA;AA2BA;AAmCA;AA2BA;AA0BA;AAEC;AAca;AASd;;;;AAGa;AA4BZ;;;;AAMY;AA2DA,iBA5OG,UAAA,CAAA,CAyPf,EAzP6B,UAyP7B;;;;;;;;;;;;AAbiB;AAmBlB;;AAEY,iBAtOI,UAAA,CAsOJ,MAAA,CAAA,EAAA,MAAA,CAAA,EAAA,MAAA;;AAEI;AAOhB;;;;;;;;;;;;;;;;;;iBA5MgB,QAAA;;;;;;;;;;;;;;;;;;;iBA2BA,aAAA;;;;;;;;;;;;;;;;;;iBA0BA,iBAAA,CAAA;;;;;;;;;;;;;iBAgBP,KAAA,CAAA;KAIJ,UAAA;;;;iBAKW,kBAAA,SACP,6BAEN;iBA8BM,uBAAA,SACA,+DAGN;;;;;;;;;;;;;;;;;;;;cA2DU,SAAK,SAajB,gBAAA,CAbiB,KAAA;qBAAA;;;;;;;;;;;;;;;KAmBN,UAAA;;aAEA;;aAEA;;;;;;KAOA,YAAA,UAAsB"}

package/dist/faker.d.mts

@@ -1,2 +1,2 @@
-import { FakerFactory, Timestamps, coordinateInRadius, faker, identifier, resetAllSequences, resetSequence, sequence, timestamps } from "./faker-Br8MzXil.mjs";
+import { FakerFactory, Timestamps, coordinateInRadius, faker, identifier, resetAllSequences, resetSequence, sequence, timestamps } from "./faker-D9gz7KjY.mjs";
 export { FakerFactory, Timestamps, coordinateInRadius, faker, identifier, resetAllSequences, resetSequence, sequence, timestamps };

package/dist/kysely.d.mts

@@ -1,6 +1,6 @@
-import { FakerFactory, faker } from "./faker-Br8MzXil.mjs";
-import { ExtractSeedAttrs, FactorySeed } from "./Factory-_w0_BN4J.mjs";
-import { KyselyFactory } from "./KyselyFactory-BFxq2hz5.mjs";
+import { FakerFactory, faker } from "./faker-D9gz7KjY.mjs";
+import { ExtractSeedAttrs, FactorySeed } from "./Factory-C6W78ulZ.mjs";
+import { KyselyFactory } from "./KyselyFactory-Cc2UmOJk.mjs";
 import "./PostgresMigrator-C_QQ6q35.mjs";
 import { PostgresKyselyMigrator } from "./PostgresKyselyMigrator-x0uvWs3U.mjs";
 import { DatabaseConnection, DatabaseFixtures, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures, TransactionWrapperOptions } from "./VitestTransactionIsolator-BNWJqh9f.mjs";

package/dist/objection.d.mts

@@ -1,6 +1,6 @@
-import { FakerFactory, faker } from "./faker-Br8MzXil.mjs";
-import { ExtractSeedAttrs, FactorySeed } from "./Factory-_w0_BN4J.mjs";
-import { ObjectionFactory } from "./ObjectionFactory-C4IsQ_wj.mjs";
+import { FakerFactory, faker } from "./faker-D9gz7KjY.mjs";
+import { ExtractSeedAttrs, FactorySeed } from "./Factory-C6W78ulZ.mjs";
+import { ObjectionFactory } from "./ObjectionFactory-BYnPr9ZP.mjs";
 import "./PostgresMigrator-C_QQ6q35.mjs";
 import { PostgresObjectionMigrator } from "./PostgresObjectionMigrator-1j6YIB1c.mjs";
 import { DatabaseConnection, DatabaseFixtures, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures, TransactionWrapperOptions } from "./VitestTransactionIsolator-BNWJqh9f.mjs";

package/dist/os/directory.d.cts

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

package/dist/os/directory.d.mts

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

package/dist/os/index.d.cts

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

package/dist/os/index.d.mts

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

package/dist/requestContext.cjs

@@ -0,0 +1,80 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const node_crypto = require_chunk.__toESM(require("node:crypto"));
+const __geekmidas_logger_console = require_chunk.__toESM(require("@geekmidas/logger/console"));
+const __geekmidas_services = require_chunk.__toESM(require("@geekmidas/services"));
+
+//#region src/requestContext.ts
+function resolveContext(opts = {}) {
+	return {
+		logger: opts.logger ?? new __geekmidas_logger_console.ConsoleLogger({ app: "test" }),
+		requestId: opts.requestId ?? (0, node_crypto.randomUUID)(),
+		startTime: opts.startTime ?? Date.now()
+	};
+}
+/**
+* Run a function inside a request context with test-friendly defaults.
+* Useful when you need `serviceContext` to be available for a single call
+* (e.g. invoking `Service.register({ context })` outside a wrapped test).
+*
+* @example
+* ```ts
+* await runInRequestContext(() =>
+*   discovery.register([databaseService]),
+* );
+* ```
+*/
+function runInRequestContext(fn, opts = {}) {
+	return (0, __geekmidas_services.runWithRequestContext)(resolveContext(opts), fn);
+}
+/**
+* Vitest fixture creator. Spread the result into `.extend()` and every test
+* runs inside `runWithRequestContext`, even tests that don't destructure
+* `requestContext` directly (the fixture is registered as `auto`).
+*
+* @example
+* ```ts
+* const it = test.extend({ ...requestContextFixture() });
+*
+* it('registers services with context', async ({ requestContext }) => {
+*   await discovery.register([databaseService]);
+*   expect(requestContext.getRequestId()).toBeDefined();
+* });
+* ```
+*/
+function requestContextFixture(opts = {}) {
+	return { requestContext: [async ({}, use) => {
+		(0, __geekmidas_services.enterRequestContext)(resolveContext(opts));
+		try {
+			await use(__geekmidas_services.serviceContext);
+		} finally {
+			(0, __geekmidas_services.exitRequestContext)();
+		}
+	}, { auto: true }] };
+}
+/**
+* Wrap any Vitest `TestAPI` (including the one returned by
+* `wrapVitestKyselyTransaction`) so every test runs inside
+* `runWithRequestContext`. Compose with the transaction wrappers:
+*
+* @example
+* ```ts
+* import { wrapVitestKyselyTransaction } from '@geekmidas/testkit/kysely';
+* import { withRequestContext } from '@geekmidas/testkit/request-context';
+*
+* const baseIt = wrapVitestKyselyTransaction<DB>(it, { connection: db });
+* const itWithCtx = withRequestContext(baseIt);
+*
+* itWithCtx('runs inside trx + context', async ({ trx, requestContext }) => {
+*   // serviceContext is set up; Service.register({ context }) works here.
+* });
+* ```
+*/
+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

@@ -0,0 +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"}

package/dist/requestContext.d.cts

@@ -0,0 +1,75 @@
+import { TestAPI } from "vitest";
+import { Logger } from "@geekmidas/logger";
+import { ServiceContext } from "@geekmidas/services";
+
+//#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 {
+  /** Logger exposed via serviceContext.getLogger(). */
+  logger?: Logger;
+  /** Request id exposed via serviceContext.getRequestId(). */
+  requestId?: string;
+  /** Start time exposed via serviceContext.getRequestStartTime(). */
+  startTime?: number;
+}
+/**
+ * Run a function inside a request context with test-friendly defaults.
+ * Useful when you need `serviceContext` to be available for a single call
+ * (e.g. invoking `Service.register({ context })` outside a wrapped test).
+ *
+ * @example
+ * ```ts
+ * await runInRequestContext(() =>
+ *   discovery.register([databaseService]),
+ * );
+ * ```
+ */
+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
+ * `requestContext` directly (the fixture is registered as `auto`).
+ *
+ * @example
+ * ```ts
+ * const it = test.extend({ ...requestContextFixture() });
+ *
+ * it('registers services with context', async ({ requestContext }) => {
+ *   await discovery.register([databaseService]);
+ *   expect(requestContext.getRequestId()).toBeDefined();
+ * });
+ * ```
+ */
+declare function requestContextFixture(opts?: RequestContextOptions): {
+  requestContext: readonly [({}: {}, use: (value: ServiceContext) => Promise<void>) => Promise<void>, {
+    readonly auto: true;
+  }];
+};
+/**
+ * Wrap any Vitest `TestAPI` (including the one returned by
+ * `wrapVitestKyselyTransaction`) so every test runs inside
+ * `runWithRequestContext`. Compose with the transaction wrappers:
+ *
+ * @example
+ * ```ts
+ * import { wrapVitestKyselyTransaction } from '@geekmidas/testkit/kysely';
+ * import { withRequestContext } from '@geekmidas/testkit/request-context';
+ *
+ * const baseIt = wrapVitestKyselyTransaction<DB>(it, { connection: db });
+ * const itWithCtx = withRequestContext(baseIt);
+ *
+ * itWithCtx('runs inside trx + context', async ({ trx, requestContext }) => {
+ *   // serviceContext is set up; Service.register({ context }) works here.
+ * });
+ * ```
+ */
+declare function withRequestContext<T extends TestAPI | ReturnType<TestAPI['extend']>>(testApi: T, opts?: RequestContextOptions): T;
+//# sourceMappingURL=requestContext.d.ts.map
+//#endregion
+export { RequestContextOptions, requestContextFixture, runInRequestContext, withRequestContext };
+//# sourceMappingURL=requestContext.d.cts.map

package/dist/requestContext.d.cts.map

@@ -0,0 +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"}

package/dist/requestContext.d.mts

@@ -0,0 +1,75 @@
+import { TestAPI } from "vitest";
+import { ServiceContext } from "@geekmidas/services";
+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 {
+  /** Logger exposed via serviceContext.getLogger(). */
+  logger?: Logger;
+  /** Request id exposed via serviceContext.getRequestId(). */
+  requestId?: string;
+  /** Start time exposed via serviceContext.getRequestStartTime(). */
+  startTime?: number;
+}
+/**
+ * Run a function inside a request context with test-friendly defaults.
+ * Useful when you need `serviceContext` to be available for a single call
+ * (e.g. invoking `Service.register({ context })` outside a wrapped test).
+ *
+ * @example
+ * ```ts
+ * await runInRequestContext(() =>
+ *   discovery.register([databaseService]),
+ * );
+ * ```
+ */
+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
+ * `requestContext` directly (the fixture is registered as `auto`).
+ *
+ * @example
+ * ```ts
+ * const it = test.extend({ ...requestContextFixture() });
+ *
+ * it('registers services with context', async ({ requestContext }) => {
+ *   await discovery.register([databaseService]);
+ *   expect(requestContext.getRequestId()).toBeDefined();
+ * });
+ * ```
+ */
+declare function requestContextFixture(opts?: RequestContextOptions): {
+  requestContext: readonly [({}: {}, use: (value: ServiceContext) => Promise<void>) => Promise<void>, {
+    readonly auto: true;
+  }];
+};
+/**
+ * Wrap any Vitest `TestAPI` (including the one returned by
+ * `wrapVitestKyselyTransaction`) so every test runs inside
+ * `runWithRequestContext`. Compose with the transaction wrappers:
+ *
+ * @example
+ * ```ts
+ * import { wrapVitestKyselyTransaction } from '@geekmidas/testkit/kysely';
+ * import { withRequestContext } from '@geekmidas/testkit/request-context';
+ *
+ * const baseIt = wrapVitestKyselyTransaction<DB>(it, { connection: db });
+ * const itWithCtx = withRequestContext(baseIt);
+ *
+ * itWithCtx('runs inside trx + context', async ({ trx, requestContext }) => {
+ *   // serviceContext is set up; Service.register({ context }) works here.
+ * });
+ * ```
+ */
+declare function withRequestContext<T extends TestAPI | ReturnType<TestAPI['extend']>>(testApi: T, opts?: RequestContextOptions): T;
+//# sourceMappingURL=requestContext.d.ts.map
+//#endregion
+export { RequestContextOptions, requestContextFixture, runInRequestContext, withRequestContext };
+//# sourceMappingURL=requestContext.d.mts.map

package/dist/requestContext.d.mts.map

@@ -0,0 +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"}

package/dist/requestContext.mjs

@@ -0,0 +1,77 @@
+import { randomUUID } from "node:crypto";
+import { ConsoleLogger } from "@geekmidas/logger/console";
+import { enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext } from "@geekmidas/services";
+
+//#region src/requestContext.ts
+function resolveContext(opts = {}) {
+	return {
+		logger: opts.logger ?? new ConsoleLogger({ app: "test" }),
+		requestId: opts.requestId ?? randomUUID(),
+		startTime: opts.startTime ?? Date.now()
+	};
+}
+/**
+* Run a function inside a request context with test-friendly defaults.
+* Useful when you need `serviceContext` to be available for a single call
+* (e.g. invoking `Service.register({ context })` outside a wrapped test).
+*
+* @example
+* ```ts
+* await runInRequestContext(() =>
+*   discovery.register([databaseService]),
+* );
+* ```
+*/
+function runInRequestContext(fn, opts = {}) {
+	return runWithRequestContext(resolveContext(opts), fn);
+}
+/**
+* Vitest fixture creator. Spread the result into `.extend()` and every test
+* runs inside `runWithRequestContext`, even tests that don't destructure
+* `requestContext` directly (the fixture is registered as `auto`).
+*
+* @example
+* ```ts
+* const it = test.extend({ ...requestContextFixture() });
+*
+* it('registers services with context', async ({ requestContext }) => {
+*   await discovery.register([databaseService]);
+*   expect(requestContext.getRequestId()).toBeDefined();
+* });
+* ```
+*/
+function requestContextFixture(opts = {}) {
+	return { requestContext: [async ({}, use) => {
+		enterRequestContext(resolveContext(opts));
+		try {
+			await use(serviceContext);
+		} finally {
+			exitRequestContext();
+		}
+	}, { auto: true }] };
+}
+/**
+* Wrap any Vitest `TestAPI` (including the one returned by
+* `wrapVitestKyselyTransaction`) so every test runs inside
+* `runWithRequestContext`. Compose with the transaction wrappers:
+*
+* @example
+* ```ts
+* import { wrapVitestKyselyTransaction } from '@geekmidas/testkit/kysely';
+* import { withRequestContext } from '@geekmidas/testkit/request-context';
+*
+* const baseIt = wrapVitestKyselyTransaction<DB>(it, { connection: db });
+* const itWithCtx = withRequestContext(baseIt);
+*
+* itWithCtx('runs inside trx + context', async ({ trx, requestContext }) => {
+*   // serviceContext is set up; Service.register({ context }) works here.
+* });
+* ```
+*/
+function withRequestContext(testApi, opts = {}) {
+	return testApi.extend(requestContextFixture(opts));
+}
+
+//#endregion
+export { requestContextFixture, runInRequestContext, withRequestContext };
+//# sourceMappingURL=requestContext.mjs.map

package/dist/requestContext.mjs.map

@@ -0,0 +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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/testkit",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "private": false,
   "type": "module",
   "exports": {
@@ -103,6 +103,16 @@
         "types": "./dist/initScript.d.cts",
         "default": "./dist/initScript.cjs"
       }
+    },
+    "./request-context": {
+      "import": {
+        "types": "./dist/requestContext.d.mts",
+        "default": "./dist/requestContext.mjs"
+      },
+      "require": {
+        "types": "./dist/requestContext.d.cts",
+        "default": "./dist/requestContext.cjs"
+      }
     }
   },
   "dependencies": {
@@ -111,7 +121,8 @@
   "devDependencies": {
     "@types/pg": "~8.15.4",
     "@geekmidas/envkit": "^1.0.7",
-    "@geekmidas/logger": "^1.0.2"
+    "@geekmidas/logger": "^1.0.2",
+    "@geekmidas/services": "^1.0.3"
   },
   "repository": {
     "type": "git",
@@ -131,7 +142,8 @@
     "@types/aws-lambda": ">=8.10.92",
     "better-auth": ">=1.3.34",
     "@geekmidas/envkit": "^1.0.7",
-    "@geekmidas/logger": "^1.0.2"
+    "@geekmidas/logger": "^1.0.2",
+    "@geekmidas/services": "^1.0.3"
   },
   "peerDependenciesMeta": {
     "@geekmidas/envkit": {
@@ -140,6 +152,9 @@
     "@geekmidas/logger": {
       "optional": true
     },
+    "@geekmidas/services": {
+      "optional": true
+    },
     "kysely": {
       "optional": true
     },

package/src/__tests__/requestContext.spec.ts

@@ -0,0 +1,109 @@
+import { EnvironmentParser } from '@geekmidas/envkit';
+import { ConsoleLogger } from '@geekmidas/logger/console';
+import {
+	type Service,
+	ServiceDiscovery,
+	serviceContext,
+} from '@geekmidas/services';
+import { afterEach, describe, expect, test } from 'vitest';
+import {
+	requestContextFixture,
+	runInRequestContext,
+	withRequestContext,
+} from '../requestContext';
+
+describe('runInRequestContext', () => {
+	test('runs callback inside request context with defaults', async () => {
+		expect(serviceContext.hasContext()).toBe(false);
+
+		const result = await runInRequestContext(() => {
+			expect(serviceContext.hasContext()).toBe(true);
+			expect(typeof serviceContext.getRequestId()).toBe('string');
+			expect(typeof serviceContext.getRequestStartTime()).toBe('number');
+			return 'ok';
+		});
+
+		expect(result).toBe('ok');
+		expect(serviceContext.hasContext()).toBe(false);
+	});
+
+	test('uses caller-supplied logger and request id', async () => {
+		const logger = new ConsoleLogger({ app: 'spec' });
+		const startTime = Date.now();
+
+		await runInRequestContext(
+			() => {
+				expect(serviceContext.getLogger()).toBe(logger);
+				expect(serviceContext.getRequestId()).toBe('req-42');
+				expect(serviceContext.getRequestStartTime()).toBe(startTime);
+			},
+			{ logger, requestId: 'req-42', startTime },
+		);
+	});
+
+	test('lets services that consume context register successfully', async () => {
+		(ServiceDiscovery as unknown as { _instance?: unknown })._instance =
+			undefined;
+		const envParser = new EnvironmentParser({ ...process.env });
+
+		const recorded: { requestId?: string } = {};
+		const recordingService = {
+			serviceName: 'recorder' as const,
+			register({ context }) {
+				recorded.requestId = context.getRequestId();
+				return { recorded };
+			},
+		} satisfies Service<'recorder', { recorded: typeof recorded }>;
+
+		await runInRequestContext(
+			async () => {
+				const discovery = ServiceDiscovery.getInstance(envParser);
+				await discovery.register([recordingService]);
+			},
+			{ requestId: 'from-test' },
+		);
+
+		expect(recorded.requestId).toBe('from-test');
+	});
+});
+
+describe('requestContextFixture', () => {
+	const itWithCtx = test.extend({
+		...requestContextFixture({ requestId: 'fixture-req' }),
+	});
+
+	itWithCtx(
+		'exposes serviceContext via fixture',
+		async ({ requestContext }) => {
+			expect(requestContext.getRequestId()).toBe('fixture-req');
+			expect(serviceContext.getRequestId()).toBe('fixture-req');
+		},
+	);
+
+	itWithCtx(
+		'runs the test body inside the ALS even without destructuring',
+		() => {
+			// `auto: true` means we get context here even though we didn't ask for it
+			expect(serviceContext.hasContext()).toBe(true);
+		},
+	);
+});
+
+describe('withRequestContext', () => {
+	const itWithCtx = withRequestContext(test, { requestId: 'wrapped-req' });
+
+	itWithCtx('wraps an existing TestAPI', () => {
+		expect(serviceContext.hasContext()).toBe(true);
+		expect(serviceContext.getRequestId()).toBe('wrapped-req');
+	});
+});
+
+describe('isolation between tests', () => {
+	afterEach(() => {
+		expect(serviceContext.hasContext()).toBe(false);
+	});
+
+	test('does not leak context outside runInRequestContext', async () => {
+		await runInRequestContext(() => undefined);
+	});
+});

package/src/requestContext.ts

@@ -0,0 +1,119 @@
+import { randomUUID } from 'node:crypto';
+import type { Logger } from '@geekmidas/logger';
+import { ConsoleLogger } from '@geekmidas/logger/console';
+import {
+	enterRequestContext,
+	exitRequestContext,
+	runWithRequestContext,
+	type ServiceContext,
+	serviceContext,
+} from '@geekmidas/services';
+import type { TestAPI } from 'vitest';
+
+/**
+ * Options for setting up a request context in tests. Any field omitted
+ * is filled with a test-friendly default (ConsoleLogger, random UUID,
+ * Date.now()).
+ */
+export interface RequestContextOptions {
+	/** Logger exposed via serviceContext.getLogger(). */
+	logger?: Logger;
+	/** Request id exposed via serviceContext.getRequestId(). */
+	requestId?: string;
+	/** Start time exposed via serviceContext.getRequestStartTime(). */
+	startTime?: number;
+}
+
+function resolveContext(opts: RequestContextOptions = {}) {
+	return {
+		logger: opts.logger ?? new ConsoleLogger({ app: 'test' }),
+		requestId: opts.requestId ?? randomUUID(),
+		startTime: opts.startTime ?? Date.now(),
+	};
+}
+
+/**
+ * Run a function inside a request context with test-friendly defaults.
+ * Useful when you need `serviceContext` to be available for a single call
+ * (e.g. invoking `Service.register({ context })` outside a wrapped test).
+ *
+ * @example
+ * ```ts
+ * await runInRequestContext(() =>
+ *   discovery.register([databaseService]),
+ * );
+ * ```
+ */
+export function runInRequestContext<T>(
+	fn: () => T | Promise<T>,
+	opts: RequestContextOptions = {},
+): T | Promise<T> {
+	return runWithRequestContext(resolveContext(opts), fn);
+}
+
+/**
+ * Vitest fixture creator. Spread the result into `.extend()` and every test
+ * runs inside `runWithRequestContext`, even tests that don't destructure
+ * `requestContext` directly (the fixture is registered as `auto`).
+ *
+ * @example
+ * ```ts
+ * const it = test.extend({ ...requestContextFixture() });
+ *
+ * it('registers services with context', async ({ requestContext }) => {
+ *   await discovery.register([databaseService]);
+ *   expect(requestContext.getRequestId()).toBeDefined();
+ * });
+ * ```
+ */
+export function requestContextFixture(opts: RequestContextOptions = {}) {
+	return {
+		requestContext: [
+			async (
+				// biome-ignore lint/correctness/noEmptyPattern: vitest fixture signature
+				{}: {},
+				use: (value: ServiceContext) => Promise<void>,
+			) => {
+				// Vitest suspends the fixture on `await use(...)` and runs the test
+				// body in a continuation of the runner's async context. A scoped
+				// `runWithRequestContext` callback ends as soon as we hand control
+				// to the runner, so the test body would see no context. Instead,
+				// mutate the current task's store with `enterRequestContext` —
+				// async/await preserves that store across the suspension, so the
+				// test body sees it. We restore on the way out so subsequent tests
+				// don't inherit the value.
+				enterRequestContext(resolveContext(opts));
+				try {
+					await use(serviceContext);
+				} finally {
+					exitRequestContext();
+				}
+			},
+			{ auto: true },
+		] as const,
+	};
+}
+
+/**
+ * Wrap any Vitest `TestAPI` (including the one returned by
+ * `wrapVitestKyselyTransaction`) so every test runs inside
+ * `runWithRequestContext`. Compose with the transaction wrappers:
+ *
+ * @example
+ * ```ts
+ * import { wrapVitestKyselyTransaction } from '@geekmidas/testkit/kysely';
+ * import { withRequestContext } from '@geekmidas/testkit/request-context';
+ *
+ * const baseIt = wrapVitestKyselyTransaction<DB>(it, { connection: db });
+ * const itWithCtx = withRequestContext(baseIt);
+ *
+ * itWithCtx('runs inside trx + context', async ({ trx, requestContext }) => {
+ *   // serviceContext is set up; Service.register({ context }) works here.
+ * });
+ * ```
+ */
+export function withRequestContext<
+	T extends TestAPI | ReturnType<TestAPI['extend']>,
+>(testApi: T, opts: RequestContextOptions = {}): T {
+	return (testApi as any).extend(requestContextFixture(opts));
+}