@typicalday/firegraph 0.14.0 → 0.15.0

package/dist/cloudflare/index.js

@@ -1,15 +1,23 @@
 import {
   GraphTimestampImpl,
-  assertJsonSafePayload,
-  buildIndexDDL,
-  compileDataOpsExpr,
-  dedupeIndexSpecs,
-  isFirestoreSpecialType,
-  validateJsonPathKey
-} from "../chunk-4MMQ5W74.js";
-import {
-  DEFAULT_CORE_INDEXES
-} from "../chunk-2DHMNTV6.js";
+  buildSchemaStatements,
+  compileAggregate,
+  compileBulkDelete,
+  compileBulkUpdate,
+  compileDelete,
+  compileDeleteAll,
+  compileExpand,
+  compileExpandHydrate,
+  compileFindEdgesProjected,
+  compileSelect,
+  compileSelectByDocId,
+  compileSet,
+  compileUpdate,
+  decodeProjectedRow,
+  rowTimestampToMillis,
+  validateTableName
+} from "../chunk-ULRDQ6HZ.js";
+import "../chunk-2DHMNTV6.js";
 import {
   createCapabilities,
   intersectCapabilities
@@ -17,561 +25,30 @@ import {
 import {
   META_EDGE_TYPE,
   META_NODE_TYPE,
-  NODE_RELATION,
   buildEdgeQueryPlan,
-  computeEdgeDocId,
-  computeNodeDocId,
   createGraphClientFromBackend,
   createMergedRegistry,
   createRegistry,
   generateId
-} from "../chunk-WRTFC5NG.js";
+} from "../chunk-5HIRYV2S.js";
+import {
+  NODE_RELATION,
+  computeEdgeDocId,
+  computeNodeDocId
+} from "../chunk-NGAJCALM.js";
 import {
   CapabilityNotSupportedError,
   FiregraphError,
-  assertUpdatePayloadExclusive,
-  deleteField,
-  flattenPatch
-} from "../chunk-TK64DNVK.js";
+  deleteField
+} from "../chunk-SIHE4UY4.js";
 import "../chunk-EQJUUVFG.js";
 
-// src/cloudflare/schema.ts
-var DO_FIELD_TO_COLUMN = {
-  aType: "a_type",
-  aUid: "a_uid",
-  axbType: "axb_type",
-  bType: "b_type",
-  bUid: "b_uid",
-  v: "v",
-  createdAt: "created_at",
-  updatedAt: "updated_at"
-};
-var IDENT_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
-function validateDOTableName(name) {
-  if (!IDENT_RE.test(name)) {
-    throw new Error(`Invalid SQL identifier: ${name}. Must match /^[A-Za-z_][A-Za-z0-9_]*$/.`);
-  }
-}
-function quoteDOIdent(name) {
-  validateDOTableName(name);
-  return `"${name}"`;
-}
-function quoteDOColumnAlias(label) {
-  return `"${label.replace(/"/g, '""')}"`;
-}
-function buildDOSchemaStatements(table, options = {}) {
-  const t = quoteDOIdent(table);
-  const statements = [
-    `CREATE TABLE IF NOT EXISTS ${t} (
-      doc_id      TEXT NOT NULL PRIMARY KEY,
-      a_type      TEXT NOT NULL,
-      a_uid       TEXT NOT NULL,
-      axb_type    TEXT NOT NULL,
-      b_type      TEXT NOT NULL,
-      b_uid       TEXT NOT NULL,
-      data        TEXT NOT NULL,
-      v           INTEGER,
-      created_at  INTEGER NOT NULL,
-      updated_at  INTEGER NOT NULL
-    )`
-  ];
-  const core = options.coreIndexes ?? [...DEFAULT_CORE_INDEXES];
-  const fromRegistry = options.registry?.entries().flatMap((e) => e.indexes ?? []) ?? [];
-  const deduped = dedupeIndexSpecs([...core, ...fromRegistry]);
-  for (const spec of deduped) {
-    statements.push(buildIndexDDL(spec, { table, fieldToColumn: DO_FIELD_TO_COLUMN }));
-  }
-  return statements;
-}
-
 // src/cloudflare/sql.ts
-var DO_BACKEND_LABEL = "DO SQLite";
-var DO_BACKEND_ERR_LABEL = "DO SQLite backend";
-function compileFieldRef(field) {
-  const column = DO_FIELD_TO_COLUMN[field];
-  if (column) {
-    return { expr: quoteDOIdent(column) };
-  }
-  if (field.startsWith("data.")) {
-    const suffix = field.slice(5);
-    for (const part of suffix.split(".")) {
-      validateJsonPathKey(part, DO_BACKEND_ERR_LABEL);
-    }
-    return { expr: `json_extract("data", '$.${suffix}')` };
-  }
-  if (field === "data") {
-    return { expr: `json_extract("data", '$')` };
-  }
-  throw new FiregraphError(
-    `DO SQLite backend cannot resolve filter field: ${field}`,
-    "INVALID_QUERY"
-  );
-}
-function bindValue(value) {
-  if (value === null || value === void 0) return null;
-  if (typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") {
-    return value;
-  }
-  if (value instanceof Date) return value.getTime();
-  if (typeof value === "object") {
-    const firestoreType = isFirestoreSpecialType(value);
-    if (firestoreType) {
-      throw new FiregraphError(
-        `DO SQLite backend cannot bind a Firestore ${firestoreType} value \u2014 JSON serialization would silently drop fields and the resulting bind would never match a stored row. Convert to a primitive (e.g. \`ts.toMillis()\` for Timestamp) before filtering or updating.`,
-        "INVALID_QUERY"
-      );
-    }
-    return JSON.stringify(value);
-  }
-  return String(value);
-}
-function compileFilter(filter, params) {
-  const { expr } = compileFieldRef(filter.field);
-  switch (filter.op) {
-    case "==":
-      params.push(bindValue(filter.value));
-      return `${expr} = ?`;
-    case "!=":
-      params.push(bindValue(filter.value));
-      return `${expr} != ?`;
-    case "<":
-      params.push(bindValue(filter.value));
-      return `${expr} < ?`;
-    case "<=":
-      params.push(bindValue(filter.value));
-      return `${expr} <= ?`;
-    case ">":
-      params.push(bindValue(filter.value));
-      return `${expr} > ?`;
-    case ">=":
-      params.push(bindValue(filter.value));
-      return `${expr} >= ?`;
-    case "in": {
-      const values = asArray(filter.value, "in");
-      const placeholders = values.map(() => "?").join(", ");
-      for (const v of values) params.push(bindValue(v));
-      return `${expr} IN (${placeholders})`;
-    }
-    case "not-in": {
-      const values = asArray(filter.value, "not-in");
-      const placeholders = values.map(() => "?").join(", ");
-      for (const v of values) params.push(bindValue(v));
-      return `${expr} NOT IN (${placeholders})`;
-    }
-    case "array-contains": {
-      params.push(bindValue(filter.value));
-      return `EXISTS (SELECT 1 FROM json_each(${expr}) WHERE value = ?)`;
-    }
-    case "array-contains-any": {
-      const values = asArray(filter.value, "array-contains-any");
-      const placeholders = values.map(() => "?").join(", ");
-      for (const v of values) params.push(bindValue(v));
-      return `EXISTS (SELECT 1 FROM json_each(${expr}) WHERE value IN (${placeholders}))`;
-    }
-    default:
-      throw new FiregraphError(
-        `DO SQLite backend does not support filter operator: ${String(filter.op)}`,
-        "INVALID_QUERY"
-      );
-  }
-}
-function asArray(value, op) {
-  if (!Array.isArray(value) || value.length === 0) {
-    throw new FiregraphError(`Operator "${op}" requires a non-empty array value`, "INVALID_QUERY");
-  }
-  return value;
-}
-function compileOrderBy(options, _params) {
-  if (!options?.orderBy) return "";
-  const { field, direction } = options.orderBy;
-  const { expr } = compileFieldRef(field);
-  const dir = direction === "desc" ? "DESC" : "ASC";
-  return ` ORDER BY ${expr} ${dir}`;
-}
-function compileLimit(options, params) {
-  if (options?.limit === void 0) return "";
-  params.push(options.limit);
-  return ` LIMIT ?`;
-}
-function compileDOSelect(table, filters, options) {
-  const params = [];
-  const conditions = [];
-  for (const f of filters) {
-    conditions.push(compileFilter(f, params));
-  }
-  const where = conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "";
-  let sql = `SELECT * FROM ${quoteDOIdent(table)}${where}`;
-  sql += compileOrderBy(options, params);
-  sql += compileLimit(options, params);
-  return { sql, params };
-}
-function compileDOExpand(table, params) {
-  if (params.sources.length === 0) {
-    throw new FiregraphError(
-      "compileDOExpand requires a non-empty sources list \u2014 empty IN () is invalid SQL.",
-      "INVALID_QUERY"
-    );
-  }
-  const direction = params.direction ?? "forward";
-  const aUidCol = compileFieldRef("aUid").expr;
-  const bUidCol = compileFieldRef("bUid").expr;
-  const aTypeCol = compileFieldRef("aType").expr;
-  const bTypeCol = compileFieldRef("bType").expr;
-  const axbTypeCol = compileFieldRef("axbType").expr;
-  const sourceColumn = direction === "forward" ? aUidCol : bUidCol;
-  const sqlParams = [params.axbType];
-  const conditions = [`${axbTypeCol} = ?`];
-  const placeholders = params.sources.map(() => "?").join(", ");
-  conditions.push(`${sourceColumn} IN (${placeholders})`);
-  for (const uid of params.sources) sqlParams.push(uid);
-  if (params.aType !== void 0) {
-    conditions.push(`${aTypeCol} = ?`);
-    sqlParams.push(params.aType);
-  }
-  if (params.bType !== void 0) {
-    conditions.push(`${bTypeCol} = ?`);
-    sqlParams.push(params.bType);
-  }
-  if (params.axbType === NODE_RELATION) {
-    conditions.push(`${aUidCol} != ${bUidCol}`);
-  }
-  let sql = `SELECT * FROM ${quoteDOIdent(table)} WHERE ${conditions.join(" AND ")}`;
-  if (params.orderBy) {
-    sql += compileOrderBy({ orderBy: params.orderBy }, sqlParams);
-  }
-  if (params.limitPerSource !== void 0) {
-    const totalLimit = params.sources.length * params.limitPerSource;
-    sql += ` LIMIT ?`;
-    sqlParams.push(totalLimit);
-  }
-  return { sql, params: sqlParams };
-}
-function compileDOExpandHydrate(table, targetUids) {
-  if (targetUids.length === 0) {
-    throw new FiregraphError(
-      "compileDOExpandHydrate requires a non-empty target list \u2014 empty IN () is invalid SQL.",
-      "INVALID_QUERY"
-    );
-  }
-  const placeholders = targetUids.map(() => "?").join(", ");
-  const sqlParams = [NODE_RELATION];
-  for (const uid of targetUids) sqlParams.push(uid);
-  const aUidCol = compileFieldRef("aUid").expr;
-  const bUidCol = compileFieldRef("bUid").expr;
-  const axbTypeCol = compileFieldRef("axbType").expr;
-  return {
-    sql: `SELECT * FROM ${quoteDOIdent(table)} WHERE ${axbTypeCol} = ? AND ${aUidCol} = ${bUidCol} AND ${bUidCol} IN (${placeholders})`,
-    params: sqlParams
-  };
-}
-function compileDOSelectByDocId(table, docId) {
-  return {
-    sql: `SELECT * FROM ${quoteDOIdent(table)} WHERE "doc_id" = ? LIMIT 1`,
-    params: [docId]
-  };
-}
-function normalizeDOProjectionField(field) {
-  if (field in DO_FIELD_TO_COLUMN) return field;
-  if (field === "data" || field.startsWith("data.")) return field;
-  return `data.${field}`;
-}
-function compileDOFindEdgesProjected(table, select, filters, options) {
-  if (select.length === 0) {
-    throw new FiregraphError(
-      "compileDOFindEdgesProjected requires a non-empty select list \u2014 an empty projection has no SQL representation distinct from `findEdges`.",
-      "INVALID_QUERY"
-    );
-  }
-  const seen = /* @__PURE__ */ new Set();
-  const uniqueFields = [];
-  for (const f of select) {
-    if (!seen.has(f)) {
-      seen.add(f);
-      uniqueFields.push(f);
-    }
-  }
-  const projections = [];
-  const columns = [];
-  for (let idx = 0; idx < uniqueFields.length; idx++) {
-    const field = uniqueFields[idx];
-    const canonical = normalizeDOProjectionField(field);
-    const { expr } = compileFieldRef(canonical);
-    const alias = quoteDOColumnAlias(field);
-    projections.push(`${expr} AS ${alias}`);
-    let kind;
-    let typeAliasName;
-    if (canonical === "data") {
-      kind = "data";
-    } else if (canonical.startsWith("data.")) {
-      kind = "json";
-      typeAliasName = `__fg_t_${idx}`;
-      const typeAlias = quoteDOColumnAlias(typeAliasName);
-      projections.push(`json_type("data", '$.${canonical.slice(5)}') AS ${typeAlias}`);
-    } else {
-      if (canonical === "v") kind = "builtin-int";
-      else if (canonical === "createdAt" || canonical === "updatedAt") kind = "builtin-timestamp";
-      else kind = "builtin-text";
-    }
-    columns.push({ field, kind, typeAlias: typeAliasName });
-  }
-  const params = [];
-  const conditions = [];
-  for (const f of filters) {
-    conditions.push(compileFilter(f, params));
-  }
-  const where = conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "";
-  let sql = `SELECT ${projections.join(", ")} FROM ${quoteDOIdent(table)}${where}`;
-  sql += compileOrderBy(options, params);
-  sql += compileLimit(options, params);
-  return { stmt: { sql, params }, columns };
-}
-function decodeDOProjectedRow(row, columns) {
-  const out = {};
-  for (const c of columns) {
-    const raw = row[c.field];
-    switch (c.kind) {
-      case "builtin-text":
-        out[c.field] = raw === null || raw === void 0 ? null : String(raw);
-        break;
-      case "builtin-int":
-        if (raw === null || raw === void 0) {
-          out[c.field] = null;
-        } else if (typeof raw === "bigint") {
-          out[c.field] = Number(raw);
-        } else if (typeof raw === "number") {
-          out[c.field] = raw;
-        } else {
-          out[c.field] = Number(raw);
-        }
-        break;
-      case "builtin-timestamp": {
-        const ms = toMillis(raw);
-        out[c.field] = GraphTimestampImpl.fromMillis(ms);
-        break;
-      }
-      case "data":
-        if (raw === null || raw === void 0 || raw === "") {
-          out[c.field] = {};
-        } else {
-          out[c.field] = JSON.parse(raw);
-        }
-        break;
-      case "json": {
-        const t = row[c.typeAlias];
-        if (raw === null || raw === void 0) {
-          out[c.field] = null;
-        } else if (t === "object" || t === "array") {
-          out[c.field] = typeof raw === "string" ? JSON.parse(raw) : raw;
-        } else if (t === "integer" && typeof raw === "bigint") {
-          out[c.field] = Number(raw);
-        } else {
-          out[c.field] = raw;
-        }
-        break;
-      }
-    }
-  }
-  return out;
-}
-function compileDOAggregate(table, spec, filters) {
-  const aliases = Object.keys(spec);
-  if (aliases.length === 0) {
-    throw new FiregraphError(
-      "aggregate() requires at least one aggregation in the `aggregates` map.",
-      "INVALID_QUERY"
-    );
-  }
-  const projections = [];
-  for (const alias of aliases) {
-    const { op, field } = spec[alias];
-    validateJsonPathKey(alias, DO_BACKEND_ERR_LABEL);
-    if (op === "count") {
-      if (field !== void 0) {
-        throw new FiregraphError(
-          `Aggregate '${alias}' op 'count' must not specify a field \u2014 count operates on rows, not a column expression.`,
-          "INVALID_QUERY"
-        );
-      }
-      projections.push(`COUNT(*) AS ${quoteDOIdent(alias)}`);
-      continue;
-    }
-    if (!field) {
-      throw new FiregraphError(
-        `Aggregate '${alias}' op '${op}' requires a field.`,
-        "INVALID_QUERY"
-      );
-    }
-    const { expr } = compileFieldRef(field);
-    const numeric = `CAST(${expr} AS REAL)`;
-    if (op === "sum") projections.push(`SUM(${numeric}) AS ${quoteDOIdent(alias)}`);
-    else if (op === "avg") projections.push(`AVG(${numeric}) AS ${quoteDOIdent(alias)}`);
-    else if (op === "min") projections.push(`MIN(${numeric}) AS ${quoteDOIdent(alias)}`);
-    else if (op === "max") projections.push(`MAX(${numeric}) AS ${quoteDOIdent(alias)}`);
-    else
-      throw new FiregraphError(
-        `DO SQLite backend does not support aggregate op: ${String(op)}`,
-        "INVALID_QUERY"
-      );
-  }
-  const params = [];
-  const conditions = [];
-  for (const f of filters) {
-    conditions.push(compileFilter(f, params));
-  }
-  const where = conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "";
-  const sql = `SELECT ${projections.join(", ")} FROM ${quoteDOIdent(table)}${where}`;
-  return { stmt: { sql, params }, aliases };
-}
-function compileDOSet(table, docId, record, nowMillis, mode) {
-  assertJsonSafePayload(record.data, DO_BACKEND_LABEL);
-  if (mode === "replace") {
-    const sql2 = `INSERT OR REPLACE INTO ${quoteDOIdent(table)} (
-      doc_id, a_type, a_uid, axb_type, b_type, b_uid, data, v, created_at, updated_at
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`;
-    const params = [
-      docId,
-      record.aType,
-      record.aUid,
-      record.axbType,
-      record.bType,
-      record.bUid,
-      JSON.stringify(record.data ?? {}),
-      record.v ?? null,
-      nowMillis,
-      nowMillis
-    ];
-    return { sql: sql2, params };
-  }
-  const insertParams = [
-    docId,
-    record.aType,
-    record.aUid,
-    record.axbType,
-    record.bType,
-    record.bUid,
-    JSON.stringify(record.data ?? {}),
-    record.v ?? null,
-    nowMillis,
-    nowMillis
-  ];
-  const ops = flattenPatch(record.data ?? {});
-  const updateParams = [];
-  const dataExpr = compileDataOpsExpr(ops, `COALESCE("data", '{}')`, updateParams, DO_BACKEND_ERR_LABEL) ?? `COALESCE("data", '{}')`;
-  const sql = `INSERT INTO ${quoteDOIdent(table)} (
-      doc_id, a_type, a_uid, axb_type, b_type, b_uid, data, v, created_at, updated_at
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    ON CONFLICT(doc_id) DO UPDATE SET
-      "a_type" = excluded."a_type",
-      "a_uid" = excluded."a_uid",
-      "axb_type" = excluded."axb_type",
-      "b_type" = excluded."b_type",
-      "b_uid" = excluded."b_uid",
-      "data" = ${dataExpr},
-      "v" = COALESCE(excluded."v", "v"),
-      "created_at" = excluded."created_at",
-      "updated_at" = excluded."updated_at"`;
-  return { sql, params: [...insertParams, ...updateParams] };
-}
-function compileDOUpdate(table, docId, update, nowMillis) {
-  assertUpdatePayloadExclusive(update);
-  const setClauses = [];
-  const params = [];
-  if (update.replaceData) {
-    assertJsonSafePayload(update.replaceData, DO_BACKEND_LABEL);
-    setClauses.push(`"data" = ?`);
-    params.push(JSON.stringify(update.replaceData));
-  } else if (update.dataOps && update.dataOps.length > 0) {
-    for (const op of update.dataOps) {
-      if (!op.delete) assertJsonSafePayload(op.value, DO_BACKEND_LABEL);
-    }
-    const expr = compileDataOpsExpr(
-      update.dataOps,
-      `COALESCE("data", '{}')`,
-      params,
-      DO_BACKEND_ERR_LABEL
-    );
-    if (expr !== null) {
-      setClauses.push(`"data" = ${expr}`);
-    }
-  }
-  if (update.v !== void 0) {
-    setClauses.push(`"v" = ?`);
-    params.push(update.v);
-  }
-  setClauses.push(`"updated_at" = ?`);
-  params.push(nowMillis);
-  params.push(docId);
-  return {
-    sql: `UPDATE ${quoteDOIdent(table)} SET ${setClauses.join(", ")} WHERE "doc_id" = ?`,
-    params
-  };
-}
-function compileDODelete(table, docId) {
-  return {
-    sql: `DELETE FROM ${quoteDOIdent(table)} WHERE "doc_id" = ?`,
-    params: [docId]
-  };
-}
-function compileDOBulkDelete(table, filters) {
-  const params = [];
-  const conditions = [];
-  for (const f of filters) {
-    conditions.push(compileFilter(f, params));
-  }
-  const where = conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "";
-  return {
-    sql: `DELETE FROM ${quoteDOIdent(table)}${where}`,
-    params
-  };
-}
-function compileDOBulkUpdate(table, filters, patchData, nowMillis) {
-  const dataOps = flattenPatch(patchData);
-  if (dataOps.length === 0) {
-    throw new FiregraphError(
-      "bulkUpdate() patch.data must contain at least one leaf \u2014 an empty patch would only rewrite `updated_at`, which is almost certainly a bug. Use `setDoc` with merge mode if you want to stamp without editing data.",
-      "INVALID_QUERY"
-    );
-  }
-  for (const op of dataOps) {
-    if (!op.delete) assertJsonSafePayload(op.value, DO_BACKEND_LABEL);
-  }
-  const setParams = [];
-  const expr = compileDataOpsExpr(
-    dataOps,
-    `COALESCE("data", '{}')`,
-    setParams,
-    DO_BACKEND_ERR_LABEL
-  );
-  if (expr === null) {
-    throw new FiregraphError(
-      "bulkUpdate() patch produced no SQL operations \u2014 internal invariant violated.",
-      "INVALID_ARGUMENT"
-    );
-  }
-  const setClauses = [`"data" = ${expr}`, `"updated_at" = ?`];
-  setParams.push(nowMillis);
-  const whereParams = [];
-  const conditions = [];
-  for (const f of filters) {
-    conditions.push(compileFilter(f, whereParams));
-  }
-  const where = conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "";
-  return {
-    sql: `UPDATE ${quoteDOIdent(table)} SET ${setClauses.join(", ")}${where}`,
-    params: [...setParams, ...whereParams]
-  };
-}
-function compileDODeleteAll(table) {
-  return {
-    sql: `DELETE FROM ${quoteDOIdent(table)}`,
-    params: []
-  };
-}
 function rowToDORecord(row) {
   const dataString = row.data;
   const data = dataString ? JSON.parse(dataString) : {};
-  const createdAtMs = toMillis(row.created_at);
-  const updatedAtMs = toMillis(row.updated_at);
+  const createdAtMs = rowTimestampToMillis(row.created_at);
+  const updatedAtMs = rowTimestampToMillis(row.updated_at);
   const record = {
     aType: row.a_type,
     aUid: row.a_uid,
@@ -603,18 +80,6 @@ function hydrateDORecord(wire) {
   }
   return record;
 }
-function toMillis(value) {
-  if (typeof value === "number") return value;
-  if (typeof value === "bigint") return Number(value);
-  if (typeof value === "string") {
-    const n = Number(value);
-    if (Number.isFinite(n)) return n;
-  }
-  throw new FiregraphError(
-    `DO SQLite row has non-numeric timestamp column: ${typeof value} (${String(value)})`,
-    "INVALID_QUERY"
-  );
-}
 
 // src/cloudflare/backend.ts
 function validateSegment(value, label) {
@@ -878,7 +343,7 @@ var DORPCBackend = class _DORPCBackend {
       );
     }
     const { rows, columns } = await stub._fgFindEdgesProjected(select, filters, options);
-    return rows.map((row) => decodeDOProjectedRow(row, columns));
+    return rows.map((row) => decodeProjectedRow(row, columns));
   }
   // --- Cross-scope queries ---
   //
@@ -1045,7 +510,7 @@ var FiregraphDO = class extends DurableObject {
     super(ctx, env);
     this.state = ctx;
     const table = options.table ?? DEFAULT_OPTIONS.table;
-    validateDOTableName(table);
+    validateTableName(table);
     this.table = table;
     this.registry = options.registry;
     this.coreIndexes = options.coreIndexes;
@@ -1064,12 +529,12 @@ var FiregraphDO = class extends DurableObject {
   // `src/cloudflare/backend.ts` calls these directly on the DO stub.
   // ---------------------------------------------------------------------------
   async _fgGetDoc(docId) {
-    const stmt = compileDOSelectByDocId(this.table, docId);
+    const stmt = compileSelectByDocId(this.table, docId);
     const rows = this.execAll(stmt);
     return rows.length === 0 ? null : rowToDORecord(rows[0]);
   }
   async _fgQuery(filters, options) {
-    const stmt = compileDOSelect(this.table, filters, options);
+    const stmt = compileSelect(this.table, filters, options);
     const rows = this.execAll(stmt);
     return rows.map(rowToDORecord);
   }
@@ -1081,7 +546,7 @@ var FiregraphDO = class extends DurableObject {
    * the wire payload stays a plain row of (alias → number | null).
    */
   async _fgAggregate(spec, filters) {
-    const { stmt, aliases } = compileDOAggregate(this.table, spec, filters);
+    const { stmt, aliases } = compileAggregate(this.table, spec, filters);
     const rows = this.execAll(stmt);
     const row = rows[0] ?? {};
     const out = {};
@@ -1098,11 +563,11 @@ var FiregraphDO = class extends DurableObject {
   // RPC: writes
   // ---------------------------------------------------------------------------
   async _fgSetDoc(docId, record, mode) {
-    const stmt = compileDOSet(this.table, docId, record, Date.now(), mode);
+    const stmt = compileSet(this.table, docId, record, Date.now(), mode);
     this.execRun(stmt);
   }
   async _fgUpdateDoc(docId, update) {
-    const stmt = compileDOUpdate(this.table, docId, update, Date.now());
+    const stmt = compileUpdate(this.table, docId, update, Date.now());
     const sqlWithReturning = `${stmt.sql} RETURNING "doc_id"`;
     const rows = this.state.storage.sql.exec(sqlWithReturning, ...stmt.params).toArray();
     if (rows.length === 0) {
@@ -1110,7 +575,7 @@ var FiregraphDO = class extends DurableObject {
     }
   }
   async _fgDeleteDoc(docId) {
-    const stmt = compileDODelete(this.table, docId);
+    const stmt = compileDelete(this.table, docId);
     this.execRun(stmt);
   }
   // ---------------------------------------------------------------------------
@@ -1128,11 +593,11 @@ var FiregraphDO = class extends DurableObject {
     const statements = ops.map((op) => {
       switch (op.kind) {
         case "set":
-          return compileDOSet(this.table, op.docId, op.record, now, op.mode);
+          return compileSet(this.table, op.docId, op.record, now, op.mode);
         case "update":
-          return compileDOUpdate(this.table, op.docId, op.update, now);
+          return compileUpdate(this.table, op.docId, op.update, now);
         case "delete":
-          return compileDODelete(this.table, op.docId);
+          return compileDelete(this.table, op.docId);
       }
     });
     this.state.storage.transactionSync(() => {
@@ -1151,8 +616,8 @@ var FiregraphDO = class extends DurableObject {
   // Without that topology the DO has no way to enumerate its children.
   // ---------------------------------------------------------------------------
   async _fgRemoveNodeCascade(uid) {
-    const outgoingStmt = compileDOSelect(this.table, [{ field: "aUid", op: "==", value: uid }]);
-    const incomingStmt = compileDOSelect(this.table, [{ field: "bUid", op: "==", value: uid }]);
+    const outgoingStmt = compileSelect(this.table, [{ field: "aUid", op: "==", value: uid }]);
+    const incomingStmt = compileSelect(this.table, [{ field: "bUid", op: "==", value: uid }]);
     const outgoingRows = this.execAll(outgoingStmt);
     const incomingRows = this.execAll(incomingStmt);
     const seen = /* @__PURE__ */ new Set();
@@ -1172,9 +637,9 @@ var FiregraphDO = class extends DurableObject {
         edgeDocIds.push(docId);
       }
     }
-    const statements = edgeDocIds.map((id) => compileDODelete(this.table, id));
+    const statements = edgeDocIds.map((id) => compileDelete(this.table, id));
     if (nodeExists) {
-      statements.push(compileDODelete(this.table, computeNodeDocId(uid)));
+      statements.push(compileDelete(this.table, computeNodeDocId(uid)));
     }
     if (statements.length === 0) {
       return {
@@ -1213,11 +678,11 @@ var FiregraphDO = class extends DurableObject {
     const plan = buildEdgeQueryPlan(params);
     let docIds;
     if (plan.strategy === "get") {
-      const existsStmt = compileDOSelectByDocId(this.table, plan.docId);
+      const existsStmt = compileSelectByDocId(this.table, plan.docId);
       const rows = this.execAll(existsStmt);
       docIds = rows.length > 0 ? [plan.docId] : [];
     } else {
-      const selectStmt = compileDOSelect(this.table, plan.filters, plan.options);
+      const selectStmt = compileSelect(this.table, plan.filters, plan.options);
       const rows = this.execAll(selectStmt);
       docIds = rows.map(
         (row) => computeEdgeDocId(row.a_uid, row.axb_type, row.b_uid)
@@ -1226,7 +691,7 @@ var FiregraphDO = class extends DurableObject {
     if (docIds.length === 0) {
       return { deleted: 0, batches: 0, errors: [] };
     }
-    const deleteStmts = docIds.map((id) => compileDODelete(this.table, id));
+    const deleteStmts = docIds.map((id) => compileDelete(this.table, id));
     try {
       this.state.storage.transactionSync(() => {
         for (const stmt of deleteStmts) {
@@ -1271,12 +736,12 @@ var FiregraphDO = class extends DurableObject {
         "INVALID_ARGUMENT"
       );
     }
-    const stmt = compileDOBulkDelete(this.table, filters);
+    const stmt = compileBulkDelete(this.table, filters);
     return this.execDmlWithReturning(stmt);
   }
   async _fgBulkUpdate(filters, patch, _options) {
     void _options;
-    const stmt = compileDOBulkUpdate(this.table, filters, patch.data, Date.now());
+    const stmt = compileBulkUpdate(this.table, filters, patch.data, Date.now());
     return this.execDmlWithReturning(stmt);
   }
   // ---------------------------------------------------------------------------
@@ -1293,7 +758,7 @@ var FiregraphDO = class extends DurableObject {
     if (params.sources.length === 0) {
       return params.hydrate ? { edges: [], targets: [] } : { edges: [] };
     }
-    const stmt = compileDOExpand(this.table, params);
+    const stmt = compileExpand(this.table, params);
     const rows = this.state.storage.sql.exec(stmt.sql, ...stmt.params).toArray();
     const edges = rows.map((row) => rowToDORecord(row));
     if (!params.hydrate) {
@@ -1305,7 +770,7 @@ var FiregraphDO = class extends DurableObject {
     if (uniqueTargets.length === 0) {
       return { edges, targets: [] };
     }
-    const hydrateStmt = compileDOExpandHydrate(this.table, uniqueTargets);
+    const hydrateStmt = compileExpandHydrate(this.table, uniqueTargets);
     const hydrateRows = this.state.storage.sql.exec(hydrateStmt.sql, ...hydrateStmt.params).toArray();
     const byUid = /* @__PURE__ */ new Map();
     for (const row of hydrateRows) {
@@ -1327,7 +792,7 @@ var FiregraphDO = class extends DurableObject {
   // a typical projection); structured clone copes happily.
   // ---------------------------------------------------------------------------
   async _fgFindEdgesProjected(select, filters, options) {
-    const { stmt, columns } = compileDOFindEdgesProjected(this.table, select, filters, options);
+    const { stmt, columns } = compileFindEdgesProjected(this.table, select, filters, options);
     const rows = this.state.storage.sql.exec(stmt.sql, ...stmt.params).toArray();
     return { rows, columns };
   }
@@ -1365,14 +830,14 @@ var FiregraphDO = class extends DurableObject {
    * forever), but its storage can be emptied.
    */
   async _fgDestroy() {
-    const stmt = compileDODeleteAll(this.table);
+    const stmt = compileDeleteAll(this.table);
     this.execRun(stmt);
   }
   // ---------------------------------------------------------------------------
   // Internals
   // ---------------------------------------------------------------------------
   runSchema() {
-    const statements = buildDOSchemaStatements(this.table, {
+    const statements = buildSchemaStatements(this.table, {
       coreIndexes: this.coreIndexes,
       registry: this.registry
     });
@@ -1393,7 +858,7 @@ export {
   FiregraphDO,
   META_EDGE_TYPE,
   META_NODE_TYPE,
-  buildDOSchemaStatements,
+  buildSchemaStatements as buildDOSchemaStatements,
   createCapabilities,
   createDOClient,
   createMergedRegistry,