@abloatai/ablo 0.34.1 → 0.36.0

package/dist/transaction/wire/frames.d.ts

@@ -0,0 +1,194 @@
+/**
+ * The write-path message shapes for the sync protocol. These cover the frames
+ * a client sends to commit work — {@link CommitMessage}, a batch of raw
+ * operations — and the server's {@link MutationResultMessage}
+ * acknowledgement. The same frames flow over a WebSocket connection and over
+ * the HTTP commit endpoint.
+ *
+ * Both the client and the server import these definitions from here, so the two
+ * sides cannot drift. Zod schemas are the definition site and every TypeScript
+ * shape is inferred from them. Changing any schema in this file changes the
+ * wire contract and requires the client and server to update together.
+ */
+import { z } from 'zod';
+import type { MutationResultMessageWire } from './commit.js';
+/**
+ * A single operation within a commit batch and its authoritative runtime
+ * validator. Each operation is the smallest unit the server applies atomically
+ * — one create, update, delete, archive, or unarchive against one model row.
+ * Both commit transports — the WebSocket `commit` frame and the HTTP
+ * `/v1/commits` endpoint — run this check
+ * on every operation before it is applied, so a malformed operation is rejected
+ * at the edge. It builds on the shared coordination schema, widening `bypass`
+ * to also accept `null`. The TypeScript type is inferred from this schema so
+ * the runtime and compile-time contracts have one definition site.
+ */
+export declare const wireCommitOperationSchema: z.ZodObject<{
+    readAt: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    onStale: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        reject: "reject";
+        overwrite: "overwrite";
+        notify: "notify";
+    }>>>;
+    type: z.ZodEnum<{
+        CREATE: "CREATE";
+        UPDATE: "UPDATE";
+        DELETE: "DELETE";
+        ARCHIVE: "ARCHIVE";
+        UNARCHIVE: "UNARCHIVE";
+    }>;
+    model: z.ZodString;
+    id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    input: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    transactionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    fenceToken: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    bypass: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+}, z.core.$strip>;
+export type WireCommitOperation = z.infer<typeof wireCommitOperationSchema>;
+/**
+ * @deprecated Renamed to {@link WireCommitOperation} — coordination/schema owns
+ * the base `CommitOperation`; this is the wire-extended form, and the two are
+ * different types that shared one name. Removed in 0.36.0.
+ */
+export type CommitOperation = WireCommitOperation;
+/** @deprecated Renamed to {@link wireCommitOperationSchema}. Removed in 0.36.0. */
+export declare const commitOperationSchema: z.ZodObject<{
+    readAt: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    onStale: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        reject: "reject";
+        overwrite: "overwrite";
+        notify: "notify";
+    }>>>;
+    type: z.ZodEnum<{
+        CREATE: "CREATE";
+        UPDATE: "UPDATE";
+        DELETE: "DELETE";
+        ARCHIVE: "ARCHIVE";
+        UNARCHIVE: "UNARCHIVE";
+    }>;
+    model: z.ZodString;
+    id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    input: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    transactionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    fenceToken: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    bypass: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+}, z.core.$strip>;
+/**
+ * The authoritative payload schema for a client-to-server commit frame. It
+ * checks every field the server acts on — `operations`, `clientTxId`, and
+ * `reads` — validating each operation with {@link wireCommitOperationSchema} and
+ * each premise entry with the shared {@link readDependencySchema}.
+ */
+export declare const commitPayloadSchema: z.ZodObject<{
+    operations: z.ZodArray<z.ZodObject<{
+        readAt: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        onStale: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            reject: "reject";
+            overwrite: "overwrite";
+            notify: "notify";
+        }>>>;
+        type: z.ZodEnum<{
+            CREATE: "CREATE";
+            UPDATE: "UPDATE";
+            DELETE: "DELETE";
+            ARCHIVE: "ARCHIVE";
+            UNARCHIVE: "UNARCHIVE";
+        }>;
+        model: z.ZodString;
+        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        input: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        transactionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        fenceToken: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        bypass: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    }, z.core.$strip>>;
+    clientTxId: z.ZodString;
+    reads: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        model: z.ZodString;
+        id: z.ZodString;
+        readAt: z.ZodNumber;
+        fields: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        onStale: z.ZodOptional<z.ZodEnum<{
+            reject: "reject";
+            overwrite: "overwrite";
+            notify: "notify";
+        }>>;
+    }, z.core.$strip>, z.ZodObject<{
+        group: z.ZodString;
+        readAt: z.ZodNumber;
+        onStale: z.ZodOptional<z.ZodEnum<{
+            reject: "reject";
+            overwrite: "overwrite";
+            notify: "notify";
+        }>>;
+    }, z.core.$strip>]>>>>;
+    track: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        id: z.ZodString;
+        model: z.ZodString;
+        readAt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        group: z.ZodString;
+        readAt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>]>>>>;
+}, z.core.$strip>;
+/** A client-to-server frame that asks the server to commit a batch atomically. */
+export declare const commitMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"commit">;
+    payload: z.ZodObject<{
+        operations: z.ZodArray<z.ZodObject<{
+            readAt: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            onStale: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                reject: "reject";
+                overwrite: "overwrite";
+                notify: "notify";
+            }>>>;
+            type: z.ZodEnum<{
+                CREATE: "CREATE";
+                UPDATE: "UPDATE";
+                DELETE: "DELETE";
+                ARCHIVE: "ARCHIVE";
+                UNARCHIVE: "UNARCHIVE";
+            }>;
+            model: z.ZodString;
+            id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            input: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+            transactionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            fenceToken: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            bypass: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        }, z.core.$strip>>;
+        clientTxId: z.ZodString;
+        reads: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            model: z.ZodString;
+            id: z.ZodString;
+            readAt: z.ZodNumber;
+            fields: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+            onStale: z.ZodOptional<z.ZodEnum<{
+                reject: "reject";
+                overwrite: "overwrite";
+                notify: "notify";
+            }>>;
+        }, z.core.$strip>, z.ZodObject<{
+            group: z.ZodString;
+            readAt: z.ZodNumber;
+            onStale: z.ZodOptional<z.ZodEnum<{
+                reject: "reject";
+                overwrite: "overwrite";
+                notify: "notify";
+            }>>;
+        }, z.core.$strip>]>>>>;
+        track: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            id: z.ZodString;
+            model: z.ZodString;
+            readAt: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            group: z.ZodString;
+            readAt: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>]>>>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type CommitMessage = z.infer<typeof commitMessageSchema>;
+/**
+ * The server's acknowledgement of a {@link CommitMessage}. Runtime shape and
+ * TypeScript type are both owned by `wire/commit.ts`; HTTP, WebSocket, and
+ * cached replay no longer maintain parallel receipt declarations.
+ */
+export type MutationResultMessage = MutationResultMessageWire;

package/dist/transaction/wire/frames.js

@@ -0,0 +1,50 @@
+/**
+ * The write-path message shapes for the sync protocol. These cover the frames
+ * a client sends to commit work — {@link CommitMessage}, a batch of raw
+ * operations — and the server's {@link MutationResultMessage}
+ * acknowledgement. The same frames flow over a WebSocket connection and over
+ * the HTTP commit endpoint.
+ *
+ * Both the client and the server import these definitions from here, so the two
+ * sides cannot drift. Zod schemas are the definition site and every TypeScript
+ * shape is inferred from them. Changing any schema in this file changes the
+ * wire contract and requires the client and server to update together.
+ */
+import { z } from 'zod';
+// The runtime schema primitives are imported straight from the coordination
+// schema module to keep this file's runtime dependencies limited to Zod.
+import { commitOperationSchema as coordinationCommitOperationSchema, readDependencySchema, trackDependencySchema, } from '../coordination/schema.js';
+// ── Client → Server ────────────────────────────────────────────────────────
+/**
+ * A single operation within a commit batch and its authoritative runtime
+ * validator. Each operation is the smallest unit the server applies atomically
+ * — one create, update, delete, archive, or unarchive against one model row.
+ * Both commit transports — the WebSocket `commit` frame and the HTTP
+ * `/v1/commits` endpoint — run this check
+ * on every operation before it is applied, so a malformed operation is rejected
+ * at the edge. It builds on the shared coordination schema, widening `bypass`
+ * to also accept `null`. The TypeScript type is inferred from this schema so
+ * the runtime and compile-time contracts have one definition site.
+ */
+export const wireCommitOperationSchema = coordinationCommitOperationSchema.extend({
+    bypass: z.boolean().nullish(),
+});
+/** @deprecated Renamed to {@link wireCommitOperationSchema}. Removed in 0.36.0. */
+export const commitOperationSchema = wireCommitOperationSchema;
+/**
+ * The authoritative payload schema for a client-to-server commit frame. It
+ * checks every field the server acts on — `operations`, `clientTxId`, and
+ * `reads` — validating each operation with {@link wireCommitOperationSchema} and
+ * each premise entry with the shared {@link readDependencySchema}.
+ */
+export const commitPayloadSchema = z.object({
+    operations: z.array(wireCommitOperationSchema),
+    clientTxId: z.string(),
+    reads: z.array(readDependencySchema).nullish(),
+    track: z.array(trackDependencySchema).nullish(),
+});
+/** A client-to-server frame that asks the server to commit a batch atomically. */
+export const commitMessageSchema = z.object({
+    type: z.literal('commit'),
+    payload: commitPayloadSchema,
+});