@abloatai/ablo 0.36.0 → 0.37.1

package/dist/source/adapters/kysely.d.ts

@@ -1,42 +0,0 @@
-/**
- * Kysely wrappers for Ablo's two customer-database write transports.
- *
- * Both wrappers compose the same exported {@link createKyselyMutationCore}:
- *
- * - {@link kyselyDataSource} is the endpoint adapter. Its transaction contains
- *   row DML, the permanent idempotency ledger, and correlated outbox events. A
- *   Postgres logical marker remains optional for compatibility.
- * - {@link kyselyDirectMutation} is the engine-side direct wrapper. Its
- *   transaction contains row DML, the same ledger, and a required logical
- *   marker. It never creates, writes, or serves `ablo_outbox`.
- *
- * The ledger reservation happens before DML via `INSERT ... ON CONFLICT DO
- * NOTHING`. Postgres waits on a concurrent uncommitted owner of the same key;
- * after that owner commits, the loser reads and hash-checks its durable response.
- * If the owner rolls back, the waiter acquires the reservation and performs the
- * mutation. This gives same-key concurrency one database arbiter and one effect.
- */
-import type { Schema, SchemaRecord } from '../../transaction/schema/schema.js';
-import type { DataSourceAdapter, MutationAdapter } from '../adapter.js';
-import { type KyselyLike, type KyselyMutationCore } from './kyselyMutationCore.js';
-export { createKyselyMutationCore, kyselyOperationRowId, type KyselyCompiledQuery, type KyselyDeleteBuilder, type KyselyInsertBuilder, type KyselyInsertValuesBuilder, type KyselyLike, type KyselyMutationCore, type KyselyReturningExecutable, type KyselySelectBuilder, type KyselyTransactionBuilder, type KyselyUpdateBuilder, type KyselyUpdateSetBuilder, } from './kyselyMutationCore.js';
-type KyselyMutationMode = 'endpoint' | 'direct';
-/**
- * Build the shared transaction policy around one Kysely mutation core. Exported
- * for engine integrations that need to inject a prebuilt core while retaining
- * the exact same ledger and mapping semantics as the endpoint adapter.
- */
-export interface KyselyMutationAdapterOptions {
-    /**
-     * Translate a mutation operation's authoring model key into the canonical
-     * marker vocabulary (the schema typename). Direct wrappers must supply the
-     * schema-backed translation; identity is only correct when a schema's
-     * typenames equal its keys.
-     */
-    readonly markerModelFor?: (operationModel: string) => string;
-}
-export declare function createKyselyMutationAdapter(db: KyselyLike, core: KyselyMutationCore, mode: KyselyMutationMode, options?: KyselyMutationAdapterOptions): MutationAdapter;
-/** Endpoint wrapper: mutation + ledger + outbox, with an optional marker. */
-export declare function kyselyDataSource<S extends SchemaRecord>(db: KyselyLike, schema: Schema<S>): DataSourceAdapter;
-/** Direct wrapper: mutation + ledger + required logical marker, never outbox. */
-export declare function kyselyDirectMutation<S extends SchemaRecord>(db: KyselyLike, schema: Schema<S>): MutationAdapter;

package/dist/source/adapters/kysely.js

@@ -1,205 +0,0 @@
-/**
- * Kysely wrappers for Ablo's two customer-database write transports.
- *
- * Both wrappers compose the same exported {@link createKyselyMutationCore}:
- *
- * - {@link kyselyDataSource} is the endpoint adapter. Its transaction contains
- *   row DML, the permanent idempotency ledger, and correlated outbox events. A
- *   Postgres logical marker remains optional for compatibility.
- * - {@link kyselyDirectMutation} is the engine-side direct wrapper. Its
- *   transaction contains row DML, the same ledger, and a required logical
- *   marker. It never creates, writes, or serves `ablo_outbox`.
- *
- * The ledger reservation happens before DML via `INSERT ... ON CONFLICT DO
- * NOTHING`. Postgres waits on a concurrent uncommitted owner of the same key;
- * after that owner commits, the loser reads and hash-checks its durable response.
- * If the owner rolls back, the waiter acquires the reservation and performs the
- * mutation. This gives same-key concurrency one database arbiter and one effect.
- */
-import { AbloValidationError } from '../../transaction/errors.js';
-import { changeSetSchema, outboxEventSchema, sourceCommitEchoMarkerSchema, } from '../contract.js';
-import { assertSourceIdempotencyIntent, assertSourceIdempotencyRetention, sourceChangeIntentHash, SOURCE_IDEMPOTENCY_RETENTION, } from '../idempotency.js';
-import { adapterTableMigrations, idempotencyLedgerMigrations, } from '../migrations.js';
-import { ABLO_POSTGRES_COMMIT_ECHO_PREFIX } from '../types.js';
-import { createKyselyMutationCore, kyselyOperationRowId, } from './kyselyMutationCore.js';
-export { createKyselyMutationCore, kyselyOperationRowId, } from './kyselyMutationCore.js';
-function rawQuery(queryId, sql, parameters) {
-    return {
-        query: { kind: 'RawNode', sqlFragments: [sql], parameters: [] },
-        queryId: { queryId },
-        sql,
-        parameters,
-    };
-}
-function reserveLedgerQuery(correlationId, requestHash) {
-    return rawQuery('ablo-idempotency-reserve', `INSERT INTO ablo_idempotency (client_tx_id, response, request_hash, expires_at)
-     VALUES ($1, $2::jsonb, $3, now() + $4::interval)
-     ON CONFLICT (client_tx_id) DO NOTHING
-     RETURNING client_tx_id`, [correlationId, '[]', requestHash, SOURCE_IDEMPOTENCY_RETENTION]);
-}
-function completeLedgerQuery(correlationId, rows) {
-    return rawQuery('ablo-idempotency-complete', `UPDATE ablo_idempotency
-        SET response = $2::jsonb
-      WHERE client_tx_id = $1`, [correlationId, JSON.stringify(rows)]);
-}
-function postgresLogicalMarkerQuery(payload) {
-    return rawQuery('ablo-postgres-logical-marker', 'SELECT pg_logical_emit_message(true, $1::text, $2::text)', [ABLO_POSTGRES_COMMIT_ECHO_PREFIX, payload]);
-}
-function parseCachedRows(response) {
-    const parsed = typeof response === 'string' ? JSON.parse(response) : response;
-    if (!Array.isArray(parsed)) {
-        throw new AbloValidationError('The source idempotency response is corrupt and cannot be replayed safely', { code: 'idempotency_conflict' });
-    }
-    return parsed;
-}
-function markerAction(type) {
-    if (type === 'CREATE')
-        return 'I';
-    if (type === 'DELETE')
-        return 'D';
-    return 'U';
-}
-function assertDirectLogicalMarker(change, markerModelFor) {
-    const payload = change.echo?.payload;
-    if (!payload) {
-        throw new AbloValidationError('A direct Kysely mutation requires a transactional Postgres logical marker', { code: 'source_adapter_misconfigured' });
-    }
-    try {
-        const marker = sourceCommitEchoMarkerSchema.parse(JSON.parse(payload));
-        if (marker.correlationId !== change.correlationId) {
-            throw new Error('marker correlation does not match the ledger key');
-        }
-        if (marker.operations.length !== change.operations.length) {
-            throw new Error('marker operation count does not match the mutation');
-        }
-        for (const [index, operation] of change.operations.entries()) {
-            const markerOperation = marker.operations[index];
-            // The marker speaks the canonical schema TYPENAME (the vocabulary the
-            // WAL consumer validates deltas against), while the mutation operation
-            // carries the authoring wire key. `markerModelFor` translates the wire
-            // key through the schema so the two vocabularies compare correctly.
-            if (!markerOperation ||
-                markerOperation.model !== markerModelFor(operation.model) ||
-                markerOperation.id !== kyselyOperationRowId(operation) ||
-                markerOperation.action !== markerAction(operation.type) ||
-                markerOperation.transactionId !== operation.transactionId) {
-                throw new Error(`marker operation ${index} does not match the mutation`);
-            }
-        }
-    }
-    catch (error) {
-        if (error instanceof AbloValidationError)
-            throw error;
-        throw new AbloValidationError(`The direct Postgres logical marker is invalid: ${error instanceof Error ? error.message : 'unknown marker error'}`, { code: 'source_adapter_misconfigured' });
-    }
-}
-export function createKyselyMutationAdapter(db, core, mode, options = {}) {
-    const markerModelFor = options.markerModelFor ?? ((model) => model);
-    return {
-        capabilities: {
-            transactions: true,
-            propose: false,
-            schemaIntrospection: true,
-            postgresWalEcho: true,
-            outboxEvents: mode === 'endpoint',
-        },
-        migrations() {
-            return mode === 'endpoint'
-                ? adapterTableMigrations()
-                : idempotencyLedgerMigrations();
-        },
-        read(request) {
-            return core.read(request);
-        },
-        async commit(change) {
-            const request = changeSetSchema.parse(change);
-            if (mode === 'direct')
-                assertDirectLogicalMarker(request, markerModelFor);
-            const requestHash = sourceChangeIntentHash(request);
-            return db.transaction().execute(async (transaction) => {
-                const reservation = await transaction.executeQuery(reserveLedgerQuery(request.correlationId, requestHash));
-                if (reservation.rows.length === 0) {
-                    const cached = await transaction
-                        .selectFrom('ablo_idempotency')
-                        .selectAll()
-                        .where('client_tx_id', '=', request.correlationId)
-                        .limit(1)
-                        .execute();
-                    const cachedRow = cached[0];
-                    if (!cachedRow) {
-                        throw new AbloValidationError('The source idempotency reservation disappeared during replay', { code: 'idempotency_conflict' });
-                    }
-                    assertSourceIdempotencyIntent(cachedRow.request_hash, requestHash);
-                    assertSourceIdempotencyRetention(cachedRow.expires_at);
-                    return { rows: parseCachedRows(cachedRow.response) };
-                }
-                const rows = [];
-                for (const [index, operation] of request.operations.entries()) {
-                    const row = await core.applyOperation(transaction, operation);
-                    rows.push(row);
-                    if (mode === 'endpoint') {
-                        const entityId = String(row.id ?? kyselyOperationRowId(operation));
-                        await transaction
-                            .insertInto('ablo_outbox')
-                            .values({
-                            id: `${request.correlationId}:${index}`,
-                            model: operation.model,
-                            entity_id: entityId,
-                            type: operation.type,
-                            data: operation.type === 'DELETE' ? null : JSON.stringify(row),
-                            correlation_id: request.correlationId,
-                            transaction_id: operation.transactionId ?? null,
-                            occurred_at: Date.now(),
-                        })
-                            .execute();
-                    }
-                }
-                await transaction.executeQuery(completeLedgerQuery(request.correlationId, rows));
-                if (request.echo?.kind === 'postgres-wal') {
-                    await transaction.executeQuery(postgresLogicalMarkerQuery(request.echo.payload));
-                }
-                return { rows };
-            });
-        },
-    };
-}
-/** Endpoint wrapper: mutation + ledger + outbox, with an optional marker. */
-export function kyselyDataSource(db, schema) {
-    const mutation = createKyselyMutationAdapter(db, createKyselyMutationCore(db, schema), 'endpoint');
-    return {
-        ...mutation,
-        capabilities: { ...mutation.capabilities, outboxEvents: true },
-        async events(cursor, limit) {
-            const rows = await db
-                .selectFrom('ablo_outbox')
-                .selectAll()
-                .where('cursor', '>', cursor ?? '0')
-                .orderBy('cursor', 'asc')
-                .limit(limit)
-                .execute();
-            const events = rows.map((row) => outboxEventSchema.parse({
-                id: row.id,
-                model: row.model,
-                entityId: row.entity_id,
-                type: row.type,
-                data: typeof row.data === 'string' ? JSON.parse(row.data) : row.data ?? null,
-                organizationId: row.organization_id ?? null,
-                clientTxId: row.client_tx_id ?? null,
-                correlationId: row.correlation_id ?? null,
-                transactionId: row.transaction_id ?? null,
-                occurredAt: row.occurred_at != null ? Number(row.occurred_at) : null,
-                cursor: String(row.cursor),
-            }));
-            return { events, nextCursor: events.at(-1)?.cursor ?? null };
-        },
-    };
-}
-/** Direct wrapper: mutation + ledger + required logical marker, never outbox. */
-export function kyselyDirectMutation(db, schema) {
-    return createKyselyMutationAdapter(db, createKyselyMutationCore(db, schema), 'direct', {
-        markerModelFor: (operationModel) => {
-            const typename = schema.models[operationModel]?.typename;
-            return typename && typename.length > 0 ? typename : operationModel;
-        },
-    });
-}

package/dist/source/adapters/kyselyMutationCore.d.ts

@@ -1,76 +0,0 @@
-/**
- * Reusable Kysely row-mutation core.
- *
- * This is the single schema-field ↔ physical-column translation used by both
- * Kysely transports. It deliberately knows nothing about outboxes, logical
- * markers, or idempotency: wrappers compose those transaction policies around
- * the same `applyOperation` implementation, so direct and endpoint DML cannot
- * drift into separate hand-written mappers.
- */
-import type { Schema, SchemaRecord } from '../../transaction/schema/schema.js';
-import type { AdapterReadRequest, Row } from '../adapter.js';
-import type { Operation } from '../contract.js';
-/** The subset of a Kysely instance, or transaction handle, used by the core. */
-export interface KyselyLike {
-    selectFrom(table: string): KyselySelectBuilder;
-    insertInto(table: string): KyselyInsertBuilder;
-    updateTable(table: string): KyselyUpdateBuilder;
-    deleteFrom(table: string): KyselyDeleteBuilder;
-    /** Execute a precompiled raw query on this exact transaction handle. */
-    executeQuery(query: KyselyCompiledQuery): Promise<{
-        readonly rows: readonly Row[];
-    }>;
-    transaction(): KyselyTransactionBuilder;
-}
-/** Structural slice of Kysely's public `CompiledQuery` shape. */
-export interface KyselyCompiledQuery {
-    readonly query: {
-        readonly kind: 'RawNode';
-        readonly sqlFragments: readonly string[];
-        readonly parameters: readonly [];
-    };
-    readonly queryId: {
-        readonly queryId: string;
-    };
-    readonly sql: string;
-    readonly parameters: readonly unknown[];
-}
-export interface KyselyTransactionBuilder {
-    execute<T>(fn: (trx: KyselyLike) => Promise<T>): Promise<T>;
-}
-export interface KyselySelectBuilder {
-    selectAll(): KyselySelectBuilder;
-    where(column: string, operator: string, value: unknown): KyselySelectBuilder;
-    orderBy(column: string, direction: 'asc' | 'desc'): KyselySelectBuilder;
-    limit(limit: number): KyselySelectBuilder;
-    execute(): Promise<readonly Row[]>;
-}
-export interface KyselyReturningExecutable {
-    execute(): Promise<readonly Row[]>;
-}
-export interface KyselyInsertBuilder {
-    values(row: Row): KyselyInsertValuesBuilder;
-}
-export interface KyselyInsertValuesBuilder {
-    returningAll(): KyselyReturningExecutable;
-    execute(): Promise<unknown>;
-}
-export interface KyselyUpdateBuilder {
-    set(patch: Row): KyselyUpdateSetBuilder;
-}
-export interface KyselyUpdateSetBuilder {
-    where(column: string, operator: string, value: unknown): KyselyUpdateSetBuilder;
-    returningAll(): KyselyReturningExecutable;
-}
-export interface KyselyDeleteBuilder {
-    where(column: string, operator: string, value: unknown): KyselyDeleteBuilder;
-    returningAll(): KyselyReturningExecutable;
-}
-/** Resolve the stable row id required by every source operation. */
-export declare function kyselyOperationRowId(operation: Operation): string;
-/** The transport-independent Kysely field/column mutation boundary. */
-export interface KyselyMutationCore {
-    read(request: AdapterReadRequest): Promise<readonly Row[]>;
-    applyOperation(transaction: KyselyLike, operation: Operation): Promise<Row>;
-}
-export declare function createKyselyMutationCore<S extends SchemaRecord>(db: KyselyLike, schema: Schema<S>): KyselyMutationCore;

package/dist/source/adapters/kyselyMutationCore.js

@@ -1,125 +0,0 @@
-/**
- * Reusable Kysely row-mutation core.
- *
- * This is the single schema-field ↔ physical-column translation used by both
- * Kysely transports. It deliberately knows nothing about outboxes, logical
- * markers, or idempotency: wrappers compose those transaction policies around
- * the same `applyOperation` implementation, so direct and endpoint DML cannot
- * drift into separate hand-written mappers.
- */
-import { AbloValidationError } from '../../transaction/errors.js';
-import { toSchemaJSON } from '../../schema/serialize.js';
-import { camelToSnake, snakeToCamel } from '../../schema/ddl.js';
-import { tenancyColumn } from '../../transaction/schema/tenancy.js';
-function buildColumnMaps(schema) {
-    const json = toSchemaJSON(schema);
-    const out = new Map();
-    for (const [key, model] of Object.entries(json.models)) {
-        const fieldToColumn = new Map();
-        const columnToField = new Map();
-        const register = (field, column) => {
-            if (column === camelToSnake(field))
-                return;
-            fieldToColumn.set(field, column);
-            columnToField.set(column, field);
-        };
-        for (const [field, meta] of Object.entries(model.fields)) {
-            if (meta.column)
-                register(field, meta.column);
-        }
-        const orgColumn = tenancyColumn(model.tenancy);
-        if (orgColumn)
-            register('organizationId', orgColumn);
-        out.set(key, {
-            table: model.tableName ?? key,
-            fieldToColumn,
-            columnToField,
-        });
-    }
-    return out;
-}
-/** Resolve the stable row id required by every source operation. */
-export function kyselyOperationRowId(operation) {
-    const id = operation.id ?? operation.input?.id;
-    if (typeof id !== 'string' || id.length === 0) {
-        throw new AbloValidationError(`operation on "${operation.model}" requires an id`, { code: 'source_operation_id_required' });
-    }
-    return id;
-}
-export function createKyselyMutationCore(db, schema) {
-    const maps = buildColumnMaps(schema);
-    const modelColumns = (model) => {
-        const columns = maps.get(model);
-        if (!columns) {
-            throw new AbloValidationError(`kysely mutation core: no model "${model}" in schema`, { code: 'source_adapter_misconfigured' });
-        }
-        return columns;
-    };
-    const columnFor = (columns, field) => columns.fieldToColumn.get(field) ?? camelToSnake(field);
-    const fieldFor = (columns, column) => columns.columnToField.get(column) ?? snakeToCamel(column);
-    const toColumns = (columns, row) => {
-        const out = {};
-        for (const key of Object.keys(row))
-            out[columnFor(columns, key)] = row[key];
-        return out;
-    };
-    const toFields = (columns, row) => {
-        const out = {};
-        for (const key of Object.keys(row))
-            out[fieldFor(columns, key)] = row[key];
-        return out;
-    };
-    return {
-        async read(request) {
-            const columns = modelColumns(request.model);
-            if (request.kind === 'load') {
-                const rows = await db
-                    .selectFrom(columns.table)
-                    .selectAll()
-                    .where('id', '=', request.id)
-                    .limit(1)
-                    .execute();
-                return rows.map((row) => toFields(columns, row));
-            }
-            const rows = await db
-                .selectFrom(columns.table)
-                .selectAll()
-                .limit(request.query?.limit ?? 1000)
-                .execute();
-            return rows.map((row) => toFields(columns, row));
-        },
-        async applyOperation(transaction, operation) {
-            const columns = modelColumns(operation.model);
-            const id = kyselyOperationRowId(operation);
-            const input = operation.input ?? {};
-            if (operation.type === 'DELETE') {
-                const deleted = await transaction
-                    .deleteFrom(columns.table)
-                    .where('id', '=', id)
-                    .returningAll()
-                    .execute();
-                return deleted[0] ? toFields(columns, deleted[0]) : { id };
-            }
-            if (operation.type === 'CREATE') {
-                const inserted = await transaction
-                    .insertInto(columns.table)
-                    .values(toColumns(columns, { id, ...input }))
-                    .returningAll()
-                    .execute();
-                return inserted[0] ? toFields(columns, inserted[0]) : { id, ...input };
-            }
-            const patch = toColumns(columns, {
-                ...input,
-                ...(operation.type === 'ARCHIVE' ? { archivedAt: new Date() } : {}),
-                ...(operation.type === 'UNARCHIVE' ? { archivedAt: null } : {}),
-            });
-            const updated = await transaction
-                .updateTable(columns.table)
-                .set(patch)
-                .where('id', '=', id)
-                .returningAll()
-                .execute();
-            return updated[0] ? toFields(columns, updated[0]) : { id, ...input };
-        },
-    };
-}

package/dist/source/adapters/memory.d.ts

@@ -1,13 +0,0 @@
-/**
- * The in-memory reference implementation of {@link DataSourceAdapter}. It is the
- * simplest correct adapter: a stand-in you can commit to and read from in tests
- * without a database, and the fixture the conformance suite runs against to confirm
- * the suite exercises real behavior. An adapter for a given object-relational
- * mapper is complete when it passes the same suite this one passes.
- *
- * It models the semantics minimally but faithfully: one row store per model, an
- * idempotency ledger keyed by scoped correlation, and an append-only outbox with a
- * monotonic cursor.
- */
-import type { DataSourceAdapter } from '../adapter.js';
-export declare function memoryDataSource(): DataSourceAdapter;

package/dist/source/adapters/memory.js

@@ -1,130 +0,0 @@
-/**
- * The in-memory reference implementation of {@link DataSourceAdapter}. It is the
- * simplest correct adapter: a stand-in you can commit to and read from in tests
- * without a database, and the fixture the conformance suite runs against to confirm
- * the suite exercises real behavior. An adapter for a given object-relational
- * mapper is complete when it passes the same suite this one passes.
- *
- * It models the semantics minimally but faithfully: one row store per model, an
- * idempotency ledger keyed by scoped correlation, and an append-only outbox with a
- * monotonic cursor.
- */
-import { AbloValidationError } from '../../transaction/errors.js';
-import { assertSourceIdempotencyIntent, sourceChangeIntentHash, } from '../idempotency.js';
-function rowId(op) {
-    const id = op.id ?? op.input?.id;
-    if (typeof id !== 'string' || id.length === 0) {
-        throw new AbloValidationError(`operation on "${op.model}" requires an id`, { code: 'source_operation_id_required' });
-    }
-    return id;
-}
-export function memoryDataSource() {
-    /** model → (id → row). */
-    const store = new Map();
-    /** Permanent correlationId → intent hash + original response ledger. */
-    const idempotency = new Map();
-    /** Append-only outbox; `cursor` is the 1-based index as a string. */
-    const outbox = [];
-    const modelStore = (model) => {
-        let m = store.get(model);
-        if (!m) {
-            m = new Map();
-            store.set(model, m);
-        }
-        return m;
-    };
-    const applyOperation = (op) => {
-        const m = modelStore(op.model);
-        const id = rowId(op);
-        switch (op.type) {
-            case 'CREATE': {
-                const row = { id, ...(op.input ?? {}) };
-                m.set(id, row);
-                return row;
-            }
-            case 'UPDATE':
-            case 'ARCHIVE':
-            case 'UNARCHIVE': {
-                const prev = m.get(id) ?? { id };
-                const row = {
-                    ...prev,
-                    ...(op.input ?? {}),
-                    ...(op.type === 'ARCHIVE' ? { archivedAt: Date.now() } : {}),
-                    ...(op.type === 'UNARCHIVE' ? { archivedAt: null } : {}),
-                };
-                m.set(id, row);
-                return row;
-            }
-            case 'DELETE': {
-                const prev = m.get(id) ?? { id };
-                m.delete(id);
-                return prev;
-            }
-        }
-    };
-    return {
-        capabilities: {
-            transactions: true,
-            propose: false,
-            schemaIntrospection: false,
-            postgresWalEcho: false,
-            outboxEvents: true,
-        },
-        migrations() {
-            // Nothing to create in memory. A database-backed adapter returns the SQL for its ablo_idempotency and ablo_outbox tables here.
-            return [];
-        },
-        async read(req) {
-            const m = store.get(req.model);
-            if (!m)
-                return [];
-            if (req.kind === 'load') {
-                const row = m.get(req.id);
-                return row ? [row] : [];
-            }
-            let rows = [...m.values()];
-            const limit = req.query?.limit;
-            if (typeof limit === 'number')
-                rows = rows.slice(0, limit);
-            return rows;
-        },
-        async commit(change) {
-            if (change.echo) {
-                throw new AbloValidationError('memoryDataSource cannot emit a Postgres WAL commit echo');
-            }
-            // Idempotency: a duplicate scoped correlation returns the original rows.
-            const requestHash = sourceChangeIntentHash(change);
-            const cached = idempotency.get(change.correlationId);
-            if (cached) {
-                assertSourceIdempotencyIntent(cached.requestHash, requestHash);
-                return { rows: cached.rows };
-            }
-            const rows = [];
-            for (const [index, op] of change.operations.entries()) {
-                const row = applyOperation(op);
-                rows.push(row);
-                // Transactional outbox: one event per op, monotonic cursor.
-                outbox.push({
-                    id: `${change.correlationId}:${index}`,
-                    model: op.model,
-                    entityId: String(row.id ?? rowId(op)),
-                    type: op.type,
-                    data: op.type === 'DELETE' ? null : row,
-                    correlationId: change.correlationId,
-                    ...(op.transactionId ? { transactionId: op.transactionId } : {}),
-                    cursor: String(outbox.length + 1),
-                });
-            }
-            idempotency.set(change.correlationId, { requestHash, rows });
-            return { rows };
-        },
-        async events(cursor, limit) {
-            const after = cursor ? Number(cursor) : 0;
-            const page = outbox.filter((e) => Number(e.cursor) > after).slice(0, limit);
-            return {
-                events: page,
-                nextCursor: page.at(-1)?.cursor ?? null,
-            };
-        },
-    };
-}

package/dist/source/adapters/prisma.d.ts

@@ -1,63 +0,0 @@
-/**
- * The Prisma adapter for the data-source interface. It implements
- * {@link DataSourceAdapter} against a Prisma client and passes the same conformance
- * suite as the in-memory reference and the other adapters.
- *
- * The adapter owns the transactional outbox and idempotency bookkeeping, so you
- * never write them: `commit` runs the row mutations, the `ablo_outbox` append, and
- * the `ablo_idempotency` record inside a single `prisma.$transaction`, and
- * `migrations` returns the SQL that creates those two tables.
- *
- * It takes no dependency on `@prisma/client`. The client is accepted structurally
- * as {@link PrismaLike}, so this module compiles without Prisma installed and can
- * be tested with a fake, while a real `PrismaClient` satisfies the shape at the
- * call site.
- */
-import type { DataSourceAdapter, Row } from '../adapter.js';
-import type { SchemaRecord, Schema } from '../../transaction/schema/schema.js';
-/** A Prisma model delegate — the subset of its methods the adapter calls. */
-export interface PrismaDelegate {
-    findUnique(args: {
-        where: {
-            id: string;
-        };
-    }): Promise<Row | null>;
-    findMany(args: {
-        where?: Record<string, unknown>;
-        take?: number;
-        orderBy?: Record<string, 'asc' | 'desc'>;
-    }): Promise<Row[]>;
-    create(args: {
-        data: Row;
-    }): Promise<Row>;
-    update(args: {
-        where: {
-            id: string;
-        };
-        data: Row;
-    }): Promise<Row>;
-    delete(args: {
-        where: {
-            id: string;
-        };
-    }): Promise<Row>;
-}
-/** The raw-SQL surface used for the adapter-owned tables. */
-export interface PrismaRaw {
-    $executeRawUnsafe(query: string, ...values: unknown[]): Promise<number>;
-    $queryRawUnsafe<T = unknown>(query: string, ...values: unknown[]): Promise<T>;
-}
-/**
- * A Prisma client as a structural shape that needs no `@prisma/client` import.
- * The interactive-transaction callback receives only {@link PrismaRaw}: Prisma's
- * own tx client strips `$transaction` (no nesting), so requiring it there made
- * a real `PrismaClient` unassignable to this shape.
- */
-export interface PrismaLike extends PrismaRaw {
-    $transaction<T>(fn: (tx: PrismaRaw) => Promise<T>): Promise<T>;
-}
-export interface PrismaDataSourceOptions {
-    /** Map a schema model name → its Prisma delegate name. Default: lower-first-letter. */
-    readonly delegateName?: (model: string) => string;
-}
-export declare function prismaDataSource<S extends SchemaRecord>(prisma: PrismaLike, schema: Schema<S>, options?: PrismaDataSourceOptions): DataSourceAdapter;