@abloatai/ablo 0.36.0 → 0.37.1

package/dist/interfaces/index.d.ts

@@ -1,311 +0,0 @@
-/**
- * The interfaces you implement to plug the SDK into your own environment.
- *
- * The SDK depends on these contracts rather than any specific framework, so you
- * provide the concrete implementations — logging, observability, analytics,
- * session-error detection, online-status checks, and the transport that carries
- * mutations to your backend. The SDK ships sensible no-op defaults where it can.
- */
-import type { MutationCommitResultInput } from '../transaction/wire/commit.js';
-import type { OnStaleMode } from '../transaction/coordination/schema.js';
-export type { ClaimEvent, ConflictEvent } from '../transaction/coordination/events.js';
-import type { CoordinationObservability } from '../transaction/observability.js';
-export type { CoordinationObservability } from '../transaction/observability.js';
-export type { Logger } from '../transaction/logger.js';
-import type { Logger } from '../transaction/logger.js';
-export type { BreadcrumbLevel, BreadcrumbCategory, WebSocketErrorDetails, TransportObservability, } from '../transaction/observability.js';
-import type { BreadcrumbCategory, TransportObservability } from '../transaction/observability.js';
-export interface RollbackDetails {
-    transactionType: string;
-    modelName: string;
-    modelId: string;
-    reason: string;
-    error?: string;
-    connectionState: string;
-}
-export interface TransactionFailureDetails {
-    context: string;
-    modelName?: string;
-    modelId?: string;
-    transactionId?: string;
-    error: Error | string;
-}
-export interface BootstrapFailureDetails {
-    attempt?: number;
-    type?: string;
-    navigatorOnline?: boolean;
-}
-export interface ReconciliationDetails {
-    reason: string;
-    model: string;
-    modelId: string;
-    syncIdNeeded?: number;
-    lastSeenSyncId: number;
-    retryCount: number;
-    connectionState?: string;
-}
-export interface DeltaRetryExhaustedDetails {
-    txId: string;
-    model: string;
-    modelId: string;
-    retryCount: number;
-    syncIdNeeded?: number;
-}
-export interface SelfHealingDetails {
-    modelName: string;
-    modelId: string;
-    field: string;
-    action: string;
-}
-export interface CommitZeroSyncIdDetails {
-    operationCount: number;
-    operations: string[];
-}
-/** Span attributes for performance monitoring */
-export type SpanAttributes = Record<string, string | number | boolean | undefined>;
-/**
- * The observability hooks the SDK calls to report its own lifecycle. The SDK
- * ships a no-op default; provide your own to forward these events to a monitoring
- * tool such as Sentry, Datadog, or OpenTelemetry.
- */
-export interface ObservabilityProvider extends CoordinationObservability, TransportObservability {
-    /** Set user/org context for error grouping */
-    setContext(userId: string, organizationId: string): void;
-    /** Update connection state tag */
-    setConnectionState(state: 'connected' | 'disconnected' | 'connecting'): void;
-    /** Capture optimistic rollback (data reverted) */
-    captureRollback(details: RollbackDetails): void;
-    /**
-     * Capture permanent mutation failure. Named `captureTransactionFailure`
-     * before 0.35.0; the rename is announced in that release note rather than
-     * aliased, because this member is required — a provider still carrying the
-     * old spelling fails to satisfy the interface and the compiler names the
-     * member, which an optional alias would only have hidden.
-     */
-    captureMutationFailure(details: TransactionFailureDetails): void;
-    /** Capture bootstrap failure */
-    captureBootstrapFailure(error: Error | unknown, details?: BootstrapFailureDetails): void;
-    /** Capture reconciliation needed (delta confirmation timeout) */
-    captureReconciliation(details: ReconciliationDetails): void;
-    /** Capture delta retry exhausted */
-    captureDeltaRetryExhausted(details: DeltaRetryExhaustedDetails): void;
-    /** Capture self-healing event */
-    captureSelfHealing(details: SelfHealingDetails): void;
-    /** Capture commit returning lastSyncId: 0 */
-    captureCommitZeroSyncId(details: CommitZeroSyncIdDetails): void;
-    /** Wrap a synchronous function in a performance span */
-    startSpan<T>(name: string, op: string, fn: () => T, attributes?: SpanAttributes): T;
-    /** Wrap an async function in a performance span */
-    startSpanAsync<T>(name: string, op: string, fn: () => Promise<T>, attributes?: SpanAttributes): Promise<T>;
-}
-export interface Analytics {
-    capture(event: string, properties?: Record<string, unknown>): void;
-}
-/**
- * Detects whether an error represents an expired/invalid session.
- * The SDK uses this to decide whether to redirect to login vs retry.
- */
-export interface SessionErrorDetector {
-    /** Check if an error is a session error (401/403) */
-    isSessionError(error: unknown): boolean;
-    /** Check if an HTTP response status indicates a session error */
-    isSessionErrorResponse(status: number, body?: string): boolean;
-}
-export interface OnlineStatusProvider {
-    /** Returns true if the device is currently online */
-    isOnline(): boolean;
-}
-export interface ModelDebugLoggerContract {
-    logOperation(info: {
-        modelName: string;
-        modelId?: string;
-        operation: string;
-        fields?: Record<string, unknown>;
-    }): void;
-    logDebug(message: string): void;
-    logError(modelName: string, operation: string, message: string, data?: unknown): void;
-    logCreation(modelName: string, data: unknown, constructor: unknown): void;
-    logObservableSetup(modelName: string, observableProps: string[], computedProps: string[]): void;
-}
-/**
- * Result returned by an injected mutation executor. The input type is inferred
- * from the runtime compatibility schema: legacy `{lastSyncId}` remains valid,
- * while every explicit queued result requires a WAL correlation.
- */
-export type CommitResult = MutationCommitResultInput;
-export type { MutationOptions } from '../transaction/resources/mutationOptions.js';
-import type { MutationOptions } from '../transaction/resources/mutationOptions.js';
-/**
- * The subset of {@link MutationOptions} that travels with each write as it is
- * queued offline and sent on the wire. A single shared type keeps the public
- * parameters, the offline queue, and the wire format from diverging. `wait` and
- * `claim` are deliberately absent: both are resolved on the client before a write
- * is staged, so neither reaches this layer.
- */
-export type WriteOptions = Pick<MutationOptions, 'readAt' | 'onStale' | 'idempotencyKey' | 'label' | 'fenceToken'>;
-/** A single mutation within a batch. Its `options` travel with it so the server
- *  can cache and replay the operation for idempotent retries. */
-export interface MutationOperation {
-    type: string;
-    model: string;
-    id: string;
-    input?: Record<string, unknown>;
-    /**
-     * A client-side id for this single operation. The server stamps it onto the
-     * resulting `sync_deltas.transaction_id`, so when the confirming delta arrives
-     * back over the sync stream the client can recognize it as an echo of its own
-     * optimistic write and skip re-applying it locally.
-     *
-     * This is distinct from the batch-level `client_tx_id` that idempotency uses:
-     * that key de-duplicates a retried batch (a request-level cache), whereas this
-     * id identifies one row within a batch (for echo matching). Both can appear on
-     * the wire at once.
-     */
-    transactionId?: string;
-    readAt?: number | null;
-    onStale?: OnStaleMode | null;
-    /**
-     * The fencing token (Option B) carried on the wire for this op — the held
-     * claim's token, validated against the entity's high-water at commit.
-     */
-    fenceToken?: number | null;
-    /**
-     * Per-operation idempotency and audit metadata. `idempotencyKey` is also the
-     * cache key the server uses to de-duplicate retries; `label` is stored for
-     * debugging. These are the only {@link MutationOptions} fields sent on the wire.
-     */
-    options?: Pick<MutationOptions, 'idempotencyKey' | 'label'>;
-}
-/**
- * The transport that carries mutations to your backend. The SDK calls the
- * methods on this interface; you implement them over whatever transport you use —
- * an HTTP API, a WebSocket, or something else.
- */
-export interface MutationExecutor {
-    /**
-     * Commits a batch of mutations atomically and returns the sync
-     * acknowledgement. The `options` argument applies to the whole batch, while
-     * per-operation `idempotencyKey` and `label` live on each
-     * {@link MutationOperation}. The method name matches the `{ type: 'commit' }`
-     * frame on the wire.
-     */
-    commit(operations: MutationOperation[], options?: MutationOptions): Promise<CommitResult>;
-    /** Execute a create mutation for a specific model */
-    executeCreate(modelName: string, id: string, input: Record<string, unknown>, clientMutationId?: string, options?: MutationOptions): Promise<void>;
-    /** Execute an update mutation for a specific model */
-    executeUpdate(modelName: string, modelId: string, data: Record<string, unknown>, clientMutationId?: string, options?: MutationOptions): Promise<CommitResult | null>;
-    /** Execute a delete mutation for a specific model */
-    executeDelete(modelName: string, modelId: string, clientMutationId?: string, options?: MutationOptions): Promise<void>;
-    /** Execute an archive mutation for a specific model */
-    executeArchive(modelName: string, modelId: string, clientMutationId?: string, options?: MutationOptions): Promise<void>;
-    /** Execute an unarchive mutation for a specific model */
-    executeUnarchive(modelName: string, modelId: string, clientMutationId?: string, options?: MutationOptions): Promise<void>;
-    /** Upload an attachment (optional, not all consumers need this) */
-    uploadAttachment?(id: string, input: Record<string, unknown>): Promise<{
-        url: string;
-    }>;
-    /** Batch upload attachments (optional) */
-    batchUploadAttachments?(items: {
-        id: string;
-        input: Record<string, unknown>;
-    }[]): Promise<{
-        id: string;
-        url: string;
-    }[]>;
-    /** Delete a subscription entity */
-    deleteSubscription?(entityType: string, entityId: string, txId: string): Promise<void>;
-    /** Delete a favorite entity */
-    deleteFavorite?(modelId: string, txId: string): Promise<void>;
-    /** Register a callback for session expiry detection */
-    onSessionExpired?(callback: () => void): void;
-}
-/**
- * Application-specific configuration for the sync engine, describing how your
- * models relate so the engine can order and merge writes correctly.
- */
-export interface RuntimeConfig {
-    /**
-     * The order in which to create models, so a row is never inserted before the
-     * parent row its foreign key points at. Keyed by each model's type name, with
-     * lower numbers created first, so parents precede children. The engine fills
-     * this in automatically by walking the schema's `belongsTo` relations — a model
-     * with no parents gets 10, its children 20, their children 30, and so on,
-     * stepping by 10 to leave room for overrides. You rarely set this by hand;
-     * override it only when a relation the schema can't see (such as a polymorphic
-     * foreign key) imposes an ordering the engine wouldn't otherwise know about.
-     */
-    modelCreatePriority: ReadonlyMap<string, number>;
-    /**
-     * The create priority for a model not listed in {@link modelCreatePriority}.
-     * It sits in the middle of the range, so an unlisted model is created after
-     * declared parents but before declared grandchildren — a safe default.
-     */
-    defaultCreatePriority: number;
-    /**
-     * The priority for update, delete, archive, and unarchive operations. These
-     * need no ordering among themselves — the row already exists when they run —
-     * so this is set higher than any create priority to ensure creates go first.
-     */
-    defaultNonCreatePriority: number;
-    /**
-     * Fields to preserve when merging a partial update into the local store. A
-     * change usually carries only the fields that changed; listing a model's
-     * essential fields here keeps them from being dropped during that merge.
-     * For example: `{ Task: ['title', 'projectId'], Section: ['reportId', 'order'] }`.
-     */
-    essentialFields: Readonly<Record<string, readonly string[]>>;
-    /**
-     * A fallback map from class name to model name, used to resolve a model's name
-     * when the usual lookup fails — for instance, when a bundler has minified the
-     * class names. For example: `{ TaskModel: 'Task', ProjectModel: 'Project' }`.
-     */
-    classNameFallbackMap: Readonly<Record<string, string>>;
-    /**
-     * The content hash of the schema this client was built against — the same hash
-     * the `ablo push` command and the server compute. It exists only to detect
-     * schema drift: if the server reports a different active hash when the client
-     * connects, the SDK warns you to run `ablo push`, so drift surfaces as a clear
-     * message rather than a confusing database error later. It is advisory, not
-     * enforced.
-     */
-    expectedSchemaHash?: string;
-    /**
-     * Set only when the bound schema is a projection (`selectModels`/`omitModels`):
-     * the content hash of the full source schema the subset was cut from. A subset
-     * hashes differently from its full schema, so without this a projection-bound
-     * client always reports drift against a server running the full schema. The
-     * drift check treats the client as in-sync when the server's active hash
-     * matches either `expectedSchemaHash` or this source hash. Advisory, like the
-     * hash above.
-     */
-    expectedSourceSchemaHash?: string;
-    /**
-     * Per-model content hashes of the schema this client was built against,
-     * keyed by schema key (`tasks` → hash of that model's serialized JSON). The
-     * semantic layer of the drift check: on a whole-schema mismatch the client
-     * compares only the models IT declares against the server's per-model
-     * surface, so a purely additive server-side change (new models this build
-     * never references) is silence, and real divergence names the exact models.
-     * Advisory, like the hashes above.
-     */
-    expectedModelHashes?: Readonly<Record<string, string>>;
-}
-/**
- * Extends the WebSocket event map with your own collaboration events, such as
- * cursor positions or selections, beyond the core delta, presence, and
- * bootstrap events.
- */
-export interface WebSocketEventConfig {
-    /** Additional event type names beyond the core delta/presence/bootstrap events */
-    customEventTypes?: readonly string[];
-}
-/** @deprecated Renamed to {@link Logger}. Removed in 0.36.0. */
-export type SyncLogger = Logger;
-/** @deprecated Renamed to {@link ObservabilityProvider}. Removed in 0.36.0. */
-export type SyncObservabilityProvider = ObservabilityProvider;
-/** @deprecated Renamed to {@link Analytics}. Removed in 0.36.0. */
-export type SyncAnalytics = Analytics;
-/** @deprecated Renamed to {@link RuntimeConfig}. Removed in 0.36.0. */
-export type SyncEngineConfig = RuntimeConfig;
-/** @deprecated Renamed to {@link BreadcrumbCategory}. Removed in 0.36.0. */
-export type SyncBreadcrumbCategory = BreadcrumbCategory;

package/dist/interfaces/index.js

@@ -1,9 +0,0 @@
-/**
- * The interfaces you implement to plug the SDK into your own environment.
- *
- * The SDK depends on these contracts rather than any specific framework, so you
- * provide the concrete implementations — logging, observability, analytics,
- * session-error detection, online-status checks, and the transport that carries
- * mutations to your backend. The SDK ships sensible no-op defaults where it can.
- */
-export {};

package/dist/keys/index.d.ts

@@ -1 +0,0 @@
-export * from '../transaction/keys/index.js';

package/dist/keys/index.js

@@ -1,8 +0,0 @@
-// Moved to @ablo/transaction (ADR 0013 — the settlement core extraction).
-// This shim re-exports it at the original path so in-package importers of
-// `keys/index.js` keep working; rewire to `@ablo/transaction/keys`
-// and delete this shim once the core package is fully wired.
-//
-// Line comments on purpose: tsc copies a leading JSDoc block into the
-// published `.d.ts`, and this note names a package npm has never heard of.
-export * from '../transaction/keys/index.js';

package/dist/mutators/RecordingMutation.d.ts

@@ -1,36 +0,0 @@
-/**
- * Wraps a {@link Transaction} and records the inverse of every write so the
- * change can be undone. Each write is observed just before it runs, to snapshot
- * the previous state, and just after, to record the forward operation for redo.
- *
- * The mutator sees an ordinary `Transaction<S>` and is unaware it is being
- * recorded. When the mutator returns, the caller reads
- * {@link RecordingMutation.getEntry} and pushes the result onto the active
- * {@link UndoScope}.
- *
- * The snapshots are taken here rather than in the undo scope because they must
- * exist before the write lands: the inverse of an update needs the field's
- * previous values, and the inverse of a delete needs the full row. The inverse
- * of a create is just a delete by id, but that id is known only after creation,
- * since the schema generates one when the caller omits it.
- */
-import type { Schema } from '../transaction/schema/schema.js';
-import type { SyncStoreContract } from '../react/context.js';
-import type { Transaction } from './Transaction.js';
-import type { UndoEntry } from './UndoManager.js';
-export interface RecordingMutation<S extends Schema> {
-    /** The wrapped transaction — pass this into the mutator. */
-    tx: Transaction<S>;
-    /**
-     * Finalize the recording. Returns the captured entry or `null` if the
-     * mutator made no reversible writes (skip the push to save memory).
-     */
-    getEntry: (label?: string) => UndoEntry | null;
-}
-/**
- * Builds a transaction that records the forward and inverse of each write as it
- * runs. Use this only when the mutator should be undoable; a read-only or
- * side-effect-only mutator should call {@link createTransaction} directly to skip
- * the bookkeeping.
- */
-export declare function createRecordingMutation<S extends Schema>(schema: S, store: SyncStoreContract, organizationId: string): RecordingMutation<S>;

package/dist/mutators/RecordingMutation.js

@@ -1,182 +0,0 @@
-/**
- * Wraps a {@link Transaction} and records the inverse of every write so the
- * change can be undone. Each write is observed just before it runs, to snapshot
- * the previous state, and just after, to record the forward operation for redo.
- *
- * The mutator sees an ordinary `Transaction<S>` and is unaware it is being
- * recorded. When the mutator returns, the caller reads
- * {@link RecordingMutation.getEntry} and pushes the result onto the active
- * {@link UndoScope}.
- *
- * The snapshots are taken here rather than in the undo scope because they must
- * exist before the write lands: the inverse of an update needs the field's
- * previous values, and the inverse of a delete needs the full row. The inverse
- * of a create is just a delete by id, but that id is known only after creation,
- * since the schema generates one when the caller omits it.
- */
-import { createTransaction } from './Transaction.js';
-/**
- * Builds a transaction that records the forward and inverse of each write as it
- * runs. Use this only when the mutator should be undoable; a read-only or
- * side-effect-only mutator should call {@link createTransaction} directly to skip
- * the bookkeeping.
- */
-export function createRecordingMutation(schema, store, organizationId) {
-    const inverses = [];
-    const forwards = [];
-    const inner = createTransaction(schema, store, organizationId);
-    // Wrap mutations with a Proxy that intercepts each model key's
-    // methods. We keep `inner.read` as-is — reads don't need recording.
-    const mutateProxy = new Proxy({}, {
-        get(_target, prop) {
-            if (typeof prop !== 'string')
-                return undefined;
-            const innerMutate = inner.mutations[prop];
-            if (!innerMutate)
-                return innerMutate;
-            return wrapMutateForKey(prop, innerMutate, store, inverses, forwards);
-        },
-    });
-    return {
-        tx: { mutations: mutateProxy, read: inner.read },
-        getEntry: (label) => {
-            if (inverses.length === 0)
-                return null;
-            // Undo applies the inverses in reverse order of the forward writes; redo
-            // applies the forwards in their original order.
-            return { label, inverses: [...inverses].reverse(), forwards: [...forwards] };
-        },
-    };
-}
-// ── Per-key wrapper ────────────────────────────────────────────────────────
-function wrapMutateForKey(modelKey, mutate, store, inverses, forwards) {
-    const snapshot = (id) => {
-        const model = store.pool.get(id);
-        if (!model)
-            return null;
-        // toJSON produces a plain object suitable for re-creating the row. The
-        // delete→create inverse needs every field, which is exactly what it returns.
-        return model.toJSON();
-    };
-    // Captures the before-image for an undo inverse, delegating to the model's
-    // shared `capturePreviousValues`. `fallbackToLive` is enabled here so that a
-    // field that was neither pre-mutated nor present in the original snapshot falls
-    // back to its current value as a last resort.
-    const snapshotFields = (id, fieldNames) => {
-        const model = store.pool.get(id);
-        if (!model)
-            return null;
-        return model.capturePreviousValues(fieldNames, { fallbackToLive: true });
-    };
-    // After an update succeeds, clear the modified-field markers it was snapshotted
-    // from, so the next write to the same row sees this update's result as its
-    // baseline rather than the older pre-update value. The queue has already taken
-    // its own frozen copy, so clearing here is safe.
-    const consumeModifiedFields = (id, fieldNames) => {
-        store.pool.get(id)?.consumeModifiedFields(fieldNames);
-    };
-    return {
-        // Overloaded — single row or array. The recorder dispatches the
-        // matching forward/inverse op shape (`create`/`createMany`,
-        // `update`/`updateMany`, `delete`/`deleteMany`) so the persisted
-        // undo entry is symmetric with what was originally invoked.
-        create: (async (data) => {
-            if (Array.isArray(data)) {
-                const created = await mutate.create(data);
-                const withIds = created.map((m, i) => ({
-                    ...data[i],
-                    id: m.id,
-                }));
-                const ids = created.map((m) => m.id);
-                forwards.push({ kind: 'createMany', modelKey, data: withIds });
-                inverses.push({ kind: 'deleteMany', modelKey, ids });
-                return created;
-            }
-            const created = await mutate.create(data);
-            const id = created.id;
-            forwards.push({
-                kind: 'create',
-                modelKey,
-                data: { ...data, id },
-            });
-            inverses.push({ kind: 'delete', modelKey, id });
-            return created;
-        }),
-        update: (async (patch) => {
-            if (Array.isArray(patch)) {
-                // Snapshot every row's previous values before applying any patch: later
-                // patches in the same list would corrupt an earlier one's inverse if the
-                // snapshots were taken lazily.
-                const prevPatches = [];
-                for (const p of patch) {
-                    const fields = Object.keys(p).filter((k) => k !== 'id');
-                    const prev = snapshotFields(p.id, fields);
-                    if (prev)
-                        prevPatches.push({ id: p.id, ...prev });
-                }
-                const updated = await mutate.update(patch);
-                const forwardPatches = patch.map((p) => ({ ...p }));
-                for (const p of forwardPatches) {
-                    consumeModifiedFields(p.id, Object.keys(p).filter((k) => k !== 'id'));
-                }
-                forwards.push({ kind: 'updateMany', modelKey, patches: forwardPatches });
-                if (prevPatches.length > 0) {
-                    inverses.push({ kind: 'updateMany', modelKey, patches: prevPatches });
-                }
-                return updated;
-            }
-            const id = patch.id;
-            const fields = Object.keys(patch).filter((k) => k !== 'id');
-            const prev = snapshotFields(id, fields);
-            const updated = await mutate.update(patch);
-            const patchCopy = {
-                id,
-                ...patch,
-            };
-            consumeModifiedFields(id, fields);
-            forwards.push({ kind: 'update', modelKey, patch: patchCopy });
-            if (prev) {
-                inverses.push({ kind: 'update', modelKey, patch: { id, ...prev } });
-            }
-            return updated;
-        }),
-        delete: (async (idOrIds) => {
-            if (Array.isArray(idOrIds)) {
-                const prevs = idOrIds
-                    .map((id) => snapshot(id))
-                    .filter((d) => d !== null);
-                await mutate.delete(idOrIds);
-                forwards.push({ kind: 'deleteMany', modelKey, ids: [...idOrIds] });
-                if (prevs.length > 0) {
-                    inverses.push({ kind: 'createMany', modelKey, data: prevs });
-                }
-                return;
-            }
-            const prev = snapshot(idOrIds);
-            await mutate.delete(idOrIds);
-            forwards.push({ kind: 'delete', modelKey, id: idOrIds });
-            if (prev) {
-                inverses.push({ kind: 'create', modelKey, data: prev });
-            }
-        }),
-        archive: async (id) => {
-            await mutate.archive(id);
-            forwards.push({
-                kind: 'update',
-                modelKey,
-                patch: { id, archivedAt: new Date() },
-            });
-            // Inverse of archive is unarchive, modeled here as a "restore" update.
-            inverses.push({ kind: 'update', modelKey, patch: { id, archivedAt: null } });
-        },
-        unarchive: async (id) => {
-            await mutate.unarchive(id);
-            forwards.push({ kind: 'update', modelKey, patch: { id, archivedAt: null } });
-            inverses.push({
-                kind: 'update',
-                modelKey,
-                patch: { id, archivedAt: new Date() },
-            });
-        },
-    };
-}

package/dist/mutators/Transaction.d.ts

@@ -1,40 +0,0 @@
-/**
- * The typed transaction object passed to a custom mutator. A mutator receives
- * `{ tx, args }` and uses `tx.mutations.<modelKey>.*` to write and
- * `tx.read.<modelKey>.*` to take synchronous snapshots of the current data.
- *
- * Writes are applied eagerly as they are called, with no buffering: if a mutator
- * throws partway through, the writes it already made stand. Reads are synchronous
- * snapshots and use a fast index lookup where one is available for the field.
- *
- * The write surface deliberately works one row at a time. To write a batch,
- * compose the calls yourself — `Promise.all(rows.map((r) => tx.mutations.x.create(r)))`.
- * Every call stages its write in the same synchronous tick and the engine
- * coalesces them into a single commit on the wire, so there is no separate
- * bulk-insert method to learn.
- */
-import type { Schema } from '../transaction/schema/schema.js';
-import type { SyncStoreContract } from '../react/context.js';
-import { type MutateActions } from './mutateActions.js';
-import { type ReaderActions, type ReaderFindOptions } from './readerActions.js';
-/**
- * The full transaction surface: `tx.mutations.<key>.*` for writes and
- * `tx.read.<key>.*` for reads. It also re-exports the read-options type so a
- * mutator author can type a `where` payload without importing it separately. The
- * property is named `mutations` to match the corresponding React hook.
- */
-export interface Transaction<S extends Schema> {
-    mutations: {
-        [K in keyof S['models'] & string]: MutateActions<S, K>;
-    };
-    read: {
-        [K in keyof S['models'] & string]: ReaderActions<S, K>;
-    };
-}
-export type { ReaderFindOptions };
-/**
- * Builds a {@link Transaction} for a single mutator invocation. The returned
- * object creates each model's actions lazily on first access, so a mutator pays
- * nothing for the models it never touches.
- */
-export declare function createTransaction<S extends Schema>(schema: S, store: SyncStoreContract, organizationId: string): Transaction<S>;

package/dist/mutators/Transaction.js

@@ -1,58 +0,0 @@
-/**
- * The typed transaction object passed to a custom mutator. A mutator receives
- * `{ tx, args }` and uses `tx.mutations.<modelKey>.*` to write and
- * `tx.read.<modelKey>.*` to take synchronous snapshots of the current data.
- *
- * Writes are applied eagerly as they are called, with no buffering: if a mutator
- * throws partway through, the writes it already made stand. Reads are synchronous
- * snapshots and use a fast index lookup where one is available for the field.
- *
- * The write surface deliberately works one row at a time. To write a batch,
- * compose the calls yourself — `Promise.all(rows.map((r) => tx.mutations.x.create(r)))`.
- * Every call stages its write in the same synchronous tick and the engine
- * coalesces them into a single commit on the wire, so there is no separate
- * bulk-insert method to learn.
- */
-import { createMutateActions } from './mutateActions.js';
-import { createReaderActions } from './readerActions.js';
-import { AbloValidationError } from '../transaction/errors.js';
-/**
- * Builds a {@link Transaction} for a single mutator invocation. The returned
- * object creates each model's actions lazily on first access, so a mutator pays
- * nothing for the models it never touches.
- */
-export function createTransaction(schema, store, organizationId) {
-    const mutateCache = new Map();
-    const readCache = new Map();
-    const mutations = new Proxy({}, {
-        get(_target, prop) {
-            if (typeof prop !== 'string')
-                return undefined;
-            const cached = mutateCache.get(prop);
-            if (cached)
-                return cached;
-            if (!(prop in schema.models)) {
-                throw new AbloValidationError(`Transaction.mutations: unknown model key "${prop}". Known keys: ${Object.keys(schema.models).join(', ')}`, { code: 'transaction_mutate_unknown_model' });
-            }
-            const actions = createMutateActions(schema, prop, store, organizationId);
-            mutateCache.set(prop, actions);
-            return actions;
-        },
-    });
-    const read = new Proxy({}, {
-        get(_target, prop) {
-            if (typeof prop !== 'string')
-                return undefined;
-            const cached = readCache.get(prop);
-            if (cached)
-                return cached;
-            if (!(prop in schema.models)) {
-                throw new AbloValidationError(`Transaction.read: unknown model key "${prop}". Known keys: ${Object.keys(schema.models).join(', ')}`, { code: 'transaction_read_unknown_model' });
-            }
-            const actions = createReaderActions(schema, prop, store);
-            readCache.set(prop, actions);
-            return actions;
-        },
-    });
-    return { mutations, read };
-}