@entifix/testing-unit 0.1.0-0

package/dist/effect/run.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/effect/run.ts"],"sourcesContent":["import type { ConfigurationRepositoryTag } from '@entifix/business';\nimport { Effect, Exit, type Layer } from 'effect';\n\nimport { stubConfigurationLayer } from '../doubles/configuration.js';\n\n/**\n * Runs an Effect that still requires `TContext`, providing it from `layer`.\n *\n * Use-cases are `Effect.gen` blocks yielding Context tags; every spec would\n * otherwise repeat the same `Effect.runPromise(uc.pipe(Effect.provide(…)))`\n * incantation.\n */\nexport const runUC = <TValue, TError, TContext>(\n  effect: Effect.Effect<TValue, TError, TContext>,\n  layer: Layer.Layer<TContext>,\n): Promise<TValue> => Effect.runPromise(Effect.provide(effect, layer));\n\n/**\n * Runs an Effect expected to fail and returns its typed error.\n *\n * Asserting on the error value beats asserting that a promise rejected: it is\n * the difference between \"something went wrong\" and \"it failed with the\n * `EntifixLockError` that the facade turns into a 409\".\n */\nexport const expectFailure = async <TValue, TError, TContext>(\n  effect: Effect.Effect<TValue, TError, TContext>,\n  layer: Layer.Layer<TContext>,\n): Promise<TError> => {\n  const exit = await Effect.runPromiseExit(Effect.provide(effect, layer));\n\n  if (Exit.isSuccess(exit)) {\n    throw new Error(\n      `Expected the effect to fail, but it succeeded with: ${JSON.stringify(\n        exit.value,\n      )}`,\n    );\n  }\n\n  const failure = exit.cause;\n  if (failure._tag === 'Fail') {\n    return failure.error;\n  }\n  throw new Error(\n    `Expected a typed failure, but the effect died with: ${String(failure)}`,\n  );\n};\n\n/**\n * Runs a repository Effect.\n *\n * Every `EntityRepository` method declares `ConfigurationRepositoryTag` in its\n * requirement channel — the REST-backed adapters resolve their endpoints\n * through it — so even a repository that needs no configuration has to be given\n * one. `configuration` supplies it for the adapters that do.\n */\nexport const runRepository = <TValue, TError>(\n  effect: Effect.Effect<TValue, TError, ConfigurationRepositoryTag>,\n  configuration: Layer.Layer<ConfigurationRepositoryTag> = stubConfigurationLayer(),\n): Promise<TValue> => Effect.runPromise(Effect.provide(effect, configuration));\n\n/** {@link runRepository}, for an Effect expected to fail. */\nexport const runRepositoryExit = <TValue, TError>(\n  effect: Effect.Effect<TValue, TError, ConfigurationRepositoryTag>,\n  configuration: Layer.Layer<ConfigurationRepositoryTag> = stubConfigurationLayer(),\n): Promise<Exit.Exit<TValue, TError>> =>\n  Effect.runPromiseExit(Effect.provide(effect, configuration));\n\n/** Runs an Effect that requires nothing, returning its value. */\nexport const run = <TValue, TError>(\n  effect: Effect.Effect<TValue, TError>,\n): Promise<TValue> => Effect.runPromise(effect);\n\n/** Runs an Effect that requires nothing and returns its typed error. */\nexport const runFailure = async <TValue, TError>(\n  effect: Effect.Effect<TValue, TError>,\n): Promise<TError> => {\n  const exit = await Effect.runPromiseExit(effect);\n\n  if (Exit.isSuccess(exit)) {\n    throw new Error(\n      `Expected the effect to fail, but it succeeded with: ${JSON.stringify(\n        exit.value,\n      )}`,\n    );\n  }\n  if (exit.cause._tag === 'Fail') {\n    return exit.cause.error;\n  }\n  throw new Error(\n    `Expected a typed failure, but the effect died with: ${String(exit.cause)}`,\n  );\n};\n"],"names":["Effect","Exit","stubConfigurationLayer","runUC","effect","layer","runPromise","provide","expectFailure","exit","runPromiseExit","isSuccess","Error","JSON","stringify","value","failure","cause","_tag","error","String","runRepository","configuration","runRepositoryExit","run","runFailure"],"mappings":"AACA,SAASA,MAAM,EAAEC,IAAI,QAAoB,SAAS;AAElD,SAASC,sBAAsB,QAAQ,8BAA8B;AAErE;;;;;;CAMC,GACD,OAAO,MAAMC,QAAQ,CACnBC,QACAC,QACoBL,OAAOM,UAAU,CAACN,OAAOO,OAAO,CAACH,QAAQC,QAAQ;AAEvE;;;;;;CAMC,GACD,OAAO,MAAMG,gBAAgB,OAC3BJ,QACAC;IAEA,MAAMI,OAAO,MAAMT,OAAOU,cAAc,CAACV,OAAOO,OAAO,CAACH,QAAQC;IAEhE,IAAIJ,KAAKU,SAAS,CAACF,OAAO;QACxB,MAAM,IAAIG,MACR,CAAC,oDAAoD,EAAEC,KAAKC,SAAS,CACnEL,KAAKM,KAAK,GACT;IAEP;IAEA,MAAMC,UAAUP,KAAKQ,KAAK;IAC1B,IAAID,QAAQE,IAAI,KAAK,QAAQ;QAC3B,OAAOF,QAAQG,KAAK;IACtB;IACA,MAAM,IAAIP,MACR,CAAC,oDAAoD,EAAEQ,OAAOJ,UAAU;AAE5E,EAAE;AAEF;;;;;;;CAOC,GACD,OAAO,MAAMK,gBAAgB,CAC3BjB,QACAkB,gBAAyDpB,wBAAwB,GAC7DF,OAAOM,UAAU,CAACN,OAAOO,OAAO,CAACH,QAAQkB,gBAAgB;AAE/E,2DAA2D,GAC3D,OAAO,MAAMC,oBAAoB,CAC/BnB,QACAkB,gBAAyDpB,wBAAwB,GAEjFF,OAAOU,cAAc,CAACV,OAAOO,OAAO,CAACH,QAAQkB,gBAAgB;AAE/D,+DAA+D,GAC/D,OAAO,MAAME,MAAM,CACjBpB,SACoBJ,OAAOM,UAAU,CAACF,QAAQ;AAEhD,sEAAsE,GACtE,OAAO,MAAMqB,aAAa,OACxBrB;IAEA,MAAMK,OAAO,MAAMT,OAAOU,cAAc,CAACN;IAEzC,IAAIH,KAAKU,SAAS,CAACF,OAAO;QACxB,MAAM,IAAIG,MACR,CAAC,oDAAoD,EAAEC,KAAKC,SAAS,CACnEL,KAAKM,KAAK,GACT;IAEP;IACA,IAAIN,KAAKQ,KAAK,CAACC,IAAI,KAAK,QAAQ;QAC9B,OAAOT,KAAKQ,KAAK,CAACE,KAAK;IACzB;IACA,MAAM,IAAIP,MACR,CAAC,oDAAoD,EAAEQ,OAAOX,KAAKQ,KAAK,GAAG;AAE/E,EAAE"}

package/dist/http/entity-handlers.d.ts

@@ -0,0 +1,37 @@
+import { type Entity, type EntityConstructor, type EntityId } from '@entifix/core';
+import { type RequestHandler } from 'msw';
+export interface EntityRestHandlerOptions<TEntity extends Entity> {
+    /** The collection endpoint, e.g. `http://service/api/product`. */
+    baseUrl: string;
+    /** The rows the fake service serves. Mutated in place by writes. */
+    data?: TEntity[];
+}
+/**
+ * MSW handlers for the five REST operations the entity adapters issue, speaking
+ * the real entifix envelope.
+ *
+ * Responses are built with `makeEntityEnvelope`/`makeEntityPageEnvelope` — the
+ * production serializer — so a fixture cannot drift from the wire format the
+ * adapters parse. Hand-written JSON literals in specs are exactly how that
+ * drift starts.
+ */
+export declare const entityRestHandlers: <TEntity extends Entity>(entityConstructor: EntityConstructor<TEntity>, { baseUrl, data }: EntityRestHandlerOptions<TEntity>) => RequestHandler[];
+/** A single entity response, for specs that need one endpoint only. */
+export declare const respondWithEntity: <TEntity extends Entity>(url: string, entityConstructor: EntityConstructor<TEntity>, instance: TEntity) => RequestHandler;
+/**
+ * The failure handlers. Adapters map transport and shape failures onto
+ * `EntifixError`s, and those branches are only reachable from here.
+ */
+export declare const respondWith500: (url: string, method?: "get" | "post" | "put" | "delete") => RequestHandler;
+export declare const respondWith404: (url: string, method?: "get" | "post" | "put" | "delete") => RequestHandler;
+/** Answers 200 with a body that is not an envelope at all. */
+export declare const respondWithMalformedEnvelope: (url: string, method?: "get" | "post" | "put" | "delete", body?: Record<string, unknown>) => RequestHandler;
+/** Answers 200 with a body that is not JSON. */
+export declare const respondWithNonJson: (url: string, method?: "get" | "post" | "put" | "delete") => RequestHandler;
+/** Fails the request at the transport level, as a dropped connection would. */
+export declare const respondWithNetworkError: (url: string, method?: "get" | "post" | "put" | "delete") => RequestHandler;
+export type { RequestHandler } from 'msw';
+export { http, HttpResponse } from 'msw';
+/** Re-exported so `EntityId` stays available to handler authors. */
+export type { EntityId };
+//# sourceMappingURL=entity-handlers.d.ts.map

package/dist/http/entity-handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-handlers.d.ts","sourceRoot":"","sources":["../../src/http/entity-handlers.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,MAAM,EACX,KAAK,iBAAiB,EACtB,KAAK,QAAQ,EAGd,MAAM,eAAe,CAAC;AACvB,OAAO,EAAsB,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAE9D,MAAM,WAAW,wBAAwB,CAAC,OAAO,SAAS,MAAM;IAC9D,kEAAkE;IAClE,OAAO,EAAE,MAAM,CAAC;IAChB,oEAAoE;IACpE,IAAI,CAAC,EAAE,OAAO,EAAE,CAAC;CAClB;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,GAAI,OAAO,SAAS,MAAM,EACvD,mBAAmB,iBAAiB,CAAC,OAAO,CAAC,EAC7C,mBAAwB,wBAAwB,CAAC,OAAO,CAAC,KACxD,cAAc,EAyEhB,CAAC;AAEF,uEAAuE;AACvE,eAAO,MAAM,iBAAiB,GAAI,OAAO,SAAS,MAAM,EACtD,KAAK,MAAM,EACX,mBAAmB,iBAAiB,CAAC,OAAO,CAAC,EAC7C,UAAU,OAAO,KAChB,cAGA,CAAC;AAEJ;;;GAGG;AACH,eAAO,MAAM,cAAc,GACzB,KAAK,MAAM,EACX,SAAQ,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,QAAgB,KAChD,cAC+D,CAAC;AAEnE,eAAO,MAAM,cAAc,GACzB,KAAK,MAAM,EACX,SAAQ,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,QAAgB,KAChD,cAC+D,CAAC;AAEnE,8DAA8D;AAC9D,eAAO,MAAM,4BAA4B,GACvC,KAAK,MAAM,EACX,SAAQ,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,QAAgB,EACjD,OAAM,MAAM,CAAC,MAAM,EAAE,OAAO,CAA0C,KACrE,cAAkE,CAAC;AAEtE,gDAAgD;AAChD,eAAO,MAAM,kBAAkB,GAC7B,KAAK,MAAM,EACX,SAAQ,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,QAAgB,KAChD,cAIA,CAAC;AAEJ,+EAA+E;AAC/E,eAAO,MAAM,uBAAuB,GAClC,KAAK,MAAM,EACX,SAAQ,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,QAAgB,KAChD,cAA+D,CAAC;AAEnE,YAAY,EAAE,cAAc,EAAE,MAAM,KAAK,CAAC;AAC1C,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,MAAM,KAAK,CAAC;AAEzC,oEAAoE;AACpE,YAAY,EAAE,QAAQ,EAAE,CAAC"}

package/dist/http/entity-handlers.js

@@ -0,0 +1,92 @@
+import { makeEntityEnvelope, makeEntityPageEnvelope } from '@entifix/core';
+import { http, HttpResponse } from 'msw';
+/**
+ * MSW handlers for the five REST operations the entity adapters issue, speaking
+ * the real entifix envelope.
+ *
+ * Responses are built with `makeEntityEnvelope`/`makeEntityPageEnvelope` — the
+ * production serializer — so a fixture cannot drift from the wire format the
+ * adapters parse. Hand-written JSON literals in specs are exactly how that
+ * drift starts.
+ */ export const entityRestHandlers = (entityConstructor, { baseUrl, data = [] })=>{
+    const rows = data;
+    const findById = (id)=>rows.find((row)=>String(row.id) === id);
+    return [
+        http.get(baseUrl, ({ request })=>{
+            var _url_searchParams_get, _url_searchParams_get1;
+            const url = new URL(request.url);
+            const page = Number((_url_searchParams_get = url.searchParams.get('page')) != null ? _url_searchParams_get : '1');
+            const pageSize = Number((_url_searchParams_get1 = url.searchParams.get('pageSize')) != null ? _url_searchParams_get1 : '10');
+            const start = (page - 1) * pageSize;
+            return HttpResponse.json(makeEntityPageEnvelope(entityConstructor, {
+                items: rows.slice(start, start + pageSize),
+                total: rows.length,
+                request: {
+                    page,
+                    pageSize
+                }
+            }));
+        }),
+        http.get(`${baseUrl}/:id`, ({ params })=>{
+            const found = findById(String(params['id']));
+            return found === undefined ? new HttpResponse(null, {
+                status: 404
+            }) : HttpResponse.json(makeEntityEnvelope(entityConstructor, found));
+        }),
+        http.post(baseUrl, async ({ request })=>{
+            var _body_data_id;
+            const body = await request.json();
+            // The service is what mints an id on create; echoing the request back
+            // unchanged would hide that the adapter must read the response.
+            const created = Object.assign(new entityConstructor(), body.data, {
+                id: (_body_data_id = body.data['id']) != null ? _body_data_id : `generated-${rows.length + 1}`
+            });
+            rows.push(created);
+            return HttpResponse.json(makeEntityEnvelope(entityConstructor, created), {
+                status: 201
+            });
+        }),
+        http.put(`${baseUrl}/:id`, async ({ params, request })=>{
+            const body = await request.json();
+            const id = String(params['id']);
+            const index = rows.findIndex((row)=>String(row.id) === id);
+            const updated = Object.assign(new entityConstructor(), body.data);
+            if (index === -1) {
+                rows.push(updated);
+            } else {
+                rows[index] = updated;
+            }
+            return HttpResponse.json(makeEntityEnvelope(entityConstructor, updated));
+        }),
+        // A delete answers with the removed entity's envelope rather than a bare
+        // `204`: the shared fetch client always parses the response as JSON, so an
+        // empty body would fail that parse — which is what the services do too.
+        http.delete(`${baseUrl}/:id`, ({ params })=>{
+            const id = String(params['id']);
+            const index = rows.findIndex((row)=>String(row.id) === id);
+            const [removed] = index === -1 ? [] : rows.splice(index, 1);
+            return HttpResponse.json(makeEntityEnvelope(entityConstructor, removed != null ? removed : new entityConstructor()));
+        })
+    ];
+};
+/** A single entity response, for specs that need one endpoint only. */ export const respondWithEntity = (url, entityConstructor, instance)=>http.get(url, ()=>HttpResponse.json(makeEntityEnvelope(entityConstructor, instance)));
+/**
+ * The failure handlers. Adapters map transport and shape failures onto
+ * `EntifixError`s, and those branches are only reachable from here.
+ */ export const respondWith500 = (url, method = 'get')=>http[method](url, ()=>new HttpResponse(null, {
+            status: 500
+        }));
+export const respondWith404 = (url, method = 'get')=>http[method](url, ()=>new HttpResponse(null, {
+            status: 404
+        }));
+/** Answers 200 with a body that is not an envelope at all. */ export const respondWithMalformedEnvelope = (url, method = 'get', body = {
+    id: 'raw',
+    name: 'not an envelope'
+})=>http[method](url, ()=>HttpResponse.json(body));
+/** Answers 200 with a body that is not JSON. */ export const respondWithNonJson = (url, method = 'get')=>http[method](url, ()=>new HttpResponse('<html>nope</html>', {
+            status: 200
+        }));
+/** Fails the request at the transport level, as a dropped connection would. */ export const respondWithNetworkError = (url, method = 'get')=>http[method](url, ()=>HttpResponse.error());
+export { http, HttpResponse } from 'msw';
+
+//# sourceMappingURL=entity-handlers.js.map

package/dist/http/entity-handlers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/http/entity-handlers.ts"],"sourcesContent":["import {\n  type Entity,\n  type EntityConstructor,\n  type EntityId,\n  makeEntityEnvelope,\n  makeEntityPageEnvelope,\n} from '@entifix/core';\nimport { http, HttpResponse, type RequestHandler } from 'msw';\n\nexport interface EntityRestHandlerOptions<TEntity extends Entity> {\n  /** The collection endpoint, e.g. `http://service/api/product`. */\n  baseUrl: string;\n  /** The rows the fake service serves. Mutated in place by writes. */\n  data?: TEntity[];\n}\n\n/**\n * MSW handlers for the five REST operations the entity adapters issue, speaking\n * the real entifix envelope.\n *\n * Responses are built with `makeEntityEnvelope`/`makeEntityPageEnvelope` — the\n * production serializer — so a fixture cannot drift from the wire format the\n * adapters parse. Hand-written JSON literals in specs are exactly how that\n * drift starts.\n */\nexport const entityRestHandlers = <TEntity extends Entity>(\n  entityConstructor: EntityConstructor<TEntity>,\n  { baseUrl, data = [] }: EntityRestHandlerOptions<TEntity>,\n): RequestHandler[] => {\n  const rows = data;\n\n  const findById = (id: string): TEntity | undefined =>\n    rows.find(row => String(row.id) === id);\n\n  return [\n    http.get(baseUrl, ({ request }) => {\n      const url = new URL(request.url);\n      const page = Number(url.searchParams.get('page') ?? '1');\n      const pageSize = Number(url.searchParams.get('pageSize') ?? '10');\n      const start = (page - 1) * pageSize;\n\n      return HttpResponse.json(\n        makeEntityPageEnvelope(entityConstructor, {\n          items: rows.slice(start, start + pageSize),\n          total: rows.length,\n          request: { page, pageSize },\n        }),\n      );\n    }),\n\n    http.get(`${baseUrl}/:id`, ({ params }) => {\n      const found = findById(String(params['id']));\n      return found === undefined\n        ? new HttpResponse(null, { status: 404 })\n        : HttpResponse.json(makeEntityEnvelope(entityConstructor, found));\n    }),\n\n    http.post(baseUrl, async ({ request }) => {\n      const body = (await request.json()) as { data: Record<string, unknown> };\n      // The service is what mints an id on create; echoing the request back\n      // unchanged would hide that the adapter must read the response.\n      const created = Object.assign(new entityConstructor(), body.data, {\n        id: body.data['id'] ?? `generated-${rows.length + 1}`,\n      }) as TEntity;\n      rows.push(created);\n      return HttpResponse.json(makeEntityEnvelope(entityConstructor, created), {\n        status: 201,\n      });\n    }),\n\n    http.put(`${baseUrl}/:id`, async ({ params, request }) => {\n      const body = (await request.json()) as { data: Record<string, unknown> };\n      const id = String(params['id']);\n      const index = rows.findIndex(row => String(row.id) === id);\n      const updated = Object.assign(\n        new entityConstructor(),\n        body.data,\n      ) as TEntity;\n      if (index === -1) {\n        rows.push(updated);\n      } else {\n        rows[index] = updated;\n      }\n      return HttpResponse.json(makeEntityEnvelope(entityConstructor, updated));\n    }),\n\n    // A delete answers with the removed entity's envelope rather than a bare\n    // `204`: the shared fetch client always parses the response as JSON, so an\n    // empty body would fail that parse — which is what the services do too.\n    http.delete(`${baseUrl}/:id`, ({ params }) => {\n      const id = String(params['id']);\n      const index = rows.findIndex(row => String(row.id) === id);\n      const [removed] = index === -1 ? [] : rows.splice(index, 1);\n      return HttpResponse.json(\n        makeEntityEnvelope(\n          entityConstructor,\n          removed ?? (new entityConstructor() as TEntity),\n        ),\n      );\n    }),\n  ];\n};\n\n/** A single entity response, for specs that need one endpoint only. */\nexport const respondWithEntity = <TEntity extends Entity>(\n  url: string,\n  entityConstructor: EntityConstructor<TEntity>,\n  instance: TEntity,\n): RequestHandler =>\n  http.get(url, () =>\n    HttpResponse.json(makeEntityEnvelope(entityConstructor, instance)),\n  );\n\n/**\n * The failure handlers. Adapters map transport and shape failures onto\n * `EntifixError`s, and those branches are only reachable from here.\n */\nexport const respondWith500 = (\n  url: string,\n  method: 'get' | 'post' | 'put' | 'delete' = 'get',\n): RequestHandler =>\n  http[method](url, () => new HttpResponse(null, { status: 500 }));\n\nexport const respondWith404 = (\n  url: string,\n  method: 'get' | 'post' | 'put' | 'delete' = 'get',\n): RequestHandler =>\n  http[method](url, () => new HttpResponse(null, { status: 404 }));\n\n/** Answers 200 with a body that is not an envelope at all. */\nexport const respondWithMalformedEnvelope = (\n  url: string,\n  method: 'get' | 'post' | 'put' | 'delete' = 'get',\n  body: Record<string, unknown> = { id: 'raw', name: 'not an envelope' },\n): RequestHandler => http[method](url, () => HttpResponse.json(body));\n\n/** Answers 200 with a body that is not JSON. */\nexport const respondWithNonJson = (\n  url: string,\n  method: 'get' | 'post' | 'put' | 'delete' = 'get',\n): RequestHandler =>\n  http[method](\n    url,\n    () => new HttpResponse('<html>nope</html>', { status: 200 }),\n  );\n\n/** Fails the request at the transport level, as a dropped connection would. */\nexport const respondWithNetworkError = (\n  url: string,\n  method: 'get' | 'post' | 'put' | 'delete' = 'get',\n): RequestHandler => http[method](url, () => HttpResponse.error());\n\nexport type { RequestHandler } from 'msw';\nexport { http, HttpResponse } from 'msw';\n\n/** Re-exported so `EntityId` stays available to handler authors. */\nexport type { EntityId };\n"],"names":["makeEntityEnvelope","makeEntityPageEnvelope","http","HttpResponse","entityRestHandlers","entityConstructor","baseUrl","data","rows","findById","id","find","row","String","get","request","url","URL","page","Number","searchParams","pageSize","start","json","items","slice","total","length","params","found","undefined","status","post","body","created","Object","assign","push","put","index","findIndex","updated","delete","removed","splice","respondWithEntity","instance","respondWith500","method","respondWith404","respondWithMalformedEnvelope","name","respondWithNonJson","respondWithNetworkError","error"],"mappings":"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"}

package/dist/http/index.d.ts

@@ -0,0 +1,3 @@
+export * from './entity-handlers.js';
+export * from './server.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/http/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/http/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,aAAa,CAAC"}

package/dist/http/index.js

@@ -0,0 +1,4 @@
+export * from './entity-handlers.js';
+export * from './server.js';
+
+//# sourceMappingURL=index.js.map

package/dist/http/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/http/index.ts"],"sourcesContent":["export * from './entity-handlers.js';\nexport * from './server.js';\n"],"names":[],"mappings":"AAAA,cAAc,uBAAuB;AACrC,cAAc,cAAc"}

package/dist/http/server.d.ts

@@ -0,0 +1,19 @@
+import { type RequestHandler } from 'msw';
+import { setupServer } from 'msw/node';
+/** What `setupServer` actually returns, so the type cannot drift from msw. */
+export type EntifixMockServer = ReturnType<typeof setupServer>;
+/**
+ * Starts an MSW server for the current test file and wires its lifecycle.
+ *
+ * `onUnhandledRequest: 'error'` is the important part: a request nobody stubbed
+ * fails the test instead of quietly escaping to the network. A test that passes
+ * because it silently talked to nothing is worse than one that fails.
+ *
+ * ```ts
+ * const server = setupEntifixServer(...entityRestHandlers(Product, { … }));
+ * // inside a test, to override for one case:
+ * server.use(respondWith500('http://service/api/product'));
+ * ```
+ */
+export declare const setupEntifixServer: (...handlers: RequestHandler[]) => EntifixMockServer;
+//# sourceMappingURL=server.d.ts.map

package/dist/http/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/http/server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAGvC,8EAA8E;AAC9E,MAAM,MAAM,iBAAiB,GAAG,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;AAE/D;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,kBAAkB,GAC7B,GAAG,UAAU,cAAc,EAAE,KAC5B,iBAcF,CAAC"}

package/dist/http/server.js

@@ -0,0 +1,31 @@
+import { setupServer } from 'msw/node';
+import { afterAll, afterEach, beforeAll } from 'vitest';
+/**
+ * Starts an MSW server for the current test file and wires its lifecycle.
+ *
+ * `onUnhandledRequest: 'error'` is the important part: a request nobody stubbed
+ * fails the test instead of quietly escaping to the network. A test that passes
+ * because it silently talked to nothing is worse than one that fails.
+ *
+ * ```ts
+ * const server = setupEntifixServer(...entityRestHandlers(Product, { … }));
+ * // inside a test, to override for one case:
+ * server.use(respondWith500('http://service/api/product'));
+ * ```
+ */ export const setupEntifixServer = (...handlers)=>{
+    const server = setupServer(...handlers);
+    beforeAll(()=>{
+        server.listen({
+            onUnhandledRequest: 'error'
+        });
+    });
+    afterEach(()=>{
+        server.resetHandlers();
+    });
+    afterAll(()=>{
+        server.close();
+    });
+    return server;
+};
+
+//# sourceMappingURL=server.js.map

package/dist/http/server.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/http/server.ts"],"sourcesContent":["import { type RequestHandler } from 'msw';\nimport { setupServer } from 'msw/node';\nimport { afterAll, afterEach, beforeAll } from 'vitest';\n\n/** What `setupServer` actually returns, so the type cannot drift from msw. */\nexport type EntifixMockServer = ReturnType<typeof setupServer>;\n\n/**\n * Starts an MSW server for the current test file and wires its lifecycle.\n *\n * `onUnhandledRequest: 'error'` is the important part: a request nobody stubbed\n * fails the test instead of quietly escaping to the network. A test that passes\n * because it silently talked to nothing is worse than one that fails.\n *\n * ```ts\n * const server = setupEntifixServer(...entityRestHandlers(Product, { … }));\n * // inside a test, to override for one case:\n * server.use(respondWith500('http://service/api/product'));\n * ```\n */\nexport const setupEntifixServer = (\n  ...handlers: RequestHandler[]\n): EntifixMockServer => {\n  const server = setupServer(...handlers);\n\n  beforeAll(() => {\n    server.listen({ onUnhandledRequest: 'error' });\n  });\n  afterEach(() => {\n    server.resetHandlers();\n  });\n  afterAll(() => {\n    server.close();\n  });\n\n  return server;\n};\n"],"names":["setupServer","afterAll","afterEach","beforeAll","setupEntifixServer","handlers","server","listen","onUnhandledRequest","resetHandlers","close"],"mappings":"AACA,SAASA,WAAW,QAAQ,WAAW;AACvC,SAASC,QAAQ,EAAEC,SAAS,EAAEC,SAAS,QAAQ,SAAS;AAKxD;;;;;;;;;;;;CAYC,GACD,OAAO,MAAMC,qBAAqB,CAChC,GAAGC;IAEH,MAAMC,SAASN,eAAeK;IAE9BF,UAAU;QACRG,OAAOC,MAAM,CAAC;YAAEC,oBAAoB;QAAQ;IAC9C;IACAN,UAAU;QACRI,OAAOG,aAAa;IACtB;IACAR,SAAS;QACPK,OAAOI,KAAK;IACd;IAEA,OAAOJ;AACT,EAAE"}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from './builders/entity-builder.js';
+export * from './doubles/configuration.js';
+export * from './doubles/entity-repository.js';
+export * from './doubles/link-resolver.js';
+export * from './doubles/transaction-ports.js';
+export * from './effect/run.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC;AAC7C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,iBAAiB,CAAC"}

package/dist/index.js

@@ -0,0 +1,8 @@
+export * from './builders/entity-builder.js';
+export * from './doubles/configuration.js';
+export * from './doubles/entity-repository.js';
+export * from './doubles/link-resolver.js';
+export * from './doubles/transaction-ports.js';
+export * from './effect/run.js';
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export * from './builders/entity-builder.js';\nexport * from './doubles/configuration.js';\nexport * from './doubles/entity-repository.js';\nexport * from './doubles/link-resolver.js';\nexport * from './doubles/transaction-ports.js';\nexport * from './effect/run.js';\n"],"names":[],"mappings":"AAAA,cAAc,+BAA+B;AAC7C,cAAc,6BAA6B;AAC3C,cAAc,iCAAiC;AAC/C,cAAc,6BAA6B;AAC3C,cAAc,iCAAiC;AAC/C,cAAc,kBAAkB"}

package/dist/react/index.d.ts

@@ -0,0 +1,3 @@
+export * from './render.js';
+export * from './ui-preferences.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/react/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/react/index.tsx"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,qBAAqB,CAAC"}

package/dist/react/index.js

@@ -0,0 +1,4 @@
+export * from './render.js';
+export * from './ui-preferences.js';
+
+//# sourceMappingURL=index.js.map

package/dist/react/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/react/index.tsx"],"sourcesContent":["export * from './render.js';\nexport * from './ui-preferences.js';\n"],"names":[],"mappings":"AAAA,cAAc,cAAc;AAC5B,cAAc,sBAAsB"}

package/dist/react/render.d.ts

@@ -0,0 +1,30 @@
+import { type UiPreferencesState } from '@entifix/react-controls';
+import { type RenderOptions, type RenderResult } from '@testing-library/react';
+import type { Context, ReactElement } from 'react';
+export interface RenderWithAdaptersOptions<TAdapters> extends Omit<RenderOptions, 'wrapper'> {
+    /**
+     * The adapters context a shell would normally provide, paired with the value
+     * to publish on it.
+     */
+    adapters?: {
+        context: Context<TAdapters>;
+        value: TAdapters;
+    };
+    /** Defaults to a fresh in-memory store, so personalization never leaks. */
+    preferences?: UiPreferencesState;
+}
+export interface RenderWithAdaptersResult extends RenderResult {
+    /** The preferences store the tree rendered against. */
+    preferences: UiPreferencesState;
+}
+/**
+ * Renders a component with the providers a real page would mount around it.
+ *
+ * Components reach their adapters through context and their personalization
+ * through {@link UiPreferencesProvider}; rendering without those is testing a
+ * configuration that never ships.
+ */
+export declare const renderWithAdapters: <TAdapters>(ui: ReactElement, { adapters, preferences, ...options }?: RenderWithAdaptersOptions<TAdapters>) => RenderWithAdaptersResult;
+export * from '@testing-library/react';
+export { default as userEvent } from '@testing-library/user-event';
+//# sourceMappingURL=render.d.ts.map

package/dist/react/render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../../src/react/render.tsx"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,kBAAkB,EACxB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAEL,KAAK,aAAa,EAClB,KAAK,YAAY,EAClB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,OAAO,EAAqB,YAAY,EAAE,MAAM,OAAO,CAAC;AAItE,MAAM,WAAW,yBAAyB,CAAC,SAAS,CAAE,SAAQ,IAAI,CAChE,aAAa,EACb,SAAS,CACV;IACC;;;OAGG;IACH,QAAQ,CAAC,EAAE;QAAE,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;QAAC,KAAK,EAAE,SAAS,CAAA;KAAE,CAAC;IAC7D,2EAA2E;IAC3E,WAAW,CAAC,EAAE,kBAAkB,CAAC;CAClC;AAED,MAAM,WAAW,wBAAyB,SAAQ,YAAY;IAC5D,uDAAuD;IACvD,WAAW,EAAE,kBAAkB,CAAC;CACjC;AAED;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,GAAI,SAAS,EAC1C,IAAI,YAAY,EAChB,wCAIG,yBAAyB,CAAC,SAAS,CAAM,KAC3C,wBAsBF,CAAC;AAEF,cAAc,wBAAwB,CAAC;AACvC,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,6BAA6B,CAAC"}

package/dist/react/render.js

@@ -0,0 +1,38 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { _ as _object_without_properties_loose } from "@swc/helpers/_/_object_without_properties_loose";
+import { UiPreferencesProvider } from '@entifix/react-controls';
+import { render } from '@testing-library/react';
+import { makeInMemoryUiPreferencesState } from './ui-preferences.js';
+/**
+ * Renders a component with the providers a real page would mount around it.
+ *
+ * Components reach their adapters through context and their personalization
+ * through {@link UiPreferencesProvider}; rendering without those is testing a
+ * configuration that never ships.
+ */ export const renderWithAdapters = (ui, _1 = void 0)=>{
+    let _ref = [
+        _1
+    ], [_ref1 = {}] = _ref, { adapters, preferences = makeInMemoryUiPreferencesState() } = _ref1, options = _object_without_properties_loose(_ref1, [
+        "adapters",
+        "preferences"
+    ]);
+    const Wrapper = ({ children })=>{
+        const withPreferences = /*#__PURE__*/ React.createElement(UiPreferencesProvider, {
+            store: preferences
+        }, children);
+        if (adapters === undefined) return withPreferences;
+        const { context: AdaptersContext, value } = adapters;
+        return /*#__PURE__*/ React.createElement(AdaptersContext.Provider, {
+            value: value
+        }, withPreferences);
+    };
+    return _extends({}, render(ui, _extends({
+        wrapper: Wrapper
+    }, options)), {
+        preferences
+    });
+};
+export * from '@testing-library/react';
+export { default as userEvent } from '@testing-library/user-event';
+
+//# sourceMappingURL=render.js.map

package/dist/react/render.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/react/render.tsx"],"sourcesContent":["import {\n  UiPreferencesProvider,\n  type UiPreferencesState,\n} from '@entifix/react-controls';\nimport {\n  render,\n  type RenderOptions,\n  type RenderResult,\n} from '@testing-library/react';\nimport type { Context, PropsWithChildren, ReactElement } from 'react';\n\nimport { makeInMemoryUiPreferencesState } from './ui-preferences.js';\n\nexport interface RenderWithAdaptersOptions<TAdapters> extends Omit<\n  RenderOptions,\n  'wrapper'\n> {\n  /**\n   * The adapters context a shell would normally provide, paired with the value\n   * to publish on it.\n   */\n  adapters?: { context: Context<TAdapters>; value: TAdapters };\n  /** Defaults to a fresh in-memory store, so personalization never leaks. */\n  preferences?: UiPreferencesState;\n}\n\nexport interface RenderWithAdaptersResult extends RenderResult {\n  /** The preferences store the tree rendered against. */\n  preferences: UiPreferencesState;\n}\n\n/**\n * Renders a component with the providers a real page would mount around it.\n *\n * Components reach their adapters through context and their personalization\n * through {@link UiPreferencesProvider}; rendering without those is testing a\n * configuration that never ships.\n */\nexport const renderWithAdapters = <TAdapters,>(\n  ui: ReactElement,\n  {\n    adapters,\n    preferences = makeInMemoryUiPreferencesState(),\n    ...options\n  }: RenderWithAdaptersOptions<TAdapters> = {},\n): RenderWithAdaptersResult => {\n  const Wrapper = ({ children }: PropsWithChildren) => {\n    const withPreferences = (\n      <UiPreferencesProvider store={preferences}>\n        {children}\n      </UiPreferencesProvider>\n    );\n\n    if (adapters === undefined) return withPreferences;\n\n    const { context: AdaptersContext, value } = adapters;\n    return (\n      <AdaptersContext.Provider value={value}>\n        {withPreferences}\n      </AdaptersContext.Provider>\n    );\n  };\n\n  return {\n    ...render(ui, { wrapper: Wrapper, ...options }),\n    preferences,\n  };\n};\n\nexport * from '@testing-library/react';\nexport { default as userEvent } from '@testing-library/user-event';\n"],"names":["UiPreferencesProvider","render","makeInMemoryUiPreferencesState","renderWithAdapters","ui","adapters","preferences","options","Wrapper","children","withPreferences","store","undefined","context","AdaptersContext","value","Provider","wrapper","default","userEvent"],"mappings":";;AAAA,SACEA,qBAAqB,QAEhB,0BAA0B;AACjC,SACEC,MAAM,QAGD,yBAAyB;AAGhC,SAASC,8BAA8B,QAAQ,sBAAsB;AAoBrE;;;;;;CAMC,GACD,OAAO,MAAMC,qBAAqB,CAChCC;;;gBAK0C,CAAC,WAJ3C,EACEC,QAAQ,EACRC,cAAcJ,gCAAgC,EAET,UADlCK;;;;IAGL,MAAMC,UAAU,CAAC,EAAEC,QAAQ,EAAqB;QAC9C,MAAMC,gCACJ,oBAACV;YAAsBW,OAAOL;WAC3BG;QAIL,IAAIJ,aAAaO,WAAW,OAAOF;QAEnC,MAAM,EAAEG,SAASC,eAAe,EAAEC,KAAK,EAAE,GAAGV;QAC5C,qBACE,oBAACS,gBAAgBE,QAAQ;YAACD,OAAOA;WAC9BL;IAGP;IAEA,OAAO,aACFT,OAAOG,IAAI;QAAEa,SAAST;OAAYD;QACrCD;;AAEJ,EAAE;AAEF,cAAc,yBAAyB;AACvC,SAASY,WAAWC,SAAS,QAAQ,8BAA8B"}

package/dist/react/ui-preferences.d.ts

@@ -0,0 +1,17 @@
+import type { UiPreferencesState } from '@entifix/react-controls';
+export interface InMemoryUiPreferencesState extends UiPreferencesState {
+    /** Everything currently stored, keyed exactly as the controls wrote it. */
+    readonly entries: Readonly<Record<string, unknown>>;
+    /** Pre-populates the store, e.g. to render a table already personalized. */
+    seed(entries: Record<string, unknown>): void;
+}
+/**
+ * In-memory {@link UiPreferencesState}.
+ *
+ * The port is Effect-returning precisely so an asynchronous, server-backed
+ * store can replace `localStorage` without touching a component; this double
+ * exists so specs can assert on personalization without depending on jsdom
+ * storage behaviour at all.
+ */
+export declare const makeInMemoryUiPreferencesState: (seed?: Record<string, unknown>) => InMemoryUiPreferencesState;
+//# sourceMappingURL=ui-preferences.d.ts.map

package/dist/react/ui-preferences.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ui-preferences.d.ts","sourceRoot":"","sources":["../../src/react/ui-preferences.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAGlE,MAAM,WAAW,0BAA2B,SAAQ,kBAAkB;IACpE,2EAA2E;IAC3E,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACpD,4EAA4E;IAC5E,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CAC9C;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,8BAA8B,GACzC,OAAM,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,KACjC,0BAqBF,CAAC"}

package/dist/react/ui-preferences.js

@@ -0,0 +1,29 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { Effect } from 'effect';
+/**
+ * In-memory {@link UiPreferencesState}.
+ *
+ * The port is Effect-returning precisely so an asynchronous, server-backed
+ * store can replace `localStorage` without touching a component; this double
+ * exists so specs can assert on personalization without depending on jsdom
+ * storage behaviour at all.
+ */ export const makeInMemoryUiPreferencesState = (seed = {})=>{
+    let entries = _extends({}, seed);
+    return {
+        read: (key)=>Effect.sync(()=>entries[key]),
+        write: (key, value)=>Effect.sync(()=>{
+                entries[key] = value;
+            }),
+        remove: (key)=>Effect.sync(()=>{
+                delete entries[key];
+            }),
+        get entries () {
+            return entries;
+        },
+        seed: (next)=>{
+            entries = _extends({}, next);
+        }
+    };
+};
+
+//# sourceMappingURL=ui-preferences.js.map

package/dist/react/ui-preferences.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/react/ui-preferences.ts"],"sourcesContent":["import type { UiPreferencesState } from '@entifix/react-controls';\nimport { Effect } from 'effect';\n\nexport interface InMemoryUiPreferencesState extends UiPreferencesState {\n  /** Everything currently stored, keyed exactly as the controls wrote it. */\n  readonly entries: Readonly<Record<string, unknown>>;\n  /** Pre-populates the store, e.g. to render a table already personalized. */\n  seed(entries: Record<string, unknown>): void;\n}\n\n/**\n * In-memory {@link UiPreferencesState}.\n *\n * The port is Effect-returning precisely so an asynchronous, server-backed\n * store can replace `localStorage` without touching a component; this double\n * exists so specs can assert on personalization without depending on jsdom\n * storage behaviour at all.\n */\nexport const makeInMemoryUiPreferencesState = (\n  seed: Record<string, unknown> = {},\n): InMemoryUiPreferencesState => {\n  let entries: Record<string, unknown> = { ...seed };\n\n  return {\n    read: <TValue>(key: string) =>\n      Effect.sync(() => entries[key] as TValue | undefined),\n    write: <TValue>(key: string, value: TValue) =>\n      Effect.sync(() => {\n        entries[key] = value;\n      }),\n    remove: (key: string) =>\n      Effect.sync(() => {\n        delete entries[key];\n      }),\n    get entries() {\n      return entries;\n    },\n    seed: next => {\n      entries = { ...next };\n    },\n  };\n};\n"],"names":["Effect","makeInMemoryUiPreferencesState","seed","entries","read","key","sync","write","value","remove","next"],"mappings":";AACA,SAASA,MAAM,QAAQ,SAAS;AAShC;;;;;;;CAOC,GACD,OAAO,MAAMC,iCAAiC,CAC5CC,OAAgC,CAAC,CAAC;IAElC,IAAIC,UAAmC,aAAKD;IAE5C,OAAO;QACLE,MAAM,CAASC,MACbL,OAAOM,IAAI,CAAC,IAAMH,OAAO,CAACE,IAAI;QAChCE,OAAO,CAASF,KAAaG,QAC3BR,OAAOM,IAAI,CAAC;gBACVH,OAAO,CAACE,IAAI,GAAGG;YACjB;QACFC,QAAQ,CAACJ,MACPL,OAAOM,IAAI,CAAC;gBACV,OAAOH,OAAO,CAACE,IAAI;YACrB;QACF,IAAIF,WAAU;YACZ,OAAOA;QACT;QACAD,MAAMQ,CAAAA;YACJP,UAAU,aAAKO;QACjB;IACF;AACF,EAAE"}

package/package.json

@@ -0,0 +1,122 @@
+{
+  "name": "@entifix/testing-unit",
+  "version": "0.1.0-0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/r10c-technologies/entifix.git",
+    "directory": "packages/ts/testing-unit"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo",
+    "LICENSE"
+  ],
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "@entifix/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./drivers": {
+      "@entifix/source": "./src/drivers/index.ts",
+      "types": "./dist/drivers/index.d.ts",
+      "import": "./dist/drivers/index.js",
+      "default": "./dist/drivers/index.js"
+    },
+    "./http": {
+      "@entifix/source": "./src/http/index.ts",
+      "types": "./dist/http/index.d.ts",
+      "import": "./dist/http/index.js",
+      "default": "./dist/http/index.js"
+    },
+    "./contracts": {
+      "@entifix/source": "./src/contracts/index.ts",
+      "types": "./dist/contracts/index.d.ts",
+      "import": "./dist/contracts/index.js",
+      "default": "./dist/contracts/index.js"
+    },
+    "./react": {
+      "@entifix/source": "./src/react/index.tsx",
+      "types": "./dist/react/index.d.ts",
+      "import": "./dist/react/index.js",
+      "default": "./dist/react/index.js"
+    }
+  },
+  "nx": {
+    "tags": [
+      "layer:entifix",
+      "scope:shared",
+      "type:testing",
+      "tier:5"
+    ],
+    "sourceRoot": "packages/ts/testing-unit/src",
+    "targets": {
+      "build": {
+        "executor": "@nx/js:swc",
+        "outputs": [
+          "{options.outputPath}"
+        ],
+        "options": {
+          "outputPath": "packages/ts/testing-unit/dist",
+          "main": "packages/ts/testing-unit/src/index.ts",
+          "tsConfig": "packages/ts/testing-unit/tsconfig.lib.json",
+          "skipTypeCheck": true,
+          "stripLeadingPaths": true
+        }
+      }
+    }
+  },
+  "dependencies": {
+    "@effect/sql": "0.52.1",
+    "@swc/helpers": "0.5.23",
+    "@entifix/business": "0.1.0-0",
+    "@entifix/core": "0.1.0-0",
+    "@entifix/transactions": "0.1.0-0"
+  },
+  "peerDependencies": {
+    "@effect/vitest": ">=0.30 <1",
+    "@testing-library/react": "*",
+    "effect": ">=3.22 <4",
+    "msw": "*",
+    "react": "*",
+    "vitest": "*",
+    "@entifix/react-controls": "0.1.0-0"
+  },
+  "peerDependenciesMeta": {
+    "@effect/vitest": {
+      "optional": true
+    },
+    "@entifix/react-controls": {
+      "optional": true
+    },
+    "@testing-library/react": {
+      "optional": true
+    },
+    "@testing-library/user-event": {
+      "optional": true
+    },
+    "msw": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "vitest": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@effect/vitest": "^0.30.0",
+    "effect": "3.22.1"
+  }
+}