js-bao 0.2.11 → 0.2.12

package/dist/client.js

@@ -0,0 +1,806 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+
+// 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/types/queryTypes.ts
+var init_queryTypes = __esm({
+  "src/types/queryTypes.ts"() {
+    "use strict";
+  }
+});
+
+// src/query/CursorManager.ts
+var init_CursorManager = __esm({
+  "src/query/CursorManager.ts"() {
+    "use strict";
+    init_queryTypes();
+  }
+});
+
+// src/utils/sql.ts
+var init_sql = __esm({
+  "src/utils/sql.ts"() {
+    "use strict";
+  }
+});
+
+// src/utils/patterns.ts
+var init_patterns = __esm({
+  "src/utils/patterns.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/BaseModel.ts
+import * as Y from "yjs";
+import { ulid } from "ulid";
+var Logger;
+var init_BaseModel = __esm({
+  "src/models/BaseModel.ts"() {
+    "use strict";
+    init_StringSet();
+    init_documentTypes();
+    init_DocumentQueryTranslator();
+    init_CursorManager();
+    init_sql();
+    Logger = class {
+      static _logLevel = 1 /* ERROR */;
+      static _logCallback = null;
+      static setLogLevel(level) {
+        this._logLevel = level;
+      }
+      static getLogLevel() {
+        return this._logLevel;
+      }
+      static setLogCallback(callback) {
+        this._logCallback = callback;
+      }
+      static error(message, ...args) {
+        if (this._logLevel >= 1 /* ERROR */) {
+          const fullMessage = args.length > 0 ? `${message} ${args.map(
+            (arg) => typeof arg === "object" ? JSON.stringify(arg) : String(arg)
+          ).join(" ")}` : message;
+          console.error(`[ERROR] ${message}`, ...args);
+          if (this._logCallback) {
+            this._logCallback(fullMessage, 1 /* ERROR */);
+          }
+        }
+      }
+      static warn(message, ...args) {
+        if (this._logLevel >= 2 /* WARN */) {
+          const fullMessage = args.length > 0 ? `${message} ${args.map(
+            (arg) => typeof arg === "object" ? JSON.stringify(arg) : String(arg)
+          ).join(" ")}` : message;
+          console.warn(`[WARN] ${message}`, ...args);
+          if (this._logCallback) {
+            this._logCallback(fullMessage, 2 /* WARN */);
+          }
+        }
+      }
+      static info(message, ...args) {
+        if (this._logLevel >= 3 /* INFO */) {
+          const fullMessage = args.length > 0 ? `${message} ${args.map(
+            (arg) => typeof arg === "object" ? JSON.stringify(arg) : String(arg)
+          ).join(" ")}` : message;
+          console.log(`[INFO] ${message}`, ...args);
+          if (this._logCallback) {
+            this._logCallback(fullMessage, 3 /* INFO */);
+          }
+        }
+      }
+      static debug(message, ...args) {
+        if (this._logLevel >= 4 /* DEBUG */) {
+          const fullMessage = args.length > 0 ? `${message} ${args.map(
+            (arg) => typeof arg === "object" ? JSON.stringify(arg) : String(arg)
+          ).join(" ")}` : message;
+          console.log(`[DEBUG] ${message}`, ...args);
+          if (this._logCallback) {
+            this._logCallback(fullMessage, 4 /* DEBUG */);
+          }
+        }
+      }
+      static verbose(message, ...args) {
+        if (this._logLevel >= 5 /* VERBOSE */) {
+          const fullMessage = args.length > 0 ? `${message} ${args.map(
+            (arg) => typeof arg === "object" ? JSON.stringify(arg) : String(arg)
+          ).join(" ")}` : message;
+          console.log(`[VERBOSE] ${message}`, ...args);
+          if (this._logCallback) {
+            this._logCallback(fullMessage, 5 /* VERBOSE */);
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/initialize-do.ts
+init_BaseModel();
+
+// src/engines/DatabaseEngine.ts
+var DatabaseEngine = class {
+  createTable(_modelName, _schema, _options) {
+    throw new Error("Method not implemented.");
+  }
+  createStringSetJunctionTable(_modelName, _fieldName) {
+    throw new Error("Method not implemented.");
+  }
+  insertStringSetValues(_modelName, _fieldName, _recordId, _values) {
+    throw new Error("Method not implemented.");
+  }
+  removeStringSetValues(_modelName, _fieldName, _recordId, _values) {
+    throw new Error("Method not implemented.");
+  }
+  insert(_modelName, _data) {
+    throw new Error("Method not implemented.");
+  }
+  delete(_modelName, _id) {
+    throw new Error("Method not implemented.");
+  }
+  /**
+   * Deletes all records for a specific document from the given model table.
+   * This is used when disconnecting a document to remove all its data.
+   * @param modelName The name of the model/table
+   * @param docId The document ID to filter by
+   */
+  deleteByDocumentId(_modelName, _docId) {
+    throw new Error("Method not implemented.");
+  }
+  getTableName(_modelName) {
+    throw new Error("Method not implemented.");
+  }
+  // Transaction support
+  async withTransaction(_callback) {
+    throw new Error("Method not implemented.");
+  }
+};
+
+// src/engines/cloudflare/DOClientEngine.ts
+var DOClientEngine = class extends DatabaseEngine {
+  endpoint;
+  customFetch;
+  authorization;
+  timeout;
+  currentDocId = null;
+  constructor(config) {
+    super();
+    this.endpoint = config.endpoint.replace(/\/$/, "");
+    this.customFetch = config.fetch || fetch;
+    this.authorization = config.authorization;
+    this.timeout = config.timeout || 3e4;
+  }
+  /**
+   * Set the current document ID for subsequent operations.
+   */
+  setCurrentDocument(docId) {
+    this.currentDocId = docId;
+  }
+  /**
+   * Get the current document ID.
+   */
+  getCurrentDocument() {
+    return this.currentDocId;
+  }
+  /**
+   * Build the URL for a DO endpoint.
+   */
+  buildUrl(path, extraParams) {
+    if (!this.currentDocId) {
+      throw new Error("No document ID set. Call setCurrentDocument() first.");
+    }
+    const url = new URL(`${this.endpoint}${path}`);
+    url.searchParams.set("docId", this.currentDocId);
+    if (extraParams) {
+      for (const [key, value] of Object.entries(extraParams)) {
+        url.searchParams.set(key, value);
+      }
+    }
+    return url.toString();
+  }
+  /**
+   * Make a fetch request to the DO.
+   */
+  async doFetch(path, body) {
+    const url = this.buildUrl(path);
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.authorization) {
+      headers["Authorization"] = this.authorization;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await this.customFetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorBody = await response.json();
+        throw new Error(errorBody.error || `HTTP ${response.status}`);
+      }
+      return response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Error(`Request timeout after ${this.timeout}ms`);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Query records from the DO.
+   */
+  async queryModel(modelName, filter = {}, options = {}) {
+    const request = {
+      modelName,
+      filter,
+      options
+    };
+    const response = await this.doFetch("/query", request);
+    return {
+      data: response.data,
+      hasMore: response.hasMore ?? false,
+      nextCursor: response.nextCursor,
+      prevCursor: response.prevCursor
+    };
+  }
+  /**
+   * Save a record to the DO.
+   */
+  async saveModel(modelName, id, data, stringSets, options) {
+    const request = {
+      modelName,
+      id,
+      data,
+      stringSets,
+      ifNotExists: options?.ifNotExists,
+      condition: options?.condition
+    };
+    const response = await this.doFetch("/save", request);
+    return response.id;
+  }
+  /**
+   * Patch (partial update) a record in the DO.
+   * Only the provided fields are updated; existing fields are preserved.
+   */
+  async patchModel(modelName, id, data, stringSets, options) {
+    const request = {
+      modelName,
+      id,
+      data,
+      stringSets,
+      condition: options?.condition
+    };
+    const response = await this.doFetch("/patch", request);
+    return response.id;
+  }
+  /**
+   * Delete a record from the DO.
+   */
+  async deleteModel(modelName, id, options) {
+    const request = {
+      modelName,
+      id,
+      condition: options?.condition
+    };
+    const response = await this.doFetch("/delete", request);
+    return response.success;
+  }
+  /**
+   * Count records matching a filter.
+   */
+  async countModel(modelName, filter = {}) {
+    const request = {
+      modelName,
+      filter
+    };
+    const response = await this.doFetch("/count", request);
+    return response.count;
+  }
+  /**
+   * Aggregate records with groupBy and operations (count, sum, avg, min, max).
+   */
+  async aggregateModel(modelName, options) {
+    const request = {
+      modelName,
+      options
+    };
+    const response = await this.doFetch("/aggregate", request);
+    return response.result;
+  }
+  /**
+   * Atomically add values to StringSet fields on a record.
+   */
+  async addToStringSet(modelName, id, sets, options) {
+    const request = { modelName, id, sets, condition: options?.condition };
+    await this.doFetch("/stringset/add", request);
+  }
+  /**
+   * Atomically remove values from StringSet fields on a record.
+   */
+  async removeFromStringSet(modelName, id, sets, options) {
+    const request = { modelName, id, sets, condition: options?.condition };
+    await this.doFetch("/stringset/remove", request);
+  }
+  /**
+   * Atomically increment/decrement numeric fields on a record.
+   * Returns the new values after the increment.
+   */
+  async incrementFields(modelName, id, fields, options) {
+    const request = { modelName, id, fields, condition: options?.condition };
+    const response = await this.doFetch("/increment", request);
+    return response.values;
+  }
+  /**
+   * Execute multiple save/patch/delete operations in a single request.
+   * All operations run in a single transaction on the server.
+   */
+  async batchWrite(operations) {
+    const request = { operations };
+    const response = await this.doFetch("/batch", request);
+    return response.results;
+  }
+  /**
+   * Check if the DO is healthy.
+   */
+  async healthCheck() {
+    const url = this.buildUrl("/health");
+    const response = await this.customFetch(url, {
+      method: "GET",
+      headers: this.authorization ? { Authorization: this.authorization } : void 0
+    });
+    if (!response.ok) {
+      throw new Error(`Health check failed: HTTP ${response.status}`);
+    }
+    return response.json();
+  }
+  /**
+   * Batch sync indexes: send all desired indexes in one request.
+   * The DO compares against its _indexes table and registers only what's missing.
+   * Returns the number of indexes/constraints newly registered.
+   */
+  async syncIndexesBatch(request) {
+    const response = await this.doFetch("/indexes/sync", request);
+    return response.registered;
+  }
+  /**
+   * Register an index on a model field.
+   * Creates a SQLite index on json_extract(data_json, '$.fieldName').
+   * Set unique=true to enforce uniqueness on this field.
+   */
+  async registerIndex(modelName, fieldName, fieldType = "string", unique = false) {
+    const request = {
+      modelName,
+      fieldName,
+      fieldType,
+      unique
+    };
+    await this.doFetch("/index/register", request);
+  }
+  /**
+   * Drop an index from a model field.
+   */
+  async dropIndex(modelName, fieldName) {
+    const request = {
+      modelName,
+      fieldName
+    };
+    await this.doFetch("/index/drop", request);
+  }
+  /**
+   * List indexes, optionally filtered by model name.
+   */
+  async listIndexes(modelName) {
+    const url = this.buildUrl(
+      "/indexes",
+      modelName ? { modelName } : void 0
+    );
+    const response = await this.customFetch(url, {
+      method: "GET",
+      headers: this.authorization ? { Authorization: this.authorization } : void 0
+    });
+    if (!response.ok) {
+      throw new Error(`List indexes failed: HTTP ${response.status}`);
+    }
+    const body = await response.json();
+    return body.indexes;
+  }
+  /**
+   * Describe tracked fields for a model.
+   */
+  async describe(modelName) {
+    const url = this.buildUrl("/describe", { modelName });
+    const response = await this.customFetch(url, {
+      method: "GET",
+      headers: this.authorization ? { Authorization: this.authorization } : void 0
+    });
+    if (!response.ok) {
+      throw new Error(`Describe failed: HTTP ${response.status}`);
+    }
+    const body = await response.json();
+    return body.fields;
+  }
+  /**
+   * Register a composite unique constraint across multiple fields.
+   */
+  async registerUniqueConstraint(modelName, constraintName, fields) {
+    const request = {
+      modelName,
+      constraintName,
+      fields
+    };
+    await this.doFetch(
+      "/unique-constraint/register",
+      request
+    );
+  }
+  /**
+   * Drop a composite unique constraint.
+   */
+  async dropUniqueConstraint(modelName, constraintName) {
+    const request = {
+      modelName,
+      constraintName
+    };
+    await this.doFetch(
+      "/unique-constraint/drop",
+      request
+    );
+  }
+  /**
+   * List composite unique constraints, optionally filtered by model name.
+   */
+  async listUniqueConstraints(modelName) {
+    const url = this.buildUrl(
+      "/unique-constraints",
+      modelName ? { modelName } : void 0
+    );
+    const response = await this.customFetch(url, {
+      method: "GET",
+      headers: this.authorization ? { Authorization: this.authorization } : void 0
+    });
+    if (!response.ok) {
+      throw new Error(
+        `List unique constraints failed: HTTP ${response.status}`
+      );
+    }
+    const body = await response.json();
+    return body.constraints;
+  }
+  // ========================================
+  // DatabaseEngine interface implementation
+  // ========================================
+  /**
+   * Ensure the engine is ready.
+   * For DOClient, this verifies connectivity.
+   */
+  async ensureReady() {
+    if (this.currentDocId) {
+      await this.healthCheck();
+    }
+  }
+  /**
+   * Execute raw SQL.
+   * Not supported in DO client mode - use queryModel instead.
+   */
+  async query(_sql, _params) {
+    throw new Error(
+      "Raw SQL queries not supported in DO client mode. Use queryModel() instead."
+    );
+  }
+  /**
+   * Get last error message.
+   */
+  getLastErrorMessage() {
+    return void 0;
+  }
+  /**
+   * Get table schema.
+   * Not directly supported - schema is managed by the DO.
+   */
+  async getTableSchema(_tableName) {
+    throw new Error("getTableSchema not supported in DO client mode");
+  }
+  /**
+   * Destroy the engine.
+   * Nothing to clean up for the client.
+   */
+  async destroy() {
+    this.currentDocId = null;
+  }
+  /**
+   * Create table.
+   * No-op in DO client mode - schema is managed by the DO.
+   */
+  async createTable(_modelName, _schema, _options) {
+  }
+  /**
+   * Create StringSet junction table.
+   * No-op in DO client mode.
+   */
+  async createStringSetJunctionTable(_modelName, _fieldName) {
+  }
+  /**
+   * Insert a record.
+   * Delegates to saveModel.
+   */
+  async insert(modelName, data) {
+    const { id, ...rest } = data;
+    await this.saveModel(modelName, id, rest);
+  }
+  /**
+   * Delete a record.
+   * Delegates to deleteModel.
+   */
+  async delete(modelName, id) {
+    await this.deleteModel(modelName, id);
+  }
+  /**
+   * Get table name.
+   * All models use 'records' in JSON schema.
+   */
+  getTableName(_modelName) {
+    return "records";
+  }
+  /**
+   * Transaction support.
+   * DO client doesn't support client-side transactions.
+   * Operations are atomic on the DO side.
+   */
+  async withTransaction(callback) {
+    const ops = {
+      insert: async (modelName, data) => {
+        await this.insert(modelName, data);
+      },
+      delete: async (modelName, id) => {
+        await this.delete(modelName, id);
+      },
+      query: async (_sql, _params) => {
+        throw new Error("Raw SQL not supported in DO client transactions");
+      }
+    };
+    return callback(ops);
+  }
+};
+
+// src/initialize-do.ts
+function resolveModelName(model) {
+  if (typeof model === "string") {
+    if (!model) throw new Error("Model name must be a non-empty string");
+    return model;
+  }
+  const name = model.modelName;
+  if (!name) {
+    throw new Error(
+      `Model ${model.name} has no modelName. Ensure it was defined with defineModelSchema + attachSchemaToClass.`
+    );
+  }
+  return name;
+}
+function createModelAccessor(engine, modelName) {
+  return {
+    query: (filter = {}, options = {}) => {
+      return engine.queryModel(modelName, filter, options);
+    },
+    find: async (id) => {
+      const result = await engine.queryModel(modelName, { id }, {});
+      return result.data.length > 0 ? result.data[0] : null;
+    },
+    save: (data, options) => {
+      if (!data.id) {
+        throw new Error("Record must have an 'id' field");
+      }
+      let stringSets;
+      let ifNotExists;
+      let condition;
+      if (options && typeof options === "object") {
+        if (options.ifNotExists !== void 0 || options.stringSets !== void 0 || options.condition !== void 0) {
+          stringSets = options.stringSets;
+          ifNotExists = options.ifNotExists;
+          condition = options.condition;
+        } else {
+          stringSets = options;
+        }
+      }
+      return engine.saveModel(modelName, data.id, data, stringSets, { ifNotExists, condition });
+    },
+    patch: (id, data, options) => {
+      let stringSets;
+      let condition;
+      if (options && typeof options === "object") {
+        if (options.condition !== void 0 || options.stringSets !== void 0) {
+          stringSets = options.stringSets;
+          condition = options.condition;
+        } else {
+          stringSets = options;
+        }
+      }
+      return engine.patchModel(modelName, id, data, stringSets, { condition });
+    },
+    delete: (id, options) => {
+      return engine.deleteModel(modelName, id, { condition: options?.condition });
+    },
+    count: (filter = {}) => {
+      return engine.countModel(modelName, filter);
+    },
+    aggregate: (options) => {
+      return engine.aggregateModel(modelName, options);
+    },
+    increment: (id, fields, options) => {
+      return engine.incrementFields(modelName, id, fields, { condition: options?.condition });
+    },
+    addToSet: (id, sets, options) => {
+      return engine.addToStringSet(modelName, id, sets, { condition: options?.condition });
+    },
+    removeFromSet: (id, sets, options) => {
+      return engine.removeFromStringSet(modelName, id, sets, { condition: options?.condition });
+    }
+  };
+}
+function extractModelSyncState(modelClass) {
+  const schema = modelClass.getSchema?.();
+  if (!schema || !schema.fields || !schema.options?.name) {
+    throw new Error(
+      `Cannot sync indexes: model ${modelClass.name} has no schema. Ensure it was defined with defineModelSchema + attachAndRegisterModel.`
+    );
+  }
+  const modelName = schema.options.name;
+  const fields = schema.fields;
+  const indexes = [];
+  for (const [fieldName, opts] of fields.entries()) {
+    if (fieldName === "id") continue;
+    if (!opts.indexed && !opts.unique) continue;
+    indexes.push({
+      fieldName,
+      fieldType: opts.type || "string",
+      unique: opts.unique ?? false
+    });
+  }
+  const uniqueConstraints = (schema.options.uniqueConstraints ?? []).map(
+    (c) => ({ name: c.name, fields: c.fields })
+  );
+  return { modelName, indexes, uniqueConstraints };
+}
+function buildSyncIndexes(engine) {
+  return async (modelClass) => {
+    const modelState = extractModelSyncState(modelClass);
+    return engine.syncIndexesBatch({ models: [modelState] });
+  };
+}
+function connectDoDb(options) {
+  const { endpoint, id, models, authorization, fetch: customFetch, timeout } = options;
+  const engine = new DOClientEngine({
+    endpoint,
+    authorization,
+    fetch: customFetch,
+    timeout
+  });
+  engine.setCurrentDocument(id);
+  const syncIndexes = buildSyncIndexes(engine);
+  const db = {
+    engine,
+    docId: id,
+    // Ad-hoc methods
+    query: (model, filter = {}, opts = {}) => {
+      return engine.queryModel(resolveModelName(model), filter, opts);
+    },
+    find: async (model, findId) => {
+      const result = await engine.queryModel(resolveModelName(model), { id: findId }, {});
+      return result.data.length > 0 ? result.data[0] : null;
+    },
+    save: (model, data, options2) => {
+      if (!data.id) {
+        throw new Error("Record must have an 'id' field");
+      }
+      let stringSets;
+      let ifNotExists;
+      let condition;
+      if (options2 && typeof options2 === "object") {
+        if (options2.ifNotExists !== void 0 || options2.stringSets !== void 0 || options2.condition !== void 0) {
+          stringSets = options2.stringSets;
+          ifNotExists = options2.ifNotExists;
+          condition = options2.condition;
+        } else {
+          stringSets = options2;
+        }
+      }
+      return engine.saveModel(resolveModelName(model), data.id, data, stringSets, { ifNotExists, condition });
+    },
+    patch: (model, id2, data, options2) => {
+      let stringSets;
+      let condition;
+      if (options2 && typeof options2 === "object") {
+        if (options2.condition !== void 0 || options2.stringSets !== void 0) {
+          stringSets = options2.stringSets;
+          condition = options2.condition;
+        } else {
+          stringSets = options2;
+        }
+      }
+      return engine.patchModel(resolveModelName(model), id2, data, stringSets, { condition });
+    },
+    delete: (model, deleteId, options2) => {
+      return engine.deleteModel(resolveModelName(model), deleteId, { condition: options2?.condition });
+    },
+    count: (model, filter = {}) => {
+      return engine.countModel(resolveModelName(model), filter);
+    },
+    aggregate: (model, options2) => {
+      return engine.aggregateModel(resolveModelName(model), options2);
+    },
+    increment: (model, id2, fields, options2) => {
+      return engine.incrementFields(resolveModelName(model), id2, fields, { condition: options2?.condition });
+    },
+    addToSet: (model, id2, sets, options2) => {
+      return engine.addToStringSet(resolveModelName(model), id2, sets, { condition: options2?.condition });
+    },
+    removeFromSet: (model, id2, sets, options2) => {
+      return engine.removeFromStringSet(resolveModelName(model), id2, sets, { condition: options2?.condition });
+    },
+    batch: (operations) => {
+      return engine.batchWrite(operations);
+    },
+    // Schema introspection
+    describe: (modelName) => {
+      return engine.describe(modelName);
+    },
+    // Index management
+    registerIndex: (modelName, fieldName, fieldType = "string", unique = false) => engine.registerIndex(modelName, fieldName, fieldType, unique),
+    dropIndex: (modelName, fieldName) => engine.dropIndex(modelName, fieldName),
+    listIndexes: (modelName) => engine.listIndexes(modelName),
+    registerUniqueConstraint: (modelName, constraintName, fields) => engine.registerUniqueConstraint(modelName, constraintName, fields),
+    dropUniqueConstraint: (modelName, constraintName) => engine.dropUniqueConstraint(modelName, constraintName),
+    listUniqueConstraints: (modelName) => engine.listUniqueConstraints(modelName),
+    syncIndexes,
+    syncAllIndexes: async () => {
+      if (!models || models.length === 0) return 0;
+      const request = {
+        models: models.map(extractModelSyncState)
+      };
+      return engine.syncIndexesBatch(request);
+    }
+  };
+  if (models) {
+    for (const model of models) {
+      const modelName = resolveModelName(model);
+      const className = model.name;
+      db[className] = createModelAccessor(engine, modelName);
+    }
+  }
+  Logger.info(`[connectDoDb] Connected to document: ${id} at ${endpoint}`);
+  return db;
+}
+export {
+  DOClientEngine,
+  connectDoDb
+};