js-bao 0.3.0 → 0.4.0

package/dist/cloudflare-do.cjs

@@ -1,8 +1,13 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -15,17 +20,542 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/utils/sql.ts
+function isValidIdentifier(name) {
+  return IDENTIFIER_PATTERN.test(name);
+}
+function assertValidIdentifier(name, context) {
+  if (!isValidIdentifier(name)) {
+    throw new Error(
+      `${context}: Identifier "${name}" must match ${IDENTIFIER_PATTERN.source}`
+    );
+  }
+}
+function quoteIdentifier(name) {
+  return `"${name.replace(/"/g, '""')}"`;
+}
+var IDENTIFIER_PATTERN;
+var init_sql = __esm({
+  "src/utils/sql.ts"() {
+    "use strict";
+    IDENTIFIER_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+  }
+});
+
+// src/types/queryTypes.ts
+var DocumentQueryError, InvalidOperatorError, InvalidFieldError, InvalidCursorError;
+var init_queryTypes = __esm({
+  "src/types/queryTypes.ts"() {
+    "use strict";
+    DocumentQueryError = class _DocumentQueryError extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "DocumentQueryError";
+        Object.setPrototypeOf(this, _DocumentQueryError.prototype);
+      }
+    };
+    InvalidOperatorError = class _InvalidOperatorError extends DocumentQueryError {
+      field;
+      operator;
+      fieldType;
+      constructor(message, field, operator, fieldType) {
+        super(message);
+        this.name = "InvalidOperatorError";
+        this.field = field;
+        this.operator = operator;
+        this.fieldType = fieldType;
+        Object.setPrototypeOf(this, _InvalidOperatorError.prototype);
+      }
+    };
+    InvalidFieldError = class _InvalidFieldError extends DocumentQueryError {
+      field;
+      modelName;
+      constructor(message, field, modelName) {
+        super(message);
+        this.name = "InvalidFieldError";
+        this.field = field;
+        this.modelName = modelName;
+        Object.setPrototypeOf(this, _InvalidFieldError.prototype);
+      }
+    };
+    InvalidCursorError = class _InvalidCursorError extends DocumentQueryError {
+      cursor;
+      constructor(message, cursor) {
+        super(message);
+        this.name = "InvalidCursorError";
+        this.cursor = cursor;
+        Object.setPrototypeOf(this, _InvalidCursorError.prototype);
+      }
+    };
+  }
+});
+
+// src/query/CursorManager.ts
+var base64Encode, base64Decode, CursorManager;
+var init_CursorManager = __esm({
+  "src/query/CursorManager.ts"() {
+    "use strict";
+    init_queryTypes();
+    base64Encode = (str) => {
+      if (typeof btoa !== "undefined") {
+        return btoa(str);
+      } else if (typeof Buffer !== "undefined") {
+        return Buffer.from(str, "utf-8").toString("base64");
+      } else {
+        throw new Error("No base64 encoding available");
+      }
+    };
+    base64Decode = (str) => {
+      if (typeof atob !== "undefined") {
+        return atob(str);
+      } else if (typeof Buffer !== "undefined") {
+        return Buffer.from(str, "base64").toString("utf-8");
+      } else {
+        throw new Error("No base64 decoding available");
+      }
+    };
+    CursorManager = class {
+      /**
+       * Encode cursor data to base64 string
+       */
+      static encodeCursor(cursorData) {
+        try {
+          const jsonString = JSON.stringify(cursorData);
+          return base64Encode(jsonString);
+        } catch (error) {
+          throw new InvalidCursorError(
+            `Failed to encode cursor: ${error instanceof Error ? error.message : "Unknown error"}`,
+            JSON.stringify(cursorData)
+          );
+        }
+      }
+      /**
+       * Decode base64 cursor string to cursor data
+       */
+      static decodeCursor(cursor) {
+        try {
+          const jsonString = base64Decode(cursor);
+          const parsed = JSON.parse(jsonString);
+          if (!parsed || typeof parsed !== "object") {
+            throw new Error("Cursor must be an object");
+          }
+          if (!parsed.values || typeof parsed.values !== "object") {
+            throw new Error("Cursor must have values object");
+          }
+          if (!Array.isArray(parsed.sortFields)) {
+            throw new Error("Cursor must have sortFields array");
+          }
+          if (parsed.direction !== 1 && parsed.direction !== -1) {
+            throw new Error("Cursor direction must be 1 or -1");
+          }
+          return parsed;
+        } catch (error) {
+          throw new InvalidCursorError(
+            `Failed to decode cursor: ${error instanceof Error ? error.message : "Unknown error"}`,
+            cursor
+          );
+        }
+      }
+      /**
+       * Generate cursor from a record and sort specification
+       */
+      static generateCursor(record, sortFields, direction) {
+        const values = {};
+        for (const field of sortFields) {
+          if (record.hasOwnProperty(field)) {
+            values[field] = record[field];
+          } else {
+            throw new Error(
+              `Cannot generate cursor: record missing sort field '${field}'`
+            );
+          }
+        }
+        const cursorData = {
+          values,
+          sortFields,
+          direction
+        };
+        return this.encodeCursor(cursorData);
+      }
+      /**
+       * Build SQL pagination conditions based on cursor
+       * Uses lexicographic ordering for stable pagination with multiple sort fields
+       */
+      static buildPaginationConditions(cursor, currentSortFields, sortDirections, requestedDirection, fieldFormatter = (field) => field) {
+        if (!this.arraysEqual(cursor.sortFields, currentSortFields)) {
+          throw new InvalidCursorError(
+            `Cursor sort fields [${cursor.sortFields.join(
+              ", "
+            )}] don't match query sort fields [${currentSortFields.join(", ")}]`,
+            JSON.stringify(cursor)
+          );
+        }
+        const conditions = [];
+        const params = [];
+        const sortFields = cursor.sortFields;
+        const direction = requestedDirection;
+        for (let i = 0; i < sortFields.length; i++) {
+          const fieldConditions = [];
+          const fieldParams = [];
+          for (let j = 0; j < i; j++) {
+            const field = sortFields[j];
+            const value = cursor.values[field];
+            fieldConditions.push(`${fieldFormatter(field)} = ?`);
+            fieldParams.push(value);
+          }
+          const currentField = sortFields[i];
+          const currentValue = cursor.values[currentField];
+          const fieldSortDir = sortDirections[i] ?? 1;
+          const forwardOp = fieldSortDir === 1 ? ">" : "<";
+          const operator = direction === 1 ? forwardOp : forwardOp === ">" ? "<" : ">";
+          fieldConditions.push(`${fieldFormatter(currentField)} ${operator} ?`);
+          fieldParams.push(currentValue);
+          const levelCondition = fieldConditions.join(" AND ");
+          conditions.push(`(${levelCondition})`);
+          params.push(...fieldParams);
+        }
+        const sql = `(${conditions.join(" OR ")})`;
+        return { sql, params };
+      }
+      /**
+       * Extract sort fields from sort specification, ensuring 'id' is always included for stability
+       */
+      static extractSortFields(sort) {
+        const fields = [];
+        if (sort && Object.keys(sort).length > 0) {
+          fields.push(...Object.keys(sort));
+        }
+        if (!fields.includes("id")) {
+          fields.push("id");
+        }
+        return fields;
+      }
+      /**
+       * Build ORDER BY clause from sort specification
+       */
+      static buildOrderClause(sort, fieldFormatter = (field) => field) {
+        const fields = this.extractSortFields(sort);
+        const clauses = [];
+        const directions = [];
+        if (sort && Object.keys(sort).length > 0) {
+          for (const [field, dir] of Object.entries(sort)) {
+            const sqlDirection = dir === 1 ? "ASC" : "DESC";
+            clauses.push(`${fieldFormatter(field)} ${sqlDirection}`);
+            directions.push(dir);
+          }
+        }
+        if (!sort || !sort.hasOwnProperty("id")) {
+          clauses.push(`${fieldFormatter("id")} ASC`);
+          directions.push(1);
+        } else if (sort && sort.hasOwnProperty("id")) {
+          directions.push(sort["id"]);
+        }
+        return {
+          sql: clauses.join(", "),
+          fields,
+          directions
+        };
+      }
+      /**
+       * Determine if there are more results available for pagination
+       */
+      static hasMoreResults(requestedLimit, actualResultCount) {
+        if (!requestedLimit || requestedLimit <= 0) {
+          return false;
+        }
+        return actualResultCount >= requestedLimit;
+      }
+      /**
+       * Generate next and previous cursors from result set
+       */
+      static generateResultCursors(results, sortFields, _requestedDirection, hasMore, isFirstPage = false) {
+        if (results.length === 0) {
+          return {};
+        }
+        const cursors = {};
+        if (hasMore && results.length > 0) {
+          const lastResult = results[results.length - 1];
+          cursors.nextCursor = this.generateCursor(lastResult, sortFields, 1);
+        }
+        if (results.length > 0 && !isFirstPage) {
+          const firstResult = results[0];
+          cursors.prevCursor = this.generateCursor(firstResult, sortFields, -1);
+        }
+        return cursors;
+      }
+      /**
+       * Utility to compare arrays for equality
+       */
+      static arraysEqual(a, b) {
+        if (a.length !== b.length) return false;
+        return a.every((val, index) => val === b[index]);
+      }
+    };
+  }
+});
+
+// src/utils/patterns.ts
+function escapeLikeLiteral(input) {
+  return input.replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_");
+}
+function buildLikePattern(value, mode) {
+  const trimmed = (value ?? "").trim();
+  if (trimmed.length === 0) return null;
+  if (trimmed.length > 1024) {
+    throw new Error("substring value exceeds 1024 characters");
+  }
+  const escaped = escapeLikeLiteral(trimmed);
+  switch (mode) {
+    case "startsWith":
+      return `${escaped}%`;
+    case "endsWith":
+      return `%${escaped}`;
+    case "containsText":
+      return `%${escaped}%`;
+  }
+}
+function shouldLogLikeEscapes() {
+  try {
+    if (typeof process !== "undefined" && process.env) {
+      return !!process.env.JS_BAO_DEBUG_LIKE_ESCAPES;
+    }
+  } catch {
+  }
+  return false;
+}
+var init_patterns = __esm({
+  "src/utils/patterns.ts"() {
+    "use strict";
+  }
+});
+
+// src/models/StringSet.ts
+var init_StringSet = __esm({
+  "src/models/StringSet.ts"() {
+    "use strict";
+  }
+});
+
+// src/types/documentTypes.ts
+var init_documentTypes = __esm({
+  "src/types/documentTypes.ts"() {
+    "use strict";
+  }
+});
+
+// src/query/DocumentQueryTranslator.ts
+var init_DocumentQueryTranslator = __esm({
+  "src/query/DocumentQueryTranslator.ts"() {
+    "use strict";
+    init_queryTypes();
+    init_CursorManager();
+    init_sql();
+    init_patterns();
+  }
+});
+
+// src/models/metaSync.ts
+function inferFieldType(value) {
+  if (value instanceof Y2.Map) return "stringset";
+  switch (typeof value) {
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    default:
+      return null;
+  }
+}
+function registerFunctionDefault(fn, name) {
+  KNOWN_FUNCTION_DEFAULTS.set(fn, name);
+}
+function encodeDefault(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value === "function") {
+    const name = KNOWN_FUNCTION_DEFAULTS.get(value);
+    return name ? `$${name}` : "$unknown_function";
+  }
+  return value;
+}
+function clearMetaSyncCache(yDoc) {
+  if (yDoc) {
+    _syncedCache.delete(yDoc);
+  }
+}
+function syncModelMeta(yDoc, modelName, schema) {
+  let synced = _syncedCache.get(yDoc);
+  if (synced?.has(modelName)) return;
+  if (!synced) {
+    synced = /* @__PURE__ */ new Set();
+    _syncedCache.set(yDoc, synced);
+  }
+  const meta = yDoc.getMap(`_meta_${modelName}`);
+  for (const [fieldName, fieldOpts] of schema.fields.entries()) {
+    syncFieldMeta(meta, fieldName, fieldOpts);
+  }
+  const compoundConstraints = schema.resolvedUniqueConstraints.filter(
+    (c) => c.fields.length > 1
+  );
+  if (compoundConstraints.length > 0) {
+    let constraints = meta.get("_constraints");
+    if (!constraints) {
+      constraints = new Y2.Map();
+      meta.set("_constraints", constraints);
+    }
+    for (const constraint of compoundConstraints) {
+      syncConstraintMeta(constraints, constraint);
+    }
+  }
+  const relationships = schema.options.relationships;
+  if (relationships && Object.keys(relationships).length > 0) {
+    let rels = meta.get("_relationships");
+    if (!rels) {
+      rels = new Y2.Map();
+      meta.set("_relationships", rels);
+    }
+    for (const [relName, relConfig] of Object.entries(relationships)) {
+      syncRelationshipMeta(rels, relName, relConfig);
+    }
+  }
+  synced.add(modelName);
+}
+function syncFieldMeta(metaMap, fieldName, fieldOpts) {
+  let fieldMeta = metaMap.get(fieldName);
+  if (!fieldMeta) {
+    fieldMeta = new Y2.Map();
+    metaMap.set(fieldName, fieldMeta);
+  }
+  setIfChanged(fieldMeta, "type", fieldOpts.type);
+  if (fieldOpts.indexed) setIfChanged(fieldMeta, "indexed", true);
+  if (fieldOpts.unique) setIfChanged(fieldMeta, "unique", true);
+  if (fieldOpts.required) setIfChanged(fieldMeta, "required", true);
+  if (fieldOpts.autoAssign) setIfChanged(fieldMeta, "autoAssign", true);
+  if (fieldOpts.maxLength !== void 0) setIfChanged(fieldMeta, "maxLength", fieldOpts.maxLength);
+  if (fieldOpts.maxCount !== void 0) setIfChanged(fieldMeta, "maxCount", fieldOpts.maxCount);
+  const encoded = encodeDefault(fieldOpts.default);
+  if (encoded !== void 0) setIfChanged(fieldMeta, "default", encoded);
+}
+function syncConstraintMeta(constraintsMap, constraint) {
+  let cMeta = constraintsMap.get(constraint.name);
+  if (!cMeta) {
+    cMeta = new Y2.Map();
+    constraintsMap.set(constraint.name, cMeta);
+  }
+  setIfChanged(cMeta, "type", "unique");
+  const fieldsJson = JSON.stringify(constraint.fields);
+  setIfChanged(cMeta, "fields", fieldsJson);
+}
+function syncRelationshipMeta(relsMap, relName, relConfig) {
+  let relMeta = relsMap.get(relName);
+  if (!relMeta) {
+    relMeta = new Y2.Map();
+    relsMap.set(relName, relMeta);
+  }
+  for (const [key, value] of Object.entries(relConfig)) {
+    if (value !== void 0) {
+      setIfChanged(relMeta, key, value);
+    }
+  }
+}
+function syncInferredMeta(yDoc, modelName, recordData) {
+  const meta = yDoc.getMap(`_meta_${modelName}`);
+  for (const [fieldName, value] of Object.entries(recordData)) {
+    if (fieldName.startsWith("_")) continue;
+    let fieldMeta = meta.get(fieldName);
+    if (!fieldMeta) {
+      fieldMeta = new Y2.Map();
+      meta.set(fieldName, fieldMeta);
+    }
+    if (!fieldMeta.has("type")) {
+      const inferredType = inferFieldType(value);
+      if (inferredType) {
+        fieldMeta.set("type", inferredType);
+      }
+    }
+  }
+}
+function setIfChanged(map, key, value) {
+  if (map.get(key) !== value) {
+    map.set(key, value);
+  }
+}
+var Y2, KNOWN_FUNCTION_DEFAULTS, _syncedCache;
+var init_metaSync = __esm({
+  "src/models/metaSync.ts"() {
+    "use strict";
+    Y2 = __toESM(require("yjs"), 1);
+    KNOWN_FUNCTION_DEFAULTS = /* @__PURE__ */ new WeakMap();
+    _syncedCache = /* @__PURE__ */ new WeakMap();
+  }
+});
+
+// src/models/BaseModel.ts
+function generateULID() {
+  return (0, import_ulid2.ulid)();
+}
+var Y3, import_ulid2;
+var init_BaseModel = __esm({
+  "src/models/BaseModel.ts"() {
+    "use strict";
+    Y3 = __toESM(require("yjs"), 1);
+    import_ulid2 = require("ulid");
+    init_StringSet();
+    init_documentTypes();
+    init_DocumentQueryTranslator();
+    init_CursorManager();
+    init_sql();
+    init_metaSync();
+    registerFunctionDefault(generateULID, "generate_ulid");
+  }
+});
+
+// src/models/relationshipManager.ts
+var init_relationshipManager = __esm({
+  "src/models/relationshipManager.ts"() {
+    "use strict";
+    init_BaseModel();
+  }
+});
+
+// src/models/ModelRegistry.ts
+var init_ModelRegistry = __esm({
+  "src/models/ModelRegistry.ts"() {
+    "use strict";
+    init_BaseModel();
+    init_relationshipManager();
+  }
+});
+
 // src/cloudflare-do.ts
 var cloudflare_do_exports = {};
 __export(cloudflare_do_exports, {
   DurableObjectEngine: () => DurableObjectEngine,
   JsonQueryTranslator: () => JsonQueryTranslator,
   JsonSchemaDDL: () => JsonSchemaDDL,
+  clearMetaSyncCache: () => clearMetaSyncCache,
   createDatabaseDO: () => createDatabaseDO,
   createDocumentDO: () => createDocumentDO,
-  handleRequest: () => handleRequest
+  discoverModelNames: () => discoverModelNames,
+  discoverSchema: () => discoverSchema,
+  handleRequest: () => handleRequest,
+  inferFieldType: () => inferFieldType,
+  loadSchemaFromTomlString: () => loadSchemaFromTomlString,
+  registerFunctionDefault: () => registerFunctionDefault,
+  schemaToToml: () => schemaToToml,
+  syncInferredMeta: () => syncInferredMeta,
+  syncModelMeta: () => syncModelMeta
 });
 module.exports = __toCommonJS(cloudflare_do_exports);
 
@@ -67,23 +597,8 @@ var DatabaseEngine = class {
   }
 };
 
-// src/utils/sql.ts
-var IDENTIFIER_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
-function isValidIdentifier(name) {
-  return IDENTIFIER_PATTERN.test(name);
-}
-function assertValidIdentifier(name, context) {
-  if (!isValidIdentifier(name)) {
-    throw new Error(
-      `${context}: Identifier "${name}" must match ${IDENTIFIER_PATTERN.source}`
-    );
-  }
-}
-function quoteIdentifier(name) {
-  return `"${name.replace(/"/g, '""')}"`;
-}
-
 // src/schema/JsonSchemaDDL.ts
+init_sql();
 var JsonSchemaDDL = class {
   /**
    * Generate CREATE TABLE statement for the records table
@@ -477,6 +992,7 @@ var JsonSchemaEngine = class extends DatabaseEngine {
 };
 
 // src/engines/cloudflare/DurableObjectEngine.ts
+init_sql();
 var DurableObjectEngine = class extends JsonSchemaEngine {
   sql;
   storage;
@@ -1047,276 +1563,11 @@ var DurableObjectEngine = class extends JsonSchemaEngine {
   }
 };
 
-// src/types/queryTypes.ts
-var DocumentQueryError = class _DocumentQueryError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "DocumentQueryError";
-    Object.setPrototypeOf(this, _DocumentQueryError.prototype);
-  }
-};
-var InvalidOperatorError = class _InvalidOperatorError extends DocumentQueryError {
-  field;
-  operator;
-  fieldType;
-  constructor(message, field, operator, fieldType) {
-    super(message);
-    this.name = "InvalidOperatorError";
-    this.field = field;
-    this.operator = operator;
-    this.fieldType = fieldType;
-    Object.setPrototypeOf(this, _InvalidOperatorError.prototype);
-  }
-};
-var InvalidFieldError = class _InvalidFieldError extends DocumentQueryError {
-  field;
-  modelName;
-  constructor(message, field, modelName) {
-    super(message);
-    this.name = "InvalidFieldError";
-    this.field = field;
-    this.modelName = modelName;
-    Object.setPrototypeOf(this, _InvalidFieldError.prototype);
-  }
-};
-var InvalidCursorError = class _InvalidCursorError extends DocumentQueryError {
-  cursor;
-  constructor(message, cursor) {
-    super(message);
-    this.name = "InvalidCursorError";
-    this.cursor = cursor;
-    Object.setPrototypeOf(this, _InvalidCursorError.prototype);
-  }
-};
-
-// src/query/CursorManager.ts
-var base64Encode = (str) => {
-  if (typeof btoa !== "undefined") {
-    return btoa(str);
-  } else if (typeof Buffer !== "undefined") {
-    return Buffer.from(str, "utf-8").toString("base64");
-  } else {
-    throw new Error("No base64 encoding available");
-  }
-};
-var base64Decode = (str) => {
-  if (typeof atob !== "undefined") {
-    return atob(str);
-  } else if (typeof Buffer !== "undefined") {
-    return Buffer.from(str, "base64").toString("utf-8");
-  } else {
-    throw new Error("No base64 decoding available");
-  }
-};
-var CursorManager = class {
-  /**
-   * Encode cursor data to base64 string
-   */
-  static encodeCursor(cursorData) {
-    try {
-      const jsonString = JSON.stringify(cursorData);
-      return base64Encode(jsonString);
-    } catch (error) {
-      throw new InvalidCursorError(
-        `Failed to encode cursor: ${error instanceof Error ? error.message : "Unknown error"}`,
-        JSON.stringify(cursorData)
-      );
-    }
-  }
-  /**
-   * Decode base64 cursor string to cursor data
-   */
-  static decodeCursor(cursor) {
-    try {
-      const jsonString = base64Decode(cursor);
-      const parsed = JSON.parse(jsonString);
-      if (!parsed || typeof parsed !== "object") {
-        throw new Error("Cursor must be an object");
-      }
-      if (!parsed.values || typeof parsed.values !== "object") {
-        throw new Error("Cursor must have values object");
-      }
-      if (!Array.isArray(parsed.sortFields)) {
-        throw new Error("Cursor must have sortFields array");
-      }
-      if (parsed.direction !== 1 && parsed.direction !== -1) {
-        throw new Error("Cursor direction must be 1 or -1");
-      }
-      return parsed;
-    } catch (error) {
-      throw new InvalidCursorError(
-        `Failed to decode cursor: ${error instanceof Error ? error.message : "Unknown error"}`,
-        cursor
-      );
-    }
-  }
-  /**
-   * Generate cursor from a record and sort specification
-   */
-  static generateCursor(record, sortFields, direction) {
-    const values = {};
-    for (const field of sortFields) {
-      if (record.hasOwnProperty(field)) {
-        values[field] = record[field];
-      } else {
-        throw new Error(
-          `Cannot generate cursor: record missing sort field '${field}'`
-        );
-      }
-    }
-    const cursorData = {
-      values,
-      sortFields,
-      direction
-    };
-    return this.encodeCursor(cursorData);
-  }
-  /**
-   * Build SQL pagination conditions based on cursor
-   * Uses lexicographic ordering for stable pagination with multiple sort fields
-   */
-  static buildPaginationConditions(cursor, currentSortFields, sortDirections, requestedDirection, fieldFormatter = (field) => field) {
-    if (!this.arraysEqual(cursor.sortFields, currentSortFields)) {
-      throw new InvalidCursorError(
-        `Cursor sort fields [${cursor.sortFields.join(
-          ", "
-        )}] don't match query sort fields [${currentSortFields.join(", ")}]`,
-        JSON.stringify(cursor)
-      );
-    }
-    const conditions = [];
-    const params = [];
-    const sortFields = cursor.sortFields;
-    const direction = requestedDirection;
-    for (let i = 0; i < sortFields.length; i++) {
-      const fieldConditions = [];
-      const fieldParams = [];
-      for (let j = 0; j < i; j++) {
-        const field = sortFields[j];
-        const value = cursor.values[field];
-        fieldConditions.push(`${fieldFormatter(field)} = ?`);
-        fieldParams.push(value);
-      }
-      const currentField = sortFields[i];
-      const currentValue = cursor.values[currentField];
-      const fieldSortDir = sortDirections[i] ?? 1;
-      const forwardOp = fieldSortDir === 1 ? ">" : "<";
-      const operator = direction === 1 ? forwardOp : forwardOp === ">" ? "<" : ">";
-      fieldConditions.push(`${fieldFormatter(currentField)} ${operator} ?`);
-      fieldParams.push(currentValue);
-      const levelCondition = fieldConditions.join(" AND ");
-      conditions.push(`(${levelCondition})`);
-      params.push(...fieldParams);
-    }
-    const sql = `(${conditions.join(" OR ")})`;
-    return { sql, params };
-  }
-  /**
-   * Extract sort fields from sort specification, ensuring 'id' is always included for stability
-   */
-  static extractSortFields(sort) {
-    const fields = [];
-    if (sort && Object.keys(sort).length > 0) {
-      fields.push(...Object.keys(sort));
-    }
-    if (!fields.includes("id")) {
-      fields.push("id");
-    }
-    return fields;
-  }
-  /**
-   * Build ORDER BY clause from sort specification
-   */
-  static buildOrderClause(sort, fieldFormatter = (field) => field) {
-    const fields = this.extractSortFields(sort);
-    const clauses = [];
-    const directions = [];
-    if (sort && Object.keys(sort).length > 0) {
-      for (const [field, dir] of Object.entries(sort)) {
-        const sqlDirection = dir === 1 ? "ASC" : "DESC";
-        clauses.push(`${fieldFormatter(field)} ${sqlDirection}`);
-        directions.push(dir);
-      }
-    }
-    if (!sort || !sort.hasOwnProperty("id")) {
-      clauses.push(`${fieldFormatter("id")} ASC`);
-      directions.push(1);
-    } else if (sort && sort.hasOwnProperty("id")) {
-      directions.push(sort["id"]);
-    }
-    return {
-      sql: clauses.join(", "),
-      fields,
-      directions
-    };
-  }
-  /**
-   * Determine if there are more results available for pagination
-   */
-  static hasMoreResults(requestedLimit, actualResultCount) {
-    if (!requestedLimit || requestedLimit <= 0) {
-      return false;
-    }
-    return actualResultCount >= requestedLimit;
-  }
-  /**
-   * Generate next and previous cursors from result set
-   */
-  static generateResultCursors(results, sortFields, _requestedDirection, hasMore, isFirstPage = false) {
-    if (results.length === 0) {
-      return {};
-    }
-    const cursors = {};
-    if (hasMore && results.length > 0) {
-      const lastResult = results[results.length - 1];
-      cursors.nextCursor = this.generateCursor(lastResult, sortFields, 1);
-    }
-    if (results.length > 0 && !isFirstPage) {
-      const firstResult = results[0];
-      cursors.prevCursor = this.generateCursor(firstResult, sortFields, -1);
-    }
-    return cursors;
-  }
-  /**
-   * Utility to compare arrays for equality
-   */
-  static arraysEqual(a, b) {
-    if (a.length !== b.length) return false;
-    return a.every((val, index) => val === b[index]);
-  }
-};
-
-// src/utils/patterns.ts
-function escapeLikeLiteral(input) {
-  return input.replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_");
-}
-function buildLikePattern(value, mode) {
-  const trimmed = (value ?? "").trim();
-  if (trimmed.length === 0) return null;
-  if (trimmed.length > 1024) {
-    throw new Error("substring value exceeds 1024 characters");
-  }
-  const escaped = escapeLikeLiteral(trimmed);
-  switch (mode) {
-    case "startsWith":
-      return `${escaped}%`;
-    case "endsWith":
-      return `%${escaped}`;
-    case "containsText":
-      return `%${escaped}%`;
-  }
-}
-function shouldLogLikeEscapes() {
-  try {
-    if (typeof process !== "undefined" && process.env) {
-      return !!process.env.JS_BAO_DEBUG_LIKE_ESCAPES;
-    }
-  } catch {
-  }
-  return false;
-}
-
 // src/query/JsonQueryTranslator.ts
+init_queryTypes();
+init_CursorManager();
+init_sql();
+init_patterns();
 var SYSTEM_FIELDS = /* @__PURE__ */ new Set(["id", "type"]);
 var JsonQueryTranslator = class {
   modelName;
@@ -1995,6 +2246,8 @@ var JsonQueryTranslator = class {
 };
 
 // src/engines/cloudflare/createDocumentDO.ts
+init_CursorManager();
+init_sql();
 var import_ulid = require("ulid");
 function createDatabaseDO(config = {}) {
   const hooks = config.hooks;
@@ -3804,3 +4057,401 @@ async function handleRequest(request, env) {
   const response = await stub.fetch(doRequest);
   return addCorsHeaders(response);
 }
+
+// src/utils/yDocSchema.ts
+var Y = __toESM(require("yjs"), 1);
+function discoverSchema(yDoc) {
+  const models = {};
+  const metaNames = /* @__PURE__ */ new Set();
+  for (const key of yDoc.share.keys()) {
+    if (!key.startsWith("_meta_")) continue;
+    const map = materializeMap(yDoc, key);
+    if (!map) continue;
+    const modelName = key.slice("_meta_".length);
+    metaNames.add(modelName);
+    models[modelName] = readModelMeta(map);
+  }
+  for (const key of yDoc.share.keys()) {
+    if (key.startsWith("_")) continue;
+    if (metaNames.has(key)) continue;
+    const map = materializeMap(yDoc, key);
+    if (!map || map.size === 0) continue;
+    const inferred = inferModelFromData(map);
+    if (inferred) models[key] = inferred;
+  }
+  return { models };
+}
+function discoverModelNames(yDoc) {
+  const names = [];
+  for (const key of yDoc.share.keys()) {
+    if (key.startsWith("_")) continue;
+    const map = materializeMap(yDoc, key);
+    if (map) names.push(key);
+  }
+  return names.sort();
+}
+function materializeMap(yDoc, key) {
+  try {
+    const map = yDoc.getMap(key);
+    return map instanceof Y.Map ? map : null;
+  } catch {
+    return null;
+  }
+}
+function readModelMeta(metaMap) {
+  const fields = {};
+  let constraints;
+  let relationships;
+  for (const [key, value] of metaMap.entries()) {
+    if (key === "_constraints" && value instanceof Y.Map) {
+      constraints = readConstraints(value);
+    } else if (key === "_relationships" && value instanceof Y.Map) {
+      relationships = readRelationships(value);
+    } else if (value instanceof Y.Map) {
+      fields[key] = readFieldMeta(value);
+    }
+  }
+  const model = { fields };
+  if (constraints && Object.keys(constraints).length > 0) {
+    model.constraints = constraints;
+  }
+  if (relationships && Object.keys(relationships).length > 0) {
+    model.relationships = relationships;
+  }
+  return model;
+}
+function readFieldMeta(fieldMap) {
+  const field = { type: fieldMap.get("type") ?? "unknown" };
+  if (fieldMap.get("indexed") === true) field.indexed = true;
+  if (fieldMap.get("unique") === true) field.unique = true;
+  if (fieldMap.get("required") === true) field.required = true;
+  if (fieldMap.get("autoAssign") === true) field.autoAssign = true;
+  const def = fieldMap.get("default");
+  if (def !== void 0) field.default = def;
+  const maxLength = fieldMap.get("maxLength");
+  if (maxLength !== void 0) field.maxLength = maxLength;
+  const maxCount = fieldMap.get("maxCount");
+  if (maxCount !== void 0) field.maxCount = maxCount;
+  return field;
+}
+function inferModelFromData(dataMap) {
+  const fields = {};
+  let sampled = 0;
+  for (const [_recordId, recordValue] of dataMap.entries()) {
+    if (!(recordValue instanceof Y.Map)) continue;
+    if (++sampled > 5) break;
+    for (const [fieldName, value] of recordValue.entries()) {
+      if (fieldName.startsWith("_")) continue;
+      if (fields[fieldName]) continue;
+      const type = inferTypeFromValue(value);
+      if (type) fields[fieldName] = { type };
+    }
+  }
+  if (Object.keys(fields).length === 0) return null;
+  return { fields };
+}
+function inferTypeFromValue(value) {
+  if (value instanceof Y.Map) return "stringset";
+  switch (typeof value) {
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    default:
+      return null;
+  }
+}
+function readConstraints(constraintsMap) {
+  const out = {};
+  for (const [name, value] of constraintsMap.entries()) {
+    if (!(value instanceof Y.Map)) continue;
+    let fields = [];
+    const rawFields = value.get("fields");
+    if (typeof rawFields === "string") {
+      try {
+        fields = JSON.parse(rawFields);
+      } catch {
+      }
+    }
+    out[name] = {
+      type: value.get("type") ?? "unknown",
+      fields
+    };
+  }
+  return out;
+}
+function readRelationships(relsMap) {
+  const out = {};
+  for (const [name, value] of relsMap.entries()) {
+    if (!(value instanceof Y.Map)) continue;
+    const rel = {};
+    for (const [k, v] of value.entries()) {
+      rel[k] = v;
+    }
+    out[name] = rel;
+  }
+  return out;
+}
+var CAMEL_TO_SNAKE = {
+  autoAssign: "auto_assign",
+  maxLength: "max_length",
+  maxCount: "max_count",
+  relatedIdField: "related_id_field",
+  joinModel: "join_model",
+  joinModelLocalField: "join_model_local_field",
+  joinModelRelatedField: "join_model_related_field",
+  joinModelOrderByField: "join_model_order_by_field",
+  joinModelOrderDirection: "join_model_order_direction",
+  orderByField: "order_by_field",
+  orderDirection: "order_direction"
+};
+function toSnake(key) {
+  return CAMEL_TO_SNAKE[key] ?? key;
+}
+function tomlValue(v) {
+  if (typeof v === "string") {
+    return `"${v.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t")}"`;
+  }
+  return String(v);
+}
+function schemaToToml(schema) {
+  const lines = [];
+  for (const [modelName, model] of Object.entries(schema.models)) {
+    if (lines.length > 0) lines.push("", "");
+    lines.push(`[models.${modelName}]`);
+    for (const [fieldName, field] of Object.entries(model.fields)) {
+      lines.push("");
+      lines.push(`[models.${modelName}.fields.${fieldName}]`);
+      lines.push(`type = ${tomlValue(field.type)}`);
+      if (field.autoAssign) lines.push("auto_assign = true");
+      if (field.indexed) lines.push("indexed = true");
+      if (field.unique) lines.push("unique = true");
+      if (field.required) lines.push("required = true");
+      if (field.maxLength !== void 0) lines.push(`max_length = ${field.maxLength}`);
+      if (field.maxCount !== void 0) lines.push(`max_count = ${field.maxCount}`);
+      if (field.default !== void 0) lines.push(`default = ${tomlValue(field.default)}`);
+    }
+    if (model.relationships) {
+      for (const [relName, rel] of Object.entries(model.relationships)) {
+        lines.push("");
+        lines.push(`[models.${modelName}.relationships.${relName}]`);
+        for (const [k, v] of Object.entries(rel)) {
+          if (v === void 0) continue;
+          lines.push(`${toSnake(k)} = ${tomlValue(v)}`);
+        }
+      }
+    }
+    if (model.constraints) {
+      for (const [cName, c] of Object.entries(model.constraints)) {
+        lines.push("");
+        lines.push(`[[models.${modelName}.unique_constraints]]`);
+        lines.push(`name = ${tomlValue(cName)}`);
+        lines.push(`fields = [${c.fields.map((f) => tomlValue(f)).join(", ")}]`);
+      }
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/models/tomlLoader.ts
+var import_smol_toml = require("smol-toml");
+
+// src/models/schema.ts
+init_BaseModel();
+init_ModelRegistry();
+function defineModelSchema(input) {
+  const { name, fields } = input;
+  const options = {
+    name,
+    uniqueConstraints: input.options?.uniqueConstraints ? [...input.options.uniqueConstraints] : void 0,
+    relationships: input.options?.relationships
+  };
+  const schema = {
+    name,
+    fields,
+    options,
+    runtimeShape: void 0,
+    buildRuntimeShape(modelClass) {
+      if (schema.runtimeShape && schema.runtimeShape.class === modelClass) {
+        return schema.runtimeShape;
+      }
+      const fieldsMap = /* @__PURE__ */ new Map();
+      for (const [fieldName, fieldOptions] of Object.entries(fields)) {
+        fieldsMap.set(fieldName, { ...fieldOptions });
+      }
+      const resolvedUniqueConstraints = resolveUniqueConstraints(
+        name,
+        fieldsMap,
+        options.uniqueConstraints
+      );
+      schema.runtimeShape = {
+        class: modelClass,
+        options,
+        fields: fieldsMap,
+        resolvedUniqueConstraints
+      };
+      return schema.runtimeShape;
+    }
+  };
+  return schema;
+}
+function resolveUniqueConstraints(modelName, fields, customConstraints) {
+  const resolved = [];
+  for (const [fieldName, options] of fields.entries()) {
+    if (options.unique) {
+      resolved.push({
+        name: `${modelName}_${fieldName}_unique`,
+        fields: [fieldName]
+      });
+    }
+  }
+  if (customConstraints) {
+    for (const constraint of customConstraints) {
+      const missingField = constraint.fields.find(
+        (field) => !fields.has(field)
+      );
+      if (missingField) {
+        console.warn(
+          `[defineModelSchema] Unique constraint "${constraint.name}" for model "${modelName}" references unknown field "${missingField}". Skipping.`
+        );
+        continue;
+      }
+      if (resolved.some((item) => item.name === constraint.name)) {
+        console.warn(
+          `[defineModelSchema] Duplicate unique constraint name "${constraint.name}" in model "${modelName}".`
+        );
+      }
+      resolved.push({
+        name: constraint.name,
+        fields: [...constraint.fields]
+      });
+    }
+  }
+  return resolved;
+}
+
+// src/models/tomlLoader.ts
+var VALID_FIELD_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "number",
+  "boolean",
+  "date",
+  "id",
+  "stringset"
+]);
+function parseFieldOptions(raw) {
+  if (!raw.type || !VALID_FIELD_TYPES.has(raw.type)) {
+    throw new Error(
+      `Invalid field type "${raw.type}". Must be one of: ${[...VALID_FIELD_TYPES].join(", ")}`
+    );
+  }
+  const opts = { type: raw.type };
+  if (raw.indexed === true) opts.indexed = true;
+  if (raw.unique === true) opts.unique = true;
+  if (raw.required === true) opts.required = true;
+  if (raw.auto_assign === true) opts.autoAssign = true;
+  if (raw.max_length !== void 0) opts.maxLength = raw.max_length;
+  if (raw.max_count !== void 0) opts.maxCount = raw.max_count;
+  if (raw.default !== void 0) opts.default = raw.default;
+  return opts;
+}
+function requireField(raw, field, context) {
+  if (!raw[field]) {
+    throw new Error(`Relationship ${context}: missing required field "${field}"`);
+  }
+}
+function parseRelationship(raw) {
+  const type = raw.type;
+  if (type === "refersTo") {
+    requireField(raw, "model", "refersTo");
+    requireField(raw, "related_id_field", "refersTo");
+    return {
+      type: "refersTo",
+      model: raw.model,
+      relatedIdField: raw.related_id_field
+    };
+  }
+  if (type === "hasMany") {
+    requireField(raw, "model", "hasMany");
+    requireField(raw, "related_id_field", "hasMany");
+    const rel = {
+      type: "hasMany",
+      model: raw.model,
+      relatedIdField: raw.related_id_field
+    };
+    if (raw.order_by_field) rel.orderByField = raw.order_by_field;
+    if (raw.order_direction) rel.orderDirection = raw.order_direction;
+    return rel;
+  }
+  if (type === "hasManyThrough") {
+    requireField(raw, "model", "hasManyThrough");
+    requireField(raw, "join_model", "hasManyThrough");
+    requireField(raw, "join_model_local_field", "hasManyThrough");
+    requireField(raw, "join_model_related_field", "hasManyThrough");
+    const rel = {
+      type: "hasManyThrough",
+      model: raw.model,
+      joinModel: raw.join_model,
+      joinModelLocalField: raw.join_model_local_field,
+      joinModelRelatedField: raw.join_model_related_field
+    };
+    if (raw.join_model_order_by_field)
+      rel.joinModelOrderByField = raw.join_model_order_by_field;
+    if (raw.join_model_order_direction)
+      rel.joinModelOrderDirection = raw.join_model_order_direction;
+    return rel;
+  }
+  throw new Error(`Unknown relationship type: ${type}`);
+}
+function loadSchemaFromTomlString(tomlString) {
+  const parsed = (0, import_smol_toml.parse)(tomlString);
+  const models = parsed.models;
+  if (!models || typeof models !== "object") {
+    throw new Error("TOML schema must have a [models] section");
+  }
+  const schemas = [];
+  for (const [modelName, modelDef] of Object.entries(models)) {
+    const fields = {};
+    if (modelDef.fields) {
+      for (const [fieldName, fieldDef] of Object.entries(modelDef.fields)) {
+        fields[fieldName] = parseFieldOptions(fieldDef);
+      }
+    }
+    let relationships;
+    if (modelDef.relationships) {
+      relationships = {};
+      for (const [relName, relDef] of Object.entries(
+        modelDef.relationships
+      )) {
+        relationships[relName] = parseRelationship(relDef);
+      }
+    }
+    let uniqueConstraints;
+    if (modelDef.unique_constraints) {
+      uniqueConstraints = [];
+      for (const raw of modelDef.unique_constraints) {
+        uniqueConstraints.push({
+          name: raw.name,
+          fields: [...raw.fields]
+        });
+      }
+    }
+    schemas.push(
+      defineModelSchema({
+        name: modelName,
+        fields,
+        options: {
+          uniqueConstraints,
+          relationships
+        }
+      })
+    );
+  }
+  return schemas;
+}
+
+// src/cloudflare-do.ts
+init_metaSync();