@nage-api/data 1.0.0-beta.2

package/dist/conformance/repository-conformance.js

@@ -0,0 +1,295 @@
+"use strict";
+/**
+ * The shared `RepositoryPort` conformance suite (PLAN.md §24 Phase 5).
+ *
+ * Driver parity is the risk this phase carries, and a shared suite is the gate.
+ * Every driver runs *these* tests — not its own paraphrase of them — so a
+ * behaviour that differs between SQL and Mongo is a failing test rather than a
+ * surprise in production.
+ *
+ * The test API is injected rather than imported, so the published package does
+ * not depend on a test framework and any runner can drive the suite.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeRepositoryConformance = describeRepositoryConformance;
+const widget = (overrides = {}) => ({
+    name: 'Widget',
+    price: 10,
+    archived: false,
+    ...overrides,
+});
+/**
+ * Register the conformance suite for one driver.
+ *
+ * ```ts
+ * describeRepositoryConformance({ describe, it, beforeEach, afterEach, expect }, harness);
+ * ```
+ */
+function describeRepositoryConformance(api, harness) {
+    const { describe, it, beforeEach, afterEach, expect } = api;
+    const unsupported = new Set(harness.unsupported ?? []);
+    describe(`RepositoryPort conformance (${harness.name})`, () => {
+        let repository;
+        let unitOfWork;
+        beforeEach(async () => {
+            const context = await harness.setup();
+            repository = context.repository;
+            unitOfWork = context.unitOfWork;
+        });
+        afterEach(async () => {
+            await harness.teardown?.();
+        });
+        const seed = async (records) => {
+            for (const record of records)
+                await repository.create(record);
+        };
+        describe('create', () => {
+            it('should return the created record with an id', async () => {
+                const created = await repository.create(widget({ name: 'First' }));
+                expect(created.id).toBeDefined();
+                expect(created.name).toBe('First');
+                expect(created.price).toBe(10);
+            });
+            it('should stamp audit timestamps', async () => {
+                const created = await repository.create(widget());
+                expect(created.created_at).toBeDefined();
+                expect(created.updated_at).toBeDefined();
+            });
+            it('should be findable afterwards', async () => {
+                const created = await repository.create(widget({ name: 'Findable' }));
+                const found = await repository.findById(created.id);
+                expect(found?.name).toBe('Findable');
+            });
+        });
+        describe('findById', () => {
+            it('should return null rather than throwing for a missing record', async () => {
+                expect(await repository.findById(999_999)).toBeNull();
+            });
+        });
+        describe('findAll', () => {
+            it('should return a page and a total count', async () => {
+                await seed([widget({ name: 'A' }), widget({ name: 'B' }), widget({ name: 'C' })]);
+                const page = await repository.findAll({ limit: 2 });
+                expect(page.records).toHaveLength(2);
+                expect(page.pagination.count).toBe(3);
+                expect(page.pagination.limit).toBe(2);
+            });
+            it('should honour offset', async () => {
+                await seed([widget({ name: 'A' }), widget({ name: 'B' }), widget({ name: 'C' })]);
+                const page = await repository.findAll({ offset: 2, limit: 10, sort: [['name', 'asc']] });
+                expect(page.records).toHaveLength(1);
+                expect(page.records[0]?.name).toBe('C');
+                // The count is of matching rows, not of the page.
+                expect(page.pagination.count).toBe(3);
+            });
+            it('should filter with a bare value', async () => {
+                await seed([widget({ name: 'A', archived: true }), widget({ name: 'B' })]);
+                const page = await repository.findAll({ where: { archived: true } });
+                expect(page.records).toHaveLength(1);
+                expect(page.records[0]?.name).toBe('A');
+            });
+            it('should filter with comparison operators', async () => {
+                await seed([widget({ price: 5 }), widget({ price: 15 }), widget({ price: 25 })]);
+                const page = await repository.findAll({ where: { price: { gte: 15 } } });
+                expect(page.pagination.count).toBe(2);
+            });
+            it('should filter with in', async () => {
+                await seed([widget({ name: 'A' }), widget({ name: 'B' }), widget({ name: 'C' })]);
+                const page = await repository.findAll({ where: { name: { in: ['A', 'C'] } } });
+                expect(page.pagination.count).toBe(2);
+            });
+            it('should combine clauses with or', async () => {
+                await seed([widget({ name: 'A', price: 1 }), widget({ name: 'B', price: 99 })]);
+                const page = await repository.findAll({
+                    where: { or: [{ name: 'A' }, { price: { gt: 50 } }] },
+                });
+                expect(page.pagination.count).toBe(2);
+            });
+            it('should sort ascending and descending', async () => {
+                await seed([widget({ price: 30 }), widget({ price: 10 }), widget({ price: 20 })]);
+                const ascending = await repository.findAll({ sort: [['price', 'asc']] });
+                const descending = await repository.findAll({ sort: [['price', 'desc']] });
+                expect(ascending.records[0]?.price).toBe(10);
+                expect(descending.records[0]?.price).toBe(30);
+            });
+            it('should project only selected fields', async () => {
+                await seed([widget({ name: 'Projected', price: 42 })]);
+                const page = await repository.findAll({ select: ['id', 'name'] });
+                expect(page.records[0]?.name).toBe('Projected');
+                expect(page.records[0]?.price).toBeUndefined();
+            });
+            it('should project a selection that omits the primary key', async () => {
+                // The case above cannot catch the defect this one exists for: a driver
+                // that widens the underlying query with the primary key — as the SQL
+                // driver deliberately does — and then forgets to narrow the row back
+                // still passes it, because `id` was selected anyway. Selecting a single
+                // non-key column is what made the SQL and memory drivers return
+                // different shapes for identical input.
+                await seed([widget({ name: 'Narrow', price: 42 })]);
+                const page = await repository.findAll({ select: ['name'] });
+                expect(Object.keys(page.records[0] ?? {})).toEqual(['name']);
+            });
+            it('should return an empty page rather than null when nothing matches', async () => {
+                const page = await repository.findAll({ where: { name: 'absent' } });
+                expect(page.records).toHaveLength(0);
+                expect(page.pagination.count).toBe(0);
+            });
+        });
+        describe('count and exists', () => {
+            it('should count matching records', async () => {
+                await seed([widget({ archived: true }), widget({ archived: false })]);
+                expect(await repository.count()).toBe(2);
+                expect(await repository.count({ where: { archived: true } })).toBe(1);
+            });
+            it('should report existence', async () => {
+                await seed([widget({ name: 'Here' })]);
+                expect(await repository.exists({ where: { name: 'Here' } })).toBe(true);
+                expect(await repository.exists({ where: { name: 'Nowhere' } })).toBe(false);
+            });
+        });
+        describe('update', () => {
+            it('should apply the change and return the record', async () => {
+                const created = await repository.create(widget({ name: 'Before' }));
+                const updated = await repository.update(created.id, { name: 'After' });
+                expect(updated.name).toBe('After');
+                expect((await repository.findById(created.id))?.name).toBe('After');
+            });
+            it('should leave unspecified fields untouched', async () => {
+                const created = await repository.create(widget({ name: 'Keep', price: 77 }));
+                const updated = await repository.update(created.id, { name: 'Changed' });
+                expect(updated.price).toBe(77);
+            });
+            it('should reject an update to a missing record', async () => {
+                await expect(repository.update(999_999, { name: 'x' })).rejects.toThrow();
+            });
+        });
+        describe('delete and restore', () => {
+            it('should hide a soft-deleted record from reads', async () => {
+                const created = await repository.create(widget({ name: 'Gone' }));
+                await repository.delete(created.id);
+                expect(await repository.findById(created.id)).toBeNull();
+                expect(await repository.count()).toBe(0);
+            });
+            it('should still return it when asked for deleted records', async () => {
+                const created = await repository.create(widget());
+                await repository.delete(created.id);
+                const found = await repository.findById(created.id, { withDeleted: true });
+                expect(found).not.toBeNull();
+                expect(found?.deleted_at).toBeDefined();
+            });
+            it('should restore a soft-deleted record', async () => {
+                const created = await repository.create(widget({ name: 'Back' }));
+                await repository.delete(created.id);
+                const restored = await repository.restore(created.id);
+                expect(restored.name).toBe('Back');
+                expect(await repository.findById(created.id)).not.toBeNull();
+            });
+            it('should remove a hard-deleted record entirely', async () => {
+                const created = await repository.create(widget());
+                await repository.delete(created.id, { mode: 'hard' });
+                expect(await repository.findById(created.id, { withDeleted: true })).toBeNull();
+            });
+        });
+        describe('bulk operations', () => {
+            it('should create many records', async () => {
+                const result = await repository.bulkCreate([widget({ name: 'A' }), widget({ name: 'B' })]);
+                expect(result.affected).toBe(2);
+                expect(await repository.count()).toBe(2);
+            });
+            it('should update every matching record', async () => {
+                await seed([widget({ price: 1 }), widget({ price: 2 })]);
+                const result = await repository.bulkUpdate({ where: { price: { lt: 10 } } }, { archived: true });
+                expect(result.affected).toBe(2);
+                expect(await repository.count({ where: { archived: true } })).toBe(2);
+            });
+            it('should delete every matching record', async () => {
+                await seed([widget({ archived: true }), widget({ archived: true }), widget()]);
+                const affected = await repository.bulkDelete({ where: { archived: true } });
+                expect(affected).toBe(2);
+                expect(await repository.count()).toBe(1);
+            });
+        });
+        if (!unsupported.has('transactions')) {
+            describe('transactions', () => {
+                it('should supply a unit of work', () => {
+                    // Every case below has to tolerate an absent unit of work to satisfy
+                    // the harness type, which means a driver that forgot to return one —
+                    // without declaring `transactions` unsupported — would see four tests
+                    // pass having asserted nothing. This is the one case that fails
+                    // instead, so the escape hatch stays something a reviewer sees.
+                    expect(unitOfWork).toBeDefined();
+                });
+                it('should commit work that succeeds', async () => {
+                    if (unitOfWork === undefined)
+                        return;
+                    await unitOfWork.run(async () => {
+                        await repository.create(widget({ name: 'Committed' }));
+                        return undefined;
+                    });
+                    expect(await repository.count()).toBe(1);
+                });
+                it('should roll back every write when the callback throws', async () => {
+                    if (unitOfWork === undefined)
+                        return;
+                    await expect(unitOfWork.run(async () => {
+                        await repository.create(widget({ name: 'One' }));
+                        await repository.create(widget({ name: 'Two' }));
+                        throw new Error('rollback please');
+                    })).rejects.toThrow();
+                    // Neither write survives: the unit is all-or-nothing.
+                    expect(await repository.count()).toBe(0);
+                });
+                it('should propagate the original error rather than wrapping it', async () => {
+                    if (unitOfWork === undefined)
+                        return;
+                    class DomainSpecificError extends Error {
+                    }
+                    await expect(unitOfWork.run(() => {
+                        throw new DomainSpecificError('specific');
+                    })).rejects.toThrow(DomainSpecificError);
+                });
+                it('should roll an update back to its previous value', async () => {
+                    if (unitOfWork === undefined)
+                        return;
+                    const created = await repository.create(widget({ name: 'Original' }));
+                    await expect(unitOfWork.run(async () => {
+                        await repository.update(created.id, { name: 'Modified' });
+                        throw new Error('nope');
+                    })).rejects.toThrow();
+                    expect((await repository.findById(created.id))?.name).toBe('Original');
+                });
+            });
+        }
+        if (!unsupported.has('cursor')) {
+            describe('cursor pagination', () => {
+                it('should walk the whole set without repeating a record', async () => {
+                    await seed([widget({ name: 'A' }), widget({ name: 'B' }), widget({ name: 'C' })]);
+                    const first = await repository.findByCursor({ limit: 2, sort: [['name', 'asc']] });
+                    expect(first.records).toHaveLength(2);
+                    expect(first.pagination.hasMore).toBe(true);
+                    const second = await repository.findByCursor({
+                        limit: 2,
+                        sort: [['name', 'asc']],
+                        ...(first.pagination.nextCursor === null
+                            ? {}
+                            : { cursor: first.pagination.nextCursor }),
+                    });
+                    expect(second.records).toHaveLength(1);
+                    expect(second.pagination.hasMore).toBe(false);
+                    expect(second.records[0]?.name).toBe('C');
+                });
+            });
+        }
+        if (!unsupported.has('search')) {
+            describe('search', () => {
+                it('should match records case-insensitively', async () => {
+                    await seed([widget({ name: 'Hammer' }), widget({ name: 'Screwdriver' })]);
+                    const page = await repository.findAll({ search: { term: 'hamm', fields: ['name'] } });
+                    expect(page.pagination.count).toBe(1);
+                    expect(page.records[0]?.name).toBe('Hammer');
+                });
+            });
+        }
+    });
+}
+//# sourceMappingURL=repository-conformance.js.map

package/dist/entity/audit.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Audit and soft-delete stamping (PLAN.md §14.2).
+ *
+ * Who created or changed a row comes from the request context, not from a
+ * parameter every service has to remember to pass. That is what makes the audit
+ * trail trustworthy: a caller cannot forget it, and cannot claim to be someone
+ * else without changing the authenticated principal.
+ */
+import type { Id, UnknownRecord } from '@nage-api/contracts';
+export interface AuditOptions {
+    /** Override the actor; defaults to the authenticated user in the context. */
+    readonly actorId?: Id | null;
+    /** Injectable clock, so stamped timestamps are testable. */
+    readonly now?: () => Date;
+}
+/** Stamp `created_at`/`updated_at`/`created_by`/`updated_by` on a new row. */
+export declare function stampCreate<TData extends UnknownRecord>(data: TData, options?: AuditOptions): TData & UnknownRecord;
+/** Stamp `updated_at`/`updated_by`, and refuse to let a caller forge them. */
+export declare function stampUpdate<TData extends UnknownRecord>(data: TData, options?: AuditOptions): TData & UnknownRecord;
+/** Fields written when a row is soft-deleted. */
+export declare function stampSoftDelete(options?: AuditOptions): UnknownRecord;
+/** Fields written when a soft-deleted row is restored. */
+export declare function stampRestore(options?: AuditOptions): UnknownRecord;
+/** Is this row soft-deleted? */
+export declare function isSoftDeleted(record: UnknownRecord): boolean;
+//# sourceMappingURL=audit.d.ts.map

package/dist/entity/audit.js

@@ -0,0 +1,60 @@
+"use strict";
+/**
+ * Audit and soft-delete stamping (PLAN.md §14.2).
+ *
+ * Who created or changed a row comes from the request context, not from a
+ * parameter every service has to remember to pass. That is what makes the audit
+ * trail trustworthy: a caller cannot forget it, and cannot claim to be someone
+ * else without changing the authenticated principal.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stampCreate = stampCreate;
+exports.stampUpdate = stampUpdate;
+exports.stampSoftDelete = stampSoftDelete;
+exports.stampRestore = stampRestore;
+exports.isSoftDeleted = isSoftDeleted;
+const core_1 = require("@nage-api/core");
+function timestamp(options) {
+    return (options.now?.() ?? new Date()).toISOString();
+}
+function actorOf(options) {
+    if (options.actorId !== undefined)
+        return options.actorId;
+    return (0, core_1.getActiveContext)()?.user?.id ?? null;
+}
+/** Stamp `created_at`/`updated_at`/`created_by`/`updated_by` on a new row. */
+function stampCreate(data, options = {}) {
+    const at = timestamp(options);
+    const by = actorOf(options);
+    return { ...data, created_at: at, updated_at: at, created_by: by, updated_by: by };
+}
+/** Stamp `updated_at`/`updated_by`, and refuse to let a caller forge them. */
+function stampUpdate(data, options = {}) {
+    const stamped = { ...data, updated_at: timestamp(options), updated_by: actorOf(options) };
+    // Creation facts are immutable: an update that carries them is either a
+    // mistake or an attempt to rewrite history.
+    delete stamped['created_at'];
+    delete stamped['created_by'];
+    delete stamped['id'];
+    return stamped;
+}
+/** Fields written when a row is soft-deleted. */
+function stampSoftDelete(options = {}) {
+    const at = timestamp(options);
+    return { deleted_at: at, deleted_by: actorOf(options), updated_at: at };
+}
+/** Fields written when a soft-deleted row is restored. */
+function stampRestore(options = {}) {
+    return {
+        deleted_at: null,
+        deleted_by: null,
+        updated_at: timestamp(options),
+        updated_by: actorOf(options),
+    };
+}
+/** Is this row soft-deleted? */
+function isSoftDeleted(record) {
+    const deletedAt = record['deleted_at'];
+    return deletedAt !== undefined && deletedAt !== null;
+}
+//# sourceMappingURL=audit.js.map

package/dist/health/data.health.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Connection health (PLAN.md §14.2, §21).
+ *
+ * Feeds `/health/ready`: an instance whose database is unreachable should be
+ * taken out of rotation rather than serving 500s. `@nage-api/observability` (Phase 8)
+ * wires this into terminus.
+ */
+import type { DataSourceHealth } from '@nage-api/contracts';
+export type HealthStatus = 'up' | 'down';
+export interface HealthReport {
+    readonly status: HealthStatus;
+    readonly driver: string;
+    readonly durationMs: number;
+    /** Present only when the probe failed; safe to surface to an operator. */
+    readonly error?: string;
+}
+export interface DataHealthOptions {
+    /** A probe that hangs is a probe that fails. */
+    readonly timeoutMs?: number;
+    readonly now?: () => number;
+}
+/**
+ * Probe a data source without letting it hang the readiness endpoint.
+ */
+export declare function checkDataSourceHealth(source: DataSourceHealth, options?: DataHealthOptions): Promise<HealthReport>;
+//# sourceMappingURL=data.health.d.ts.map

package/dist/health/data.health.js

@@ -0,0 +1,46 @@
+"use strict";
+/**
+ * Connection health (PLAN.md §14.2, §21).
+ *
+ * Feeds `/health/ready`: an instance whose database is unreachable should be
+ * taken out of rotation rather than serving 500s. `@nage-api/observability` (Phase 8)
+ * wires this into terminus.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkDataSourceHealth = checkDataSourceHealth;
+/**
+ * Probe a data source without letting it hang the readiness endpoint.
+ */
+async function checkDataSourceHealth(source, options = {}) {
+    const now = options.now ?? Date.now;
+    const timeoutMs = options.timeoutMs ?? 2000;
+    const startedAt = now();
+    let timer;
+    try {
+        const timeout = new Promise((_resolve, reject) => {
+            timer = setTimeout(() => {
+                reject(new Error(`Health check timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+        });
+        const healthy = await Promise.race([source.ping(), timeout]);
+        return {
+            status: healthy ? 'up' : 'down',
+            driver: source.driver,
+            durationMs: now() - startedAt,
+            ...(healthy ? {} : { error: 'The data source reported that it is not healthy' }),
+        };
+    }
+    catch (error) {
+        return {
+            status: 'down',
+            driver: source.driver,
+            durationMs: now() - startedAt,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}
+//# sourceMappingURL=data.health.js.map

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * `@nage-api/data` — the engine-agnostic data layer (PLAN.md §14).
+ *
+ * One contract, pluggable drivers, one engine per project. Application code
+ * depends on `RepositoryPort` and `ModelService`; `@nage-api/data-sql` and
+ * `@nage-api/data-mongo` implement the ports and are validated by the conformance
+ * suite exported here.
+ */
+export type * from '@nage-api/contracts';
+export { defineQueryPolicy, trustedQueryPolicy, DEFAULT_LIMIT, DEFAULT_MAX_LIMIT, DEFAULT_MAX_POPULATE_DEPTH, DEFAULT_OPERATORS, type QueryPolicyInput, } from './query/policy.js';
+export { parseQuery, parseSort, parseWhere, resolvePagination, type RawQuery, } from './query/parse-query.js';
+export { matchesWhere } from './query/where-matcher.js';
+export { isSoftDeleted, stampCreate, stampRestore, stampSoftDelete, stampUpdate, type AuditOptions, } from './entity/audit.js';
+export { MemoryRepository, type MemoryRepositoryOptions } from './memory/memory.repository.js';
+export { MemoryUnitOfWork } from './memory/memory.unit-of-work.js';
+export { ModelService, type ModelServiceOptions } from './service/model.service.js';
+export { MigrationRunner, type AppliedMigration, type Migration, type MigrationResult, type MigrationRunnerOptions, type MigrationStore, } from './migrations/migration.runner.js';
+export { SeedRunner, type Seed, type SeedMode, type SeedResult, type SeedRunnerOptions, } from './migrations/seed.runner.js';
+export { checkDataSourceHealth, type DataHealthOptions, type HealthReport, type HealthStatus, } from './health/data.health.js';
+export { NageDataModule, registerModel, type DataModuleOptions, type ErasedModelRegistration, type ModelRegistration, } from './module/data.module.js';
+export { NAGE_DATA_HEALTH } from './tokens.js';
+export { describeRepositoryConformance, type ConformanceHarness, type ConformanceWidget, type TestApi, } from './conformance/repository-conformance.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * `@nage-api/data` — the engine-agnostic data layer (PLAN.md §14).
+ *
+ * One contract, pluggable drivers, one engine per project. Application code
+ * depends on `RepositoryPort` and `ModelService`; `@nage-api/data-sql` and
+ * `@nage-api/data-mongo` implement the ports and are validated by the conformance
+ * suite exported here.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeRepositoryConformance = exports.NAGE_DATA_HEALTH = exports.registerModel = exports.NageDataModule = exports.checkDataSourceHealth = exports.SeedRunner = exports.MigrationRunner = exports.ModelService = exports.MemoryUnitOfWork = exports.MemoryRepository = exports.stampUpdate = exports.stampSoftDelete = exports.stampRestore = exports.stampCreate = exports.isSoftDeleted = exports.matchesWhere = exports.resolvePagination = exports.parseWhere = exports.parseSort = exports.parseQuery = exports.DEFAULT_OPERATORS = exports.DEFAULT_MAX_POPULATE_DEPTH = exports.DEFAULT_MAX_LIMIT = exports.DEFAULT_LIMIT = exports.trustedQueryPolicy = exports.defineQueryPolicy = void 0;
+// Query DSL: typed, allow-listed, bounded (§12).
+var policy_js_1 = require("./query/policy.js");
+Object.defineProperty(exports, "defineQueryPolicy", { enumerable: true, get: function () { return policy_js_1.defineQueryPolicy; } });
+Object.defineProperty(exports, "trustedQueryPolicy", { enumerable: true, get: function () { return policy_js_1.trustedQueryPolicy; } });
+Object.defineProperty(exports, "DEFAULT_LIMIT", { enumerable: true, get: function () { return policy_js_1.DEFAULT_LIMIT; } });
+Object.defineProperty(exports, "DEFAULT_MAX_LIMIT", { enumerable: true, get: function () { return policy_js_1.DEFAULT_MAX_LIMIT; } });
+Object.defineProperty(exports, "DEFAULT_MAX_POPULATE_DEPTH", { enumerable: true, get: function () { return policy_js_1.DEFAULT_MAX_POPULATE_DEPTH; } });
+Object.defineProperty(exports, "DEFAULT_OPERATORS", { enumerable: true, get: function () { return policy_js_1.DEFAULT_OPERATORS; } });
+var parse_query_js_1 = require("./query/parse-query.js");
+Object.defineProperty(exports, "parseQuery", { enumerable: true, get: function () { return parse_query_js_1.parseQuery; } });
+Object.defineProperty(exports, "parseSort", { enumerable: true, get: function () { return parse_query_js_1.parseSort; } });
+Object.defineProperty(exports, "parseWhere", { enumerable: true, get: function () { return parse_query_js_1.parseWhere; } });
+Object.defineProperty(exports, "resolvePagination", { enumerable: true, get: function () { return parse_query_js_1.resolvePagination; } });
+var where_matcher_js_1 = require("./query/where-matcher.js");
+Object.defineProperty(exports, "matchesWhere", { enumerable: true, get: function () { return where_matcher_js_1.matchesWhere; } });
+// Audit and soft delete, stamped from the request context (§14.2).
+var audit_js_1 = require("./entity/audit.js");
+Object.defineProperty(exports, "isSoftDeleted", { enumerable: true, get: function () { return audit_js_1.isSoftDeleted; } });
+Object.defineProperty(exports, "stampCreate", { enumerable: true, get: function () { return audit_js_1.stampCreate; } });
+Object.defineProperty(exports, "stampRestore", { enumerable: true, get: function () { return audit_js_1.stampRestore; } });
+Object.defineProperty(exports, "stampSoftDelete", { enumerable: true, get: function () { return audit_js_1.stampSoftDelete; } });
+Object.defineProperty(exports, "stampUpdate", { enumerable: true, get: function () { return audit_js_1.stampUpdate; } });
+// The in-memory driver: a real implementation, used as a test double.
+var memory_repository_js_1 = require("./memory/memory.repository.js");
+Object.defineProperty(exports, "MemoryRepository", { enumerable: true, get: function () { return memory_repository_js_1.MemoryRepository; } });
+var memory_unit_of_work_js_1 = require("./memory/memory.unit-of-work.js");
+Object.defineProperty(exports, "MemoryUnitOfWork", { enumerable: true, get: function () { return memory_unit_of_work_js_1.MemoryUnitOfWork; } });
+// The retained template-method service with lifecycle hooks (§14.1).
+var model_service_js_1 = require("./service/model.service.js");
+Object.defineProperty(exports, "ModelService", { enumerable: true, get: function () { return model_service_js_1.ModelService; } });
+// Migrations and seeds replace `synchronize` auto-sync (§14.2).
+var migration_runner_js_1 = require("./migrations/migration.runner.js");
+Object.defineProperty(exports, "MigrationRunner", { enumerable: true, get: function () { return migration_runner_js_1.MigrationRunner; } });
+var seed_runner_js_1 = require("./migrations/seed.runner.js");
+Object.defineProperty(exports, "SeedRunner", { enumerable: true, get: function () { return seed_runner_js_1.SeedRunner; } });
+// Connection health for `/health/ready` (§21).
+var data_health_js_1 = require("./health/data.health.js");
+Object.defineProperty(exports, "checkDataSourceHealth", { enumerable: true, get: function () { return data_health_js_1.checkDataSourceHealth; } });
+// Wiring.
+var data_module_js_1 = require("./module/data.module.js");
+Object.defineProperty(exports, "NageDataModule", { enumerable: true, get: function () { return data_module_js_1.NageDataModule; } });
+Object.defineProperty(exports, "registerModel", { enumerable: true, get: function () { return data_module_js_1.registerModel; } });
+var tokens_js_1 = require("./tokens.js");
+Object.defineProperty(exports, "NAGE_DATA_HEALTH", { enumerable: true, get: function () { return tokens_js_1.NAGE_DATA_HEALTH; } });
+// The gate every driver has to pass.
+var repository_conformance_js_1 = require("./conformance/repository-conformance.js");
+Object.defineProperty(exports, "describeRepositoryConformance", { enumerable: true, get: function () { return repository_conformance_js_1.describeRepositoryConformance; } });
+//# sourceMappingURL=index.js.map

package/dist/memory/memory.repository.d.ts

@@ -0,0 +1,50 @@
+/**
+ * In-memory `RepositoryPort` (PLAN.md §19 — mock at the port boundary).
+ *
+ * It is a real implementation, not a stub: it enforces the query policy, stamps
+ * audit fields, honours soft delete and participates in transactions. That is
+ * what makes it useful as the reference the shared conformance suite pins down,
+ * and as the driver unit tests run against instead of a database.
+ */
+import type { BulkResult, ByIdQuery, CursorPaginated, DeepPartial, DeleteOptions, Id, ModelDescriptor, Paginated, Query, QueryPolicy, RepositoryPort, UnknownRecord, WriteOptions } from '@nage-api/contracts';
+import type { MemoryUnitOfWork } from './memory.unit-of-work.js';
+export interface MemoryRepositoryOptions<TEntity> {
+    readonly descriptor?: Partial<ModelDescriptor<TEntity>>;
+    readonly policy?: QueryPolicy<TEntity>;
+    /** Seed data, inserted without audit stamping. */
+    readonly records?: readonly TEntity[];
+    /** Injectable clock for deterministic timestamps. */
+    readonly now?: () => Date;
+    /** Registers the store with a unit of work so transactions can roll it back. */
+    readonly unitOfWork?: MemoryUnitOfWork;
+}
+/** Anything the store can hold: an object with an id. */
+type Row = UnknownRecord & {
+    id: Id;
+};
+export declare class MemoryRepository<TEntity extends {
+    id: Id;
+}> implements RepositoryPort<TEntity> {
+    #private;
+    readonly descriptor: ModelDescriptor<TEntity>;
+    constructor(name: string, options?: MemoryRepositoryOptions<TEntity>);
+    /** @internal */
+    snapshot(): Row[];
+    /** @internal */
+    restoreSnapshot(rows: Row[]): void;
+    findAll(query?: Query<TEntity>): Promise<Paginated<TEntity>>;
+    findByCursor(query?: Query<TEntity>): Promise<CursorPaginated<TEntity>>;
+    findOne(query?: Query<TEntity>): Promise<TEntity | null>;
+    findById(id: Id, query?: Omit<ByIdQuery<TEntity>, 'id'>): Promise<TEntity | null>;
+    exists(query?: Query<TEntity>): Promise<boolean>;
+    count(query?: Query<TEntity>): Promise<number>;
+    create(data: DeepPartial<TEntity>, _options?: WriteOptions): Promise<TEntity>;
+    update(id: Id, data: DeepPartial<TEntity>, _options?: WriteOptions): Promise<TEntity>;
+    delete(id: Id, options?: DeleteOptions): Promise<void>;
+    restore(id: Id, _options?: WriteOptions): Promise<TEntity>;
+    bulkCreate(data: readonly DeepPartial<TEntity>[], options?: WriteOptions): Promise<BulkResult<TEntity>>;
+    bulkUpdate(query: Query<TEntity>, data: DeepPartial<TEntity>, options?: WriteOptions): Promise<BulkResult<TEntity>>;
+    bulkDelete(query: Query<TEntity>, options?: DeleteOptions): Promise<number>;
+}
+export {};
+//# sourceMappingURL=memory.repository.d.ts.map