@abloatai/transaction 0.37.0

package/dist/schema/tenancy.js

@@ -0,0 +1,191 @@
+/**
+ * Defines how a model's rows are scoped to a tenant. Two forms live here, and the
+ * separation between them is deliberate:
+ *
+ *   1. The canonical form, {@link Tenancy} — a discriminated union that every
+ *      consumer reads (provisioning and row-level security, introspection, the
+ *      runtime, and the CLI) and the shape that crosses the wire in `ModelJSON`.
+ *      One exhaustively switchable shape, so the type system enforces the isolation
+ *      boundary.
+ *   2. The authoring form, {@link PolicyInput} — the `policy: { by }` option a
+ *      schema author writes. The name follows SQL row-level security, where a
+ *      policy is the rule that decides which rows a tenant may read.
+ *      {@link resolvePolicy} converts it to the canonical {@link Tenancy} when the
+ *      model is built, so the authoring vocabulary never reaches the wire or any
+ *      consumer.
+ *
+ * The canonical form is an exhaustively switchable discriminated union, so the type
+ * system enforces the isolation boundary at every consumer. The authoring form is a
+ * flat object whose `by` names the choice and whose per-branch rules are checked by a
+ * refinement — the opt-out from tenant scoping (`{ by: 'none' }`) and the
+ * source-derived case (`{ by: 'source' }`) are explicit, named values rather than
+ * falsy flags, important because `none` makes an entire table readable across tenants.
+ */
+import { z } from 'zod';
+/** The default physical tenancy column. This is the single canonical definition of that column name. */
+export const DEFAULT_ORG_COLUMN = 'organization_id';
+/**
+ * Scopes a table's rows through a parent table, for rows that carry no tenancy
+ * column of their own (for example, blocks scoped through their section, report,
+ * and organization). This is the canonical `parent` payload; authors write the
+ * friendlier {@link PolicyInput} `{ by: 'parent', fk, parent }` form, which
+ * {@link resolvePolicy} normalizes into this.
+ */
+export const scopedViaRefSchema = z.object({
+    /** Column on this table that points at the parent (for example, `'team_id'`). */
+    localKey: z.string().min(1),
+    /** Parent table name (e.g. `'team'`). */
+    parentTable: z.string().min(1),
+    /** Column on the parent that `localKey` references. Default `'id'`. */
+    parentKey: z.string().min(1).optional(),
+    /** Column on the parent holding the tenant id. Default {@link DEFAULT_ORG_COLUMN}. */
+    parentOrgColumn: z.string().min(1).optional(),
+});
+/** How a model's rows are scoped to a tenant — the canonical, wire-facing form. */
+export const tenancySchema = z.discriminatedUnion('kind', [
+    /** Row-local tenancy column (default name `organization_id`, overridable). */
+    z.object({ kind: z.literal('column'), column: z.string().min(1) }),
+    /** Scoped through a parent table's tenancy. */
+    z.object({ kind: z.literal('parent'), via: scopedViaRefSchema }),
+    /** Not tenant-scoped (global / reference data). */
+    z.object({ kind: z.literal('none') }),
+    /**
+     * Scoped by the data source itself: the model carries no tenancy column, and the
+     * owning organization is derived from the connected source that registered it — the
+     * registration is the tenant boundary. This is the natural default for a
+     * single-tenant connected database (`ablo connect`), which holds one org's rows and
+     * so has no per-row `organization_id` to read. Carries no payload for the same
+     * reason `none` does: the binding lives in the source registration, not the model.
+     */
+    z.object({ kind: z.literal('source') }),
+]);
+/**
+ * The authoring form of tenancy — what a schema author writes as the model's
+ * `policy` option. The name follows SQL row-level security, where a policy is the
+ * rule that decides which rows a tenant may read.
+ *
+ * The four choices `by` can take:
+ *
+ * - `{ by: 'column' }` — a row-local tenancy column (the default). `column`
+ *   overrides the name (default {@link DEFAULT_ORG_COLUMN}).
+ * - `{ by: 'parent', fk, parent }` — inherit tenancy through a foreign key when
+ *   this table has no tenancy column of its own. `parentKey` (default `'id'`) and
+ *   `parentTenantColumn` (default {@link DEFAULT_ORG_COLUMN}) are optional overrides.
+ * - `{ by: 'source' }` — derive the organization from the connected source that
+ *   registered the model, for a single-tenant connected database that carries no
+ *   `organization_id` column. The registration is the tenant boundary.
+ * - `{ by: 'none' }` — genuinely global or reference data. This makes the whole
+ *   table readable across tenants, so it is correct only for tables that have no tenant.
+ *
+ * The runtime schema is one flat object rather than a discriminated union: `by`
+ * selects the branch, and the {@link https://zod.dev | superRefine} pass enforces
+ * the per-branch field rules (`parent` requires `fk` and `parent`; the other three
+ * take no branch fields). The exported {@link PolicyInput} type is hand-written as a
+ * precise union so the compiler still requires the right fields per `by` — the flat
+ * schema validates at runtime, the union guides at author time, and the type guard
+ * below keeps the two from drifting.
+ */
+export const policyInputSchema = z
+    .object({
+    by: z.enum(['column', 'parent', 'none', 'source']),
+    /** `by: 'column'` — override the physical tenancy column name. Default {@link DEFAULT_ORG_COLUMN}. */
+    column: z.string().min(1).optional(),
+    /** `by: 'parent'` — column on this table that points at the parent (for example, `'sectionId'`). */
+    fk: z.string().min(1).optional(),
+    /** `by: 'parent'` — parent table name (e.g. `'sections'`). */
+    parent: z.string().min(1).optional(),
+    /** `by: 'parent'` — column on the parent that `fk` references. Default `'id'`. */
+    parentKey: z.string().min(1).optional(),
+    /** `by: 'parent'` — column on the parent holding the tenant id. Default {@link DEFAULT_ORG_COLUMN}. */
+    parentTenantColumn: z.string().min(1).optional(),
+})
+    .superRefine((policy, ctx) => {
+    if (policy.by === 'parent') {
+        if (!policy.fk) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ['fk'],
+                message: "A `by: 'parent'` policy needs `fk` — the column on this table that points at the parent row whose tenancy it inherits.",
+            });
+        }
+        if (!policy.parent) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ['parent'],
+                message: "A `by: 'parent'` policy needs `parent` — the name of the parent table this table is scoped through.",
+            });
+        }
+    }
+    // A `column` policy may carry `column`; the parent fields belong only to `parent`.
+    // Flag a field that landed on the wrong branch so a typo doesn't silently no-op.
+    const parentOnly = ['fk', 'parent', 'parentKey', 'parentTenantColumn'];
+    if (policy.by !== 'parent') {
+        for (const field of parentOnly) {
+            if (policy[field] !== undefined) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    path: [field],
+                    message: `\`${field}\` only applies to a \`by: 'parent'\` policy; remove it or set \`by: 'parent'\`.`,
+                });
+            }
+        }
+    }
+    if (policy.by !== 'column' && policy.column !== undefined) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['column'],
+            message: "`column` only applies to a `by: 'column'` policy; remove it or set `by: 'column'`.",
+        });
+    }
+});
+const _policyInputAssignable = [
+    true,
+    true,
+];
+void _policyInputAssignable;
+/**
+ * Normalizes the authoring {@link PolicyInput} into the canonical {@link Tenancy}.
+ * Called once, when the model is built, so that `ModelDef`, `ModelJSON`, and every
+ * consumer see only the canonical union. Omitting `policy` defaults to a row-local
+ * `organization_id` column.
+ */
+export function resolvePolicy(input) {
+    if (!input)
+        return { kind: 'column', column: DEFAULT_ORG_COLUMN };
+    switch (input.by) {
+        case 'column':
+            return { kind: 'column', column: input.column ?? DEFAULT_ORG_COLUMN };
+        case 'parent':
+            return {
+                kind: 'parent',
+                via: {
+                    localKey: input.fk,
+                    parentTable: input.parent,
+                    parentKey: input.parentKey,
+                    parentOrgColumn: input.parentTenantColumn,
+                },
+            };
+        case 'source':
+            return { kind: 'source' };
+        case 'none':
+            return { kind: 'none' };
+    }
+}
+/**
+ * Reads the canonical {@link Tenancy} off an already-built model definition (or a
+ * parsed `ModelJSON`), defaulting to a row-local `organization_id` column when it is
+ * absent.
+ *
+ * This is the read-side helper. Consumers — provisioning and row-level security, the
+ * membership resolver, DDL generation, and the CLI — call it to get a model's
+ * tenancy without re-deriving the default each time. It is not the authoring
+ * normalizer; that is {@link resolvePolicy}.
+ */
+export function resolveTenancy(def) {
+    return def.tenancy ?? { kind: 'column', column: DEFAULT_ORG_COLUMN };
+}
+/** The physical tenancy column for a column-scoped model, else `null`. */
+export function tenancyColumn(t) {
+    return t.kind === 'column' ? t.column : null;
+}
+//# sourceMappingURL=tenancy.js.map

package/dist/schema/tenancy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tenancy.js","sourceRoot":"","sources":["../../src/schema/tenancy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,wGAAwG;AACxG,MAAM,CAAC,MAAM,kBAAkB,GAAG,iBAAiB,CAAC;AAEpD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC;IACzC,iFAAiF;IACjF,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC3B,yCAAyC;IACzC,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC9B,uEAAuE;IACvE,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;IACvC,sFAAsF;IACtF,eAAe,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;CAC9C,CAAC,CAAC;AAGH,mFAAmF;AACnF,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,CAAC,kBAAkB,CAAC,MAAM,EAAE;IACxD,8EAA8E;IAC9E,CAAC,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;IAClE,+CAA+C;IAC/C,CAAC,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,GAAG,EAAE,kBAAkB,EAAE,CAAC;IAChE,mDAAmD;IACnD,CAAC,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;IACrC;;;;;;;OAOG;IACH,CAAC,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;CACxC,CAAC,CAAC;AAGH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC;KAC/B,MAAM,CAAC;IACN,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;IAClD,sGAAsG;IACtG,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;IACpC,oGAAoG;IACpG,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;IAChC,8DAA8D;IAC9D,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;IACpC,kFAAkF;IAClF,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;IACvC,uGAAuG;IACvG,kBAAkB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;CACjD,CAAC;KACD,WAAW,CAAC,CAAC,MAAM,EAAE,GAAG,EAAE,EAAE;IAC3B,IAAI,MAAM,CAAC,EAAE,KAAK,QAAQ,EAAE,CAAC;QAC3B,IAAI,CAAC,MAAM,CAAC,EAAE,EAAE,CAAC;YACf,GAAG,CAAC,QAAQ,CAAC;gBACX,IAAI,EAAE,CAAC,CAAC,YAAY,CAAC,MAAM;gBAC3B,IAAI,EAAE,CAAC,IAAI,CAAC;gBACZ,OAAO,EACL,wHAAwH;aAC3H,CAAC,CAAC;QACL,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;YACnB,GAAG,CAAC,QAAQ,CAAC;gBACX,IAAI,EAAE,CAAC,CAAC,YAAY,CAAC,MAAM;gBAC3B,IAAI,EAAE,CAAC,QAAQ,CAAC;gBAChB,OAAO,EACL,qGAAqG;aACxG,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IACD,mFAAmF;IACnF,iFAAiF;IACjF,MAAM,UAAU,GAAG,CAAC,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,oBAAoB,CAAU,CAAC;IAChF,IAAI,MAAM,CAAC,EAAE,KAAK,QAAQ,EAAE,CAAC;QAC3B,KAAK,MAAM,KAAK,IAAI,UAAU,EAAE,CAAC;YAC/B,IAAI,MAAM,CAAC,KAAK,CAAC,KAAK,SAAS,EAAE,CAAC;gBAChC,GAAG,CAAC,QAAQ,CAAC;oBACX,IAAI,EAAE,CAAC,CAAC,YAAY,CAAC,MAAM;oBAC3B,IAAI,EAAE,CAAC,KAAK,CAAC;oBACb,OAAO,EAAE,KAAK,KAAK,kFAAkF;iBACtG,CAAC,CAAC;YACL,CAAC;QACH,CAAC;IACH,CAAC;IACD,IAAI,MAAM,CAAC,EAAE,KAAK,QAAQ,IAAI,MAAM,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;QAC1D,GAAG,CAAC,QAAQ,CAAC;YACX,IAAI,EAAE,CAAC,CAAC,YAAY,CAAC,MAAM;YAC3B,IAAI,EAAE,CAAC,QAAQ,CAAC;YAChB,OAAO,EAAE,oFAAoF;SAC9F,CAAC,CAAC;IACL,CAAC;AACH,CAAC,CAAC,CAAC;AAqBL,MAAM,sBAAsB,GAA6D;IACvF,IAAI;IACJ,IAAI;CACL,CAAC;AACF,KAAK,sBAAsB,CAAC;AAE5B;;;;;GAKG;AACH,MAAM,UAAU,aAAa,CAAC,KAAmB;IAC/C,IAAI,CAAC,KAAK;QAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,kBAAkB,EAAE,CAAC;IAClE,QAAQ,KAAK,CAAC,EAAE,EAAE,CAAC;QACjB,KAAK,QAAQ;YACX,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,IAAI,kBAAkB,EAAE,CAAC;QACxE,KAAK,QAAQ;YACX,OAAO;gBACL,IAAI,EAAE,QAAQ;gBACd,GAAG,EAAE;oBACH,QAAQ,EAAE,KAAK,CAAC,EAAE;oBAClB,WAAW,EAAE,KAAK,CAAC,MAAM;oBACzB,SAAS,EAAE,KAAK,CAAC,SAAS;oBAC1B,eAAe,EAAE,KAAK,CAAC,kBAAkB;iBAC1C;aACF,CAAC;QACJ,KAAK,QAAQ;YACX,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;QAC5B,KAAK,MAAM;YACT,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAC5B,CAAC;AACH,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,cAAc,CAAC,GAA0B;IACvD,OAAO,GAAG,CAAC,OAAO,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,kBAAkB,EAAE,CAAC;AACvE,CAAC;AAED,0EAA0E;AAC1E,MAAM,UAAU,aAAa,CAAC,CAAU;IACtC,OAAO,CAAC,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC;AAC/C,CAAC"}

package/dist/server/adapter.d.ts

@@ -0,0 +1,174 @@
+/**
+ * `@abloatai/transaction/server` — the `DataAdapter` storage contract.
+ *
+ * A `DataAdapter` is the boundary between the sync engine and a database. The
+ * engine asks it to do three things — `read` canonical rows, `commit` a change,
+ * and `sync` the change log — and expects nothing beyond that. Everything
+ * higher up, such as proposing a change or resolving a conflict, is handled
+ * before the adapter is ever called.
+ *
+ * This module declares the contract and the value types that travel through it;
+ * you supply the implementation for your own database. The reference Postgres
+ * implementation ships separately, because it carries a SQL driver and raw
+ * queries that have no place in this browser-safe build.
+ *
+ * Every shape here builds on {@link Row}, the single canonical form of a
+ * database row that the rest of the engine reads and writes.
+ */
+import type { SourceListQuery, SourceOperation, SourceRequestContext } from '../source/index.js';
+import type { ServerSyncDelta } from '../wire/delta.js';
+import type { BootstrapModel } from './readConfig.js';
+import type { CommitContext, CommitExecutionResult } from './commit.js';
+import type { StorageMode } from './storageMode.js';
+/**
+ * A canonical database row: one record, keyed by column name. The value type is
+ * `unknown` by design, not `any` — columns arrive as JSON or in whatever form
+ * the driver hands back, so a caller must narrow a value before using it. Reach
+ * for this type wherever a row is passed around; it is the one name for that
+ * shape, and a later schema-typed `read<T>()` can specialize it to a concrete
+ * model without changing any call site.
+ */
+export type Row = Record<string, unknown>;
+/**
+ * The result of a {@link Row} read. Its two shapes mirror the two kinds of
+ * {@link ReadRequest}:
+ *  - `bootstrap`: a full load, returned as a map from model name to its rows.
+ *  - `query`: the rows of a single filtered query.
+ */
+export type ReadResult = {
+    readonly kind: 'bootstrap';
+    /** model name → its rows. Empty models are omitted. */
+    readonly models: Record<string, Row[]>;
+    /** Models whose read failed (partial success), if any. */
+    readonly failedModels?: string[];
+    /**
+     * Present when a paged read (`ReadRequest.page`) stopped at its row
+     * limit with rows remaining: pass it back as the next page's cursor.
+     * Absent on the final page and on unpaged reads.
+     */
+    readonly nextCursor?: string;
+} | {
+    readonly kind: 'query';
+    readonly rows: readonly Row[];
+};
+/**
+ * Where a `sync` call resumes: the client's last-seen position in the
+ * `sync_deltas` change log. The cursor carries only that position. Everything
+ * else a sync needs — the organization, the sync groups, the largest gap it
+ * will stream — is bound onto the adapter when it is resolved, so a client can
+ * never ask to read an organization other than its own. A `lastSyncId` of zero
+ * or less means "no position yet", which `sync` answers with `needsFullRead`.
+ */
+export interface SyncCursor {
+    readonly lastSyncId: number;
+}
+export interface DataAdapterCapabilities {
+    /** The backend can dry-run a change without committing it. */
+    readonly propose?: boolean;
+    /** `commit` is atomic (all-or-nothing) across the change's operations. */
+    readonly transactions?: boolean;
+    /** Changes fan out in real time (vs poll-only). */
+    readonly realtime?: boolean;
+    /** The backend can be introspected for its schema. */
+    readonly schemaIntrospection?: boolean;
+}
+/** Result of a dry-run proposal (only adapters with `capabilities.propose`). */
+export interface ProposalResult {
+    readonly ok: boolean;
+    readonly conflicts?: readonly {
+        readonly model: string;
+        readonly id: string;
+        readonly reason: string;
+    }[];
+    readonly rows?: readonly Row[];
+}
+/**
+ * A request for canonical rows, in one of two shapes:
+ *  - `bootstrap`: the full-load reader — every enabled model's rows at once.
+ *  - `query`: a single filtered query against one model, used by the live
+ *    `/sync/query` path.
+ *
+ * A `query` carries its own execution as the `runHosted` closure, the same way
+ * a {@link ChangeSet} carries its write. This lets the adapter decide how to
+ * answer the request — a data source runs the customer's `list`, a hosted
+ * database runs the closure — without the query engine itself having to live
+ * inside the adapter.
+ */
+export type ReadRequest = {
+    readonly kind: 'bootstrap';
+    readonly models: readonly BootstrapModel[];
+    readonly requestedModels?: readonly string[];
+    readonly scope?: SourceRequestContext;
+    /**
+     * Keyset pagination for a SINGLE-model read (`requestedModels` names
+     * exactly one model): return at most `limit` rows, starting after the
+     * row whose id equals `cursor`. The result carries `nextCursor` while
+     * rows remain. Ignored for multi-model reads and by adapters whose
+     * backend pages upstream on its own.
+     */
+    readonly page?: {
+        readonly cursor?: string;
+        readonly limit: number;
+    };
+} | {
+    readonly kind: 'query';
+    readonly model: string;
+    /** Source-side model name, when it differs from `model`. */
+    readonly sourceModel?: string;
+    /** `__typename` stamped on each returned row. */
+    readonly typename: string;
+    readonly query: SourceListQuery;
+    readonly scope?: SourceRequestContext;
+    /** Runs the query against a hosted database: compile, take the tenant pool, apply row-level security, unpack the rows. */
+    readonly runHosted: () => Promise<Row[]>;
+};
+/**
+ * A change to apply to the canonical store. `runHosted` holds the write already
+ * bound to its execution: a hosted adapter simply runs it, while a data-source
+ * adapter ignores it and ships the operations to the customer's own endpoint.
+ * The adapter therefore decides how a change is applied, while the write logic
+ * itself is prepared above it.
+ */
+export interface ChangeSet {
+    readonly operations: readonly SourceOperation[];
+    readonly context: CommitContext;
+    readonly clientTxId: string;
+    readonly runHosted: () => Promise<CommitExecutionResult>;
+}
+export interface SyncResult {
+    /** Deltas in `(cursor.lastSyncId, nextCursor.lastSyncId]`, scoped to syncGroups. */
+    readonly changes: readonly ServerSyncDelta[];
+    readonly nextCursor: {
+        readonly lastSyncId: number;
+    };
+    /** True when the gap was too large to stream — caller must full-`read`. */
+    readonly needsFullRead: boolean;
+}
+/**
+ * The interface every storage mode implements. The package defines the
+ * contract; you implement it against your own database. An adapter is
+ * responsible for one thing — reaching the data — and offers exactly three
+ * methods to do it: `read` fetches canonical rows, `commit` applies a change,
+ * and `sync` reads the change log. Anything above that line, such as proposing
+ * a change or resolving a conflict, happens before the adapter is called.
+ * `propose` is an optional capability, not a required method.
+ */
+export interface DataAdapter {
+    /** Names the adapter's storage mode, for diagnostics. Routing is decided by
+     *  the resolver, not by reading this field. */
+    readonly mode: StorageMode;
+    readonly capabilities: DataAdapterCapabilities;
+    read(req: ReadRequest): Promise<ReadResult>;
+    commit(change: ChangeSet): Promise<CommitExecutionResult>;
+    sync(cursor: SyncCursor): Promise<SyncResult>;
+}
+/** A `DataAdapter` whose backend can dry-run a change. Narrow to this only after confirming the `propose` capability. */
+export interface ProposableDataAdapter extends DataAdapter {
+    propose(change: ChangeSet): Promise<ProposalResult>;
+}
+/** Resolves an authenticated scope to the adapter that serves it. */
+export type AdapterResolver = (scope: {
+    readonly projectId: string;
+    readonly accountScope?: string;
+}) => Promise<DataAdapter> | DataAdapter;
+//# sourceMappingURL=adapter.d.ts.map

package/dist/server/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../src/server/adapter.ts"],"names":[],"mappings":"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"}

package/dist/server/adapter.js

@@ -0,0 +1,19 @@
+/**
+ * `@abloatai/transaction/server` — the `DataAdapter` storage contract.
+ *
+ * A `DataAdapter` is the boundary between the sync engine and a database. The
+ * engine asks it to do three things — `read` canonical rows, `commit` a change,
+ * and `sync` the change log — and expects nothing beyond that. Everything
+ * higher up, such as proposing a change or resolving a conflict, is handled
+ * before the adapter is ever called.
+ *
+ * This module declares the contract and the value types that travel through it;
+ * you supply the implementation for your own database. The reference Postgres
+ * implementation ships separately, because it carries a SQL driver and raw
+ * queries that have no place in this browser-safe build.
+ *
+ * Every shape here builds on {@link Row}, the single canonical form of a
+ * database row that the rest of the engine reads and writes.
+ */
+export {};
+//# sourceMappingURL=adapter.js.map

package/dist/server/adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.js","sourceRoot":"","sources":["../../src/server/adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG"}

package/dist/server/commit.d.ts

@@ -0,0 +1,108 @@
+/**
+ * The commit contract types for the sync engine's server surface.
+ *
+ * {@link CommitContext} is the attribution envelope stamped onto every delta a
+ * commit produces; {@link CommitExecutionResult} is the receipt returned when the commit
+ * finishes. Both are plain data descriptors — no database driver, no SQL, no
+ * functions — so they belong to this package's public contract, which your commit
+ * implementation reads and writes. They feed the `ChangeSet` and `DataAdapter`
+ * contracts defined alongside them.
+ *
+ * The attribution fields reuse the shared {@link ParticipantKind},
+ * {@link ConfirmationState}, and {@link ParticipantRef} types, so the shape at
+ * commit time and the shape of a stored or broadcast delta share one definition
+ * rather than being kept in step by hand.
+ */
+import type { ParticipantKind, ConfirmationState } from '../log/syncDeltaRow.js';
+import type { ParticipantRef } from '../wire/delta.js';
+import type { CommitExecutionResultInput } from '../wire/commit.js';
+import type { Environment } from '../environment.js';
+import type { ReadDependency, TrackDependency } from '../coordination/schema.js';
+export interface CommitContext {
+    participantId: string;
+    /**
+     * The kind of participant making the commit. Required, so that every delta carries
+     * structured attribution rather than a string-prefix convention.
+     */
+    participantKind: ParticipantKind;
+    organizationId: string;
+    /**
+     * Project scope used to route source-mode storage. When omitted, the commit
+     * targets the organization's default project.
+     */
+    projectId?: string;
+    /** Exact sandbox plane derived from the authenticated key, when present. */
+    sandboxId?: string;
+    /** Optional external account scope forwarded to storage resolvers. */
+    accountScope?: string;
+    /**
+     * The environment this commit runs in. Source-mode adapters forward it to the
+     * customer's handlers so that sandbox and production traffic can reach distinct
+     * customer-owned stores.
+     */
+    environment?: Environment;
+    /**
+     * The sync groups this participant subscribes to, taken from the connection
+     * upgrade or the capability token. Each is appended to every delta's `sync_groups`
+     * so that writes fan out to subscribers of entity-level groups (such as
+     * `report:abc`), not only the default `org:X` and `user:Y` groups. When omitted, the
+     * commit fans out to just the organization and user groups.
+     */
+    syncGroups?: readonly string[];
+    /**
+     * When true, the commit does not add `org:<organizationId>` to a delta's sync
+     * groups. Set this for sandbox writes, so that live organization subscribers do
+     * not receive test-environment changes.
+     */
+    omitOrgSyncGroup?: boolean;
+    /**
+     * The participant on whose authority the actor acted. For a direct human commit
+     * this equals the actor; for an agent commit it is the human at the root of the
+     * capability's delegation chain. Null for `system` principals.
+     */
+    onBehalfOf?: ParticipantRef | null;
+    /**
+     * The id of the scoped credential that authorized the commit. Non-null for agent
+     * and system commits when that credential is known; null for direct human commits.
+     */
+    capabilityId?: string | null;
+    /**
+     * The id of the human user at the root of the delegated-authority chain. Stored
+     * directly on `sync_deltas` so that audit triggers appending the hash chain never
+     * need to join mutable credential tables.
+     */
+    delegationChainRootUserId?: string | null;
+    /**
+     * The id of the API key row when the caller authenticated with an API key. Used by
+     * the idempotency cache and for usage attribution. Null for session and capability
+     * callers.
+     */
+    apiKeyId?: string | null;
+    /**
+     * Whether a human explicitly approved the change. Defaults to `auto` when the
+     * caller does not specify an approval state.
+     */
+    confirmationState?: ConfirmationState;
+    /**
+     * The premise for the whole batch. The committer declares the rows or groups
+     * it read to form this batch; the engine checks that none of them changed since
+     * each entry's `readAt` timestamp and applies that entry's `onStale` disposition
+     * across the batch. This differs from the per-operation `readAt` guard, which
+     * validates only the rows being written. Omit it to check the write targets alone.
+     */
+    reads?: ReadDependency[] | null;
+    /**
+     * Durable premises to persist for this commit's participant. Each entry is
+     * kept in `track_dependencies` and re-checked against every future delta; a
+     * later match opens a `StaleNotification` delivered out of band. Distinct
+     * from `reads`, which is checked once here and discarded.
+     */
+    track?: TrackDependency[] | null;
+}
+/**
+ * The server execution receipt persisted in `mutation_log`. Its runtime schema
+ * lives with the HTTP/WS settlement contract so queued correlation cannot drift
+ * between cache, transport, and client.
+ */
+export type CommitExecutionResult = CommitExecutionResultInput;
+//# sourceMappingURL=commit.d.ts.map

package/dist/server/commit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commit.d.ts","sourceRoot":"","sources":["../../src/server/commit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AACjF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,mBAAmB,CAAC;AACpE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAEjF,MAAM,WAAW,aAAa;IAC5B,aAAa,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,eAAe,EAAE,eAAe,CAAC;IACjC,cAAc,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,4EAA4E;IAC5E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,sEAAsE;IACtE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B;;;;OAIG;IACH,UAAU,CAAC,EAAE,cAAc,GAAG,IAAI,CAAC;IACnC;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B;;;;OAIG;IACH,yBAAyB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1C;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB;;;OAGG;IACH,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IACtC;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,cAAc,EAAE,GAAG,IAAI,CAAC;IAChC;;;;;OAKG;IACH,KAAK,CAAC,EAAE,eAAe,EAAE,GAAG,IAAI,CAAC;CAClC;AAED;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,GAAG,0BAA0B,CAAC"}

package/dist/server/commit.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=commit.js.map

package/dist/server/commit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"commit.js","sourceRoot":"","sources":["../../src/server/commit.ts"],"names":[],"mappings":""}

package/dist/server/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The server-side entry point of the sync engine. It re-exports the contract types
+ * you implement a storage backend against: the {@link DataAdapter} and its
+ * vocabulary ({@link Row}, {@link ReadRequest}, {@link ChangeSet}, and the rest),
+ * the {@link CommitContext} and {@link CommitExecutionResult} commit types, the
+ * {@link StorageMode} enumeration, and the per-model read configuration
+ * ({@link BootstrapModel}, {@link ColumnOverride}). These are plain, driver-free
+ * types; you supply the database code that fulfills them.
+ */
+export type { Row, ReadResult, SyncCursor, DataAdapterCapabilities, ProposalResult, ReadRequest, ChangeSet, SyncResult, DataAdapter, ProposableDataAdapter, AdapterResolver, } from './adapter.js';
+export type { CommitContext, CommitExecutionResult } from './commit.js';
+export { commitExecutionResultSchema } from '../wire/commit.js';
+export { storageModeSchema, type StorageMode } from './storageMode.js';
+export type { ColumnOverride, BootstrapModel } from './readConfig.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/server/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,YAAY,EACV,GAAG,EACH,UAAU,EACV,UAAU,EACV,uBAAuB,EACvB,cAAc,EACd,WAAW,EACX,SAAS,EACT,UAAU,EACV,WAAW,EACX,qBAAqB,EACrB,eAAe,GAChB,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACxE,OAAO,EAAE,2BAA2B,EAAE,MAAM,mBAAmB,CAAC;AAChE,OAAO,EAAE,iBAAiB,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACvE,YAAY,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/server/index.js

@@ -0,0 +1,3 @@
+export { commitExecutionResultSchema } from '../wire/commit.js';
+export { storageModeSchema } from './storageMode.js';
+//# sourceMappingURL=index.js.map

package/dist/server/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"AAuBA,OAAO,EAAE,2BAA2B,EAAE,MAAM,mBAAmB,CAAC;AAChE,OAAO,EAAE,iBAAiB,EAAoB,MAAM,kBAAkB,CAAC"}

package/dist/server/readConfig.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Canonical per-model read configuration consumed when a client bootstraps. Each
+ * {@link BootstrapModel} maps a model to its physical table, its tenancy column, and
+ * any parent scoping — plain data with no database driver. It feeds the read side of
+ * the data adapter contract; your query builder reads it to load a model's initial
+ * rows.
+ */
+/** A mapping from a declared field to a physical column, with the alias to apply after a `SELECT *`. */
+export interface ColumnOverride {
+    readonly field: string;
+    readonly column: string;
+    readonly alias: string;
+}
+/** Read configuration for one model: how to locate its rows and scope them to a tenant. */
+export interface BootstrapModel {
+    name: string;
+    /**
+     * Extra names accepted when a request looks up or filters this model. When the
+     * physical table name is canonical, `name` stays that table name and the aliases
+     * cover generated compatibility names such as `WeatherReports` or `weatherReports`.
+     */
+    aliases?: readonly string[];
+    /**
+     * The schema key used by source endpoints. `name` stays the wire and result model
+     * name (usually the typename), while source handlers are keyed by the developer's
+     * schema key, such as `files` or `blocks`.
+     */
+    sourceModel?: string;
+    table: string;
+    syncGroups?: string[];
+    enabled?: boolean;
+    /** Max rows to return. Omit for unlimited. Maps to schema's bootstrapLimit. */
+    limit?: number;
+    /** SQL ORDER BY clause. Default: 'id'. Maps to schema's bootstrapOrderBy. */
+    orderBy?: string;
+    /** Whether the table has organization_id. Default: true. */
+    orgScoped?: boolean;
+    /**
+     * The model derives its tenant from the connected data source (`policy:
+     * { by: 'source' }`) rather than a row column. It carries no tenant predicate on a
+     * log plane, so it is excluded from the bootstrap set entirely until the
+     * write-through connect path can resolve the org from the source registration —
+     * serving it now would return every row to every tenant. Kept on the type as a
+     * defense-in-depth marker so a source-scoped model that reaches `getBootstrapData`
+     * fails closed rather than bootstrapping unscoped.
+     */
+    sourceScoped?: boolean;
+    /** Physical tenancy column (default `organization_id`, configurable per model). */
+    orgColumn?: string;
+    /**
+     * Parent-table scoping for rows that have no `organization_id` column, mirroring
+     * the schema's `scopedVia` option. When set, the bootstrap query adds:
+     *
+     *   WHERE <table>.<localKey> IN
+     *     (SELECT <parentKey> FROM <parentTable> WHERE <parentOrgColumn> = $1)
+     *
+     * This applies on top of whatever `orgScoped` dictates, so a table can carry its
+     * own `organization_id` and still narrow through a parent. The common case,
+     * though, is `orgScoped: false` together with `scopedVia` on a table that lacks the
+     * column.
+     */
+    scopedVia?: {
+        localKey: string;
+        parentTable: string;
+        parentKey?: string;
+        parentOrgColumn?: string;
+    };
+    /** Client-facing field name → physical DB column for declared fields. */
+    fieldColumns?: Record<string, string>;
+    /** Physical-column aliases needed after SELECT * for `.from(...)` fields. */
+    columnOverrides?: readonly ColumnOverride[];
+    /**
+     * Physical columns the schema declares as JSON (via `field.json()`). A JSON field
+     * stored in a text column comes back from `row_to_json` as a serialized string, so
+     * the bootstrap reparses these columns to make the wire value the canonical object
+     * regardless of the physical column type. A `jsonb` column already returns an
+     * object, so reparsing it is a no-op.
+     */
+    jsonColumns?: readonly string[];
+}
+//# sourceMappingURL=readConfig.d.ts.map

package/dist/server/readConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readConfig.d.ts","sourceRoot":"","sources":["../../src/server/readConfig.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,wGAAwG;AACxG,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,2FAA2F;AAC3F,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,+EAA+E;IAC/E,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,6EAA6E;IAC7E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,4DAA4D;IAC5D,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;;;;;;OAQG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,mFAAmF;IACnF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,EAAE;QACV,QAAQ,EAAE,MAAM,CAAC;QACjB,WAAW,EAAE,MAAM,CAAC;QACpB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,eAAe,CAAC,EAAE,MAAM,CAAC;KAC1B,CAAC;IACF,yEAAyE;IACzE,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,6EAA6E;IAC7E,eAAe,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;IAC5C;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACjC"}

package/dist/server/readConfig.js

@@ -0,0 +1,9 @@
+/**
+ * Canonical per-model read configuration consumed when a client bootstraps. Each
+ * {@link BootstrapModel} maps a model to its physical table, its tenancy column, and
+ * any parent scoping — plain data with no database driver. It feeds the read side of
+ * the data adapter contract; your query builder reads it to load a model's initial
+ * rows.
+ */
+export {};
+//# sourceMappingURL=readConfig.js.map