orez-sync-cf-host 0.5.18 → 0.5.19

package/src/platform-probe-worker.ts

@@ -1,18 +1,21 @@
-import { DurableObject } from 'cloudflare:workers'
-
+import { ZeroDO } from '../../../src/cf-do/worker.js'
+import { createQueryCompiler } from './query-compiler.js'
+import {
+  SqlStorageDirect,
+  SqlStorageMutatorTransaction,
+  SqlStorageSyncDb,
+} from './sql-storage-adapter.js'
 import {
-  initSync,
   init_probe_schema,
   pull_snapshot,
   push_finalize,
   push_preflight,
   rust_panic_after_writes,
   value_round_trip,
-} from './generated/sync_wasm.js'
-import wasmModule from './generated/sync_wasm_bg.wasm'
-import { SqlStorageSyncDb } from './sql-storage-adapter.js'
+} from './wasm-platform.js'
 
-initSync({ module: wasmModule })
+import type { TransactionQueryFormat } from './transaction-query.js'
+import type { ZeroSchemaConfig } from './types.js'
 
 interface Env {
   PROBE_DO: DurableObjectNamespace<ProbeDurableObject>
@@ -21,6 +24,54 @@ interface Env {
 type DeferredEffect = { mutationID: string; kind: string }
 type MutatorName = 'read-then-write' | 'multi-table' | 'application-error'
 
+const transactionQuerySchema = {
+  tables: {
+    account: {
+      name: 'account',
+      serverName: 'accounts',
+      columns: {
+        id: { type: 'string' },
+        balance: { type: 'number' },
+      },
+      primaryKey: ['id'],
+    },
+    entry: {
+      name: 'entry',
+      serverName: 'ledger',
+      columns: {
+        id: { type: 'number' },
+        accountId: { type: 'string', serverName: 'account_id' },
+        amount: { type: 'number' },
+        note: { type: 'string' },
+      },
+      primaryKey: ['id'],
+    },
+  },
+} as const satisfies ZeroSchemaConfig
+
+const transactionQueryAst = {
+  table: 'account',
+  where: {
+    type: 'simple',
+    op: '=',
+    left: { type: 'column', name: 'id' },
+    right: { type: 'literal', value: 'primary' },
+  },
+  related: [
+    {
+      correlation: { parentField: ['id'], childField: ['accountId'] },
+      subquery: { table: 'entry', alias: 'entries', orderBy: [['id', 'asc']] },
+    },
+  ],
+}
+
+const transactionQueryFormat = {
+  singular: true,
+  relationships: { entries: { singular: false, relationships: {} } },
+} as const satisfies TransactionQueryFormat
+
+const compileTransactionQuery = createQueryCompiler(transactionQuerySchema)
+
 // Deterministic local analogue of normal DO idle eviction, matching the
 // harness/cf probe: discard all in-memory state after an idle gap while SQL
 // storage remains intact. This keeps the test sub-second instead of waiting
@@ -33,7 +84,7 @@ const json = (value: unknown, status = 200) =>
     headers: { 'cache-control': 'no-store' },
   })
 
-export class ProbeDurableObject extends DurableObject<Env> {
+export class ProbeDurableObject extends ZeroDO {
   readonly #db: SqlStorageSyncDb
   #bootID = crypto.randomUUID()
   #lastRequestAt = 0
@@ -41,7 +92,7 @@ export class ProbeDurableObject extends DurableObject<Env> {
   #effects: Array<DeferredEffect & { observedCommitted: boolean }> = []
 
   constructor(ctx: DurableObjectState, env: Env) {
-    super(ctx, env)
+    super(ctx, env as never)
     this.#db = new SqlStorageSyncDb(ctx.storage.sql)
     ctx.storage.transactionSync(() => init_probe_schema(this.#db))
   }
@@ -291,6 +342,68 @@ export class ProbeDurableObject extends DurableObject<Env> {
       return json({ errors })
     }
 
+    if (route === '/transaction-query') {
+      let plan: ReturnType<typeof compileTransactionQuery> | undefined
+      const tx = new SqlStorageMutatorTransaction(
+        new SqlStorageDirect(this.ctx.storage.sql),
+        (queryAst, queryFormat) => {
+          plan = compileTransactionQuery(queryAst, queryFormat)
+          return plan
+        }
+      )
+      const result = await tx.queryAst(
+        transactionQueryAst,
+        transactionQueryFormat,
+        'platformTransactionQuery'
+      )
+      let malformedFormatStatus: unknown
+      try {
+        await tx.queryAst(transactionQueryAst, undefined as never)
+      } catch (error) {
+        malformedFormatStatus = (error as { status?: unknown }).status
+      }
+      return json({ result, malformedFormatStatus, plan })
+    }
+
+    if (route === '/application-transaction-query') {
+      const result = await this.runApplicationTransaction(
+        compileTransactionQuery,
+        (tx) =>
+          tx.queryAst(
+            transactionQueryAst,
+            transactionQueryFormat,
+            'applicationTransactionQuery'
+          ),
+        { maxSelects: 8, maxRows: 20 }
+      )
+      return json({ result })
+    }
+
+    if (route === '/application-transaction-query-budget') {
+      try {
+        await this.runApplicationTransaction(
+          compileTransactionQuery,
+          (tx) =>
+            tx.queryAst(
+              transactionQueryAst,
+              transactionQueryFormat,
+              'budgetedApplicationTransactionQuery'
+            ),
+          { maxSelects: 1 }
+        )
+      } catch (error) {
+        return json(
+          {
+            code: Reflect.get(error as object, 'code'),
+            query: Reflect.get(error as object, 'query'),
+            selects: Reflect.get(error as object, 'selects'),
+          },
+          409
+        )
+      }
+      return json({ error: 'query budget did not abort the transaction' }, 500)
+    }
+
     return json({ error: 'not found', route }, 404)
   }
 }

package/src/post-commit.ts

@@ -0,0 +1,40 @@
+export type DeferredEffect = () => void | Promise<void>
+
+export type PostCommitEffects = {
+  /** discard effects from a storage-transaction attempt before starting another */
+  beginAttempt(): void
+  defer(effect: DeferredEffect): void
+  /** run the committed attempt's effects in order without rejecting */
+  runAfterCommit(onError: (error: unknown) => void): Promise<void>
+}
+
+/**
+ * collect external work during a retryable transaction and run only the effects
+ * belonging to the attempt that commits.
+ */
+export function createPostCommitEffects(): PostCommitEffects {
+  const effects: DeferredEffect[] = []
+
+  return {
+    beginAttempt() {
+      effects.length = 0
+    },
+    defer(effect) {
+      effects.push(effect)
+    },
+    async runAfterCommit(onError) {
+      const committed = effects.splice(0)
+      for (const effect of committed) {
+        try {
+          await effect()
+        } catch (error) {
+          try {
+            onError(error)
+          } catch {
+            // reporting must not turn a committed effect failure into a rejection
+          }
+        }
+      }
+    },
+  }
+}

package/src/query-compiler.ts

@@ -0,0 +1,16 @@
+import { engine_compile_query } from './wasm.js'
+
+import type {
+  CompiledTransactionQueryPlan,
+  TransactionQueryFormat,
+} from './transaction-query.js'
+import type { ZeroSchemaConfig } from './types.js'
+
+export type TransactionQueryCompiler = (
+  ast: unknown,
+  format: TransactionQueryFormat
+) => CompiledTransactionQueryPlan
+
+export function createQueryCompiler(schema: ZeroSchemaConfig): TransactionQueryCompiler {
+  return (ast, format) => engine_compile_query(schema, ast, format)
+}

package/src/sql-storage-adapter.ts

@@ -1,5 +1,11 @@
+import { executeTransactionQueryPlan } from './transaction-query.js'
 import { trackBillableCursorRows } from './write-safeguards.js'
 
+import type {
+  CompiledTransactionQueryPlan,
+  TransactionQueryBudget,
+  TransactionQueryFormat,
+} from './transaction-query.js'
 import type { MutatorSql, SyncSql } from './types.js'
 
 type WireValue =
@@ -16,8 +22,6 @@ interface JsSyncDb {
   query(sql: string, params: WireValue[]): WireRow[]
 }
 
-export type CompiledQuery = { sql: string; params: WireValue[] }
-
 export type AdapterStats = {
   execCalls: number
   queryCalls: number
@@ -40,24 +44,79 @@ export function assertHostSql(sql: string): void {
   }
 }
 
-function decodeBinding(value: WireValue): unknown {
-  switch (value.kind) {
+function decodeBinding(value: unknown, path = 'binding'): unknown {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new TypeError(`${path} must be a typed SQL value`)
+  }
+  const binding = value as { kind?: unknown; value?: unknown }
+  const keys = Object.keys(binding)
+  const assertValueShape = () => {
+    if (keys.length !== 2 || !keys.includes('kind') || !keys.includes('value')) {
+      throw new TypeError(`${path} must contain only kind and value`)
+    }
+  }
+  switch (binding.kind) {
     case 'null':
+      if (keys.length !== 1 || keys[0] !== 'kind') {
+        throw new TypeError(`${path} null binding must contain only kind`)
+      }
       return null
     case 'integer': {
-      const exact = BigInt(value.value)
+      assertValueShape()
+      if (typeof binding.value !== 'string') {
+        throw new TypeError(`${path}.value must be an i64 decimal string`)
+      }
+      if (!/^-?\d+$/.test(binding.value)) {
+        throw new TypeError(`${path}.value must be an i64 decimal string`)
+      }
+      let exact: bigint
+      try {
+        exact = BigInt(binding.value)
+      } catch {
+        throw new TypeError(`${path}.value must be an i64 decimal string`)
+      }
+      if (exact < -(1n << 63n) || exact > (1n << 63n) - 1n) {
+        throw new TypeError(`${path}.value is outside the i64 range`)
+      }
       // SqlStorage does not accept bigint. Safe values can use Number; unsafe
       // values use decimal text and rely on the destination's INTEGER affinity.
-      return exact >= MIN_SAFE && exact <= MAX_SAFE ? Number(exact) : value.value
+      return exact >= MIN_SAFE && exact <= MAX_SAFE ? Number(exact) : binding.value
+    }
+    case 'real': {
+      assertValueShape()
+      if (typeof binding.value !== 'number' || !Number.isFinite(binding.value)) {
+        throw new TypeError(`${path}.value must be a finite number`)
+      }
+      return binding.value
+    }
+    case 'text': {
+      assertValueShape()
+      if (typeof binding.value !== 'string') {
+        throw new TypeError(`${path}.value must be a string`)
+      }
+      return binding.value
     }
-    case 'real':
-    case 'text':
-      return value.value
-    case 'blob':
-      return Uint8Array.from(value.value).buffer
+    case 'blob': {
+      assertValueShape()
+      if (
+        !Array.isArray(binding.value) ||
+        binding.value.some((byte) => !Number.isInteger(byte) || byte < 0 || byte > 255)
+      ) {
+        throw new TypeError(`${path}.value must be an array of bytes`)
+      }
+      return Uint8Array.from(binding.value).buffer
+    }
+    default:
+      throw new TypeError(`${path}.kind must be null, integer, real, text, or blob`)
   }
 }
 
+export function decodeSqlParams(value: unknown): unknown[] {
+  if (value === undefined) return []
+  if (!Array.isArray(value)) throw new TypeError('params must be an array')
+  return value.map((binding, index) => decodeBinding(binding, `params[${index}]`))
+}
+
 function encodeResult(value: unknown): WireValue {
   if (value === null) return { kind: 'null' }
   if (typeof value === 'number') {
@@ -103,7 +162,7 @@ export class SqlStorageSyncDb implements JsSyncDb {
     assertHostSql(sql)
     const start = performance.now()
     trackBillableCursorRows(
-      this.sql.exec(sql, ...params.map(decodeBinding)),
+      this.sql.exec(sql, ...params.map((value) => decodeBinding(value))),
       this.recordRowsWritten
     )
     this.stats.execCalls++
@@ -114,7 +173,7 @@ export class SqlStorageSyncDb implements JsSyncDb {
     assertHostSql(sql)
     const start = performance.now()
     const cursor = trackBillableCursorRows(
-      this.sql.exec(sql, ...params.map(decodeBinding)),
+      this.sql.exec(sql, ...params.map((value) => decodeBinding(value))),
       this.recordRowsWritten
     )
     const columns = [...cursor.columnNames]
@@ -162,7 +221,11 @@ export class SqlStorageDirect implements SyncSql {
 export class SqlStorageMutatorTransaction implements MutatorSql {
   constructor(
     private readonly direct: SqlStorageDirect,
-    private readonly compileQuery: (ast: unknown) => CompiledQuery
+    private readonly compileQuery: (
+      ast: unknown,
+      format: TransactionQueryFormat
+    ) => CompiledTransactionQueryPlan,
+    private readonly queryBudget?: Partial<TransactionQueryBudget>
   ) {}
 
   async exec(sql: string, params: readonly unknown[] = []): Promise<void> {
@@ -176,10 +239,16 @@ export class SqlStorageMutatorTransaction implements MutatorSql {
     return this.direct.query<Row>(sql, params)
   }
 
-  async queryAst<Row extends Record<string, unknown> = Record<string, unknown>>(
-    ast: unknown
-  ): Promise<Row[]> {
-    const compiled = this.compileQuery(ast)
-    return this.direct.query<Row>(compiled.sql, compiled.params.map(decodeBinding))
+  async queryAst<Result = unknown>(
+    ast: unknown,
+    format: TransactionQueryFormat,
+    queryName?: string
+  ): Promise<Result> {
+    const compiled = this.compileQuery(ast, format)
+    return executeTransactionQueryPlan<Result>(
+      compiled,
+      (sql, params) => this.direct.query(sql, params),
+      { queryName, budget: this.queryBudget }
+    )
   }
 }