@abloatai/ablo 0.51.0 → 0.52.0

package/examples/agent-turn.ts

@@ -2,32 +2,32 @@
  * Canonical cheap turn: explicitly attach the exact rows used to decide the
  * write. Ablo keeps their watermarks opaque and checks them at commit time.
  *
- * Run: ABLO_API_KEY=sk_... TASK_ID=task_... npx tsx examples/agent-turn.ts
+ * Run: ABLO_API_KEY=sk_... RECORD_ID=record_... npx tsx examples/agent-turn.ts
  */
 import { Ablo } from '@abloatai/ablo';
 import { defineSchema, model, z } from '@abloatai/ablo/schema';
 
 const schema = defineSchema({
-  tasks: model({
+  records: model({
     title: z.string(),
     status: z.enum(['pending', 'done']),
     result: z.string().optional(),
   }),
 });
 
-const taskId = process.env.TASK_ID;
-if (!taskId) throw new Error('TASK_ID is required');
+const recordId = process.env.RECORD_ID;
+if (!recordId) throw new Error('RECORD_ID is required');
 
 const ablo = Ablo({ schema, apiKey: process.env.ABLO_API_KEY });
 try {
   await ablo.ready();
-  const task = await ablo.tasks.get({ id: taskId });
-  if (!task) throw new Error(`Task ${taskId} was not found`);
-  const commitId = `task:${taskId}:cheap`;
-  await ablo.tasks.update({
-    id: task.id,
-    data: { status: 'done', result: `Completed: ${task.title}` },
-    reads: [task],
+  const record = await ablo.records.get({ id: recordId });
+  if (!record) throw new Error(`Record ${recordId} was not found`);
+  const commitId = `record:${recordId}:cheap`;
+  await ablo.records.update({
+    id: record.id,
+    data: { status: 'done', result: `Completed: ${record.title}` },
+    reads: [record],
     idempotencyKey: commitId,
   });
   const record = await ablo.commits.get({ id: commitId });

package/examples/data-source/README.md

@@ -93,9 +93,9 @@ createServer(async (req, res) => {
 Replace the `Map`-based store in `customer-server.ts` with your real
 data layer. The handler shape stays the same:
 
-- `tasks.load({ id })` -> `db.task.findUnique({ where: { id } })`
-- `tasks.list({ query })` -> `db.task.findMany({ take, cursor })`
-- `tasks.commit({ operations, clientTxId })` -> `db.$transaction` that
+- `records.load({ id })` -> `db.record.findUnique({ where: { id } })`
+- `records.list({ query })` -> `db.record.findMany({ take, cursor })`
+- `records.commit({ operations, clientTxId })` -> `db.$transaction` that
   applies each `op` and writes an outbox marker with `clientTxId` before commit
 - `events({ cursor, limit })` -> read from your outbox table, return
   rows with their `clientTxId` (Ablo dedupes its own commits) and the

package/examples/data-source/customer-server.ts

@@ -23,7 +23,7 @@ import {
 } from '@abloatai/ablo/source';
 import { schema } from './schema';
 
-type TaskRow = {
+type RecordRow = {
   id: string;
   title: string;
   status: 'todo' | 'doing' | 'done';
@@ -31,9 +31,9 @@ type TaskRow = {
 };
 
 // Stand-in for the customer's real database. Map keyed by row id.
-const taskStore = new Map<string, TaskRow>();
+const recordStore = new Map<string, RecordRow>();
 
-// Outbox table. In production this is a `tasks_outbox` Postgres table
+// Outbox table. In production this is a `records_outbox` Postgres table
 // populated in the same transaction as the app-row write. Ablo polls `events`
 // to fan out changes that bypassed Ablo, and to repair SDK-origin writes if
 // Ablo's immediate post-commit append failed.
@@ -41,8 +41,8 @@ const outbox: SourceEvent[] = [];
 let outboxSequence = 0;
 
 // Seed one row so the example's first `load` returns something.
-taskStore.set('task_seed', {
-  id: 'task_seed',
+recordStore.set('record_seed', {
+  id: 'record_seed',
   title: 'Seeded by customer database',
   status: 'todo',
 });
@@ -91,13 +91,13 @@ export const handleAbloSource = dataSource({
     return {};
   },
 
-  tasks: {
+  records: {
     load({ id }) {
-      return taskStore.get(id) ?? null;
+      return recordStore.get(id) ?? null;
     },
 
     list({ query }) {
-      const all = Array.from(taskStore.values());
+      const all = Array.from(recordStore.values());
       const start = query.cursor ? Number(query.cursor) : 0;
       const limit = query.limit ?? 50;
       const page = all.slice(start, start + limit);
@@ -115,7 +115,7 @@ export const handleAbloSource = dataSource({
     // update; the surrounding `apply` helper shows where you would
     // open `db.transaction(async (tx) => { ... })`.
     commit({ operations, clientTxId }) {
-      const rows: TaskRow[] = [];
+      const rows: RecordRow[] = [];
       for (const op of operations) {
         const row = applyOperation(op, clientTxId);
         if (row) rows.push(row);
@@ -145,38 +145,38 @@ export const handleAbloSource = dataSource({
 function applyOperation(
   op: SourceOperation,
   clientTxId: string | undefined,
-): TaskRow | null {
-  if (op.model !== 'tasks') return null;
-  const id = op.id ?? `task_${Math.random().toString(36).slice(2, 10)}`;
+): RecordRow | null {
+  if (op.model !== 'records') return null;
+  const id = op.id ?? `record_${Math.random().toString(36).slice(2, 10)}`;
 
   if (op.type === 'CREATE') {
-    const row: TaskRow = {
+    const row: RecordRow = {
       id,
       title: String(op.input?.title ?? ''),
       status:
-        (op.input?.status as TaskRow['status'] | undefined) ?? 'todo',
+        (op.input?.status as RecordRow['status'] | undefined) ?? 'todo',
       ...(op.input?.assignee
         ? { assignee: String(op.input.assignee) }
         : {}),
     };
-    taskStore.set(id, row);
+    recordStore.set(id, row);
     appendOutbox({ operation: op, entityId: id, data: row, clientTxId });
     return row;
   }
 
   if (op.type === 'UPDATE') {
-    const existing = taskStore.get(id);
+    const existing = recordStore.get(id);
     if (!existing) return null;
-    const next: TaskRow = { ...existing, ...(op.input as Partial<TaskRow>) };
-    taskStore.set(id, next);
+    const next: RecordRow = { ...existing, ...(op.input as Partial<RecordRow>) };
+    recordStore.set(id, next);
     appendOutbox({ operation: op, entityId: id, data: next, clientTxId });
     return next;
   }
 
   if (op.type === 'DELETE') {
-    const existing = taskStore.get(id);
+    const existing = recordStore.get(id);
     if (!existing) return null;
-    taskStore.delete(id);
+    recordStore.delete(id);
     appendOutbox({ operation: op, entityId: id, data: null, clientTxId });
     return existing;
   }
@@ -187,7 +187,7 @@ function applyOperation(
 function appendOutbox(input: {
   operation: SourceOperation;
   entityId: string;
-  data: TaskRow | null;
+  data: RecordRow | null;
   clientTxId: string | undefined;
 }): void {
   outboxSequence += 1;
@@ -205,11 +205,11 @@ function appendOutbox(input: {
 // Exposed for the orchestrator's `run.ts`. A real customer doesn't
 // need this — it's a back door for the demo to verify state.
 export function _inspectStore(): {
-  rows: TaskRow[];
+  rows: RecordRow[];
   outboxSize: number;
 } {
   return {
-    rows: Array.from(taskStore.values()),
+    rows: Array.from(recordStore.values()),
     outboxSize: outbox.length,
   };
 }

package/examples/data-source/run.ts

@@ -36,7 +36,7 @@ async function main() {
   });
 
   log('--- 1. load (existing seeded row) ---');
-  const seeded = await driver.load('tasks', 'task_seed');
+  const seeded = await driver.load('records', 'record_seed');
   log('loaded:', seeded);
 
   log('\n--- 2. commit (CREATE + UPDATE in one batch) ---');
@@ -44,14 +44,14 @@ async function main() {
     [
       {
         type: 'CREATE',
-        model: 'tasks',
-        id: 'task_new',
+        model: 'records',
+        id: 'record_new',
         input: { title: 'Wire the data source', status: 'todo' },
       },
       {
         type: 'UPDATE',
-        model: 'tasks',
-        id: 'task_seed',
+        model: 'records',
+        id: 'record_seed',
         input: { status: 'doing', assignee: 'alice' },
       },
     ],
@@ -59,8 +59,8 @@ async function main() {
   );
   log('committed rows:', committed);
 
-  log('\n--- 3. list (all tasks after commit) ---');
-  const listed = await driver.list('tasks');
+  log('\n--- 3. list (all records after commit) ---');
+  const listed = await driver.list('records');
   log('listed:', listed);
 
   log('\n--- 4. events (outbox feed for cross-channel writes) ---');
@@ -73,7 +73,7 @@ async function main() {
     apiKey: 'sk_wrong_example_key',
   });
   try {
-    await badDriver.load('tasks', 'task_seed');
+    await badDriver.load('records', 'record_seed');
     throw new Error('expected signature failure');
   } catch (err) {
     log('rejected as expected:', (err as Error).message);

package/examples/data-source/schema.ts

@@ -3,7 +3,7 @@
  *
  * The schema is the contract between three sides:
  *
- *   1. The application UI — `ablo.tasks.update(...)`.
+ *   1. The application UI — `ablo.records.update(...)`.
  *   2. The Ablo Cloud — translates writes into signed POSTs.
  *   3. The customer's Data Source endpoint — applies them to its own
  *      database.
@@ -15,7 +15,7 @@
 import { defineSchema, model, z } from '@abloatai/ablo/schema';
 
 export const schema = defineSchema({
-  tasks: model({
+  records: model({
     title: z.string(),
     status: z.enum(['todo', 'doing', 'done']),
     assignee: z.string().optional(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abloatai/ablo",
-  "version": "0.51.0",
+  "version": "0.52.0",
   "description": "The public Ablo SDK for coordinated reads, commits, claims, observation, and reactive applications.",
   "license": "Apache-2.0",
   "type": "module",
@@ -137,8 +137,8 @@
     "directory": "packages/ablo"
   },
   "dependencies": {
-    "@abloatai/humans": "^0.51.0",
-    "@abloatai/transaction": "^0.51.0",
+    "@abloatai/humans": "^0.52.0",
+    "@abloatai/transaction": "^0.52.0",
     "zod": "^4.4.3"
   },
   "peerDependencies": {