@nage-api/data 1.0.0-beta.2

package/dist/memory/memory.repository.js

@@ -0,0 +1,231 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryRepository = void 0;
+const core_1 = require("@nage-api/core");
+const audit_js_1 = require("../entity/audit.js");
+const policy_js_1 = require("../query/policy.js");
+const parse_query_js_1 = require("../query/parse-query.js");
+const where_matcher_js_1 = require("../query/where-matcher.js");
+class MemoryRepository {
+    descriptor;
+    #rows;
+    #policy;
+    #now;
+    #nextId = 1;
+    constructor(name, options = {}) {
+        this.descriptor = {
+            name,
+            primaryKey: 'id',
+            softDelete: true,
+            timestamps: true,
+            versioned: false,
+            ...options.descriptor,
+        };
+        this.#policy = options.policy ?? (0, policy_js_1.defineQueryPolicy)();
+        this.#now = options.now ?? (() => new Date());
+        this.#rows = (options.records ?? []).map((record) => ({ ...record }));
+        for (const row of this.#rows)
+            this.#reserveId(row.id);
+        options.unitOfWork?.enlist(this);
+    }
+    // ── Snapshot support, used by MemoryUnitOfWork ────────────────────────────
+    /** @internal */
+    snapshot() {
+        return this.#rows.map((row) => ({ ...row }));
+    }
+    /** @internal */
+    restoreSnapshot(rows) {
+        this.#rows = rows;
+    }
+    // ── Reads ─────────────────────────────────────────────────────────────────
+    findAll(query = {}) {
+        const matched = this.#match(query);
+        const { offset, limit } = (0, parse_query_js_1.resolvePagination)(query, this.#policy);
+        const page = matched.slice(offset, offset + limit);
+        return Promise.resolve({
+            records: page.map((row) => this.#project(row, query)),
+            pagination: { offset, limit, count: matched.length },
+        });
+    }
+    findByCursor(query = {}) {
+        const matched = this.#match(query);
+        const { limit } = (0, parse_query_js_1.resolvePagination)(query, this.#policy);
+        const start = query.cursor === undefined ? 0 : Number(decodeCursor(query.cursor));
+        const page = matched.slice(start, start + limit);
+        const nextIndex = start + page.length;
+        const hasMore = nextIndex < matched.length;
+        return Promise.resolve({
+            records: page.map((row) => this.#project(row, query)),
+            pagination: {
+                nextCursor: hasMore ? encodeCursor(String(nextIndex)) : null,
+                limit,
+                hasMore,
+            },
+        });
+    }
+    findOne(query = {}) {
+        const [first] = this.#match(query);
+        return Promise.resolve(first === undefined ? null : this.#project(first, query));
+    }
+    findById(id, query = {}) {
+        const row = this.#rows.find((candidate) => sameId(candidate.id, id));
+        if (row === undefined)
+            return Promise.resolve(null);
+        if ((0, audit_js_1.isSoftDeleted)(row) && query.withDeleted !== true)
+            return Promise.resolve(null);
+        return Promise.resolve(this.#project(row, query));
+    }
+    exists(query = {}) {
+        return Promise.resolve(this.#match(query).length > 0);
+    }
+    count(query = {}) {
+        return Promise.resolve(this.#match(query).length);
+    }
+    // ── Writes ────────────────────────────────────────────────────────────────
+    async create(data, _options = {}) {
+        await Promise.resolve();
+        const row = {
+            ...(0, audit_js_1.stampCreate)(data, { now: this.#now }),
+            id: data['id'] ?? this.#nextId++,
+        };
+        this.#reserveId(row.id);
+        this.#rows.push(row);
+        return { ...row };
+    }
+    async update(id, data, _options = {}) {
+        // Awaiting first means a failed lookup *rejects* rather than throwing
+        // synchronously: a method typed `Promise<T>` must never do the latter, or
+        // `repository.update(...).catch(...)` misses the error.
+        const row = await Promise.resolve(this.#requireRow(id));
+        Object.assign(row, (0, audit_js_1.stampUpdate)(data, { now: this.#now }));
+        return { ...row };
+    }
+    async delete(id, options = {}) {
+        const row = await Promise.resolve(this.#requireRow(id));
+        const mode = options.mode ?? (this.descriptor.softDelete ? 'soft' : 'hard');
+        if (mode === 'hard' || !this.descriptor.softDelete) {
+            this.#rows = this.#rows.filter((candidate) => !sameId(candidate.id, id));
+        }
+        else {
+            Object.assign(row, (0, audit_js_1.stampSoftDelete)({ now: this.#now }));
+        }
+    }
+    async restore(id, _options = {}) {
+        const row = await Promise.resolve(this.#rows.find((candidate) => sameId(candidate.id, id)));
+        if (row === undefined)
+            throw this.#notFound(id);
+        Object.assign(row, (0, audit_js_1.stampRestore)({ now: this.#now }));
+        return { ...row };
+    }
+    async bulkCreate(data, options = {}) {
+        const records = [];
+        for (const entry of data)
+            records.push(await this.create(entry, options));
+        return { affected: records.length, records };
+    }
+    async bulkUpdate(query, data, options = {}) {
+        const targets = this.#match(query);
+        const records = [];
+        for (const row of targets)
+            records.push(await this.update(row.id, data, options));
+        return { affected: records.length, records };
+    }
+    async bulkDelete(query, options = {}) {
+        const targets = this.#match(query);
+        for (const row of targets)
+            await this.delete(row.id, options);
+        return targets.length;
+    }
+    // ── Internals ─────────────────────────────────────────────────────────────
+    #match(query) {
+        let rows = this.#rows.filter((row) => {
+            if (this.descriptor.softDelete && (0, audit_js_1.isSoftDeleted)(row) && query.withDeleted !== true) {
+                return false;
+            }
+            return (0, where_matcher_js_1.matchesWhere)(row, query.where);
+        });
+        if (query.search !== undefined) {
+            const term = query.search.term.toLowerCase();
+            const fields = query.search.fields ?? this.#policy.searchable;
+            rows = rows.filter((row) => fields.some((field) => searchableText(row[field]).includes(term)));
+        }
+        if (query.sort !== undefined && query.sort.length > 0) {
+            rows = [...rows].sort((left, right) => compareBySort(left, right, query.sort ?? []));
+        }
+        return rows;
+    }
+    #project(row, query) {
+        if (query.select === undefined || query.select.length === 0) {
+            return { ...row };
+        }
+        const projected = {};
+        for (const field of query.select)
+            projected[field] = row[field];
+        return projected;
+    }
+    /**
+     * Keep the generated-id counter clear of an id the store already holds.
+     *
+     * This used to be `rows.length + 1`, computed once in the constructor, which
+     * only holds while every id is a contiguous integer from 1. Seed data with a
+     * gap — or a `create` that supplied its own id — left the counter behind the
+     * ids in use, and the next generated row duplicated one of them. Nothing
+     * rejected that: `findById` then answered with whichever row came first and
+     * `update` mutated it, so a write landed on the wrong record rather than
+     * failing.
+     */
+    #reserveId(id) {
+        const numeric = typeof id === 'number' ? id : Number(id);
+        // A Mongo-style string id contributes nothing to a numeric counter.
+        if (Number.isFinite(numeric) && numeric >= this.#nextId)
+            this.#nextId = numeric + 1;
+    }
+    #requireRow(id) {
+        const row = this.#rows.find((candidate) => sameId(candidate.id, id));
+        if (row === undefined || (0, audit_js_1.isSoftDeleted)(row))
+            throw this.#notFound(id);
+        return row;
+    }
+    #notFound(id) {
+        return new core_1.NotFoundError({
+            detail: `${this.descriptor.name} ${String(id)} was not found`,
+            meta: { model: this.descriptor.name, id },
+        });
+    }
+}
+exports.MemoryRepository = MemoryRepository;
+/** Only primitives take part in search; an object column has no text to match. */
+function searchableText(value) {
+    return typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean'
+        ? String(value).toLowerCase()
+        : '';
+}
+function sameId(left, right) {
+    return String(left) === String(right);
+}
+function compareBySort(left, right, sort) {
+    for (const [field, direction] of sort) {
+        const a = left[field];
+        const b = right[field];
+        if (a === b)
+            continue;
+        const ascending = (a ?? '') < (b ?? '') ? -1 : 1;
+        return direction === 'desc' ? -ascending : ascending;
+    }
+    return 0;
+}
+function encodeCursor(value) {
+    return Buffer.from(value, 'utf8').toString('base64url');
+}
+function decodeCursor(cursor) {
+    return Buffer.from(cursor, 'base64url').toString('utf8');
+}
+//# sourceMappingURL=memory.repository.js.map

package/dist/memory/memory.unit-of-work.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Transactions for the in-memory driver (PLAN.md §14.2).
+ *
+ * Snapshot on entry, discard on success, restore on failure. It is not a real
+ * transaction manager, but it gives the same observable contract the conformance
+ * suite asserts of every driver: work inside `run()` is all-or-nothing, and a
+ * failing lifecycle hook rolls the write back.
+ */
+import type { Id, TxContext, UnitOfWork } from '@nage-api/contracts';
+import type { MemoryRepository } from './memory.repository.js';
+export declare class MemoryUnitOfWork implements UnitOfWork {
+    #private;
+    /** Register a repository whose state participates in transactions. */
+    enlist<TEntity extends {
+        id: Id;
+    }>(repository: MemoryRepository<TEntity>): void;
+    run<TResult>(fn: (tx: TxContext) => Promise<TResult>): Promise<TResult>;
+    /** True while a transaction is open — used by tests and diagnostics. */
+    get isActive(): boolean;
+}
+//# sourceMappingURL=memory.unit-of-work.d.ts.map

package/dist/memory/memory.unit-of-work.js

@@ -0,0 +1,50 @@
+"use strict";
+/**
+ * Transactions for the in-memory driver (PLAN.md §14.2).
+ *
+ * Snapshot on entry, discard on success, restore on failure. It is not a real
+ * transaction manager, but it gives the same observable contract the conformance
+ * suite asserts of every driver: work inside `run()` is all-or-nothing, and a
+ * failing lifecycle hook rolls the write back.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryUnitOfWork = void 0;
+const core_1 = require("@nage-api/core");
+class MemoryUnitOfWork {
+    #repositories = new Set();
+    #depth = 0;
+    /** Register a repository whose state participates in transactions. */
+    enlist(repository) {
+        this.#repositories.add(repository);
+    }
+    async run(fn) {
+        const snapshots = new Map();
+        for (const repository of this.#repositories)
+            snapshots.set(repository, repository.snapshot());
+        const context = { id: (0, core_1.randomId)(), driver: 'memory' };
+        this.#depth += 1;
+        try {
+            return await fn(context);
+        }
+        catch (error) {
+            // Restore every enlisted store, not just the one that failed: a
+            // transaction spanning two models must roll back both.
+            for (const [repository, rows] of snapshots)
+                repository.restoreSnapshot(rows);
+            // The caller's error propagates unchanged. Wrapping it would hide a
+            // NotFoundError or a validation failure behind an infrastructure error,
+            // and every driver behaves the same way here so the conformance suite can
+            // assert it.
+            throw error;
+        }
+        finally {
+            this.#depth -= 1;
+        }
+    }
+    /** True while a transaction is open — used by tests and diagnostics. */
+    get isActive() {
+        return this.#depth > 0;
+    }
+}
+exports.MemoryUnitOfWork = MemoryUnitOfWork;
+//# sourceMappingURL=memory.unit-of-work.js.map

package/dist/migrations/migration.runner.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Migration runner (PLAN.md §14.2, §21).
+ *
+ * Replaces `synchronize`/`alter` auto-sync, which rewrote tables at boot and put
+ * data loss one model edit away. Migrations are versioned, checked in, applied
+ * in order, and recorded — so what ran against a database is a fact rather than
+ * an inference.
+ *
+ * The runner is driver-agnostic: a driver supplies a `MigrationStore` (where the
+ * ledger lives) and each migration receives the driver's own context.
+ */
+import type { LoggerPort } from '@nage-api/contracts';
+/** One checked-in migration. */
+export interface Migration<TContext = unknown> {
+    /** Sort key; conventionally a timestamp such as `20260814120000`. */
+    readonly id: string;
+    readonly name: string;
+    up(context: TContext): Promise<void>;
+    /** Omit for a migration that cannot be undone; `down` then refuses to run. */
+    down?(context: TContext): Promise<void>;
+}
+/** A migration that has been applied. */
+export interface AppliedMigration {
+    readonly id: string;
+    readonly name: string;
+    readonly appliedAt: string;
+    /** Fingerprint of the migration when it ran, used to detect edits. */
+    readonly checksum?: string;
+}
+/** Where the ledger of applied migrations lives — a table, a collection. */
+export interface MigrationStore {
+    /** Create the ledger if it does not exist. */
+    initialize(): Promise<void>;
+    applied(): Promise<readonly AppliedMigration[]>;
+    record(migration: AppliedMigration): Promise<void>;
+    remove(id: string): Promise<void>;
+    /**
+     * Prevent two instances migrating at once. Drivers that cannot lock return
+     * `false`, and the runner says so rather than pretending.
+     */
+    lock?(): Promise<boolean>;
+    unlock?(): Promise<void>;
+}
+export interface MigrationRunnerOptions<TContext> {
+    readonly store: MigrationStore;
+    readonly migrations: readonly Migration<TContext>[];
+    /** Passed to each migration — a transaction, a connection, a client. */
+    readonly context: TContext;
+    readonly logger?: LoggerPort;
+    /** Compute a fingerprint so an edited, already-applied migration is caught. */
+    readonly checksum?: (migration: Migration<TContext>) => string;
+}
+export interface MigrationResult {
+    readonly applied: readonly string[];
+    readonly skipped: readonly string[];
+}
+export declare class MigrationRunner<TContext = unknown> {
+    #private;
+    private readonly options;
+    constructor(options: MigrationRunnerOptions<TContext>);
+    /** Migrations in id order; ids must be unique. */
+    get ordered(): readonly Migration<TContext>[];
+    /** Apply every migration that has not run yet. */
+    up(): Promise<MigrationResult>;
+    /** Undo the most recent `steps` migrations, newest first. */
+    down(steps?: number): Promise<MigrationResult>;
+    /** Which migrations have not been applied — what `nage db status` reports. */
+    pending(): Promise<readonly Migration<TContext>[]>;
+}
+//# sourceMappingURL=migration.runner.d.ts.map

package/dist/migrations/migration.runner.js

@@ -0,0 +1,138 @@
+"use strict";
+/**
+ * Migration runner (PLAN.md §14.2, §21).
+ *
+ * Replaces `synchronize`/`alter` auto-sync, which rewrote tables at boot and put
+ * data loss one model edit away. Migrations are versioned, checked in, applied
+ * in order, and recorded — so what ran against a database is a fact rather than
+ * an inference.
+ *
+ * The runner is driver-agnostic: a driver supplies a `MigrationStore` (where the
+ * ledger lives) and each migration receives the driver's own context.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MigrationRunner = void 0;
+const core_1 = require("@nage-api/core");
+class MigrationRunner {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    /** Migrations in id order; ids must be unique. */
+    get ordered() {
+        const seen = new Set();
+        for (const migration of this.options.migrations) {
+            if (seen.has(migration.id)) {
+                throw new core_1.DatabaseError({
+                    detail: `Duplicate migration id "${migration.id}"`,
+                    meta: { id: migration.id },
+                });
+            }
+            seen.add(migration.id);
+        }
+        return [...this.options.migrations].sort((left, right) => left.id.localeCompare(right.id));
+    }
+    /** Apply every migration that has not run yet. */
+    async up() {
+        await this.options.store.initialize();
+        const locked = (await this.options.store.lock?.()) ?? true;
+        if (!locked) {
+            throw new core_1.DatabaseError({
+                detail: 'Another process is already applying migrations',
+                meta: { hint: 'Run migrations as a single deploy step, not on every instance boot.' },
+            });
+        }
+        try {
+            const applied = await this.options.store.applied();
+            const appliedById = new Map(applied.map((entry) => [entry.id, entry]));
+            this.#assertUnchanged(appliedById);
+            const pending = this.ordered.filter((migration) => !appliedById.has(migration.id));
+            const ran = [];
+            for (const migration of pending) {
+                this.options.logger?.info('Applying migration', { id: migration.id, name: migration.name });
+                try {
+                    await migration.up(this.options.context);
+                }
+                catch (error) {
+                    // Stop at the first failure: continuing would apply migrations on top
+                    // of a schema that is not in the state they expect.
+                    throw new core_1.DatabaseError({
+                        detail: `Migration ${migration.id} (${migration.name}) failed`,
+                        cause: error,
+                        meta: { id: migration.id, applied: ran },
+                    });
+                }
+                await this.options.store.record({
+                    id: migration.id,
+                    name: migration.name,
+                    appliedAt: new Date().toISOString(),
+                    ...(this.options.checksum === undefined
+                        ? {}
+                        : { checksum: this.options.checksum(migration) }),
+                });
+                ran.push(migration.id);
+            }
+            return { applied: ran, skipped: [...appliedById.keys()] };
+        }
+        finally {
+            await this.options.store.unlock?.();
+        }
+    }
+    /** Undo the most recent `steps` migrations, newest first. */
+    async down(steps = 1) {
+        await this.options.store.initialize();
+        const applied = [...(await this.options.store.applied())].sort((left, right) => right.id.localeCompare(left.id));
+        const byId = new Map(this.ordered.map((migration) => [migration.id, migration]));
+        const reverted = [];
+        for (const entry of applied.slice(0, steps)) {
+            const migration = byId.get(entry.id);
+            if (migration === undefined) {
+                throw new core_1.DatabaseError({
+                    detail: `Applied migration ${entry.id} is no longer in the migrations directory`,
+                    meta: { id: entry.id },
+                });
+            }
+            if (migration.down === undefined) {
+                throw new core_1.DatabaseError({
+                    detail: `Migration ${migration.id} (${migration.name}) cannot be reverted`,
+                    meta: { id: migration.id },
+                });
+            }
+            await migration.down(this.options.context);
+            await this.options.store.remove(migration.id);
+            reverted.push(migration.id);
+        }
+        return { applied: [], skipped: reverted };
+    }
+    /** Which migrations have not been applied — what `nage db status` reports. */
+    async pending() {
+        await this.options.store.initialize();
+        const applied = new Set((await this.options.store.applied()).map((entry) => entry.id));
+        return this.ordered.filter((migration) => !applied.has(migration.id));
+    }
+    /**
+     * An already-applied migration whose content changed is a divergence between
+     * environments — the schema here is not the schema its checksum describes.
+     */
+    #assertUnchanged(applied) {
+        if (this.options.checksum === undefined)
+            return;
+        for (const migration of this.options.migrations) {
+            const entry = applied.get(migration.id);
+            if (entry?.checksum === undefined)
+                continue;
+            const current = this.options.checksum(migration);
+            if (current !== entry.checksum) {
+                throw new core_1.DatabaseError({
+                    detail: `Migration ${migration.id} (${migration.name}) changed after it was applied`,
+                    meta: {
+                        id: migration.id,
+                        hint: 'Add a new migration instead of editing one that has already run.',
+                    },
+                });
+            }
+        }
+    }
+}
+exports.MigrationRunner = MigrationRunner;
+//# sourceMappingURL=migration.runner.js.map

package/dist/migrations/seed.runner.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Seed runner (PLAN.md §14.2).
+ *
+ * Keeps the two genuinely useful ideas from the legacy seeders — `once` versus
+ * `always`, and references between seeds — while separating them from
+ * migrations, which change schema rather than data.
+ *
+ * `once` seeds are recorded in the same ledger migrations use, so a single
+ * instance applies them even when four boot together.
+ */
+import type { LoggerPort } from '@nage-api/contracts';
+import type { MigrationStore } from './migration.runner.js';
+export type SeedMode = 'once' | 'always';
+export interface Seed<TContext = unknown> {
+    readonly id: string;
+    readonly name: string;
+    /** `once` runs a single time ever; `always` runs on every invocation. */
+    readonly mode?: SeedMode;
+    /** Ids of seeds that must run first — the cross-seed references. */
+    readonly dependsOn?: readonly string[];
+    run(context: TContext): Promise<void>;
+}
+export interface SeedRunnerOptions<TContext> {
+    readonly store: MigrationStore;
+    readonly seeds: readonly Seed<TContext>[];
+    readonly context: TContext;
+    readonly logger?: LoggerPort;
+}
+export interface SeedResult {
+    readonly ran: readonly string[];
+    readonly skipped: readonly string[];
+}
+export declare class SeedRunner<TContext = unknown> {
+    #private;
+    private readonly options;
+    constructor(options: SeedRunnerOptions<TContext>);
+    run(): Promise<SeedResult>;
+}
+//# sourceMappingURL=seed.runner.d.ts.map

package/dist/migrations/seed.runner.js

@@ -0,0 +1,100 @@
+"use strict";
+/**
+ * Seed runner (PLAN.md §14.2).
+ *
+ * Keeps the two genuinely useful ideas from the legacy seeders — `once` versus
+ * `always`, and references between seeds — while separating them from
+ * migrations, which change schema rather than data.
+ *
+ * `once` seeds are recorded in the same ledger migrations use, so a single
+ * instance applies them even when four boot together.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SeedRunner = void 0;
+const core_1 = require("@nage-api/core");
+class SeedRunner {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async run() {
+        await this.options.store.initialize();
+        const applied = new Set((await this.options.store.applied()).map((entry) => entry.id));
+        const ordered = this.#resolveOrder();
+        const ran = [];
+        const skipped = [];
+        for (const seed of ordered) {
+            const mode = seed.mode ?? 'once';
+            if (mode === 'once' && applied.has(seedKey(seed.id))) {
+                skipped.push(seed.id);
+                continue;
+            }
+            this.options.logger?.info('Running seed', { id: seed.id, name: seed.name, mode });
+            try {
+                await seed.run(this.options.context);
+            }
+            catch (error) {
+                throw new core_1.DatabaseError({
+                    detail: `Seed ${seed.id} (${seed.name}) failed`,
+                    cause: error,
+                    meta: { id: seed.id, ran },
+                });
+            }
+            if (mode === 'once') {
+                await this.options.store.record({
+                    id: seedKey(seed.id),
+                    name: `seed:${seed.name}`,
+                    appliedAt: new Date().toISOString(),
+                });
+            }
+            ran.push(seed.id);
+        }
+        return { ran, skipped };
+    }
+    /**
+     * Topological order over `dependsOn`.
+     *
+     * A cycle is reported rather than silently resolved: two seeds that each
+     * expect the other's data cannot both be satisfied, and picking an order
+     * quietly would produce a database that depends on the sort.
+     */
+    #resolveOrder() {
+        const byId = new Map(this.options.seeds.map((seed) => [seed.id, seed]));
+        const ordered = [];
+        const state = new Map();
+        const visit = (seed, trail) => {
+            const status = state.get(seed.id);
+            if (status === 'done')
+                return;
+            if (status === 'visiting') {
+                throw new core_1.DatabaseError({
+                    detail: `Seed dependency cycle: ${[...trail, seed.id].join(' → ')}`,
+                    meta: { cycle: [...trail, seed.id] },
+                });
+            }
+            state.set(seed.id, 'visiting');
+            for (const dependency of seed.dependsOn ?? []) {
+                const target = byId.get(dependency);
+                if (target === undefined) {
+                    throw new core_1.DatabaseError({
+                        detail: `Seed "${seed.id}" depends on "${dependency}", which does not exist`,
+                        meta: { id: seed.id, dependsOn: dependency },
+                    });
+                }
+                visit(target, [...trail, seed.id]);
+            }
+            state.set(seed.id, 'done');
+            ordered.push(seed);
+        };
+        for (const seed of [...this.options.seeds].sort((a, b) => a.id.localeCompare(b.id))) {
+            visit(seed, []);
+        }
+        return ordered;
+    }
+}
+exports.SeedRunner = SeedRunner;
+/** Seeds share the migrations ledger; the prefix keeps the two apart. */
+function seedKey(id) {
+    return `seed:${id}`;
+}
+//# sourceMappingURL=seed.runner.js.map