@entifix/testing-e2e 0.1.0-0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 r10c Technologies
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,150 @@
+# @entifix/testing-e2e
+
+The e2e layer: one set of journeys, two profiles. Test-only — private, no build
+target, resolves straight to source through the `@r10c/source` condition. Depend
+on it as a `devDependency`.
+
+## `E2E_PROFILE`
+
+| Profile          | What is real                           | Needs infrastructure | Where it runs      |
+| ---------------- | -------------------------------------- | -------------------- | ------------------ |
+| `mock` (default) | the app / the service under test       | no                   | every pull request |
+| `live`           | everything, down to Mongo and RabbitMQ | yes                  | locally, on demand |
+
+```sh
+pnpm nx e2e marketplace-admin-app-e2e                       # mock, the default
+E2E_PROFILE=live MARKETPLACE_ADMIN_SERVICE_URL=http://localhost:3101 \
+  pnpm nx e2e marketplace-admin-app-e2e
+```
+
+`mock` is the default because the default has to run anywhere. `live` never
+falls back: a missing target URL **throws**, because a suite that skips itself
+reports green for a run that tested nothing.
+
+## What `mock` is not
+
+It is not a stub that answers every filter with all the rows. `makeEntityBackend`
+is assembled from the **production query pipeline**:
+
+```
+parseLoadRequestParams  →  loadUCFactory  →  makeMongoRepository  →  fake mongo driver
+  (core: RSQL + the         (business)        (mongo-client:          (testing-unit/drivers)
+   filterable/sortable                         filter translation)
+   allowlist)
+```
+
+So RSQL, sorting, paging and the `400 invalid query` the metadata allowlist
+produces behave identically in both profiles — which is what lets one spec suite
+serve both. A mock backend with its _own_ query semantics would disagree with
+the service the first time an operator was added.
+
+## Spec layout
+
+Selection is by filename, enforced by the config presets (`testIgnore` for
+Playwright, `exclude` for Vitest) — never by an in-spec `test.skip`, so a run
+with the wrong environment fails loudly.
+
+```
+src/
+  <journey>.spec.ts        profile-agnostic — runs in BOTH profiles
+  <journey>.mock.spec.ts   mock-only: wire assertions, injected failures
+  <journey>.live.spec.ts   live-only: real infra, seeded data
+  support/                 per-project fixtures and seed
+```
+
+Put a journey in `*.spec.ts` unless it _cannot_ run in both. Wire-shape
+assertions (the exact `rsql=` string) and injected transport failures are
+mock-only by nature; assertions about real seeded data are live-only.
+
+## Entry points
+
+```ts
+import { resolveE2eProfile, isMockProfile, requireLiveUrl } from '@entifix/testing-e2e';
+import { entityBackendHandlers, configurationHandler } from '@entifix/testing-e2e/fixtures';
+import { defineServiceE2e } from '@entifix/testing-e2e/service';
+import { defineEntifixE2eConfig, defineEntifixE2eTest, EntityTablePage } from '@entifix/testing-e2e/playwright';
+```
+
+`.` carries no Playwright, no msw and no vitest, so a consumer pulls only what
+its transport needs.
+
+### App e2e (Playwright)
+
+```ts
+// playwright.config.ts
+export default defineEntifixE2eConfig({
+  configFile: __filename,
+  appDir: 'apps/marketplace-admin-app',
+  port: 3001,
+});
+
+// src/support/fixtures.ts
+const { handlers, backend } = entityBackendHandlers(ProductBrand, { baseUrl, seed });
+export const test = defineEntifixE2eTest({ handlers: [...handlers, configurationHandler(...)] });
+```
+
+Playwright starts the app itself (`next start`), never `nx run <app>:start`: an
+nx invocation in `webServer.command` is inferred by `@nx/playwright/plugin` as a
+_continuous task dependency_ of `e2e`, and the run then waits forever on a
+server that never completes. The build is expressed as a plain `dependsOn` on
+the e2e target instead.
+
+Interception is `@msw/playwright` over Playwright's `page.route()`. The
+application is untouched: no worker script, no `NEXT_PUBLIC_*` switch, no
+mocking code in the shipped bundle. Unhandled requests **error** rather than
+escaping to the network.
+
+Two stubs are always needed, not one: the entity endpoint _and_ the app's
+`/api/config`, because the REST adapters resolve their base URL through the
+latter before they can issue the former. `configurationHandler` exists so that
+is not something each suite has to remember.
+
+### Service e2e (Vitest)
+
+```ts
+const service = defineServiceE2e({
+  liveUrlEnvVar: 'MARKETPLACE_ADMIN_SERVICE_URL',
+  startMock: () => serveTestService({ name, port: 0, router, appLayer: MockAppLayer }),
+});
+
+it('lists the catalog', async () => {
+  const response = await service.client.get('/api/product-brand');
+});
+```
+
+In `mock`, `serveTestService` (from `@entifix/service-shell`) boots the
+service's **real router** through the **real `makeServerLayer`** on an ephemeral
+port, with only the `appLayer` swapped for one built from the driver fakes. The
+routes, the use-cases, the repository adapter and the query translation all
+execute — what is absent is the infrastructure, not the service.
+
+## Why the e2e targets set `NODE_OPTIONS`
+
+`nx.json` gives every `e2e` target `NODE_OPTIONS=--conditions=@r10c/source`.
+
+Vitest applies the workspace's `@r10c/source` condition through its own
+`resolve.conditions` (see `vitest.shared.mts`), but Playwright resolves specs
+with plain Node, which knows nothing about it — so a spec importing a workspace
+package would resolve to its `dist/` and fail with `Cannot find module …/dist/index.js`
+on any machine that has not built that package. Passing the condition to Node
+keeps Playwright on the same source-first resolution as everything else, so the
+e2e suites need no prior build.
+
+This is easy to miss locally: a stale `dist/` from an earlier build makes the
+broken resolution look like it works, and it only fails on a clean checkout —
+which is exactly what CI is.
+
+## Layering note
+
+This package sits under `entifix`, so it must not import from `shells` or
+`apps`. That is why `defineServiceE2e` takes a `startMock` callback instead of
+booting the service itself: the e2e project — which may depend on both — is what
+puts `serveTestService` and its service's `router` together.
+
+## Relationship to `@entifix/testing-unit`
+
+`testing-unit` owns doubles, port contract suites and msw handlers for **unit**
+specs; this package owns **profiles, fixtures and drivers** for e2e. It depends
+on `testing-unit` (the fake Mongo driver is the same one), never the reverse.
+`testing-unit/http`'s `entityRestHandlers` stays the naive in-array fixture for
+unit specs — the faithful pipeline-backed one lives here.

package/dist/fixtures/entity-backend.d.ts

@@ -0,0 +1,54 @@
+import { type Entity, type EntityConstructor, type EntityId } from '@entifix/core';
+import { type FakeMongoDb } from '@entifix/testing-unit/drivers';
+/**
+ * A response as an HTTP transport would send it. `body` is an entifix envelope
+ * or an error record; it stays `unknown` here so the backend is not coupled to
+ * one transport's body type.
+ */
+export interface BackendResponse {
+    readonly status: number;
+    readonly body: unknown;
+}
+/** Rows as they are stored — the entity wire shape, exactly like the seed. */
+export type BackendRow = Record<string, unknown>;
+export interface EntityBackendOptions {
+    /** Initial documents, in the entity wire shape. */
+    seed?: ReadonlyArray<BackendRow>;
+}
+export interface EntityBackend {
+    /** The entity `key` — collection name and REST path segment alike. */
+    readonly key: string;
+    /** `GET /api/<key>?<search>` — filtering, sorting and paging included. */
+    list(search: URLSearchParams): Promise<BackendResponse>;
+    /** `GET /api/<key>/:id`. */
+    get(id: EntityId): Promise<BackendResponse>;
+    /** Replaces the stored rows, so one fixture can serve several journeys. */
+    seed(rows: ReadonlyArray<BackendRow>): void;
+    /** The rows currently stored, for assertions about what a write did. */
+    rows(): BackendRow[];
+    /** The underlying driver fake, for failure injection. */
+    readonly db: FakeMongoDb;
+}
+/**
+ * A read backend for one entity, assembled from the PRODUCTION query pipeline:
+ *
+ * ```
+ * parseLoadRequestParams  →  loadUCFactory  →  makeMongoRepository  →  fake driver
+ *   (core: RSQL + the         (business:        (mongo-client:          (testing-unit)
+ *    filterable/sortable       the use-case)     filter translation)
+ *    allowlist)
+ * ```
+ *
+ * Nothing here re-implements query semantics. That is the whole point: a mock
+ * backend that answers a filter with "all the rows" makes a green `mock` run
+ * meaningless, and a mock backend that implements its *own* RSQL makes the two
+ * profiles disagree the first time an operator is added. Because the real
+ * pipeline runs, `mock` and `live` agree on filtering, sorting, paging, and on
+ * the `400 invalid query` the metadata allowlist produces.
+ *
+ * Writes are deliberately absent: a `POST` in the admin service is a
+ * *transaction* answering `202`, and a fixture that answered `201` instead
+ * would be a lie about the protocol rather than a stand-in for it.
+ */
+export declare const makeEntityBackend: <TEntity extends Entity>(entityConstructor: EntityConstructor<TEntity>, { seed }?: EntityBackendOptions) => EntityBackend;
+//# sourceMappingURL=entity-backend.d.ts.map

package/dist/fixtures/entity-backend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-backend.d.ts","sourceRoot":"","sources":["../../src/fixtures/entity-backend.ts"],"names":[],"mappings":"AAOA,OAAO,EAEL,KAAK,MAAM,EACX,KAAK,iBAAiB,EACtB,KAAK,QAAQ,EAMd,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,KAAK,WAAW,EAEjB,MAAM,+BAA+B,CAAC;AAGvC;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;CACxB;AAED,8EAA8E;AAC9E,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEjD,MAAM,WAAW,oBAAoB;IACnC,mDAAmD;IACnD,IAAI,CAAC,EAAE,aAAa,CAAC,UAAU,CAAC,CAAC;CAClC;AAED,MAAM,WAAW,aAAa;IAC5B,sEAAsE;IACtE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,0EAA0E;IAC1E,IAAI,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;IACxD,4BAA4B;IAC5B,GAAG,CAAC,EAAE,EAAE,QAAQ,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;IAC5C,2EAA2E;IAC3E,IAAI,CAAC,IAAI,EAAE,aAAa,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC;IAC5C,wEAAwE;IACxE,IAAI,IAAI,UAAU,EAAE,CAAC;IACrB,yDAAyD;IACzD,QAAQ,CAAC,EAAE,EAAE,WAAW,CAAC;CAC1B;AAcD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,SAAS,MAAM,EACtD,mBAAmB,iBAAiB,CAAC,OAAO,CAAC,EAC7C,WAAe,oBAAyB,KACvC,aAsGF,CAAC"}

package/dist/fixtures/entity-backend.js

@@ -0,0 +1,130 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { EntityIdTag, EntityLoadRequestTag, EntityRepositoryTag, getUCFactory, loadUCFactory } from '@entifix/business';
+import { envelopeEntityName, makeEntityEnvelope, makeEntityPageEnvelope, parseLoadRequestParams } from '@entifix/core';
+import { makeMongoRepository } from '@entifix/mongo';
+import { stubConfigurationLayer } from '@entifix/testing-unit';
+import { makeFakeMongoDb } from '@entifix/testing-unit/drivers';
+import { Effect } from 'effect';
+const collectionLinks = (key)=>[
+        {
+            rel: 'self',
+            href: `/api/${key}`,
+            method: 'GET'
+        },
+        {
+            rel: 'create',
+            href: `/api/${key}`,
+            method: 'POST'
+        }
+    ];
+const entityLinks = (key, id)=>[
+        {
+            rel: 'self',
+            href: `/api/${key}/${String(id)}`,
+            method: 'GET'
+        },
+        {
+            rel: 'list',
+            href: `/api/${key}`,
+            method: 'GET'
+        },
+        {
+            rel: 'update',
+            href: `/api/${key}/${String(id)}`,
+            method: 'PUT'
+        },
+        {
+            rel: 'delete',
+            href: `/api/${key}/${String(id)}`,
+            method: 'DELETE'
+        }
+    ];
+/**
+ * A read backend for one entity, assembled from the PRODUCTION query pipeline:
+ *
+ * ```
+ * parseLoadRequestParams  →  loadUCFactory  →  makeMongoRepository  →  fake driver
+ *   (core: RSQL + the         (business:        (mongo-client:          (testing-unit)
+ *    filterable/sortable       the use-case)     filter translation)
+ *    allowlist)
+ * ```
+ *
+ * Nothing here re-implements query semantics. That is the whole point: a mock
+ * backend that answers a filter with "all the rows" makes a green `mock` run
+ * meaningless, and a mock backend that implements its *own* RSQL makes the two
+ * profiles disagree the first time an operator is added. Because the real
+ * pipeline runs, `mock` and `live` agree on filtering, sorting, paging, and on
+ * the `400 invalid query` the metadata allowlist produces.
+ *
+ * Writes are deliberately absent: a `POST` in the admin service is a
+ * *transaction* answering `202`, and a fixture that answered `201` instead
+ * would be a lie about the protocol rather than a stand-in for it.
+ */ export const makeEntityBackend = (entityConstructor, { seed = [] } = {})=>{
+    const key = envelopeEntityName(entityConstructor);
+    const db = makeFakeMongoDb({
+        [key]: seed.map((row)=>_extends({}, row))
+    });
+    const repository = makeMongoRepository(// The driver fake is typed `unknown` so `testing-unit` need not depend on
+    // the mongodb types; the cast is the documented way to hand it over.
+    db.db, entityConstructor);
+    /** Both use-cases need a configuration store in their requirement channel. */ const run = (effect)=>Effect.runPromise(effect);
+    const provided = (effect)=>Effect.provide(effect, stubConfigurationLayer());
+    return {
+        key,
+        list: async (search)=>{
+            let request;
+            try {
+                request = parseLoadRequestParams(entityConstructor, search);
+            } catch (error) {
+                // The same 400 the service answers: an unparseable expression, or a
+                // member the entity never declared filterable/sortable. The codec only
+                // ever throws `EntifixBuildError` here, so there is no second case to
+                // discriminate — anything else would be a bug in the codec, and
+                // reporting it verbatim is more useful than hiding it behind a 500.
+                return {
+                    status: 400,
+                    body: {
+                        error: 'invalid query',
+                        detail: String(error)
+                    }
+                };
+            }
+            try {
+                const page = await run(provided(loadUCFactory().pipe(Effect.provideService(EntityRepositoryTag, repository), Effect.provideService(EntityLoadRequestTag, request))));
+                return {
+                    status: 200,
+                    body: makeEntityPageEnvelope(entityConstructor, page, collectionLinks(key))
+                };
+            } catch (error) {
+                // A repository that fails is a 500, exactly as in the service: the
+                // request was valid, the store was not reachable.
+                return {
+                    status: 500,
+                    body: {
+                        error: 'request failed',
+                        detail: String(error)
+                    }
+                };
+            }
+        },
+        get: async (id)=>{
+            const entity = await run(provided(getUCFactory().pipe(Effect.provideService(EntityRepositoryTag, repository), Effect.provideService(EntityIdTag, id))).pipe(Effect.option));
+            return entity._tag === 'None' ? {
+                status: 404,
+                body: {
+                    message: `${key} not found`
+                }
+            } : {
+                status: 200,
+                body: makeEntityEnvelope(entityConstructor, entity.value, entityLinks(key, id))
+            };
+        },
+        seed: (rows)=>{
+            db.seed(key, rows.map((row)=>_extends({}, row)));
+        },
+        rows: ()=>db.read(key),
+        db
+    };
+};
+
+//# sourceMappingURL=entity-backend.js.map

package/dist/fixtures/entity-backend.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/fixtures/entity-backend.ts"],"sourcesContent":["import {\n  EntityIdTag,\n  EntityLoadRequestTag,\n  EntityRepositoryTag,\n  getUCFactory,\n  loadUCFactory,\n} from '@entifix/business';\nimport {\n  type EntifixEnvelopeLink,\n  type Entity,\n  type EntityConstructor,\n  type EntityId,\n  type EntityLoadRequest,\n  envelopeEntityName,\n  makeEntityEnvelope,\n  makeEntityPageEnvelope,\n  parseLoadRequestParams,\n} from '@entifix/core';\nimport { makeMongoRepository } from '@entifix/mongo';\nimport { stubConfigurationLayer } from '@entifix/testing-unit';\nimport {\n  type FakeMongoDb,\n  makeFakeMongoDb,\n} from '@entifix/testing-unit/drivers';\nimport { Effect } from 'effect';\n\n/**\n * A response as an HTTP transport would send it. `body` is an entifix envelope\n * or an error record; it stays `unknown` here so the backend is not coupled to\n * one transport's body type.\n */\nexport interface BackendResponse {\n  readonly status: number;\n  readonly body: unknown;\n}\n\n/** Rows as they are stored — the entity wire shape, exactly like the seed. */\nexport type BackendRow = Record<string, unknown>;\n\nexport interface EntityBackendOptions {\n  /** Initial documents, in the entity wire shape. */\n  seed?: ReadonlyArray<BackendRow>;\n}\n\nexport interface EntityBackend {\n  /** The entity `key` — collection name and REST path segment alike. */\n  readonly key: string;\n  /** `GET /api/<key>?<search>` — filtering, sorting and paging included. */\n  list(search: URLSearchParams): Promise<BackendResponse>;\n  /** `GET /api/<key>/:id`. */\n  get(id: EntityId): Promise<BackendResponse>;\n  /** Replaces the stored rows, so one fixture can serve several journeys. */\n  seed(rows: ReadonlyArray<BackendRow>): void;\n  /** The rows currently stored, for assertions about what a write did. */\n  rows(): BackendRow[];\n  /** The underlying driver fake, for failure injection. */\n  readonly db: FakeMongoDb;\n}\n\nconst collectionLinks = (key: string): EntifixEnvelopeLink[] => [\n  { rel: 'self', href: `/api/${key}`, method: 'GET' },\n  { rel: 'create', href: `/api/${key}`, method: 'POST' },\n];\n\nconst entityLinks = (key: string, id: EntityId): EntifixEnvelopeLink[] => [\n  { rel: 'self', href: `/api/${key}/${String(id)}`, method: 'GET' },\n  { rel: 'list', href: `/api/${key}`, method: 'GET' },\n  { rel: 'update', href: `/api/${key}/${String(id)}`, method: 'PUT' },\n  { rel: 'delete', href: `/api/${key}/${String(id)}`, method: 'DELETE' },\n];\n\n/**\n * A read backend for one entity, assembled from the PRODUCTION query pipeline:\n *\n * ```\n * parseLoadRequestParams  →  loadUCFactory  →  makeMongoRepository  →  fake driver\n *   (core: RSQL + the         (business:        (mongo-client:          (testing-unit)\n *    filterable/sortable       the use-case)     filter translation)\n *    allowlist)\n * ```\n *\n * Nothing here re-implements query semantics. That is the whole point: a mock\n * backend that answers a filter with \"all the rows\" makes a green `mock` run\n * meaningless, and a mock backend that implements its *own* RSQL makes the two\n * profiles disagree the first time an operator is added. Because the real\n * pipeline runs, `mock` and `live` agree on filtering, sorting, paging, and on\n * the `400 invalid query` the metadata allowlist produces.\n *\n * Writes are deliberately absent: a `POST` in the admin service is a\n * *transaction* answering `202`, and a fixture that answered `201` instead\n * would be a lie about the protocol rather than a stand-in for it.\n */\nexport const makeEntityBackend = <TEntity extends Entity>(\n  entityConstructor: EntityConstructor<TEntity>,\n  { seed = [] }: EntityBackendOptions = {},\n): EntityBackend => {\n  const key = envelopeEntityName(entityConstructor);\n  const db = makeFakeMongoDb({ [key]: seed.map(row => ({ ...row })) });\n  const repository = makeMongoRepository(\n    // The driver fake is typed `unknown` so `testing-unit` need not depend on\n    // the mongodb types; the cast is the documented way to hand it over.\n    db.db as Parameters<typeof makeMongoRepository>[0],\n    entityConstructor,\n  );\n\n  /** Both use-cases need a configuration store in their requirement channel. */\n  const run = <TValue, TError>(\n    effect: Effect.Effect<TValue, TError, never>,\n  ): Promise<TValue> => Effect.runPromise(effect);\n\n  const provided = <TValue, TError, TContext>(\n    effect: Effect.Effect<TValue, TError, TContext>,\n  ) => Effect.provide(effect, stubConfigurationLayer());\n\n  return {\n    key,\n\n    list: async search => {\n      let request: EntityLoadRequest;\n      try {\n        request = parseLoadRequestParams(\n          entityConstructor,\n          search,\n        ) as unknown as EntityLoadRequest;\n      } catch (error) {\n        // The same 400 the service answers: an unparseable expression, or a\n        // member the entity never declared filterable/sortable. The codec only\n        // ever throws `EntifixBuildError` here, so there is no second case to\n        // discriminate — anything else would be a bug in the codec, and\n        // reporting it verbatim is more useful than hiding it behind a 500.\n        return {\n          status: 400,\n          body: { error: 'invalid query', detail: String(error) },\n        };\n      }\n\n      try {\n        const page = await run(\n          provided(\n            loadUCFactory<TEntity>().pipe(\n              Effect.provideService(EntityRepositoryTag, repository),\n              Effect.provideService(EntityLoadRequestTag, request),\n            ),\n          ),\n        );\n\n        return {\n          status: 200,\n          body: makeEntityPageEnvelope(\n            entityConstructor,\n            page,\n            collectionLinks(key),\n          ),\n        };\n      } catch (error) {\n        // A repository that fails is a 500, exactly as in the service: the\n        // request was valid, the store was not reachable.\n        return {\n          status: 500,\n          body: { error: 'request failed', detail: String(error) },\n        };\n      }\n    },\n\n    get: async id => {\n      const entity = await run(\n        provided(\n          getUCFactory<TEntity>().pipe(\n            Effect.provideService(EntityRepositoryTag, repository),\n            Effect.provideService(EntityIdTag, id),\n          ),\n        ).pipe(Effect.option),\n      );\n\n      return entity._tag === 'None'\n        ? { status: 404, body: { message: `${key} not found` } }\n        : {\n            status: 200,\n            body: makeEntityEnvelope(\n              entityConstructor,\n              entity.value,\n              entityLinks(key, id),\n            ),\n          };\n    },\n\n    seed: rows => {\n      db.seed(\n        key,\n        rows.map(row => ({ ...row })),\n      );\n    },\n\n    rows: () => db.read(key),\n\n    db,\n  };\n};\n"],"names":["EntityIdTag","EntityLoadRequestTag","EntityRepositoryTag","getUCFactory","loadUCFactory","envelopeEntityName","makeEntityEnvelope","makeEntityPageEnvelope","parseLoadRequestParams","makeMongoRepository","stubConfigurationLayer","makeFakeMongoDb","Effect","collectionLinks","key","rel","href","method","entityLinks","id","String","makeEntityBackend","entityConstructor","seed","db","map","row","repository","run","effect","runPromise","provided","provide","list","search","request","error","status","body","detail","page","pipe","provideService","get","entity","option","_tag","message","value","rows","read"],"mappings":"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"}

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

@@ -0,0 +1,32 @@
+import type { ConfigurationPlain } from '@entifix/core';
+import type { Entity, EntityConstructor } from '@entifix/core';
+import { type RequestHandler } from 'msw';
+import { type EntityBackend, type EntityBackendOptions } from './entity-backend.js';
+export interface EntityBackendHandlerOptions extends EntityBackendOptions {
+    /** The collection endpoint, e.g. `http://localhost:3101/api/product-brand`. */
+    baseUrl: string;
+}
+/**
+ * Puts an {@link makeEntityBackend} behind msw handlers, so a browser under
+ * Playwright talks to the real query pipeline over the real wire format.
+ *
+ * The backend is returned alongside the handlers because a spec usually wants
+ * both: the handlers to install, and the backend to reseed or to break with
+ * `backend.db.failWith(...)`.
+ */
+export declare const entityBackendHandlers: <TEntity extends Entity>(entityConstructor: EntityConstructor<TEntity>, { baseUrl, ...options }: EntityBackendHandlerOptions) => {
+    handlers: RequestHandler[];
+    backend: EntityBackend;
+};
+/**
+ * The configuration lookup every entifix frontend makes before it can issue a
+ * single entity request: the REST adapters resolve their base URL through it.
+ *
+ * Stubbing the entity endpoint without this one leaves the page waiting
+ * forever and the spec passing vacuously, so it is a first-class fixture rather
+ * than something each suite remembers to add.
+ */
+export declare const configurationHandler: (url: string, configuration: ConfigurationPlain) => RequestHandler;
+export type { RequestHandler } from 'msw';
+export { http, HttpResponse } from 'msw';
+//# sourceMappingURL=entity-handlers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"entity-handlers.d.ts","sourceRoot":"","sources":["../../src/fixtures/entity-handlers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,KAAK,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAC/D,OAAO,EAAsB,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAE9D,OAAO,EAEL,KAAK,aAAa,EAClB,KAAK,oBAAoB,EAE1B,MAAM,qBAAqB,CAAC;AAE7B,MAAM,WAAW,2BAA4B,SAAQ,oBAAoB;IACvE,+EAA+E;IAC/E,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,GAAI,OAAO,SAAS,MAAM,EAC1D,mBAAmB,iBAAiB,CAAC,OAAO,CAAC,EAC7C,yBAAyB,2BAA2B,KACnD;IAAE,QAAQ,EAAE,cAAc,EAAE,CAAC;IAAC,OAAO,EAAE,aAAa,CAAA;CAmBtD,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,GAC/B,KAAK,MAAM,EACX,eAAe,kBAAkB,KAChC,cAAuE,CAAC;AAE3E,YAAY,EAAE,cAAc,EAAE,MAAM,KAAK,CAAC;AAC1C,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,MAAM,KAAK,CAAC"}

package/dist/fixtures/entity-handlers.js

@@ -0,0 +1,39 @@
+import { _ as _object_without_properties_loose } from "@swc/helpers/_/_object_without_properties_loose";
+import { http, HttpResponse } from 'msw';
+import { makeEntityBackend } from './entity-backend.js';
+/**
+ * Puts an {@link makeEntityBackend} behind msw handlers, so a browser under
+ * Playwright talks to the real query pipeline over the real wire format.
+ *
+ * The backend is returned alongside the handlers because a spec usually wants
+ * both: the handlers to install, and the backend to reseed or to break with
+ * `backend.db.failWith(...)`.
+ */ export const entityBackendHandlers = (entityConstructor, _1)=>{
+    let { baseUrl } = _1, options = _object_without_properties_loose(_1, [
+        "baseUrl"
+    ]);
+    const backend = makeEntityBackend(entityConstructor, options);
+    // Every body is an envelope or an error record — JSON either way. The cast is
+    // the one place the backend's transport-free `unknown` meets msw's body type.
+    const respond = ({ status, body })=>HttpResponse.json(body, {
+            status
+        });
+    return {
+        backend,
+        handlers: [
+            http.get(baseUrl, async ({ request })=>respond(await backend.list(new URL(request.url).searchParams))),
+            http.get(`${baseUrl}/:id`, async ({ params })=>respond(await backend.get(String(params['id']))))
+        ]
+    };
+};
+/**
+ * The configuration lookup every entifix frontend makes before it can issue a
+ * single entity request: the REST adapters resolve their base URL through it.
+ *
+ * Stubbing the entity endpoint without this one leaves the page waiting
+ * forever and the spec passing vacuously, so it is a first-class fixture rather
+ * than something each suite remembers to add.
+ */ export const configurationHandler = (url, configuration)=>http.get(url, ()=>HttpResponse.json(configuration));
+export { http, HttpResponse } from 'msw';
+
+//# sourceMappingURL=entity-handlers.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/fixtures/entity-handlers.ts"],"sourcesContent":["import type { ConfigurationPlain } from '@entifix/core';\nimport type { Entity, EntityConstructor } from '@entifix/core';\nimport { http, HttpResponse, type RequestHandler } from 'msw';\n\nimport {\n  type BackendResponse,\n  type EntityBackend,\n  type EntityBackendOptions,\n  makeEntityBackend,\n} from './entity-backend.js';\n\nexport interface EntityBackendHandlerOptions extends EntityBackendOptions {\n  /** The collection endpoint, e.g. `http://localhost:3101/api/product-brand`. */\n  baseUrl: string;\n}\n\n/**\n * Puts an {@link makeEntityBackend} behind msw handlers, so a browser under\n * Playwright talks to the real query pipeline over the real wire format.\n *\n * The backend is returned alongside the handlers because a spec usually wants\n * both: the handlers to install, and the backend to reseed or to break with\n * `backend.db.failWith(...)`.\n */\nexport const entityBackendHandlers = <TEntity extends Entity>(\n  entityConstructor: EntityConstructor<TEntity>,\n  { baseUrl, ...options }: EntityBackendHandlerOptions,\n): { handlers: RequestHandler[]; backend: EntityBackend } => {\n  const backend = makeEntityBackend(entityConstructor, options);\n\n  // Every body is an envelope or an error record — JSON either way. The cast is\n  // the one place the backend's transport-free `unknown` meets msw's body type.\n  const respond = ({ status, body }: BackendResponse) =>\n    HttpResponse.json(body as Record<string, unknown>, { status });\n\n  return {\n    backend,\n    handlers: [\n      http.get(baseUrl, async ({ request }) =>\n        respond(await backend.list(new URL(request.url).searchParams)),\n      ),\n      http.get(`${baseUrl}/:id`, async ({ params }) =>\n        respond(await backend.get(String(params['id']))),\n      ),\n    ],\n  };\n};\n\n/**\n * The configuration lookup every entifix frontend makes before it can issue a\n * single entity request: the REST adapters resolve their base URL through it.\n *\n * Stubbing the entity endpoint without this one leaves the page waiting\n * forever and the spec passing vacuously, so it is a first-class fixture rather\n * than something each suite remembers to add.\n */\nexport const configurationHandler = (\n  url: string,\n  configuration: ConfigurationPlain,\n): RequestHandler => http.get(url, () => HttpResponse.json(configuration));\n\nexport type { RequestHandler } from 'msw';\nexport { http, HttpResponse } from 'msw';\n"],"names":["http","HttpResponse","makeEntityBackend","entityBackendHandlers","entityConstructor","baseUrl","options","backend","respond","status","body","json","handlers","get","request","list","URL","url","searchParams","params","String","configurationHandler","configuration"],"mappings":";AAEA,SAASA,IAAI,EAAEC,YAAY,QAA6B,MAAM;AAE9D,SAIEC,iBAAiB,QACZ,sBAAsB;AAO7B;;;;;;;CAOC,GACD,OAAO,MAAMC,wBAAwB,CACnCC;QACA,EAAEC,OAAO,EAA2C,OAAtCC;;;IAEd,MAAMC,UAAUL,kBAAkBE,mBAAmBE;IAErD,8EAA8E;IAC9E,8EAA8E;IAC9E,MAAME,UAAU,CAAC,EAAEC,MAAM,EAAEC,IAAI,EAAmB,GAChDT,aAAaU,IAAI,CAACD,MAAiC;YAAED;QAAO;IAE9D,OAAO;QACLF;QACAK,UAAU;YACRZ,KAAKa,GAAG,CAACR,SAAS,OAAO,EAAES,OAAO,EAAE,GAClCN,QAAQ,MAAMD,QAAQQ,IAAI,CAAC,IAAIC,IAAIF,QAAQG,GAAG,EAAEC,YAAY;YAE9DlB,KAAKa,GAAG,CAAC,GAAGR,QAAQ,IAAI,CAAC,EAAE,OAAO,EAAEc,MAAM,EAAE,GAC1CX,QAAQ,MAAMD,QAAQM,GAAG,CAACO,OAAOD,MAAM,CAAC,KAAK;SAEhD;IACH;AACF,EAAE;AAEF;;;;;;;CAOC,GACD,OAAO,MAAME,uBAAuB,CAClCJ,KACAK,gBACmBtB,KAAKa,GAAG,CAACI,KAAK,IAAMhB,aAAaU,IAAI,CAACW,gBAAgB;AAG3E,SAAStB,IAAI,EAAEC,YAAY,QAAQ,MAAM"}

package/dist/fixtures/fake-infrastructure.d.ts

@@ -0,0 +1,61 @@
+import { AmqpChannelTag } from '@entifix/amqp';
+import { ConfigurationRepositoryTag, TenantDatabaseResolverTag } from '@entifix/business';
+import { type ConfigurationPlain } from '@entifix/core';
+import { MongoClientTag, MongoDatabaseTag } from '@entifix/mongo';
+import { RedisTag } from '@entifix/redis';
+import { type FakeAmqpChannel, type FakeMongoDb, type FakeRedis } from '@entifix/testing-unit/drivers';
+import { Layer } from 'effect';
+import type { BackendRow } from './entity-backend.js';
+/**
+ * The driver fakes, wired as the Layers a service's composition root provides.
+ *
+ * These stand in for the *connections*, one level below the adapters — so the
+ * Mongo repository, the Redis lock and sequence services and the AMQP event bus
+ * all still run their own code. Substituting at the port level instead would
+ * leave the filter translation, the `SET NX PX` and the envelope framing
+ * unexecuted while the suite reported the service as covered.
+ *
+ * Each helper returns the fake alongside its Layer, because a spec usually
+ * wants both: the Layer to boot with, the fake to seed, inspect or break.
+ *
+ * The casts are `never` on purpose: it keeps this package free of the mongodb,
+ * ioredis and amqplib type packages while staying honest that these are not
+ * real drivers.
+ */
+/**
+ * A driver fake and the Layer that provides it. `TService` is the tag the Layer
+ * satisfies, so `Effect.provide` actually discharges the requirement — typing
+ * the Layer's output as `never` would leave every consumer still asking for it.
+ */
+export interface FakeInfrastructure<TDriver, TService> {
+    readonly driver: TDriver;
+    readonly layer: Layer.Layer<TService>;
+}
+/**
+ * The Mongo fake, provided under all three tags a service may ask for: the
+ * shared `Db`, the `MongoClient` (the pool), and the tenant resolver.
+ *
+ * Every organization resolves to the **same** in-memory store, which is the
+ * honest mock of db-per-organization: there is one fake, so isolation is not
+ * what this profile tests. That is deliberate — a `mock` run proves routing,
+ * guards and query translation; only a live run against real Mongo can prove
+ * that two organizations' collections actually live apart, and that is what the
+ * `mongosh` check in the tenancy verification does.
+ */
+export declare const fakeMongoLayer: (seed?: Record<string, ReadonlyArray<BackendRow>>) => FakeInfrastructure<FakeMongoDb, MongoClientTag | MongoDatabaseTag | TenantDatabaseResolverTag>;
+export declare const fakeRedisLayer: () => FakeInfrastructure<FakeRedis, RedisTag>;
+/**
+ * The tag carries an `AmqpConnector`, not a channel — a held channel does not
+ * survive the broker restarting, so the real adapter asks for one per call. The
+ * fixture therefore has to supply that indirection rather than handing the fake
+ * channel over directly: a layer that provided the channel would satisfy the
+ * type through a cast and then fail at the first `withChannel` call.
+ */
+export declare const fakeAmqpLayer: () => FakeInfrastructure<FakeAmqpChannel, AmqpChannelTag>;
+/**
+ * The configuration a service would otherwise fetch from config-service at
+ * boot, provided directly. The `mock` profile has no config-service, and going
+ * through one would test the platform rather than the service under test.
+ */
+export declare const fakeConfigurationLayer: (plain?: ConfigurationPlain) => Layer.Layer<ConfigurationRepositoryTag>;
+//# sourceMappingURL=fake-infrastructure.d.ts.map

package/dist/fixtures/fake-infrastructure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake-infrastructure.d.ts","sourceRoot":"","sources":["../../src/fixtures/fake-infrastructure.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAsB,MAAM,eAAe,CAAC;AACnE,OAAO,EACL,0BAA0B,EAC1B,yBAAyB,EAC1B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAEL,KAAK,kBAAkB,EACxB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClE,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,WAAW,EAChB,KAAK,SAAS,EAIf,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAU,KAAK,EAAE,MAAM,QAAQ,CAAC;AAEvC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEtD;;;;;;;;;;;;;;;GAeG;AAEH;;;;GAIG;AACH,MAAM,WAAW,kBAAkB,CAAC,OAAO,EAAE,QAAQ;IACnD,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;CACvC;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,cAAc,GACzB,OAAM,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,UAAU,CAAC,CAAM,KACnD,kBAAkB,CACnB,WAAW,EACX,cAAc,GAAG,gBAAgB,GAAG,yBAAyB,CAgC9D,CAAC;AAEF,eAAO,MAAM,cAAc,QAAO,kBAAkB,CAAC,SAAS,EAAE,QAAQ,CAMvE,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,QAAO,kBAAkB,CACjD,eAAe,EACf,cAAc,CAgBf,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,GACjC,QAAO,kBAAuB,KAC7B,KAAK,CAAC,KAAK,CAAC,0BAA0B,CAItC,CAAC"}

package/dist/fixtures/fake-infrastructure.js

@@ -0,0 +1,77 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { AmqpChannelTag } from '@entifix/amqp';
+import { ConfigurationRepositoryTag, TenantDatabaseResolverTag } from '@entifix/business';
+import { ConfigurationClientInMemory } from '@entifix/core';
+import { MongoClientTag, MongoDatabaseTag } from '@entifix/mongo';
+import { RedisTag } from '@entifix/redis';
+import { makeFakeAmqpChannel, makeFakeMongoDb, makeFakeRedis } from '@entifix/testing-unit/drivers';
+import { Effect, Layer } from 'effect';
+/**
+ * The Mongo fake, provided under all three tags a service may ask for: the
+ * shared `Db`, the `MongoClient` (the pool), and the tenant resolver.
+ *
+ * Every organization resolves to the **same** in-memory store, which is the
+ * honest mock of db-per-organization: there is one fake, so isolation is not
+ * what this profile tests. That is deliberate — a `mock` run proves routing,
+ * guards and query translation; only a live run against real Mongo can prove
+ * that two organizations' collections actually live apart, and that is what the
+ * `mongosh` check in the tenancy verification does.
+ */ export const fakeMongoLayer = (seed = {})=>{
+    const db = makeFakeMongoDb(Object.fromEntries(Object.entries(seed).map(([collection, rows])=>[
+            collection,
+            rows.map((row)=>_extends({}, row))
+        ])));
+    return {
+        driver: db,
+        layer: Layer.mergeAll(Layer.succeed(MongoDatabaseTag, db.db), // `client.db(name)` ignores the name for the same reason.
+        //
+        // `startSession` is forwarded rather than stubbed: a service that writes
+        // a row and folds it into a counter does both inside one transaction, so
+        // a client without it fails at the first write with a `TypeError` — and
+        // a stub that returned a no-op session would commit the two halves
+        // independently, which is precisely the crash-between-them state the
+        // transaction exists to rule out.
+        Layer.succeed(MongoClientTag, {
+            db: ()=>db.db,
+            startSession: ()=>db.startSession()
+        }), Layer.succeed(TenantDatabaseResolverTag, {
+            forOrganization: ()=>Effect.succeed(db.db)
+        }))
+    };
+};
+export const fakeRedisLayer = ()=>{
+    const redis = makeFakeRedis();
+    return {
+        driver: redis,
+        layer: Layer.succeed(RedisTag, redis.redis)
+    };
+};
+/**
+ * The tag carries an `AmqpConnector`, not a channel — a held channel does not
+ * survive the broker restarting, so the real adapter asks for one per call. The
+ * fixture therefore has to supply that indirection rather than handing the fake
+ * channel over directly: a layer that provided the channel would satisfy the
+ * type through a cast and then fail at the first `withChannel` call.
+ */ export const fakeAmqpLayer = ()=>{
+    const channel = makeFakeAmqpChannel();
+    const connector = {
+        withChannel: (use)=>use(channel.channel),
+        addConsumer: async (setup)=>{
+            await setup(channel.channel);
+        },
+        // The mock profile boots and closes services in-process, so the drain runs
+        // for real against this — it simply has one channel and no broker to tell.
+        cancelConsumers: async ()=>undefined
+    };
+    return {
+        driver: channel,
+        layer: Layer.succeed(AmqpChannelTag, connector)
+    };
+};
+/**
+ * The configuration a service would otherwise fetch from config-service at
+ * boot, provided directly. The `mock` profile has no config-service, and going
+ * through one would test the platform rather than the service under test.
+ */ export const fakeConfigurationLayer = (plain = {})=>Layer.succeed(ConfigurationRepositoryTag, new ConfigurationClientInMemory(plain));
+
+//# sourceMappingURL=fake-infrastructure.js.map

package/dist/fixtures/fake-infrastructure.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/fixtures/fake-infrastructure.ts"],"sourcesContent":["import { AmqpChannelTag, type AmqpConnector } from '@entifix/amqp';\nimport {\n  ConfigurationRepositoryTag,\n  TenantDatabaseResolverTag,\n} from '@entifix/business';\nimport {\n  ConfigurationClientInMemory,\n  type ConfigurationPlain,\n} from '@entifix/core';\nimport { MongoClientTag, MongoDatabaseTag } from '@entifix/mongo';\nimport { RedisTag } from '@entifix/redis';\nimport {\n  type FakeAmqpChannel,\n  type FakeMongoDb,\n  type FakeRedis,\n  makeFakeAmqpChannel,\n  makeFakeMongoDb,\n  makeFakeRedis,\n} from '@entifix/testing-unit/drivers';\nimport { Effect, Layer } from 'effect';\n\nimport type { BackendRow } from './entity-backend.js';\n\n/**\n * The driver fakes, wired as the Layers a service's composition root provides.\n *\n * These stand in for the *connections*, one level below the adapters — so the\n * Mongo repository, the Redis lock and sequence services and the AMQP event bus\n * all still run their own code. Substituting at the port level instead would\n * leave the filter translation, the `SET NX PX` and the envelope framing\n * unexecuted while the suite reported the service as covered.\n *\n * Each helper returns the fake alongside its Layer, because a spec usually\n * wants both: the Layer to boot with, the fake to seed, inspect or break.\n *\n * The casts are `never` on purpose: it keeps this package free of the mongodb,\n * ioredis and amqplib type packages while staying honest that these are not\n * real drivers.\n */\n\n/**\n * A driver fake and the Layer that provides it. `TService` is the tag the Layer\n * satisfies, so `Effect.provide` actually discharges the requirement — typing\n * the Layer's output as `never` would leave every consumer still asking for it.\n */\nexport interface FakeInfrastructure<TDriver, TService> {\n  readonly driver: TDriver;\n  readonly layer: Layer.Layer<TService>;\n}\n\n/**\n * The Mongo fake, provided under all three tags a service may ask for: the\n * shared `Db`, the `MongoClient` (the pool), and the tenant resolver.\n *\n * Every organization resolves to the **same** in-memory store, which is the\n * honest mock of db-per-organization: there is one fake, so isolation is not\n * what this profile tests. That is deliberate — a `mock` run proves routing,\n * guards and query translation; only a live run against real Mongo can prove\n * that two organizations' collections actually live apart, and that is what the\n * `mongosh` check in the tenancy verification does.\n */\nexport const fakeMongoLayer = (\n  seed: Record<string, ReadonlyArray<BackendRow>> = {},\n): FakeInfrastructure<\n  FakeMongoDb,\n  MongoClientTag | MongoDatabaseTag | TenantDatabaseResolverTag\n> => {\n  const db = makeFakeMongoDb(\n    Object.fromEntries(\n      Object.entries(seed).map(([collection, rows]) => [\n        collection,\n        rows.map(row => ({ ...row })),\n      ]),\n    ),\n  );\n\n  return {\n    driver: db,\n    layer: Layer.mergeAll(\n      Layer.succeed(MongoDatabaseTag, db.db as never),\n      // `client.db(name)` ignores the name for the same reason.\n      //\n      // `startSession` is forwarded rather than stubbed: a service that writes\n      // a row and folds it into a counter does both inside one transaction, so\n      // a client without it fails at the first write with a `TypeError` — and\n      // a stub that returned a no-op session would commit the two halves\n      // independently, which is precisely the crash-between-them state the\n      // transaction exists to rule out.\n      Layer.succeed(MongoClientTag, {\n        db: () => db.db,\n        startSession: () => db.startSession(),\n      } as never),\n      Layer.succeed(TenantDatabaseResolverTag, {\n        forOrganization: () => Effect.succeed(db.db),\n      }),\n    ),\n  };\n};\n\nexport const fakeRedisLayer = (): FakeInfrastructure<FakeRedis, RedisTag> => {\n  const redis = makeFakeRedis();\n  return {\n    driver: redis,\n    layer: Layer.succeed(RedisTag, redis.redis as never),\n  };\n};\n\n/**\n * The tag carries an `AmqpConnector`, not a channel — a held channel does not\n * survive the broker restarting, so the real adapter asks for one per call. The\n * fixture therefore has to supply that indirection rather than handing the fake\n * channel over directly: a layer that provided the channel would satisfy the\n * type through a cast and then fail at the first `withChannel` call.\n */\nexport const fakeAmqpLayer = (): FakeInfrastructure<\n  FakeAmqpChannel,\n  AmqpChannelTag\n> => {\n  const channel = makeFakeAmqpChannel();\n  const connector: AmqpConnector = {\n    withChannel: use => use(channel.channel as never),\n    addConsumer: async setup => {\n      await setup(channel.channel as never);\n    },\n    // The mock profile boots and closes services in-process, so the drain runs\n    // for real against this — it simply has one channel and no broker to tell.\n    cancelConsumers: async () => undefined,\n  };\n  return {\n    driver: channel,\n    layer: Layer.succeed(AmqpChannelTag, connector),\n  };\n};\n\n/**\n * The configuration a service would otherwise fetch from config-service at\n * boot, provided directly. The `mock` profile has no config-service, and going\n * through one would test the platform rather than the service under test.\n */\nexport const fakeConfigurationLayer = (\n  plain: ConfigurationPlain = {},\n): Layer.Layer<ConfigurationRepositoryTag> =>\n  Layer.succeed(\n    ConfigurationRepositoryTag,\n    new ConfigurationClientInMemory(plain),\n  );\n"],"names":["AmqpChannelTag","ConfigurationRepositoryTag","TenantDatabaseResolverTag","ConfigurationClientInMemory","MongoClientTag","MongoDatabaseTag","RedisTag","makeFakeAmqpChannel","makeFakeMongoDb","makeFakeRedis","Effect","Layer","fakeMongoLayer","seed","db","Object","fromEntries","entries","map","collection","rows","row","driver","layer","mergeAll","succeed","startSession","forOrganization","fakeRedisLayer","redis","fakeAmqpLayer","channel","connector","withChannel","use","addConsumer","setup","cancelConsumers","undefined","fakeConfigurationLayer","plain"],"mappings":";AAAA,SAASA,cAAc,QAA4B,gBAAgB;AACnE,SACEC,0BAA0B,EAC1BC,yBAAyB,QACpB,oBAAoB;AAC3B,SACEC,2BAA2B,QAEtB,gBAAgB;AACvB,SAASC,cAAc,EAAEC,gBAAgB,QAAQ,iBAAiB;AAClE,SAASC,QAAQ,QAAQ,iBAAiB;AAC1C,SAIEC,mBAAmB,EACnBC,eAAe,EACfC,aAAa,QACR,gCAAgC;AACvC,SAASC,MAAM,EAAEC,KAAK,QAAQ,SAAS;AA+BvC;;;;;;;;;;CAUC,GACD,OAAO,MAAMC,iBAAiB,CAC5BC,OAAkD,CAAC,CAAC;IAKpD,MAAMC,KAAKN,gBACTO,OAAOC,WAAW,CAChBD,OAAOE,OAAO,CAACJ,MAAMK,GAAG,CAAC,CAAC,CAACC,YAAYC,KAAK,GAAK;YAC/CD;YACAC,KAAKF,GAAG,CAACG,CAAAA,MAAQ,aAAKA;SACvB;IAIL,OAAO;QACLC,QAAQR;QACRS,OAAOZ,MAAMa,QAAQ,CACnBb,MAAMc,OAAO,CAACpB,kBAAkBS,GAAGA,EAAE,GACrC,0DAA0D;QAC1D,EAAE;QACF,yEAAyE;QACzE,yEAAyE;QACzE,wEAAwE;QACxE,mEAAmE;QACnE,qEAAqE;QACrE,kCAAkC;QAClCH,MAAMc,OAAO,CAACrB,gBAAgB;YAC5BU,IAAI,IAAMA,GAAGA,EAAE;YACfY,cAAc,IAAMZ,GAAGY,YAAY;QACrC,IACAf,MAAMc,OAAO,CAACvB,2BAA2B;YACvCyB,iBAAiB,IAAMjB,OAAOe,OAAO,CAACX,GAAGA,EAAE;QAC7C;IAEJ;AACF,EAAE;AAEF,OAAO,MAAMc,iBAAiB;IAC5B,MAAMC,QAAQpB;IACd,OAAO;QACLa,QAAQO;QACRN,OAAOZ,MAAMc,OAAO,CAACnB,UAAUuB,MAAMA,KAAK;IAC5C;AACF,EAAE;AAEF;;;;;;CAMC,GACD,OAAO,MAAMC,gBAAgB;IAI3B,MAAMC,UAAUxB;IAChB,MAAMyB,YAA2B;QAC/BC,aAAaC,CAAAA,MAAOA,IAAIH,QAAQA,OAAO;QACvCI,aAAa,OAAMC;YACjB,MAAMA,MAAML,QAAQA,OAAO;QAC7B;QACA,2EAA2E;QAC3E,2EAA2E;QAC3EM,iBAAiB,UAAYC;IAC/B;IACA,OAAO;QACLhB,QAAQS;QACRR,OAAOZ,MAAMc,OAAO,CAACzB,gBAAgBgC;IACvC;AACF,EAAE;AAEF;;;;CAIC,GACD,OAAO,MAAMO,yBAAyB,CACpCC,QAA4B,CAAC,CAAC,GAE9B7B,MAAMc,OAAO,CACXxB,4BACA,IAAIE,4BAA4BqC,QAChC"}

package/dist/fixtures/index.d.ts

@@ -0,0 +1,5 @@
+export * from './entity-backend.js';
+export * from './entity-handlers.js';
+export * from './fake-infrastructure.js';
+export * from './signing-key.js';
+//# sourceMappingURL=index.d.ts.map