@abloatai/ablo 0.35.0 → 0.37.0

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/footprint.d.ts

@@ -1,111 +0,0 @@
-/**
- * The footprint — every object Ablo leaves inside a customer's own database,
- * declared once.
- *
- * Four things need this list and each used to carry its own copy: the setup SQL
- * that creates the objects, the replication runtime that reads them, the audit
- * that tells a customer what Ablo put there, and (eventually) the teardown that
- * removes them. They drifted, as hand-maintained copies do — `ABLO_PUBLICATION`
- * was declared twice, under a comment insisting the literals "MUST equal the
- * CLI's" and pointing at a file that no longer held it, and the audit went on
- * looking for a footprint from an earlier era while seeing none of what Ablo
- * installs today.
- *
- * The audit is the copy that matters most. A customer runs it to answer "what is
- * still in my database", and a stale list answers "nothing" — which reads as
- * clean rather than as unexamined. So the list lives here, every consumer
- * derives from it, and an object added to Ablo's setup is visible to the audit
- * because it could not have been added anywhere else.
- *
- * Retired objects stay in the list, marked {@link FootprintArtifact.retired}.
- * They are no longer installed, but a database connected to an older Ablo still
- * holds them, and those are precisely the ones a customer would never think to
- * look for.
- */
-/** The Postgres object class, which decides how the audit looks it up. */
-export type FootprintKind = 'publication' | 'slot' | 'role' | 'table' | 'type';
-export interface FootprintArtifact {
-    readonly kind: FootprintKind;
-    readonly name: string;
-    /** What it is for, in the words a customer reading an audit would want. */
-    readonly purpose: string;
-    /**
-     * Installed only for a data source that reports through the signed endpoint
-     * rather than the write-ahead log.
-     */
-    readonly endpointOnly?: boolean;
-    /**
-     * No longer installed by any current version. A database that once ran an
-     * older Ablo still holds it; the audit reports it so it can be cleaned up.
-     */
-    readonly retired?: boolean;
-    /**
-     * What it costs to leave behind, when leaving it behind costs something. The
-     * audit leads with this, because "you still have an object named X" is not a
-     * reason to act and "this one is retaining your write-ahead log" is.
-     */
-    readonly hazard?: string;
-}
-/**
- * The publication Ablo's replication reads from. Constant by design: a
- * publication declares what streams, and several readers are meant to share one
- * (`publication_names` is a per-stream option, not slot state).
- */
-export declare const ABLO_PUBLICATION = "ablo_publication";
-/**
- * The replication slot that holds Ablo's position in the write-ahead log.
- *
- * Constant, and it should not be — a slot stores ONE position, so two
- * connections sharing this name compete for the same marker. It is why a
- * database can be connected to one plane at a time. ADR 0020 derives it per
- * connection; {@link isValidReplicationSlotName} is the check a derived name
- * has to pass.
- */
-export declare const ABLO_REPLICATION_SLOT = "ablo_slot";
-/** The least-privilege login Ablo reads with. Per-connection under ADR 0020. */
-export declare const ABLO_REPLICATION_ROLE = "ablo_replicator";
-/** The separate least-privilege login used only for row writes. */
-export declare const ABLO_WRITE_ROLE = "ablo_writer";
-/** The bookkeeping table that makes a retried write land once. */
-export declare const ABLO_IDEMPOTENCY_TABLE = "ablo_idempotency";
-/** The transactional outbox an endpoint source reports through. */
-export declare const ABLO_OUTBOX_TABLE = "ablo_outbox";
-/**
- * Postgres will not accept a replication slot name outside this shape — the
- * check is in `ReplicationSlotValidateNameInternal`, and identifier quoting does
- * not exempt a name from it. Anything derived into a slot name is validated
- * here, at the point it is derived, rather than failing at the point it is used.
- */
-export declare const REPLICATION_SLOT_NAME: RegExp;
-export declare function isValidReplicationSlotName(name: string): boolean;
-/** The four plane axes a connection is identified by. */
-export interface FootprintPlane {
-    readonly organizationId: string;
-    readonly environment: string;
-    /** '' for the organization-default project. */
-    readonly projectId?: string;
-    /** '' for the default sandbox. */
-    readonly sandboxId?: string;
-}
-/** The names one connection owns. Nothing here is shared with another plane. */
-export interface FootprintNames {
-    readonly slot: string;
-    readonly publication: string;
-    readonly replicationRole: string;
-    readonly writeRole: string;
-}
-/**
- * The objects this connection owns, named so no other connection can claim them.
- *
- * A slot stores ONE position, so two connections sharing a name compete for the
- * same marker and Postgres reports nothing — which is why the constants these
- * replace made a database connectable to one plane at a time. The publication
- * and roles are derived from the same digest so a database's footprint reads as
- * one set per connection rather than a mix of shared and private objects.
- *
- * Stable: the same plane always derives the same names, so re-running setup is a
- * no-op rather than a second installation.
- */
-export declare function footprintNamesFor(plane: FootprintPlane): FootprintNames;
-/** Everything Ablo has ever put in a customer's database, current and retired. */
-export declare const ABLO_FOOTPRINT: readonly FootprintArtifact[];

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 './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 './footprint.js';