@abloatai/ablo 0.36.0 → 0.37.1

package/dist/source/factory.js

@@ -1,286 +0,0 @@
-/**
- * Builds the request handler returned by `dataSource()`. Given your options —
- * the schema, the API key, and either
- * per-model handlers or an ORM adapter — the handler verifies each signed request,
- * enforces the per-key scopes, and routes the four wire operations (`load`,
- * `list`, `commit`, and `events`) to whichever handlers you configured.
- */
-import { changeSetSchema } from './contract.js';
-import { SourceSignatureError, verifyAbloSourceRequest, } from './signing.js';
-function json(data, status = 200) {
-    return new Response(JSON.stringify(data), {
-        status,
-        headers: { 'Content-Type': 'application/json' },
-    });
-}
-/**
- * Serves one request from an ORM `adapter`, mapping each of the four operations to
- * the adapter's `read`, `commit`, or `events` method and shaping the wire response.
- * The adapter is the only dispatch point, so there is no per-model branching here.
- */
-async function handleViaAdapter(adapter, body, scope) {
-    if (body.type === 'load') {
-        const rows = await adapter.read({
-            kind: 'load',
-            model: body.model,
-            id: body.id,
-            ...(scope ? { scope } : {}),
-        });
-        return json({ row: rows[0] ?? null });
-    }
-    if (body.type === 'list') {
-        const rows = await adapter.read({
-            kind: 'list',
-            model: body.model,
-            ...(body.query ? { query: body.query } : {}),
-            ...(scope ? { scope } : {}),
-        });
-        return json({ rows });
-    }
-    if (body.type === 'commit') {
-        const correlationId = body.correlationId ?? body.clientTxId;
-        if (!correlationId) {
-            return json({
-                error: 'source_commit_requires_correlation_id',
-                message: 'commit requires a scoped correlationId for idempotency',
-            }, 400);
-        }
-        const parsed = changeSetSchema.safeParse({
-            operations: body.operations,
-            correlationId,
-            intentHash: body.intentHash,
-            echo: body.echo,
-        });
-        if (!parsed.success) {
-            return json({ error: 'source_commit_invalid', message: parsed.error.message }, 400);
-        }
-        if (parsed.data.echo?.kind === 'postgres-wal' &&
-            adapter.capabilities.postgresWalEcho !== true) {
-            return json({
-                error: 'source_commit_echo_not_supported',
-                message: 'This adapter cannot emit the required Postgres WAL commit echo',
-            }, 409);
-        }
-        const result = await adapter.commit(parsed.data);
-        return json({ rows: result.rows });
-    }
-    if (body.type === 'events') {
-        const page = await adapter.events(body.cursor ?? null, body.limit ?? 100);
-        return json({
-            events: page.events.map((event) => ({
-                id: event.id,
-                model: event.model,
-                entityId: event.entityId,
-                type: event.type,
-                ...(event.data !== undefined && event.data !== null ? { data: event.data } : {}),
-                ...(event.organizationId ? { organizationId: event.organizationId } : {}),
-                ...(event.clientTxId ? { clientTxId: event.clientTxId } : {}),
-                ...(event.correlationId ? { correlationId: event.correlationId } : {}),
-                ...(event.transactionId ? { transactionId: event.transactionId } : {}),
-                ...(event.occurredAt !== undefined && event.occurredAt !== null
-                    ? { occurredAt: event.occurredAt }
-                    : {}),
-            })),
-            ...(page.nextCursor !== null ? { nextCursor: page.nextCursor } : {}),
-        });
-    }
-    return json({ error: 'unknown_source_request' }, 400);
-}
-async function readBody(request) {
-    if (typeof request.text === 'function') {
-        const rawBody = await request.text();
-        return { rawBody, body: JSON.parse(rawBody) };
-    }
-    const body = (await request.json());
-    return { rawBody: JSON.stringify(body), body };
-}
-async function resolveApiKey(apiKey, context) {
-    if (!apiKey)
-        return null;
-    return typeof apiKey === 'function' ? apiKey(context) : apiKey;
-}
-/**
- * Maps a wire request to the single scope it requires. The mapping is exhaustive,
- * so a new request type must be given its own scope, keeping the scope vocabulary
- * in step with the set of operations.
- */
-function scopeFor(body) {
-    switch (body.type) {
-        case 'load':
-            return 'load';
-        case 'list':
-            return 'list';
-        case 'commit':
-            return 'commit';
-        case 'events':
-            return 'events';
-    }
-}
-function normalizeListResult(result) {
-    if (Array.isArray(result)) {
-        return { rows: result };
-    }
-    const page = result;
-    return page.nextCursor !== undefined
-        ? { rows: page.rows, nextCursor: page.nextCursor }
-        : { rows: page.rows };
-}
-function getModelHandlers(options, model) {
-    const grouped = options.models?.[model];
-    if (grouped)
-        return grouped;
-    const direct = options[model];
-    return direct;
-}
-function sameModel(operations) {
-    const first = operations[0]?.model;
-    if (!first)
-        return null;
-    return operations.every((op) => op.model === first) ? first : null;
-}
-/**
- * Creates a Data Source endpoint you host in front of your own database.
- *
- * Your application code still reads and writes through Ablo, as in
- * `ablo.files.load`, `.list`, and `.update`. This helper is for keeping the
- * canonical rows in your database: Ablo calls a narrow, signed endpoint you
- * control rather than holding your database credentials.
- */
-export function dataSource(options) {
-    return async function handleDataSource(request) {
-        if (request.method !== 'POST') {
-            return json({ error: 'method_not_allowed' }, 405);
-        }
-        let body;
-        let rawBody;
-        try {
-            const parsed = await readBody(request);
-            body = parsed.body;
-            rawBody = parsed.rawBody;
-        }
-        catch {
-            return json({ error: 'invalid_json' }, 400);
-        }
-        let signature = null;
-        try {
-            const apiKey = await resolveApiKey(options.apiKey, {
-                request,
-                body,
-                rawBody,
-            });
-            if (!apiKey) {
-                return json({
-                    error: 'source_api_key_missing',
-                    message: 'Data Source apiKey is required',
-                }, 401);
-            }
-            signature = await verifyAbloSourceRequest({
-                request,
-                body: rawBody,
-                apiKey,
-                toleranceMs: options.signatureToleranceMs,
-            });
-        }
-        catch (err) {
-            if (err instanceof SourceSignatureError) {
-                return json({ error: err.code, message: err.message }, 401);
-            }
-            throw err;
-        }
-        const auth = options.authorize
-            ? await options.authorize({ request, body, rawBody })
-            : undefined;
-        // Enforce the per-key scope. When `resolveScopes` is set, it returns the
-        // operations this key may invoke, and we check the request against that set
-        // before any model handler runs.
-        if (options.resolveScopes) {
-            const required = scopeFor(body);
-            const granted = await options.resolveScopes({ auth, request, body });
-            const grantedSet = granted instanceof Set ? granted : new Set(granted);
-            if (!grantedSet.has(required)) {
-                return json({
-                    error: 'source_forbidden',
-                    required,
-                    granted: Array.from(grantedSet),
-                }, 403);
-            }
-        }
-        const context = {
-            auth,
-            request,
-            messageId: signature?.messageId,
-            signedAt: signature?.signedAt,
-            ...(body.scope ? { scope: body.scope } : {}),
-        };
-        // When an ORM adapter is configured it serves every operation here, at the
-        // generic layer where rows are plain JSON, so there is no per-model handler
-        // lookup on this path.
-        if (options.adapter) {
-            return handleViaAdapter(options.adapter, body, context.scope);
-        }
-        if (body.type === 'load') {
-            const handlers = getModelHandlers(options, body.model);
-            if (!handlers?.load) {
-                return json({ error: 'source_load_not_configured', model: body.model }, 404);
-            }
-            const row = await handlers.load({ id: body.id, context });
-            return json({ row });
-        }
-        if (body.type === 'list') {
-            const handlers = getModelHandlers(options, body.model);
-            if (!handlers?.list) {
-                return json({ error: 'source_list_not_configured', model: body.model }, 404);
-            }
-            const result = await handlers.list({ query: body.query ?? {}, context });
-            const normalized = normalizeListResult(result);
-            return json(normalized);
-        }
-        if (body.type === 'commit') {
-            if (options.commit) {
-                const result = await options.commit({
-                    operations: body.operations,
-                    correlationId: body.correlationId ?? body.clientTxId,
-                    clientTxId: body.clientTxId,
-                    intentHash: body.intentHash,
-                    echo: body.echo,
-                    context,
-                });
-                return json(result);
-            }
-            const model = body.model ?? sameModel(body.operations);
-            if (!model) {
-                return json({ error: 'source_commit_requires_single_model' }, 400);
-            }
-            const handlers = getModelHandlers(options, model);
-            if (!handlers?.commit) {
-                return json({ error: 'source_commit_not_configured', model }, 404);
-            }
-            const result = await handlers.commit({
-                operations: body.operations,
-                correlationId: body.correlationId ?? body.clientTxId,
-                clientTxId: body.clientTxId,
-                intentHash: body.intentHash,
-                echo: body.echo,
-                context,
-            });
-            return json(result);
-        }
-        if (body.type === 'events') {
-            if (!options.events) {
-                return json({ error: 'source_events_not_configured' }, 404);
-            }
-            const result = await options.events({
-                cursor: body.cursor,
-                limit: body.limit,
-                context,
-            });
-            return json({
-                events: result.events,
-                ...(result.nextCursor !== undefined
-                    ? { nextCursor: result.nextCursor }
-                    : {}),
-            });
-        }
-        return json({ error: 'unknown_source_request' }, 400);
-    };
-}

package/dist/source/idempotency.d.ts

@@ -1,61 +0,0 @@
-/**
- * Customer-side source idempotency helpers.
- *
- * Connected writes use a permanent, server-derived correlation key at the
- * customer boundary. The matching intent hash must therefore also be
- * permanent: replaying the key with a different request is a conflict, never a
- * fresh execution. Ablo supplies the hash for signed source requests because
- * it covers context/read guards that an adapter cannot reconstruct from the
- * effective operation list alone. Direct adapter users get a canonical
- * operations-only fallback.
- */
-import { z } from 'zod';
-import type { ChangeSet, Operation } from './contract.js';
-/** Runtime shape recovered from the internal storage envelope. */
-export declare const sourceEchoTransactionIdSchema: z.ZodObject<{
-    correlationId: z.ZodString;
-    transactionId: z.ZodString;
-}, z.core.$strict>;
-export type SourceEchoTransactionId = z.infer<typeof sourceEchoTransactionIdSchema>;
-/**
- * Store both source-batch identity and the originating optimistic-write id in
- * the existing `sync_deltas.transaction_id` column. The database value is an
- * internal envelope: the server unwraps it before broadcasting, so clients
- * still receive the exact operation transaction id they authored.
- *
- * Keeping the opaque, authenticated-scope correlation in the stored value is
- * load-bearing for crash recovery. A raw caller may choose or reuse an
- * operation transaction id; that value alone must never be able to satisfy a
- * different participant's queued receipt.
- */
-export declare function encodeSourceEchoTransactionId(correlationId: string, transactionId: string): string;
-/** Decode a source-WAL transaction envelope, or return null for normal rows. */
-export declare function decodeSourceEchoTransactionId(value: string | null): SourceEchoTransactionId | null;
-/** Canonical operations-only fallback for direct adapter use. */
-export declare function sourceOperationsIntentHash(operations: readonly Operation[]): string;
-/** Resolve the hash every newly-written customer ledger row must persist. */
-export declare function sourceChangeIntentHash(change: ChangeSet): string;
-/** Fail closed for changed intent and legacy rows that lack hash evidence. */
-export declare function assertSourceIdempotencyIntent(cachedHash: unknown, requestHash: string): void;
-/**
- * How long a ledger row stays replayable, as a Postgres interval. New rows are
- * written with `expires_at = now() + this`, so the customer can prune anything
- * past it — the writer can't (it holds no DELETE, by design), so pruning is a
- * job for their own admin/cron: `DELETE FROM ablo_idempotency WHERE expires_at <
- * now()`.
- *
- * This is an ops/UX window, not a safety one: {@link assertSourceIdempotencyRetention}
- * already refuses to replay an expired key (fail-closed), so an expired row can
- * never be safely re-applied whether or not it has been pruned. The window only
- * governs how late a retry can still collect its cached response before it's
- * told to start over. 30 days comfortably covers an offline client's queued
- * commits while keeping the table bounded.
- */
-export declare const SOURCE_IDEMPOTENCY_RETENTION = "30 days";
-/**
- * Enforce the retention contract on replay. A row past its `expires_at` is
- * refused (fail-closed) rather than re-applied, so pruning expired rows is
- * always safe. Rows written before the column existed (`infinity`/null) are
- * accepted — they predate bounded retention and never expire.
- */
-export declare function assertSourceIdempotencyRetention(expiresAt: unknown, now?: number): void;

package/dist/source/idempotency.js

@@ -1,144 +0,0 @@
-/**
- * Customer-side source idempotency helpers.
- *
- * Connected writes use a permanent, server-derived correlation key at the
- * customer boundary. The matching intent hash must therefore also be
- * permanent: replaying the key with a different request is a conflict, never a
- * fresh execution. Ablo supplies the hash for signed source requests because
- * it covers context/read guards that an adapter cannot reconstruct from the
- * effective operation list alone. Direct adapter users get a canonical
- * operations-only fallback.
- */
-import { createHash } from 'node:crypto';
-import { z } from 'zod';
-import { AbloValidationError } from '../transaction/errors.js';
-import { COMMIT_CORRELATION_ID_MAX_LENGTH, correlationIdSchema, } from '../transaction/wire/commit.js';
-const SOURCE_ECHO_TRANSACTION_ID_PREFIX = 'ablo_echo_tx_v1:';
-const sourceOperationTransactionIdSchema = z
-    .string()
-    .min(1)
-    .max(COMMIT_CORRELATION_ID_MAX_LENGTH);
-/** Runtime shape recovered from the internal storage envelope. */
-export const sourceEchoTransactionIdSchema = z.strictObject({
-    correlationId: correlationIdSchema,
-    transactionId: sourceOperationTransactionIdSchema,
-});
-const sourceEchoTransactionIdTupleSchema = z.tuple([
-    correlationIdSchema,
-    sourceOperationTransactionIdSchema,
-]);
-/**
- * Store both source-batch identity and the originating optimistic-write id in
- * the existing `sync_deltas.transaction_id` column. The database value is an
- * internal envelope: the server unwraps it before broadcasting, so clients
- * still receive the exact operation transaction id they authored.
- *
- * Keeping the opaque, authenticated-scope correlation in the stored value is
- * load-bearing for crash recovery. A raw caller may choose or reuse an
- * operation transaction id; that value alone must never be able to satisfy a
- * different participant's queued receipt.
- */
-export function encodeSourceEchoTransactionId(correlationId, transactionId) {
-    const tuple = sourceEchoTransactionIdTupleSchema.parse([
-        correlationId,
-        transactionId,
-    ]);
-    return `${SOURCE_ECHO_TRANSACTION_ID_PREFIX}${JSON.stringify(tuple)}`;
-}
-/** Decode a source-WAL transaction envelope, or return null for normal rows. */
-export function decodeSourceEchoTransactionId(value) {
-    if (!value?.startsWith(SOURCE_ECHO_TRANSACTION_ID_PREFIX))
-        return null;
-    try {
-        const parsed = JSON.parse(value.slice(SOURCE_ECHO_TRANSACTION_ID_PREFIX.length));
-        const tuple = sourceEchoTransactionIdTupleSchema.safeParse(parsed);
-        if (!tuple.success)
-            return null;
-        return sourceEchoTransactionIdSchema.parse({
-            correlationId: tuple.data[0],
-            transactionId: tuple.data[1],
-        });
-    }
-    catch {
-        return null;
-    }
-}
-function canonicalJson(value) {
-    if (value === null || typeof value !== 'object') {
-        const encoded = JSON.stringify(value);
-        return encoded ?? 'null';
-    }
-    if (Array.isArray(value)) {
-        return `[${value
-            .map((entry) => canonicalJson(entry === undefined ? null : entry))
-            .join(',')}]`;
-    }
-    const record = value;
-    return `{${Object.keys(record)
-        .filter((key) => record[key] !== undefined)
-        .sort()
-        .map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`)
-        .join(',')}}`;
-}
-/** Canonical operations-only fallback for direct adapter use. */
-export function sourceOperationsIntentHash(operations) {
-    return createHash('sha256')
-        .update(canonicalJson(operations))
-        .digest('hex');
-}
-/** Resolve the hash every newly-written customer ledger row must persist. */
-export function sourceChangeIntentHash(change) {
-    if (change.echo && !change.intentHash) {
-        throw new AbloValidationError('A WAL-correlated source commit requires Ablo intentHash evidence', { code: 'idempotency_conflict' });
-    }
-    return change.intentHash ?? sourceOperationsIntentHash(change.operations);
-}
-/** Fail closed for changed intent and legacy rows that lack hash evidence. */
-export function assertSourceIdempotencyIntent(cachedHash, requestHash) {
-    if (cachedHash !== requestHash) {
-        throw new AbloValidationError(cachedHash == null
-            ? 'The source idempotency row predates intent hashing and cannot be replayed safely'
-            : 'The source idempotency key was already used with a different request intent', { code: 'idempotency_conflict' });
-    }
-}
-/**
- * How long a ledger row stays replayable, as a Postgres interval. New rows are
- * written with `expires_at = now() + this`, so the customer can prune anything
- * past it — the writer can't (it holds no DELETE, by design), so pruning is a
- * job for their own admin/cron: `DELETE FROM ablo_idempotency WHERE expires_at <
- * now()`.
- *
- * This is an ops/UX window, not a safety one: {@link assertSourceIdempotencyRetention}
- * already refuses to replay an expired key (fail-closed), so an expired row can
- * never be safely re-applied whether or not it has been pruned. The window only
- * governs how late a retry can still collect its cached response before it's
- * told to start over. 30 days comfortably covers an offline client's queued
- * commits while keeping the table bounded.
- */
-export const SOURCE_IDEMPOTENCY_RETENTION = '30 days';
-/**
- * Enforce the retention contract on replay. A row past its `expires_at` is
- * refused (fail-closed) rather than re-applied, so pruning expired rows is
- * always safe. Rows written before the column existed (`infinity`/null) are
- * accepted — they predate bounded retention and never expire.
- */
-export function assertSourceIdempotencyRetention(expiresAt, now = Date.now()) {
-    if (expiresAt == null ||
-        expiresAt === 'infinity' ||
-        expiresAt === Infinity) {
-        return;
-    }
-    const timestamp = expiresAt instanceof Date
-        ? expiresAt.getTime()
-        : typeof expiresAt === 'number'
-            ? expiresAt
-            : typeof expiresAt === 'string'
-                ? Date.parse(expiresAt)
-                : Number.NaN;
-    if (!Number.isFinite(timestamp)) {
-        throw new AbloValidationError('The source idempotency retention evidence is invalid', { code: 'idempotency_conflict' });
-    }
-    if (timestamp <= now) {
-        throw new AbloValidationError('The source idempotency key has expired and cannot be executed again safely', { code: 'idempotency_key_expired' });
-    }
-}

package/dist/source/index.d.ts

@@ -1,23 +0,0 @@
-/**
- * The entry point for the Data Source API, re-exporting the pieces you need from
- * their individual modules:
- *
- *   - `types.ts`   — the shared wire and handler types, plus `sourceEventForOperation`
- *   - `signing.ts` — request signing and verification
- *   - `factory.ts` — the `dataSource()` endpoint factory
- *
- * Import from here; the sibling modules import one another directly.
- */
-export { sourceEventForOperation, ABLO_POSTGRES_COMMIT_ECHO_PREFIX, ABLO_SOURCE_CLIENT_TX_ID_MAX_LENGTH, ABLO_SOURCE_ECHO_MAX_OPERATIONS, ABLO_SOURCE_ECHO_MAX_PAYLOAD_BYTES, type SourcePrimitive, type SourceWhere, type SourceListQuery, type SourceListPage, type SourceListResult, type SourceRequestContext, type SourceOperation, type SourceDelta, type SourceEvent, type SourceEventForOperationOptions, type SourceCommitResult, type SourceCommitEcho, type SourceCommitEchoOperation, type SourceCommitEchoMarker, type SourceCommitParams, type SourceScope, type SourceEventsResult, type SourceEventsHandler, type SourceAuthorizeContext, type SourceHandlerContext, type SourceModelHandlers, type SourceCommitHandler, type SourceApiKey, type SourceLoadRequest, type SourceListRequest, type SourceCommitRequest, type SourceEventsRequest, type SourceRequest, type SourceResponse, } from './types.js';
-export { ABLO_SOURCE_HEADERS, SourceSignatureError, signAbloSourceRequest, verifyAbloSourceRequest, type SourceSignatureOptions, type SourceSignatureVerificationOptions, type SourceSignatureVerificationResult, } from './signing.js';
-export { dataSource, type DataSourceOptions, } from './factory.js';
-export { createPushQueue, InMemoryPushQueueStorage, STANDARD_WEBHOOKS_RETRY_SCHEDULE, type PushQueue, type PushQueueItem, type PushQueueOptions, type PushQueueStorage, } from './pushQueue.js';
-export { createSourceConnector, DEFAULT_RECONNECT_SCHEDULE, type SourceConnector, type SourceConnectorOptions, type ConnectorWebSocket, type ConnectorWebSocketFactory, type ConnectorStatus, } from './connector.js';
-export { SOURCE_CONNECTOR_PROTOCOL_VERSION, SOURCE_CONNECTOR_WS_PATH, WS_SOURCE_SUBPROTOCOL, sourceConnectorSubprotocols, encodeFrame, decodeFrame, ConnectorProtocolError, connectorFrameSchema, type ConnectorFrame, type RegisterFrame, type ReadyFrame, type RequestFrame, type ResponseFrame, type ErrorFrame, } from './connectorProtocol.js';
-export { type DataSourceAdapter, type MutationAdapter, type AdapterReadRequest, type AdapterCommitResult, type Row as AdapterRow, } from './adapter.js';
-export { operationSchema, operationTypeSchema, sourceCommitEchoSchema, sourceCommitEchoOperationSchema, sourceCommitEchoMarkerSchema, changeSetSchema, outboxEventSchema, eventsPageSchema, migrationSchema, adapterCapabilitiesSchema, type Operation, type ChangeSet, type OutboxEvent, type EventsPage, type Migration, type AdapterCapabilities, type SourceCommitEchoMarkerWire, } from './contract.js';
-export { prismaDataSource, type PrismaLike, type PrismaDataSourceOptions } from './adapters/prisma.js';
-export { adapterTableMigrations, endpointOutboxMigrations, idempotencyLedgerMigrations, } from './migrations.js';
-export { createKyselyMutationAdapter, createKyselyMutationCore, kyselyDataSource, kyselyDirectMutation, kyselyOperationRowId, type KyselyCompiledQuery, type KyselyDeleteBuilder, type KyselyInsertBuilder, type KyselyInsertValuesBuilder, type KyselyLike, type KyselyMutationCore, type KyselyReturningExecutable, type KyselySelectBuilder, type KyselyTransactionBuilder, type KyselyUpdateBuilder, type KyselyUpdateSetBuilder, } from './adapters/kysely.js';
-export { sourceOperationsIntentHash, sourceChangeIntentHash, assertSourceIdempotencyIntent, assertSourceIdempotencyRetention, sourceEchoTransactionIdSchema, encodeSourceEchoTransactionId, decodeSourceEchoTransactionId, type SourceEchoTransactionId, } from './idempotency.js';
-export { ABLO_FOOTPRINT, ABLO_PUBLICATION, ABLO_REPLICATION_SLOT, ABLO_REPLICATION_ROLE, ABLO_WRITE_ROLE, ABLO_IDEMPOTENCY_TABLE, ABLO_OUTBOX_TABLE, REPLICATION_SLOT_NAME, isValidReplicationSlotName, footprintNamesFor, type FootprintArtifact, type FootprintKind, type FootprintNames, type FootprintPlane, } from '../transaction/footprint.js';

package/dist/source/index.js

@@ -1,30 +0,0 @@
-/**
- * The entry point for the Data Source API, re-exporting the pieces you need from
- * their individual modules:
- *
- *   - `types.ts`   — the shared wire and handler types, plus `sourceEventForOperation`
- *   - `signing.ts` — request signing and verification
- *   - `factory.ts` — the `dataSource()` endpoint factory
- *
- * Import from here; the sibling modules import one another directly.
- */
-export { sourceEventForOperation, ABLO_POSTGRES_COMMIT_ECHO_PREFIX, ABLO_SOURCE_CLIENT_TX_ID_MAX_LENGTH, ABLO_SOURCE_ECHO_MAX_OPERATIONS, ABLO_SOURCE_ECHO_MAX_PAYLOAD_BYTES, } from './types.js';
-export { ABLO_SOURCE_HEADERS, SourceSignatureError, signAbloSourceRequest, verifyAbloSourceRequest, } from './signing.js';
-export { dataSource, } from './factory.js';
-export { createPushQueue, InMemoryPushQueueStorage, STANDARD_WEBHOOKS_RETRY_SCHEDULE, } from './pushQueue.js';
-// The reverse-channel connector — an outbound transport for the load, list, and
-// commit leg, and the dial-out counterpart to `createPushQueue`. It lets you serve
-// a Data Source from localhost or a private network that has no public inbound
-// URL. See `connectorProtocol.ts` for the frames it exchanges.
-export { createSourceConnector, DEFAULT_RECONNECT_SCHEDULE, } from './connector.js';
-export { SOURCE_CONNECTOR_PROTOCOL_VERSION, SOURCE_CONNECTOR_WS_PATH, WS_SOURCE_SUBPROTOCOL, sourceConnectorSubprotocols, encodeFrame, decodeFrame, ConnectorProtocolError, connectorFrameSchema, } from './connectorProtocol.js';
-// The Data Source adapter interface and its Zod contract, with per-ORM implementations.
-export {} from './adapter.js';
-export { operationSchema, operationTypeSchema, sourceCommitEchoSchema, sourceCommitEchoOperationSchema, sourceCommitEchoMarkerSchema, changeSetSchema, outboxEventSchema, eventsPageSchema, migrationSchema, adapterCapabilitiesSchema, } from './contract.js';
-export { prismaDataSource } from './adapters/prisma.js';
-export { adapterTableMigrations, endpointOutboxMigrations, idempotencyLedgerMigrations, } from './migrations.js';
-export { createKyselyMutationAdapter, createKyselyMutationCore, kyselyDataSource, kyselyDirectMutation, kyselyOperationRowId, } from './adapters/kysely.js';
-export { sourceOperationsIntentHash, sourceChangeIntentHash, assertSourceIdempotencyIntent, assertSourceIdempotencyRetention, sourceEchoTransactionIdSchema, encodeSourceEchoTransactionId, decodeSourceEchoTransactionId, } from './idempotency.js';
-// What Ablo leaves inside a customer's database, declared once — read by the
-// setup SQL, the replication runtime, and the audit that reports it back.
-export { ABLO_FOOTPRINT, ABLO_PUBLICATION, ABLO_REPLICATION_SLOT, ABLO_REPLICATION_ROLE, ABLO_WRITE_ROLE, ABLO_IDEMPOTENCY_TABLE, ABLO_OUTBOX_TABLE, REPLICATION_SLOT_NAME, isValidReplicationSlotName, footprintNamesFor, } from '../transaction/footprint.js';

package/dist/source/migrations.d.ts

@@ -1,21 +0,0 @@
-/**
- * The table-creation SQL every ORM adapter ships for its own infrastructure
- * tables: `ablo_idempotency`, whose legacy-named `client_tx_id` column stores the
- * scoped server correlation, and (for endpoint wrappers only) `ablo_outbox`, the
- * transactional outbox the `events()` feed reads. Direct wrappers install only
- * the ledger migration because WAL is their authoritative feed.
- *
- * These are infrastructure tables, not model tables, and they exist only on your
- * own database when you run a Data Source. Ablo's hosted storage does not use them;
- * it records changes in its own `sync_deltas` log instead.
- */
-import type { Migration } from './contract.js';
-/** The idempotency ledger shared by direct and endpoint mutation wrappers. New
- *  rows carry a bounded `expires_at` (set by the adapter at write time) so the
- *  customer can prune them; the `infinity` column default is only a fallback for
- *  a row inserted without one. */
-export declare function idempotencyLedgerMigrations(): readonly Migration[];
-/** Endpoint-only transactional outbox and its correlation columns. */
-export declare function endpointOutboxMigrations(): readonly Migration[];
-/** Full endpoint adapter migrations (ledger + outbox). */
-export declare function adapterTableMigrations(): readonly Migration[];

package/dist/source/migrations.js

@@ -1,103 +0,0 @@
-/**
- * The table-creation SQL every ORM adapter ships for its own infrastructure
- * tables: `ablo_idempotency`, whose legacy-named `client_tx_id` column stores the
- * scoped server correlation, and (for endpoint wrappers only) `ablo_outbox`, the
- * transactional outbox the `events()` feed reads. Direct wrappers install only
- * the ledger migration because WAL is their authoritative feed.
- *
- * These are infrastructure tables, not model tables, and they exist only on your
- * own database when you run a Data Source. Ablo's hosted storage does not use them;
- * it records changes in its own `sync_deltas` log instead.
- */
-/**
- * Add a column to `ablo_idempotency` only when it is genuinely missing.
- *
- * `ADD COLUMN IF NOT EXISTS` performs its ownership check before the existence
- * short-circuit, so on a ledger owned by another role the no-op re-run still
- * errors "must be owner of table ablo_idempotency" — the setup's re-run promise
- * breaks. `pg_attribute` is readable regardless of table ownership, so this DO
- * block resolves the ledger through the search path and runs the `ALTER` only
- * when the column is absent — a true no-op on a table that already has it.
- */
-function addColumnIfAbsent(column, definition) {
-    return `DO $$
-DECLARE ledger regclass := to_regclass('ablo_idempotency');
-BEGIN
-  IF ledger IS NOT NULL AND NOT EXISTS (
-    SELECT 1 FROM pg_attribute
-    WHERE attrelid = ledger AND attname = '${column}' AND attnum > 0 AND NOT attisdropped
-  ) THEN
-    ALTER TABLE ablo_idempotency ADD COLUMN ${column} ${definition};
-  END IF;
-END $$;`;
-}
-/** The idempotency ledger shared by direct and endpoint mutation wrappers. New
- *  rows carry a bounded `expires_at` (set by the adapter at write time) so the
- *  customer can prune them; the `infinity` column default is only a fallback for
- *  a row inserted without one. */
-export function idempotencyLedgerMigrations() {
-    return [
-        {
-            name: 'ablo_idempotency',
-            up: `CREATE TABLE IF NOT EXISTS ablo_idempotency (
-  client_tx_id TEXT PRIMARY KEY,
-  response     JSONB NOT NULL,
-  request_hash TEXT,
-  expires_at   TIMESTAMPTZ NOT NULL DEFAULT 'infinity',
-  created_at   TIMESTAMPTZ NOT NULL DEFAULT now()
-);`,
-        },
-        {
-            name: 'ablo_idempotency_request_hash',
-            // Nullable only for rows created by older adapter versions. New writes
-            // always populate it; replaying a legacy NULL row fails closed because
-            // the adapter cannot prove that the intent matches.
-            //
-            // The column already exists on any current table (the CREATE above
-            // includes it), so this only matters when upgrading a pre-existing
-            // ledger. `ALTER TABLE ... ADD COLUMN IF NOT EXISTS` checks ownership
-            // BEFORE it evaluates IF NOT EXISTS, so on a ledger that predates the
-            // setup — owned by another role — the no-op still errors "must be owner".
-            // Guard on the catalog (readable regardless of ownership) so the ALTER
-            // runs only when the column is genuinely absent, keeping re-runs safe.
-            up: addColumnIfAbsent('request_hash', 'TEXT'),
-        },
-        {
-            name: 'ablo_idempotency_permanent_retention',
-            up: addColumnIfAbsent('expires_at', `TIMESTAMPTZ NOT NULL DEFAULT 'infinity'`),
-        },
-    ];
-}
-/** Endpoint-only transactional outbox and its correlation columns. */
-export function endpointOutboxMigrations() {
-    return [
-        {
-            name: 'ablo_outbox',
-            up: `CREATE TABLE IF NOT EXISTS ablo_outbox (
-  cursor          BIGSERIAL PRIMARY KEY,
-  id              TEXT NOT NULL UNIQUE,
-  model           TEXT NOT NULL,
-  entity_id       TEXT NOT NULL,
-  type            TEXT NOT NULL,
-  data            JSONB,
-  organization_id TEXT,
-  client_tx_id    TEXT,
-  correlation_id  TEXT,
-  transaction_id  TEXT,
-  occurred_at     BIGINT,
-  created_at      TIMESTAMPTZ NOT NULL DEFAULT now()
-);`,
-        },
-        {
-            name: 'ablo_outbox_correlation',
-            up: `ALTER TABLE ablo_outbox
-  ADD COLUMN IF NOT EXISTS correlation_id TEXT;
-ALTER TABLE ablo_outbox
-  ADD COLUMN IF NOT EXISTS transaction_id TEXT;`,
-        },
-    ];
-}
-/** Full endpoint adapter migrations (ledger + outbox). */
-export function adapterTableMigrations() {
-    return [...idempotencyLedgerMigrations(), ...endpointOutboxMigrations()];
-}