@afora/core 0.0.6 → 0.0.8

package/dist/testing/index.js

@@ -1,11 +1,25 @@
-import"../index-3nd9bjnc.js";
+import"../index-qxfkyd6k.js";
 import {
   RepositoryUniqueViolation2,
   RepositoryEntityNotFound2,
+  RepositoryConcurrencyConflict2,
   blueprintOf2,
   entityOf2
-} from "../index-gbgc40xe.js";
+} from "../index-t5qwtyj5.js";
 
+// src/testing/memory-publisher.ts
+function memoryPublisher() {
+  const published = [];
+  return {
+    published,
+    publish(topic, event) {
+      published.push({ topic, event });
+    },
+    clear() {
+      published.length = 0;
+    }
+  };
+}
 // src/testing/provider-contract.ts
 function contextOf(name = "Accounts") {
   class Account extends entityOf2(blueprintOf2((ctx) => ({ email: ctx.string, name: ctx.string }))) {
@@ -43,6 +57,11 @@ function providerContract(runner, makeProvider, options = {}) {
     };
     return { provider, context, seed };
   }
+  const gated = (capability) => (name, body) => it(name, async () => {
+    const enabled = options[capability] ?? (await makeProvider()).capabilities?.[capability];
+    if (enabled === true)
+      await body();
+  });
   describe("provider contract", () => {
     describe("writes and reads", () => {
       it("inserts and finds by id, empty provider counts zero", async () => {
@@ -129,6 +148,14 @@ function providerContract(runner, makeProvider, options = {}) {
         await provider.update(context, { ...data, name: "Other" });
         expect(await provider.findOne(context, { where: { id: data.id } })).toEqual({ ...data, name: "Other" });
       });
+      it("update clears a value that is left out", async () => {
+        const { provider, context, seed } = await fixture();
+        const data = row({ deletedAt: "2024-01-01T00:00:00.000Z" });
+        await seed(data);
+        const { deletedAt: _deletedAt, ...alive } = data;
+        await provider.update(context, alive);
+        expect(await provider.findOne(context, { where: { id: data.id } })).toEqual(alive);
+      });
       it("soft-deleted rows keep occupying unique values", async () => {
         const { provider, context, seed } = await fixture();
         await seed(row({
@@ -460,6 +487,80 @@ function providerContract(runner, makeProvider, options = {}) {
         })).toBe(5);
       });
     });
+    describe("indexes", () => {
+      const indexed = (name, body) => it(name, async () => {
+        const enabled = options.indexes ?? (await makeProvider()).capabilities?.indexes;
+        if (enabled === true)
+          await body();
+      });
+      const seeded = async () => {
+        const f = await fixture();
+        const context = {
+          ...f.context,
+          indexes: {
+            byGroup: { where: ["group"], orderBy: "n" },
+            byName: { where: ["name"] }
+          }
+        };
+        const rows = [
+          row({ n: 3, group: 1, name: "Gil" }),
+          row({ group: 1, name: "Érico" }),
+          row({ n: 2, group: 2, name: "Ana" }),
+          row({ n: 2, group: 1, name: "Ana" }),
+          row({ n: 1, group: 1, name: "Bia" }),
+          row({ n: 4, group: 2, name: "Zoe" })
+        ];
+        for (const data of rows)
+          await f.provider.insert(context, data);
+        await f.provider.update(context, {
+          ...rows[4],
+          deletedAt: "2024-01-01T00:00:00.000Z"
+        });
+        return { ...f, context };
+      };
+      indexed("an indexed query gives what the scan gives", async () => {
+        const { provider, context } = await seeded();
+        const queries = [
+          ["byGroup", { where: { group: 1 } }],
+          [
+            "byGroup",
+            {
+              where: { group: 1 },
+              orderBy: [{ key: "n" }, { key: "id" }]
+            }
+          ],
+          [
+            "byGroup",
+            {
+              where: { group: 1, name: "Ana" },
+              orderBy: [{ key: "n", direction: "desc" }, { key: "id" }],
+              limit: 2,
+              offset: 1
+            }
+          ],
+          [
+            "byGroup",
+            {
+              where: { group: 1 },
+              orderBy: [{ key: "n" }, { key: "id" }],
+              withDeleted: true
+            }
+          ],
+          ["byName", { where: { name: "Ana" }, orderBy: [{ key: "id" }] }]
+        ];
+        for (const [index, query] of queries) {
+          expect(ids(await provider.findMany(context, { ...query, index }))).toEqual(ids(await provider.findMany(context, query)));
+          expect(await provider.count(context, {
+            ...query,
+            index
+          })).toBe(await provider.count(context, query));
+          expect((await provider.findOne(context, {
+            ...query,
+            index
+          }))?.id).toBe((await provider.findOne(context, query))?.id);
+        }
+      });
+    });
     const withTransactions = async () => {
       const enabled = options.transactions ?? (await makeProvider()).capabilities?.transactions;
       return enabled === true;
@@ -584,8 +685,260 @@ function providerContract(runner, makeProvider, options = {}) {
         expect(await provider.count(context)).toBe(0);
       });
     });
+    describe("versioning", () => {
+      const versioned = gated("versioning");
+      versioned("update writes with the expected version, and throws RepositoryConcurrencyConflict with a stale one", async () => {
+        const { provider, context, seed } = await fixture();
+        const data = row({ version: 1 });
+        await seed(data);
+        await provider.update(context, { ...data, name: "Bia", version: 2 }, { expectedVersion: 1 });
+        const stale = await failure(provider.update(context, { ...data, name: "Caio", version: 2 }, { expectedVersion: 1 }));
+        expect(stale instanceof RepositoryConcurrencyConflict2).toBe(true);
+        const { details } = stale;
+        expect([details.id, details.expected]).toEqual([data.id, 1]);
+        expect(await provider.findOne(context, { where: { id: data.id } })).toEqual({ ...data, name: "Bia", version: 2 });
+      });
+      versioned("two updates with the same expected version: exactly one succeeds", async () => {
+        const { provider, context, seed } = await fixture();
+        const data = row({ version: 1 });
+        await seed(data);
+        const results = await Promise.allSettled(["Bia", "Caio"].map((name) => provider.update(context, { ...data, name, version: 2 }, { expectedVersion: 1 })));
+        const rejected = results.filter((result) => result.status === "rejected");
+        expect(rejected.length).toBe(1);
+        expect(rejected[0]?.reason instanceof RepositoryConcurrencyConflict2).toBe(true);
+        const stored = await provider.findOne(context, {
+          where: { id: data.id }
+        });
+        expect(stored?.version).toBe(2);
+      });
+      versioned("update without an expected version ignores the stored one", async () => {
+        const { provider, context, seed } = await fixture();
+        const data = row({ version: 3 });
+        await seed(data);
+        await provider.update(context, { ...data, name: "Bia", version: 1 });
+        expect(await provider.findOne(context, { where: { id: data.id } })).toEqual({ ...data, name: "Bia", version: 1 });
+      });
+      versioned("an unknown id is still RepositoryEntityNotFound", async () => {
+        const { provider, context } = await fixture();
+        const error = await failure(provider.update(context, row({ version: 2 }), {
+          expectedVersion: 1
+        }));
+        expect(error instanceof RepositoryEntityNotFound2).toBe(true);
+      });
+    });
+    describe("atomic", () => {
+      const atomic = gated("atomic");
+      const increment = (provider, ...args) => provider.increment(...args);
+      atomic("increment adds the deltas, stores set and gives the row", async () => {
+        const { provider, context, seed } = await fixture();
+        const data = row({ visits: 2, age: 30 });
+        await seed(data);
+        const stored = await increment(provider, context, data.id, { visits: 3, age: -1, n: 5 }, { set: { name: "Bia" } });
+        const expected = { ...data, visits: 5, age: 29, n: 5, name: "Bia" };
+        expect(stored).toEqual(expected);
+        expect(await provider.findOne(context, { where: { id: data.id } })).toEqual(expected);
+      });
+      atomic("N concurrent increments sum to N", async () => {
+        const { provider, context, seed } = await fixture();
+        const data = row({ visits: 0 });
+        await seed(data);
+        await Promise.all(Array.from({ length: 25 }, () => increment(provider, context, data.id, { visits: 1 })));
+        const stored = await provider.findOne(context, {
+          where: { id: data.id }
+        });
+        expect(stored?.visits).toBe(25);
+      });
+      atomic("a missing id is RepositoryEntityNotFound without create, and inserted with it", async () => {
+        const { provider, context } = await fixture();
+        const data = row({ visits: 1 });
+        const missing = await failure(increment(provider, context, data.id, { visits: 1 }));
+        expect(missing instanceof RepositoryEntityNotFound2).toBe(true);
+        expect(await provider.count(context)).toBe(0);
+        const created = await increment(provider, context, data.id, { visits: 1 }, { create: data, set: { name: "Bia" } });
+        expect(created).toEqual(data);
+        const again = await increment(provider, context, data.id, { visits: 1 }, { create: data });
+        expect(again.visits).toBe(2);
+        expect(await provider.count(context)).toBe(1);
+      });
+      atomic("concurrent increments with create lose nothing", async () => {
+        const { provider, context } = await fixture();
+        const data = row({ visits: 1 });
+        await Promise.all(Array.from({ length: 10 }, () => increment(provider, context, data.id, { visits: 1 }, { create: data })));
+        const stored = await provider.findOne(context, {
+          where: { id: data.id }
+        });
+        expect(stored?.visits).toBe(10);
+      });
+      atomic("soft-deleted rows are not incremented", async () => {
+        const { provider, context, seed } = await fixture();
+        const data = row({ visits: 1, deletedAt: "2024-01-01T00:00:00.000Z" });
+        await seed(data);
+        const error = await failure(increment(provider, context, data.id, { visits: 1 }));
+        expect(error instanceof RepositoryEntityNotFound2).toBe(true);
+        const stored = await provider.findOne(context, {
+          where: { id: data.id },
+          withDeleted: true
+        });
+        expect(stored?.visits).toBe(1);
+      });
+      atomic("an increment of version makes an update with the old one conflict", async () => {
+        const { provider, context, seed } = await fixture();
+        if ((options.versioning ?? provider.capabilities?.versioning) !== true)
+          return;
+        const data = row({ visits: 0, version: 1 });
+        await seed(data);
+        const stored = await increment(provider, context, data.id, {
+          visits: 1,
+          version: 1
+        });
+        expect(stored.version).toBe(2);
+        const error = await failure(provider.update(context, { ...data, name: "Bia", version: 2 }, { expectedVersion: 1 }));
+        expect(error instanceof RepositoryConcurrencyConflict2).toBe(true);
+        expect((await provider.findOne(context, { where: { id: data.id } }))?.visits).toBe(1);
+      });
+      atomic("an expired row counts as absent: not found, or replaced by create", async () => {
+        const provider = await makeProvider();
+        if ((options.expiry ?? provider.capabilities?.expiry) !== true)
+          return;
+        const now = "2026-06-01T12:00:00.000Z";
+        const context = {
+          ...contextOf(),
+          expiry: { key: "expiresAt" }
+        };
+        const window = row({
+          visits: 7,
+          expiresAt: "2026-06-01T11:00:00.000Z"
+        });
+        const live = row({
+          visits: 1,
+          expiresAt: "2026-06-01T13:00:00.000Z"
+        });
+        await provider.insert(context, window);
+        await provider.insert(context, live);
+        const missing = await failure(increment(provider, context, window.id, { visits: 1 }, {
+          now
+        }));
+        expect(missing instanceof RepositoryEntityNotFound2).toBe(true);
+        const fresh = {
+          id: window.id,
+          email: window.email,
+          name: "fresh",
+          visits: 1,
+          expiresAt: "2026-06-01T13:00:00.000Z"
+        };
+        const created = await increment(provider, context, window.id, { visits: 1 }, { create: fresh, set: { name: "incremented" }, now });
+        expect(created).toEqual(fresh);
+        const again = await increment(provider, context, window.id, { visits: 1 }, { create: fresh, set: { name: "incremented" }, now });
+        expect([again.visits, again.name]).toEqual([2, "incremented"]);
+        const counted = await increment(provider, context, live.id, { visits: 1 }, { create: { ...live, visits: 100 }, now });
+        expect(counted.visits).toBe(2);
+      });
+    });
+    describe("expiry", () => {
+      const expiring = gated("expiry");
+      const NOW = "2026-06-01T12:00:00.000Z";
+      const seeded = async () => {
+        const provider = await makeProvider();
+        const context = {
+          ...contextOf(),
+          expiry: { key: "expiresAt" }
+        };
+        const [past, edge, never, future] = [
+          row({ n: 1, expiresAt: "2026-05-01T00:00:00.000Z" }),
+          row({ n: 2, expiresAt: NOW }),
+          row({ n: 3 }),
+          row({ n: 4, expiresAt: "2026-07-01T00:00:00.000Z" })
+        ];
+        for (const data of [past, edge, never, future])
+          await provider.insert(context, data);
+        return { provider, context, past, edge, never, future };
+      };
+      expiring("reads leave out rows whose date is at or before now", async () => {
+        const { provider, context, past, edge, never, future } = await seeded();
+        const query = { now: NOW };
+        expect(ids(await provider.findMany(context, query))).toEqual([
+          never.id,
+          future.id
+        ]);
+        expect(await provider.count(context, query)).toBe(2);
+        expect(await provider.findOne(context, {
+          ...query,
+          where: { id: past.id }
+        })).toBe(undefined);
+        expect(await provider.findOne(context, {
+          ...query,
+          where: { id: edge.id }
+        })).toBe(undefined);
+        expect((await provider.findOne(context, {
+          ...query,
+          where: { id: future.id }
+        }))?.id).toBe(future.id);
+        expect(ids(await provider.findMany(context, {
+          ...query,
+          where: { id: { in: [past.id, never.id] } }
+        }))).toEqual([never.id]);
+      });
+      expiring("a row without a date never expires", async () => {
+        const { provider, context, never } = await seeded();
+        const later = { now: "2999-01-01T00:00:00.000Z" };
+        expect(ids(await provider.findMany(context, later))).toEqual([
+          never.id
+        ]);
+        expect(await provider.count(context, later)).toBe(1);
+      });
+      expiring("withExpired gives the expired rows too", async () => {
+        const { provider, context, past, edge, never, future } = await seeded();
+        const query = { now: NOW, withExpired: true };
+        expect(ids(await provider.findMany(context, query))).toEqual([
+          past.id,
+          edge.id,
+          never.id,
+          future.id
+        ]);
+        expect(await provider.count(context, query)).toBe(4);
+        expect((await provider.findOne(context, {
+          ...query,
+          where: { id: past.id }
+        }))?.id).toBe(past.id);
+      });
+      expiring("leaves expired rows out of a read after a position", async () => {
+        const enabled = options.keyset ?? (await makeProvider()).capabilities?.keyset;
+        if (enabled !== true)
+          return;
+        const { provider, context, past, edge, never, future } = await seeded();
+        const orderBy = [{ key: "n" }, { key: "id" }];
+        expect(ids(await provider.findMany(context, {
+          now: NOW,
+          orderBy,
+          after: [0, ""]
+        }))).toEqual([never.id, future.id]);
+        expect(ids(await provider.findMany(context, {
+          now: NOW,
+          orderBy,
+          after: [1, past.id],
+          withExpired: true
+        }))).toEqual([edge.id, never.id, future.id]);
+      });
+      expiring("unique keys still count expired rows", async () => {
+        const { provider, context, past } = await seeded();
+        const error = await failure(provider.insert(context, row({ email: past.email })));
+        expect(error instanceof RepositoryUniqueViolation2).toBe(true);
+        expect(error.details.key).toBe("email");
+        expect(await provider.count(context, { now: NOW, withExpired: true })).toBe(4);
+      });
+      expiring("an entity that does not expire ignores now", async () => {
+        const { provider, context, seed } = await fixture();
+        const data = row({ expiresAt: "2000-01-01T00:00:00.000Z" });
+        await seed(data);
+        expect(ids(await provider.findMany(context, { now: NOW }))).toEqual([
+          data.id
+        ]);
+        expect(await provider.count(context, { now: NOW })).toBe(1);
+      });
+    });
   });
 }
 export {
+  memoryPublisher,
   providerContract
 };

package/dist/testing/memory-publisher.d.ts

@@ -0,0 +1,16 @@
+import type { IEventPublisher, PublishedEvent } from "../core/event-policy/types/event-policy.interface.js";
+/** A publisher that keeps what it is given, for tests. */
+export interface MemoryPublisher extends IEventPublisher {
+    /** Each publish, in order. */
+    readonly published: readonly {
+        readonly topic: string;
+        readonly event: PublishedEvent;
+    }[];
+    /** Forgets what was published. */
+    clear(): void;
+}
+/**
+ * A publisher for `applicationOf({ publishers })` in tests: it keeps each
+ * `{ topic, event }` it is given in `published`.
+ */
+export declare function memoryPublisher(): MemoryPublisher;

package/dist/testing/provider-contract.d.ts

@@ -18,6 +18,20 @@ export interface ProviderContractOptions {
      * to `provider.capabilities?.keyset`.
      */
     readonly keyset?: boolean;
+    /**
+     * Run the cases of declared indexes (`context.indexes`, `query.index`).
+     * Defaults to `provider.capabilities?.indexes`.
+     */
+    readonly indexes?: boolean;
+    /**
+     * Run the cases of an expected `version` on `update`. Defaults to
+     * `provider.capabilities?.versioning`.
+     */
+    readonly versioning?: boolean;
+    /** Run the cases of `increment`. Defaults to `provider.capabilities?.atomic`. */
+    readonly atomic?: boolean;
+    /** Run the cases of expired records. Defaults to `provider.capabilities?.expiry`. */
+    readonly expiry?: boolean;
 }
 /**
  * Registers the behavior every `IRepositoryProvider` v2 must have. Pass the

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@afora/core",
-	"version": "0.0.6",
+	"version": "0.0.8",
 	"description": "Domain modeling on TypeBox: entities with invariants, repositories, use cases, sensitive data masking and layered exceptions, usable by any Standard Schema consumer.",
 	"keywords": [
 		"domain-driven-design",
@@ -84,8 +84,9 @@
 		"test:roundtrip": "bun run --cwd packages/codegen test:roundtrip",
 		"test:mcp": "bun test --cwd packages/mcp",
 		"test:hono": "bun test --cwd packages/hono",
+		"test:ws": "bun test --cwd packages/ws",
 		"test:drizzle": "bun test --cwd packages/drizzle",
-		"build:packages": "bun run build && bun run --cwd packages/codegen build && bun run --cwd packages/mcp build && bun run --cwd packages/hono build && bun run --cwd packages/drizzle build"
+		"build:packages": "bun run build && bun run --cwd packages/codegen build && bun run --cwd packages/mcp build && bun run --cwd packages/hono build && bun run --cwd packages/ws build && bun run --cwd packages/drizzle build"
 	},
 	"dependencies": {
 		"slugify": "^1.6.9"