@entifix/testing-unit 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,60 @@
+# @entifix/testing-unit
+
+Shared test doubles, port contract suites, and HTTP stubbing for the workspace.
+Test-only: it is private, has no build target, and resolves straight to source
+through the `@r10c/source` condition. Depend on it as a `devDependency`.
+
+## Vocabulary
+
+Which kind of double to reach for, and where each lives:
+
+| Kind            | What it is                                                 | Where                  |
+| --------------- | ---------------------------------------------------------- | ---------------------- |
+| **Stub**        | Canned answers, no assertions on it                        | inline, or `makeStub*` |
+| **Fake**        | Working in-memory implementation of a **driven port**      | `.` (`makeInMemory*`)  |
+| **Driver fake** | Fake of a _third-party client_, one level below an adapter | `./drivers`            |
+| **Recording**   | A fake that records what happened, asserted as state       | `.` (`makeRecording*`) |
+| **MSW**         | The boundary for everything HTTP                           | `./http`               |
+
+Mocks with call assertions are a last resort, kept for cases where the
+behaviour _is_ the interaction (event publication, lock ordering, rollback).
+Prefer a recording fake — `expect(bus.published)` reads as state, a spy
+protocol does not.
+
+## Entry points
+
+```ts
+import { makeInMemoryEntityRepository, runRepository } from '@entifix/testing-unit';
+import { makeFakeMongoDb } from '@entifix/testing-unit/drivers';
+import { entityRestHandlers, setupEntifixServer } from '@entifix/testing-unit/http';
+import { describeEntityRepositoryContract } from '@entifix/testing-unit/contracts';
+import { renderWithAdapters } from '@entifix/testing-unit/react';
+```
+
+`.` carries no React and no msw, so TS-only packages pull neither.
+
+## Why driver fakes rather than port fakes
+
+A fake at the port level replaces the adapter, so none of the adapter's own code
+runs — the filter translation, the `SET NX PX`, the envelope framing, the error
+mapping all go unmeasured while coverage still reports the port as exercised.
+The driver fakes sit one level lower, so the real adapter executes against them.
+
+## Contract suites
+
+Each driven port has one suite, run against **every** implementation:
+
+```ts
+describeEntityRepositoryContract('in-memory fake', { makeRepository: seed => makeInMemoryEntityRepository(seed) });
+describeEntityRepositoryContract('mongo adapter over a fake driver', { makeRepository: seed => makeMongoRepository(fakeDb, Widget) });
+```
+
+This is what keeps a fake from quietly becoming a more forgiving version of the
+thing it stands in for. `@entifix/testing-integration` will later run
+the same suites against real infrastructure.
+
+## Known constraint
+
+`@entifix/business` and `@entifix/transactions` **cannot** use this
+package: it is built on their interfaces, so depending on it from them is a
+cycle. Those two define their doubles locally. Everything else uses this.

package/dist/builders/entity-builder.d.ts

@@ -0,0 +1,26 @@
+import type { Entity, EntityConstructor } from '@entifix/core';
+export interface EntityBuilder<TEntity extends Entity> {
+    /** Produces one instance, overriding the defaults with `overrides`. */
+    (overrides?: Partial<TEntity>): TEntity;
+    /**
+     * Produces `count` instances. `overrides` may be a function of the index, so
+     * a list of distinguishable rows takes one line.
+     */
+    many(count: number, overrides?: (index: number) => Partial<TEntity>): TEntity[];
+}
+/**
+ * Builds test entities from a set of defaults.
+ *
+ * Entities are `#field` + accessor classes, so a literal will not do — every
+ * value has to go through its setter for `MetaEntity` introspection and
+ * serialization to see it. This keeps that assignment in one place instead of
+ * in a `makeWidget` helper redefined in every spec.
+ *
+ * ```ts
+ * const aProduct = defineEntityBuilder(Product, { name: 'Widget', price: 10 });
+ * const cheap = aProduct({ price: 1 });
+ * const rows = aProduct.many(3, (index) => ({ id: `p-${index}` }));
+ * ```
+ */
+export declare const defineEntityBuilder: <TEntity extends Entity>(entityConstructor: EntityConstructor<TEntity>, defaults?: Partial<TEntity>) => EntityBuilder<TEntity>;
+//# sourceMappingURL=entity-builder.d.ts.map

package/dist/builders/entity-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-builder.d.ts","sourceRoot":"","sources":["../../src/builders/entity-builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAE/D,MAAM,WAAW,aAAa,CAAC,OAAO,SAAS,MAAM;IACnD,uEAAuE;IACvE,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;IACxC;;;OAGG;IACH,IAAI,CACF,KAAK,EAAE,MAAM,EACb,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,GAC9C,OAAO,EAAE,CAAC;CACd;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mBAAmB,GAAI,OAAO,SAAS,MAAM,EACxD,mBAAmB,iBAAiB,CAAC,OAAO,CAAC,EAC7C,WAAU,OAAO,CAAC,OAAO,CAAM,KAC9B,aAAa,CAAC,OAAO,CAiBvB,CAAC"}

package/dist/builders/entity-builder.js

@@ -0,0 +1,30 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+/**
+ * Builds test entities from a set of defaults.
+ *
+ * Entities are `#field` + accessor classes, so a literal will not do — every
+ * value has to go through its setter for `MetaEntity` introspection and
+ * serialization to see it. This keeps that assignment in one place instead of
+ * in a `makeWidget` helper redefined in every spec.
+ *
+ * ```ts
+ * const aProduct = defineEntityBuilder(Product, { name: 'Widget', price: 10 });
+ * const cheap = aProduct({ price: 1 });
+ * const rows = aProduct.many(3, (index) => ({ id: `p-${index}` }));
+ * ```
+ */ export const defineEntityBuilder = (entityConstructor, defaults = {})=>{
+    const build = (overrides = {})=>{
+        const instance = new entityConstructor();
+        for (const [property, value] of Object.entries(_extends({}, defaults, overrides))){
+            instance[property] = value;
+        }
+        return instance;
+    };
+    const builder = build;
+    builder.many = (count, overrides = ()=>({}))=>Array.from({
+            length: count
+        }, (_unused, index)=>build(overrides(index)));
+    return builder;
+};
+
+//# sourceMappingURL=entity-builder.js.map

package/dist/builders/entity-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/builders/entity-builder.ts"],"sourcesContent":["import type { Entity, EntityConstructor } from '@entifix/core';\n\nexport interface EntityBuilder<TEntity extends Entity> {\n  /** Produces one instance, overriding the defaults with `overrides`. */\n  (overrides?: Partial<TEntity>): TEntity;\n  /**\n   * Produces `count` instances. `overrides` may be a function of the index, so\n   * a list of distinguishable rows takes one line.\n   */\n  many(\n    count: number,\n    overrides?: (index: number) => Partial<TEntity>,\n  ): TEntity[];\n}\n\n/**\n * Builds test entities from a set of defaults.\n *\n * Entities are `#field` + accessor classes, so a literal will not do — every\n * value has to go through its setter for `MetaEntity` introspection and\n * serialization to see it. This keeps that assignment in one place instead of\n * in a `makeWidget` helper redefined in every spec.\n *\n * ```ts\n * const aProduct = defineEntityBuilder(Product, { name: 'Widget', price: 10 });\n * const cheap = aProduct({ price: 1 });\n * const rows = aProduct.many(3, (index) => ({ id: `p-${index}` }));\n * ```\n */\nexport const defineEntityBuilder = <TEntity extends Entity>(\n  entityConstructor: EntityConstructor<TEntity>,\n  defaults: Partial<TEntity> = {},\n): EntityBuilder<TEntity> => {\n  const build = (overrides: Partial<TEntity> = {}): TEntity => {\n    const instance = new entityConstructor();\n    for (const [property, value] of Object.entries({\n      ...defaults,\n      ...overrides,\n    })) {\n      (instance as Record<string, unknown>)[property] = value;\n    }\n    return instance;\n  };\n\n  const builder = build as EntityBuilder<TEntity>;\n  builder.many = (count, overrides = () => ({})) =>\n    Array.from({ length: count }, (_unused, index) => build(overrides(index)));\n\n  return builder;\n};\n"],"names":["defineEntityBuilder","entityConstructor","defaults","build","overrides","instance","property","value","Object","entries","builder","many","count","Array","from","length","_unused","index"],"mappings":";AAeA;;;;;;;;;;;;;CAaC,GACD,OAAO,MAAMA,sBAAsB,CACjCC,mBACAC,WAA6B,CAAC,CAAC;IAE/B,MAAMC,QAAQ,CAACC,YAA8B,CAAC,CAAC;QAC7C,MAAMC,WAAW,IAAIJ;QACrB,KAAK,MAAM,CAACK,UAAUC,MAAM,IAAIC,OAAOC,OAAO,CAAC,aAC1CP,UACAE,YACD;YACDC,QAAoC,CAACC,SAAS,GAAGC;QACpD;QACA,OAAOF;IACT;IAEA,MAAMK,UAAUP;IAChBO,QAAQC,IAAI,GAAG,CAACC,OAAOR,YAAY,IAAO,CAAA,CAAC,CAAA,CAAE,GAC3CS,MAAMC,IAAI,CAAC;YAAEC,QAAQH;QAAM,GAAG,CAACI,SAASC,QAAUd,MAAMC,UAAUa;IAEpE,OAAOP;AACT,EAAE"}

package/dist/contracts/entity-repository.contract.d.ts

@@ -0,0 +1,36 @@
+import type { EntityRepository } from '@entifix/business';
+import { type Entity, type EntityId } from '@entifix/core';
+/**
+ * The entity every implementation of the contract is exercised against. It is
+ * declared here rather than by each caller so the suite controls exactly which
+ * fields exist.
+ */
+export declare class ContractWidget implements Entity {
+    #private;
+    get id(): EntityId;
+    set id(value: EntityId);
+    get name(): string | undefined;
+    set name(value: string | undefined);
+    get size(): number | undefined;
+    set size(value: number | undefined);
+}
+export declare const makeContractWidget: (id: EntityId, name: string, size: number) => ContractWidget;
+export interface EntityRepositoryContractOptions {
+    /**
+     * Builds a repository over `seed`. Called fresh for each test, so no state
+     * leaks between them.
+     */
+    makeRepository(seed: ContractWidget[]): EntityRepository | Promise<EntityRepository>;
+}
+/**
+ * The behaviour every {@link EntityRepository} must exhibit, regardless of what
+ * backs it.
+ *
+ * Run it against the in-memory fake *and* against each real adapter. That is
+ * what stops a fake from drifting into a more forgiving version of the thing it
+ * stands in for — the failure mode where a suite is green and production is
+ * not. `entifix-ts-testing-integration` will run this same suite against real
+ * infrastructure later.
+ */
+export declare const describeEntityRepositoryContract: (name: string, { makeRepository }: EntityRepositoryContractOptions) => void;
+//# sourceMappingURL=entity-repository.contract.d.ts.map

package/dist/contracts/entity-repository.contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-repository.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/entity-repository.contract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,EAAY,KAAK,MAAM,EAAU,KAAK,QAAQ,EAAE,MAAM,eAAe,CAAC;AAM7E;;;;GAIG;AACH,qBACa,cAAe,YAAW,MAAM;;IAK3C,IACI,EAAE,IAAI,QAAQ,CAEjB;IACD,IAAI,EAAE,CAAC,KAAK,EAAE,QAAQ,EAErB;IAED,IACI,IAAI,IAAI,MAAM,GAAG,SAAS,CAE7B;IACD,IAAI,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAEjC;IAED,IACI,IAAI,IAAI,MAAM,GAAG,SAAS,CAE7B;IACD,IAAI,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAEjC;CACF;AAED,eAAO,MAAM,kBAAkB,GAC7B,IAAI,QAAQ,EACZ,MAAM,MAAM,EACZ,MAAM,MAAM,KACX,cAMF,CAAC;AAEF,MAAM,WAAW,+BAA+B;IAC9C;;;OAGG;IACH,cAAc,CACZ,IAAI,EAAE,cAAc,EAAE,GACrB,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;CACjD;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,gCAAgC,GAC3C,MAAM,MAAM,EACZ,oBAAoB,+BAA+B,KAClD,IAsMF,CAAC"}

package/dist/contracts/entity-repository.contract.js

@@ -0,0 +1,273 @@
+import { _ as _class_private_field_loose_base } from "@swc/helpers/_/_class_private_field_loose_base";
+import { _ as _class_private_field_loose_key } from "@swc/helpers/_/_class_private_field_loose_key";
+import { _ as _apply_decs_2203_r } from "@swc/helpers/_/_apply_decs_2203_r";
+var _dec, _initClass, _dec1, _dec2, _dec3, _initProto;
+import { accessor, entity } from '@entifix/core';
+import { Exit } from 'effect';
+import { describe, expect, it } from 'vitest';
+import { runRepository, runRepositoryExit } from '../effect/run.js';
+_dec = entity({
+    key: 'contract-widget'
+}), _dec1 = accessor({
+    type: 'id'
+}), _dec2 = accessor({
+    type: 'string'
+}), _dec3 = accessor({
+    type: 'number'
+});
+let _ContractWidget;
+var _id = /*#__PURE__*/ _class_private_field_loose_key("_id"), _name = /*#__PURE__*/ _class_private_field_loose_key("_name"), _size = /*#__PURE__*/ _class_private_field_loose_key("_size");
+let ContractWidget = class ContractWidget {
+    get id() {
+        return _class_private_field_loose_base(this, _id)[_id];
+    }
+    set id(value) {
+        _class_private_field_loose_base(this, _id)[_id] = value;
+    }
+    get name() {
+        return _class_private_field_loose_base(this, _name)[_name];
+    }
+    set name(value) {
+        _class_private_field_loose_base(this, _name)[_name] = value;
+    }
+    get size() {
+        return _class_private_field_loose_base(this, _size)[_size];
+    }
+    set size(value) {
+        _class_private_field_loose_base(this, _size)[_size] = value;
+    }
+    constructor(){
+        Object.defineProperty(this, _id, {
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, _name, {
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, _size, {
+            writable: true,
+            value: void 0
+        });
+        _initProto(this);
+    }
+};
+({ e: [_initProto], c: [_ContractWidget, _initClass] } = _apply_decs_2203_r(ContractWidget, [
+    [
+        _dec1,
+        3,
+        "id"
+    ],
+    [
+        _dec2,
+        3,
+        "name"
+    ],
+    [
+        _dec3,
+        3,
+        "size"
+    ]
+], [
+    _dec
+]));
+_initClass();
+export const makeContractWidget = (id, name, size)=>{
+    const widget = new _ContractWidget();
+    widget.id = id;
+    widget.name = name;
+    widget.size = size;
+    return widget;
+};
+/**
+ * The behaviour every {@link EntityRepository} must exhibit, regardless of what
+ * backs it.
+ *
+ * Run it against the in-memory fake *and* against each real adapter. That is
+ * what stops a fake from drifting into a more forgiving version of the thing it
+ * stands in for — the failure mode where a suite is green and production is
+ * not. `entifix-ts-testing-integration` will run this same suite against real
+ * infrastructure later.
+ */ export const describeEntityRepositoryContract = (name, { makeRepository })=>{
+    describe(`EntityRepository contract: ${name}`, ()=>{
+        const seeded = ()=>[
+                makeContractWidget('w-1', 'Alpha', 10),
+                makeContractWidget('w-2', 'Beta', 20),
+                makeContractWidget('w-3', 'Gamma', 30)
+            ];
+        const withRepository = async (use, seed = seeded())=>{
+            await use(await makeRepository(seed));
+        };
+        it('loads every stored entity with its total', async ()=>{
+            await withRepository(async (repository)=>{
+                const page = await runRepository(repository.load({}));
+                expect(page.total).toBe(3);
+                expect(page.items.map((item)=>item.name)).toEqual([
+                    'Alpha',
+                    'Beta',
+                    'Gamma'
+                ]);
+            });
+        });
+        it('echoes the request it served on the page', async ()=>{
+            await withRepository(async (repository)=>{
+                const request = {
+                    page: 1,
+                    pageSize: 2
+                };
+                const page = await runRepository(repository.load(request));
+                expect(page.request).toEqual(request);
+            });
+        });
+        it('pages with a 1-based page number', async ()=>{
+            await withRepository(async (repository)=>{
+                var _page_items_;
+                const page = await runRepository(repository.load({
+                    page: 2,
+                    pageSize: 2
+                }));
+                expect(page.items).toHaveLength(1);
+                expect((_page_items_ = page.items[0]) == null ? void 0 : _page_items_.name).toBe('Gamma');
+                // The total counts matches, not the page.
+                expect(page.total).toBe(3);
+            });
+        });
+        it('filters by an equality operator', async ()=>{
+            await withRepository(async (repository)=>{
+                var _page_items_;
+                const page = await runRepository(repository.load({
+                    filtering: [
+                        {
+                            property: 'name',
+                            operator: 'eq',
+                            value: 'Beta'
+                        }
+                    ]
+                }));
+                expect(page.items).toHaveLength(1);
+                expect((_page_items_ = page.items[0]) == null ? void 0 : _page_items_.id).toBe('w-2');
+                expect(page.total).toBe(1);
+            });
+        });
+        it('filters by a range operator', async ()=>{
+            await withRepository(async (repository)=>{
+                const page = await runRepository(repository.load({
+                    filtering: [
+                        {
+                            property: 'size',
+                            operator: 'between',
+                            start: 15,
+                            end: 35
+                        }
+                    ]
+                }));
+                expect(page.items.map((item)=>item.id)).toEqual([
+                    'w-2',
+                    'w-3'
+                ]);
+            });
+        });
+        it('matches `like` case-insensitively on a substring', async ()=>{
+            await withRepository(async (repository)=>{
+                const page = await runRepository(repository.load({
+                    filtering: [
+                        {
+                            property: 'name',
+                            operator: 'like',
+                            value: 'et'
+                        }
+                    ]
+                }));
+                expect(page.items.map((item)=>item.id)).toEqual([
+                    'w-2'
+                ]);
+            });
+        });
+        it('sorts descending when asked to', async ()=>{
+            await withRepository(async (repository)=>{
+                const page = await runRepository(repository.load({
+                    sorting: [
+                        {
+                            0: {
+                                property: 'size',
+                                type: 'desc'
+                            }
+                        }
+                    ]
+                }));
+                expect(page.items.map((item)=>item.size)).toEqual([
+                    30,
+                    20,
+                    10
+                ]);
+            });
+        });
+        it('reads a single entity by id', async ()=>{
+            await withRepository(async (repository)=>{
+                const found = await runRepository(repository.get('w-2'));
+                expect(found.id).toBe('w-2');
+                expect(found.name).toBe('Beta');
+            });
+        });
+        it('fails rather than resolving undefined for an unknown id', async ()=>{
+            await withRepository(async (repository)=>{
+                const exit = await runRepositoryExit(repository.get('missing'));
+                expect(Exit.isFailure(exit)).toBe(true);
+            });
+        });
+        it('mints an id when saving an entity that has none', async ()=>{
+            await withRepository(async (repository)=>{
+                const created = await runRepository(repository.save(makeContractWidget(undefined, 'Delta', 40)));
+                expect(created.id).toBeDefined();
+                const page = await runRepository(repository.load({}));
+                expect(page.total).toBe(4);
+            });
+        });
+        it('overwrites in place when saving an entity that already has an id', async ()=>{
+            await withRepository(async (repository)=>{
+                await runRepository(repository.save(makeContractWidget('w-2', 'Renamed', 25)));
+                const found = await runRepository(repository.get('w-2'));
+                expect(found.name).toBe('Renamed');
+                const page = await runRepository(repository.load({}));
+                expect(page.total).toBe(3);
+            });
+        });
+        it('deletes by id', async ()=>{
+            await withRepository(async (repository)=>{
+                await runRepository(repository.delete('w-1'));
+                const page = await runRepository(repository.load({}));
+                expect(page.items.map((item)=>item.id)).toEqual([
+                    'w-2',
+                    'w-3'
+                ]);
+            });
+        });
+        it('deletes by entity', async ()=>{
+            await withRepository(async (repository)=>{
+                await runRepository(repository.delete(makeContractWidget('w-3', 'Gamma', 30)));
+                const page = await runRepository(repository.load({}));
+                expect(page.items.map((item)=>item.id)).toEqual([
+                    'w-1',
+                    'w-2'
+                ]);
+            });
+        });
+        it('treats deleting an unknown id as a no-op', async ()=>{
+            await withRepository(async (repository)=>{
+                await runRepository(repository.delete('missing'));
+                const page = await runRepository(repository.load({}));
+                expect(page.total).toBe(3);
+            });
+        });
+        it('loads an empty page from an empty store', async ()=>{
+            await withRepository(async (repository)=>{
+                const page = await runRepository(repository.load({}));
+                expect(page.items).toEqual([]);
+                expect(page.total).toBe(0);
+            }, []);
+        });
+    });
+};
+export { _ContractWidget as ContractWidget };
+
+//# sourceMappingURL=entity-repository.contract.js.map

package/dist/contracts/entity-repository.contract.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/contracts/entity-repository.contract.ts"],"sourcesContent":["import type { EntityRepository } from '@entifix/business';\nimport { accessor, type Entity, entity, type EntityId } from '@entifix/core';\nimport { Exit } from 'effect';\nimport { describe, expect, it } from 'vitest';\n\nimport { runRepository, runRepositoryExit } from '../effect/run.js';\n\n/**\n * The entity every implementation of the contract is exercised against. It is\n * declared here rather than by each caller so the suite controls exactly which\n * fields exist.\n */\n@entity({ key: 'contract-widget' })\nexport class ContractWidget implements Entity {\n  #id?: EntityId;\n  #name?: string;\n  #size?: number;\n\n  @accessor({ type: 'id' })\n  get id(): EntityId {\n    return this.#id;\n  }\n  set id(value: EntityId) {\n    this.#id = value;\n  }\n\n  @accessor({ type: 'string' })\n  get name(): string | undefined {\n    return this.#name;\n  }\n  set name(value: string | undefined) {\n    this.#name = value;\n  }\n\n  @accessor({ type: 'number' })\n  get size(): number | undefined {\n    return this.#size;\n  }\n  set size(value: number | undefined) {\n    this.#size = value;\n  }\n}\n\nexport const makeContractWidget = (\n  id: EntityId,\n  name: string,\n  size: number,\n): ContractWidget => {\n  const widget = new ContractWidget();\n  widget.id = id;\n  widget.name = name;\n  widget.size = size;\n  return widget;\n};\n\nexport interface EntityRepositoryContractOptions {\n  /**\n   * Builds a repository over `seed`. Called fresh for each test, so no state\n   * leaks between them.\n   */\n  makeRepository(\n    seed: ContractWidget[],\n  ): EntityRepository | Promise<EntityRepository>;\n}\n\n/**\n * The behaviour every {@link EntityRepository} must exhibit, regardless of what\n * backs it.\n *\n * Run it against the in-memory fake *and* against each real adapter. That is\n * what stops a fake from drifting into a more forgiving version of the thing it\n * stands in for — the failure mode where a suite is green and production is\n * not. `entifix-ts-testing-integration` will run this same suite against real\n * infrastructure later.\n */\nexport const describeEntityRepositoryContract = (\n  name: string,\n  { makeRepository }: EntityRepositoryContractOptions,\n): void => {\n  describe(`EntityRepository contract: ${name}`, () => {\n    const seeded = () => [\n      makeContractWidget('w-1', 'Alpha', 10),\n      makeContractWidget('w-2', 'Beta', 20),\n      makeContractWidget('w-3', 'Gamma', 30),\n    ];\n\n    const withRepository = async (\n      use: (repository: EntityRepository) => Promise<void>,\n      seed: ContractWidget[] = seeded(),\n    ) => {\n      await use(await makeRepository(seed));\n    };\n\n    it('loads every stored entity with its total', async () => {\n      await withRepository(async repository => {\n        const page = await runRepository(repository.load<ContractWidget>({}));\n\n        expect(page.total).toBe(3);\n        expect(page.items.map(item => item.name)).toEqual([\n          'Alpha',\n          'Beta',\n          'Gamma',\n        ]);\n      });\n    });\n\n    it('echoes the request it served on the page', async () => {\n      await withRepository(async repository => {\n        const request = { page: 1, pageSize: 2 };\n        const page = await runRepository(\n          repository.load<ContractWidget>(request),\n        );\n\n        expect(page.request).toEqual(request);\n      });\n    });\n\n    it('pages with a 1-based page number', async () => {\n      await withRepository(async repository => {\n        const page = await runRepository(\n          repository.load<ContractWidget>({ page: 2, pageSize: 2 }),\n        );\n\n        expect(page.items).toHaveLength(1);\n        expect(page.items[0]?.name).toBe('Gamma');\n        // The total counts matches, not the page.\n        expect(page.total).toBe(3);\n      });\n    });\n\n    it('filters by an equality operator', async () => {\n      await withRepository(async repository => {\n        const page = await runRepository(\n          repository.load<ContractWidget>({\n            filtering: [{ property: 'name', operator: 'eq', value: 'Beta' }],\n          }),\n        );\n\n        expect(page.items).toHaveLength(1);\n        expect(page.items[0]?.id).toBe('w-2');\n        expect(page.total).toBe(1);\n      });\n    });\n\n    it('filters by a range operator', async () => {\n      await withRepository(async repository => {\n        const page = await runRepository(\n          repository.load<ContractWidget>({\n            filtering: [\n              { property: 'size', operator: 'between', start: 15, end: 35 },\n            ],\n          }),\n        );\n\n        expect(page.items.map(item => item.id)).toEqual(['w-2', 'w-3']);\n      });\n    });\n\n    it('matches `like` case-insensitively on a substring', async () => {\n      await withRepository(async repository => {\n        const page = await runRepository(\n          repository.load<ContractWidget>({\n            filtering: [{ property: 'name', operator: 'like', value: 'et' }],\n          }),\n        );\n\n        expect(page.items.map(item => item.id)).toEqual(['w-2']);\n      });\n    });\n\n    it('sorts descending when asked to', async () => {\n      await withRepository(async repository => {\n        const page = await runRepository(\n          repository.load<ContractWidget>({\n            sorting: [{ 0: { property: 'size', type: 'desc' } }],\n          }),\n        );\n\n        expect(page.items.map(item => item.size)).toEqual([30, 20, 10]);\n      });\n    });\n\n    it('reads a single entity by id', async () => {\n      await withRepository(async repository => {\n        const found = await runRepository(\n          repository.get<ContractWidget>('w-2'),\n        );\n\n        expect(found.id).toBe('w-2');\n        expect(found.name).toBe('Beta');\n      });\n    });\n\n    it('fails rather than resolving undefined for an unknown id', async () => {\n      await withRepository(async repository => {\n        const exit = await runRepositoryExit(\n          repository.get<ContractWidget>('missing'),\n        );\n\n        expect(Exit.isFailure(exit)).toBe(true);\n      });\n    });\n\n    it('mints an id when saving an entity that has none', async () => {\n      await withRepository(async repository => {\n        const created = await runRepository(\n          repository.save<ContractWidget>(\n            makeContractWidget(undefined, 'Delta', 40),\n          ),\n        );\n\n        expect(created.id).toBeDefined();\n\n        const page = await runRepository(repository.load<ContractWidget>({}));\n        expect(page.total).toBe(4);\n      });\n    });\n\n    it('overwrites in place when saving an entity that already has an id', async () => {\n      await withRepository(async repository => {\n        await runRepository(\n          repository.save<ContractWidget>(\n            makeContractWidget('w-2', 'Renamed', 25),\n          ),\n        );\n\n        const found = await runRepository(\n          repository.get<ContractWidget>('w-2'),\n        );\n        expect(found.name).toBe('Renamed');\n\n        const page = await runRepository(repository.load<ContractWidget>({}));\n        expect(page.total).toBe(3);\n      });\n    });\n\n    it('deletes by id', async () => {\n      await withRepository(async repository => {\n        await runRepository(repository.delete<ContractWidget>('w-1'));\n\n        const page = await runRepository(repository.load<ContractWidget>({}));\n        expect(page.items.map(item => item.id)).toEqual(['w-2', 'w-3']);\n      });\n    });\n\n    it('deletes by entity', async () => {\n      await withRepository(async repository => {\n        await runRepository(\n          repository.delete<ContractWidget>(\n            makeContractWidget('w-3', 'Gamma', 30),\n          ),\n        );\n\n        const page = await runRepository(repository.load<ContractWidget>({}));\n        expect(page.items.map(item => item.id)).toEqual(['w-1', 'w-2']);\n      });\n    });\n\n    it('treats deleting an unknown id as a no-op', async () => {\n      await withRepository(async repository => {\n        await runRepository(repository.delete<ContractWidget>('missing'));\n\n        const page = await runRepository(repository.load<ContractWidget>({}));\n        expect(page.total).toBe(3);\n      });\n    });\n\n    it('loads an empty page from an empty store', async () => {\n      await withRepository(async repository => {\n        const page = await runRepository(repository.load<ContractWidget>({}));\n\n        expect(page.items).toEqual([]);\n        expect(page.total).toBe(0);\n      }, []);\n    });\n  });\n};\n"],"names":["accessor","entity","Exit","describe","expect","it","runRepository","runRepositoryExit","key","type","ContractWidget","id","value","name","size","makeContractWidget","widget","describeEntityRepositoryContract","makeRepository","seeded","withRepository","use","seed","repository","page","load","total","toBe","items","map","item","toEqual","request","pageSize","toHaveLength","filtering","property","operator","start","end","sorting","found","get","exit","isFailure","created","save","undefined","toBeDefined","delete"],"mappings":"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"}

package/dist/contracts/index.d.ts

@@ -0,0 +1,3 @@
+export * from './entity-repository.contract.js';
+export * from './transaction-ports.contract.js';
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/contracts/index.js

@@ -0,0 +1,4 @@
+export * from './entity-repository.contract.js';
+export * from './transaction-ports.contract.js';
+
+//# sourceMappingURL=index.js.map

package/dist/contracts/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/contracts/index.ts"],"sourcesContent":["export * from './entity-repository.contract.js';\nexport * from './transaction-ports.contract.js';\n"],"names":[],"mappings":"AAAA,cAAc,kCAAkC;AAChD,cAAc,kCAAkC"}

package/dist/contracts/transaction-ports.contract.d.ts

@@ -0,0 +1,44 @@
+import type { DomainEvent } from '@entifix/core';
+import type { EventBus, LockService, SequenceService, TransactionInbox } from '@entifix/transactions';
+/**
+ * What every {@link LockService} must guarantee: exclusivity while held,
+ * availability after release, and a release that only frees the caller's own
+ * lock. The last one is why `release` takes a handle rather than a key — a lock
+ * that lapsed and was re-acquired by someone else must not be freed by the
+ * previous holder.
+ */
+export declare const describeLockServiceContract: (name: string, makeLockService: () => LockService | Promise<LockService>) => void;
+/**
+ * What every {@link SequenceService} must guarantee: strictly increasing values
+ * per name, never repeating, with names independent of one another. This is the
+ * property incremental codes rest on.
+ */
+export declare const describeSequenceServiceContract: (name: string, makeSequenceService: () => SequenceService | Promise<SequenceService>) => void;
+export interface EventBusContractHarness {
+    bus: EventBus;
+    /** Delivers `event` to whatever subscribed, as the broker would. */
+    deliver(event: DomainEvent): Promise<void>;
+    /** Everything the bus published, decoded back into events. */
+    published(): DomainEvent[];
+}
+/**
+ * What every {@link EventBus} must guarantee: what goes out comes back
+ * unchanged, subscribers receive deliveries, and a subscriber receives only what
+ * its pattern matches. The transports differ wildly (an array here, a topic
+ * exchange in RabbitMQ) — the observable contract does not.
+ */
+export declare const describeEventBusContract: (name: string, makeHarness: () => EventBusContractHarness | Promise<EventBusContractHarness>) => void;
+/**
+ * What every {@link TransactionInbox} must guarantee: a first claim is granted,
+ * every repeat of it is refused, and one consumer's claim says nothing about
+ * another's.
+ *
+ * That last one is the property with teeth. Two consumers legitimately process
+ * the same event — the saga tracker's fold and the SSE hub both bind
+ * `transaction.*` — so an implementation keyed on `eventId` alone passes the
+ * first two cases and silently starves every consumer but the first. It looks
+ * like exactly-once from inside one consumer, which is why it is asserted here
+ * rather than left to each adapter's own spec.
+ */
+export declare const describeTransactionInboxContract: (name: string, makeInbox: (consumer: string) => TransactionInbox | Promise<TransactionInbox>) => void;
+//# sourceMappingURL=transaction-ports.contract.d.ts.map

package/dist/contracts/transaction-ports.contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction-ports.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/transaction-ports.contract.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,KAAK,EACV,QAAQ,EACR,WAAW,EACX,eAAe,EAEf,gBAAgB,EACjB,MAAM,uBAAuB,CAAC;AAO/B;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,GACtC,MAAM,MAAM,EACZ,iBAAiB,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,KACxD,IAqDF,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,+BAA+B,GAC1C,MAAM,MAAM,EACZ,qBAAqB,MAAM,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,KACpE,IA6BF,CAAC;AAEF,MAAM,WAAW,uBAAuB;IACtC,GAAG,EAAE,QAAQ,CAAC;IACd,oEAAoE;IACpE,OAAO,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3C,8DAA8D;IAC9D,SAAS,IAAI,WAAW,EAAE,CAAC;CAC5B;AAwCD;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,GACnC,MAAM,MAAM,EACZ,aAAa,MAAM,uBAAuB,GAAG,OAAO,CAAC,uBAAuB,CAAC,KAC5E,IAkDF,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gCAAgC,GAC3C,MAAM,MAAM,EACZ,WAAW,CAAC,QAAQ,EAAE,MAAM,KAAK,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAC,KAC5E,IAyCF,CAAC"}