@bluecopa/core 0.1.55 → 0.1.57

package/dist/index.es.js

@@ -3,13 +3,19 @@ var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { en
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 import axios from "axios";
 import _ from "lodash";
+import { createRxDatabase } from "rxdb";
+import { getRxStorageDexie } from "rxdb/plugins/storage-dexie";
+import { replicateRxCollection } from "rxdb/plugins/replication";
+import { Subject } from "rxjs";
 class ConfigSingleton {
   constructor() {
     this.config = {
       apiBaseUrl: "",
       accessToken: "",
       workspaceId: "",
-      userId: ""
+      userId: "",
+      solutionId: void 0,
+      websocketProvider: void 0
     };
   }
   static getInstance() {
@@ -29,7 +35,9 @@ class ConfigSingleton {
       apiBaseUrl: "",
       accessToken: "",
       workspaceId: "",
-      userId: ""
+      userId: "",
+      solutionId: void 0,
+      websocketProvider: void 0
     };
   }
 }
@@ -60,6 +68,9 @@ const createApiClient = () => {
       if (copaConfig.workspaceId && config.headers) {
         config.headers["X-COPA-WORKSPACE-ID"] = copaConfig.workspaceId;
       }
+      if (copaConfig.solutionId && config.headers) {
+        config.headers["x-bluecopa-solution-id"] = copaConfig.solutionId;
+      }
       console.log("API Request Config:", {
         baseURL: config.baseURL,
         hasToken: !!copaConfig.accessToken,
@@ -8312,8 +8323,8 @@ var pusher = { exports: {} };
               },
               randomInt(max) {
                 const random = function() {
-                  const crypto = window.crypto || window["msCrypto"];
-                  const random2 = crypto.getRandomValues(new Uint32Array(1))[0];
+                  const crypto2 = window.crypto || window["msCrypto"];
+                  const random2 = crypto2.getRandomValues(new Uint32Array(1))[0];
                   return random2 / Math.pow(2, 32);
                 };
                 return Math.floor(random() * max);
@@ -11843,6 +11854,844 @@ const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePropert
   workflow: index$m,
   worksheet: index$j
 }, Symbol.toStringTag, { value: "Module" }));
+var InputTableColumnType = /* @__PURE__ */ ((InputTableColumnType2) => {
+  InputTableColumnType2["UUID"] = "uuid";
+  InputTableColumnType2["TEXT"] = "text";
+  InputTableColumnType2["INTEGER"] = "integer";
+  InputTableColumnType2["BIGINT"] = "bigint";
+  InputTableColumnType2["NUMERIC"] = "numeric";
+  InputTableColumnType2["BOOLEAN"] = "boolean";
+  InputTableColumnType2["TIMESTAMPTZ"] = "timestamptz";
+  InputTableColumnType2["DATE"] = "date";
+  InputTableColumnType2["TIME"] = "time";
+  InputTableColumnType2["JSONB"] = "jsonb";
+  return InputTableColumnType2;
+})(InputTableColumnType || {});
+const OP_MAP = {
+  "==": "$eq",
+  "!=": "$ne",
+  "<": "$lt",
+  "<=": "$lte",
+  ">": "$gt",
+  ">=": "$gte",
+  in: "$in",
+  "not-in": "$nin"
+};
+class QueryBuilderImpl {
+  constructor(collection, initialWhere, initialOrder, initialLimit, initialSkip) {
+    this.collection = collection;
+    this.wheres = [];
+    this.orders = [];
+    if (initialWhere) this.wheres.push(initialWhere);
+    if (initialOrder) this.orders.push(initialOrder);
+    if (initialLimit !== void 0) this.limitCount = initialLimit;
+    if (initialSkip !== void 0) this.skipCount = initialSkip;
+  }
+  where(field, op, value) {
+    this.wheres.push({ field, op, value });
+    return this;
+  }
+  orderBy(field, direction = "asc") {
+    this.orders.push({ field, direction });
+    return this;
+  }
+  limit(count) {
+    this.limitCount = count;
+    return this;
+  }
+  skip(count) {
+    this.skipCount = count;
+    return this;
+  }
+  subscribe(callback) {
+    const query = this.buildQuery();
+    const rxSub = query.$.subscribe((docs) => {
+      callback(docs.map((d) => d.toJSON()));
+    });
+    return () => rxSub.unsubscribe();
+  }
+  async get() {
+    const query = this.buildQuery();
+    const docs = await query.exec();
+    return docs.map((d) => d.toJSON());
+  }
+  buildQuery() {
+    const selector = {};
+    for (const { field, op, value } of this.wheres) {
+      const rxOp = OP_MAP[op];
+      if (!selector[field]) selector[field] = {};
+      selector[field][rxOp] = value;
+    }
+    const queryParams = { selector };
+    if (this.orders.length > 0) {
+      queryParams.sort = this.orders.map(({ field, direction }) => ({ [field]: direction }));
+    }
+    if (this.limitCount !== void 0) {
+      queryParams.limit = this.limitCount;
+    }
+    if (this.skipCount !== void 0) {
+      queryParams.skip = this.skipCount;
+    }
+    return this.collection.find(queryParams);
+  }
+}
+const CHECKPOINT_FIELD = "updated_at";
+const MAX_COLLECTIONS = 14;
+const REPLICATION_RETRY_TIME = 5e3;
+const PULL_BATCH_SIZE = 100;
+const PUSH_BATCH_SIZE = 10;
+const IDENTIFIER_PATTERN = /^[a-zA-Z0-9_-]+$/;
+const ISO_TIMESTAMP_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/;
+class InputTableError extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "InputTableError";
+  }
+}
+function validateIdentifier(value, label) {
+  const trimmed = value.trim();
+  if (!trimmed || !IDENTIFIER_PATTERN.test(trimmed)) {
+    throw new InputTableError(`Invalid ${label}: "${value}"`, 400);
+  }
+  return trimmed;
+}
+function validateCheckpointTimestamp(value) {
+  if (!ISO_TIMESTAMP_PATTERN.test(value)) {
+    throw new InputTableError(`Invalid checkpoint timestamp: "${value}"`, 400);
+  }
+  return value;
+}
+function validateCheckpointId(value) {
+  return validateIdentifier(value, "checkpoint id");
+}
+function stripNullsAndCoercePk(row, primaryKeyField) {
+  const doc = {};
+  for (const [key, value] of Object.entries(row)) {
+    if (value === null) continue;
+    doc[key] = value;
+  }
+  doc[primaryKeyField] = String(row[primaryKeyField]);
+  return doc;
+}
+function deferSubscription(resolve, callback, fallback) {
+  let innerUnsub = null;
+  let cancelled = false;
+  resolve().then((subscribeFn) => {
+    if (!cancelled) {
+      innerUnsub = subscribeFn(callback);
+    }
+  }).catch((err) => {
+    console.error("[copaInputTableDb]", err);
+    if (!cancelled) callback(fallback);
+  });
+  return () => {
+    cancelled = true;
+    innerUnsub == null ? void 0 : innerUnsub();
+  };
+}
+class DocRefImpl {
+  constructor(collection, id, solutionId, tableName, primaryKeyField, websocketProvider) {
+    this.collection = collection;
+    this.id = id;
+    this.solutionId = solutionId;
+    this.tableName = tableName;
+    this.primaryKeyField = primaryKeyField;
+    this.websocketProvider = websocketProvider;
+  }
+  async get() {
+    const doc = await this.collection.findOne(this.id).exec();
+    return doc ? doc.toJSON() : null;
+  }
+  async update(data) {
+    const doc = await this.collection.findOne(this.id).exec();
+    if (!doc) {
+      throw new InputTableError(`Document "${this.id}" not found`, 404);
+    }
+    const patch = { ...data };
+    delete patch[this.primaryKeyField];
+    delete patch[CHECKPOINT_FIELD];
+    await doc.patch(patch);
+  }
+  async delete() {
+    await apiClient.request({
+      url: `input-table-v2/${this.solutionId}/rows/${this.tableName}`,
+      method: "DELETE",
+      params: { [this.primaryKeyField]: `eq.${this.id}` }
+    });
+    const doc = await this.collection.findOne(this.id).exec();
+    if (doc) await doc.remove();
+  }
+  onSnapshot(callback) {
+    const rxSub = this.collection.findOne(this.id).$.subscribe((doc) => {
+      callback(doc ? doc.toJSON() : null);
+    });
+    return () => rxSub.unsubscribe();
+  }
+}
+class CollectionRefImpl {
+  constructor(collection, solutionId, tableName, primaryKeyField, pkColumn, replicationState, getWebsocketProvider) {
+    this.collection = collection;
+    this.solutionId = solutionId;
+    this.tableName = tableName;
+    this.primaryKeyField = primaryKeyField;
+    this.pkColumn = pkColumn;
+    this.replicationState = replicationState;
+    this.getWebsocketProvider = getWebsocketProvider;
+  }
+  where(field, op, value) {
+    return new QueryBuilderImpl(this.collection, { field, op, value });
+  }
+  orderBy(field, direction = "asc") {
+    return new QueryBuilderImpl(this.collection, void 0, { field, direction });
+  }
+  limit(count) {
+    return new QueryBuilderImpl(this.collection, void 0, void 0, count);
+  }
+  skip(count) {
+    return new QueryBuilderImpl(this.collection, void 0, void 0, void 0, count);
+  }
+  doc(id) {
+    return new DocRefImpl(
+      this.collection,
+      id,
+      this.solutionId,
+      this.tableName,
+      this.primaryKeyField,
+      this.getWebsocketProvider
+    );
+  }
+  async add(data) {
+    var _a, _b;
+    const pk = this.primaryKeyField;
+    const insertData = { ...data };
+    const needsServerPk = ((_a = this.pkColumn) == null ? void 0 : _a.auto_increment) && this.pkColumn.type !== InputTableColumnType.UUID && !insertData[pk];
+    if (needsServerPk) {
+      delete insertData[pk];
+      delete insertData[CHECKPOINT_FIELD];
+      const response = await apiClient.post(
+        `/input-table-v2/${this.solutionId}/rows/${this.tableName}`,
+        insertData,
+        { headers: { Prefer: "return=representation" } }
+      );
+      this.replicationState.reSync();
+      const serverRow = Array.isArray(response.data) ? response.data[0] : response.data;
+      return String((serverRow == null ? void 0 : serverRow[pk]) ?? "");
+    }
+    if (((_b = this.pkColumn) == null ? void 0 : _b.type) === InputTableColumnType.UUID && this.pkColumn.auto_increment && !insertData[pk]) {
+      insertData[pk] = crypto.randomUUID();
+    }
+    if (!insertData[pk]) {
+      insertData[pk] = generatePushID();
+    }
+    insertData[pk] = String(insertData[pk]).trim();
+    delete insertData[CHECKPOINT_FIELD];
+    await this.collection.insert(insertData);
+    return String(insertData[pk]);
+  }
+  subscribe(callback) {
+    const rxSub = this.collection.find().$.subscribe((docs) => {
+      callback(docs.map((d) => d.toJSON()));
+    });
+    return () => rxSub.unsubscribe();
+  }
+  async get() {
+    const docs = await this.collection.find().exec();
+    return docs.map((d) => d.toJSON());
+  }
+  count(callback) {
+    const rxSub = this.collection.count().$.subscribe((count) => {
+      callback(count);
+    });
+    return () => rxSub.unsubscribe();
+  }
+}
+let dbPromise = null;
+function getInputTableDatabase() {
+  if (typeof window === "undefined") {
+    return Promise.reject(
+      new Error(
+        "[copaInputTableDb] RxDB requires a browser environment (IndexedDB). Cannot run on server."
+      )
+    );
+  }
+  if (!dbPromise) {
+    dbPromise = createDatabase();
+  }
+  return dbPromise;
+}
+async function createDatabase() {
+  const db = await createRxDatabase({
+    name: "bluecopa_input_tables_v2",
+    storage: getRxStorageDexie(),
+    multiInstance: true,
+    eventReduce: true
+  });
+  return db;
+}
+async function closeInputTableDatabase() {
+  if (dbPromise) {
+    const db = await dbPromise;
+    await db.close();
+    dbPromise = null;
+  }
+}
+const PG_TO_JSON_SCHEMA = {
+  [InputTableColumnType.UUID]: { type: "string" },
+  [InputTableColumnType.TEXT]: { type: "string" },
+  [InputTableColumnType.INTEGER]: { type: "integer" },
+  [InputTableColumnType.BIGINT]: { type: "string" },
+  [InputTableColumnType.NUMERIC]: { type: "number" },
+  [InputTableColumnType.BOOLEAN]: { type: "boolean" },
+  [InputTableColumnType.TIMESTAMPTZ]: { type: "string" },
+  [InputTableColumnType.DATE]: { type: "string" },
+  [InputTableColumnType.TIME]: { type: "string" },
+  [InputTableColumnType.JSONB]: { type: "string" }
+};
+function buildRxdbSchema(tableDef) {
+  const pkColumn = tableDef.columns.find((c) => c.primary_key);
+  const primaryKey = (pkColumn == null ? void 0 : pkColumn.name) ?? "id";
+  const properties = {};
+  const required = [primaryKey];
+  for (const col of tableDef.columns) {
+    const jsonType = PG_TO_JSON_SCHEMA[col.type] ?? { type: "string" };
+    properties[col.name] = { ...jsonType };
+    if (col.primary_key) {
+      properties[col.name] = { type: "string", maxLength: 200 };
+    }
+    if (!col.nullable && !col.primary_key) {
+      required.push(col.name);
+    }
+  }
+  properties[CHECKPOINT_FIELD] = { type: "string", maxLength: 50 };
+  return {
+    title: `input_table_${tableDef.name}`,
+    version: 0,
+    primaryKey,
+    type: "object",
+    properties,
+    required,
+    indexes: [CHECKPOINT_FIELD]
+  };
+}
+function toCollectionName(solutionId, tableName) {
+  const sanitized = tableName.replace(/[^a-z0-9]/g, "");
+  const solPrefix = solutionId.replace(/[^a-z0-9]/g, "").slice(-12);
+  return `s${solPrefix}t${sanitized}`;
+}
+function createReplication(collection, solutionId, tableName, primaryKeyField) {
+  const pullStream$ = new Subject();
+  const state = replicateRxCollection({
+    collection,
+    replicationIdentifier: `input-table-v2-${solutionId}-${tableName}`,
+    live: true,
+    retryTime: REPLICATION_RETRY_TIME,
+    autoStart: true,
+    waitForLeadership: false,
+    pull: {
+      async handler(checkpoint, batchSize) {
+        const params = {
+          order: `${CHECKPOINT_FIELD}.asc,${primaryKeyField}.asc`,
+          limit: String(batchSize),
+          select: "*"
+        };
+        if ((checkpoint == null ? void 0 : checkpoint.id) && (checkpoint == null ? void 0 : checkpoint.updatedAt)) {
+          const updatedAt = validateCheckpointTimestamp(checkpoint.updatedAt);
+          const id = validateCheckpointId(checkpoint.id);
+          params.or = `(${CHECKPOINT_FIELD}.gt.${updatedAt},and(${CHECKPOINT_FIELD}.eq.${updatedAt},${primaryKeyField}.gt.${id}))`;
+        }
+        const response = await apiClient.get(`/input-table-v2/${solutionId}/rows/${tableName}`, {
+          params,
+          headers: { Prefer: "count=exact" }
+        });
+        const rows = response.data ?? [];
+        const documents = rows.map((row) => stripNullsAndCoercePk(row, primaryKeyField));
+        const lastDoc = documents[documents.length - 1];
+        const newCheckpoint = documents.length === 0 ? checkpoint : {
+          id: String(lastDoc[primaryKeyField]),
+          updatedAt: String(lastDoc[CHECKPOINT_FIELD])
+        };
+        return { documents, checkpoint: newCheckpoint };
+      },
+      batchSize: PULL_BATCH_SIZE,
+      stream$: pullStream$.asObservable()
+    },
+    push: {
+      async handler(changeRows) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const conflicts = [];
+        for (const row of changeRows) {
+          const doc = row.newDocumentState;
+          try {
+            let serverResponse;
+            if (row.assumedMasterState == null) {
+              const insertData = { ...doc };
+              delete insertData[CHECKPOINT_FIELD];
+              delete insertData._deleted;
+              serverResponse = await apiClient.post(`/input-table-v2/${solutionId}/rows/${tableName}`, insertData, {
+                headers: { Prefer: "return=representation" }
+              });
+            } else {
+              const updateData = { ...doc };
+              delete updateData[primaryKeyField];
+              delete updateData[CHECKPOINT_FIELD];
+              delete updateData._deleted;
+              serverResponse = await apiClient.patch(`/input-table-v2/${solutionId}/rows/${tableName}`, updateData, {
+                params: { [primaryKeyField]: `eq.${doc[primaryKeyField]}` },
+                headers: { Prefer: "return=representation" }
+              });
+            }
+            const serverRow = Array.isArray(serverResponse == null ? void 0 : serverResponse.data) ? serverResponse.data[0] : serverResponse == null ? void 0 : serverResponse.data;
+            if (serverRow) {
+              const cleaned = stripNullsAndCoercePk(serverRow, primaryKeyField);
+              const localDoc = await collection.findOne(String(cleaned[primaryKeyField])).exec();
+              if (localDoc) {
+                const patch = { ...cleaned };
+                delete patch[primaryKeyField];
+                delete patch._deleted;
+                await localDoc.patch(patch);
+              }
+            }
+          } catch (err) {
+            const status = (_a = err == null ? void 0 : err.response) == null ? void 0 : _a.status;
+            const pgCode = ((_c = (_b = err == null ? void 0 : err.response) == null ? void 0 : _b.data) == null ? void 0 : _c.code) ?? ((_f = (_e = (_d = err == null ? void 0 : err.response) == null ? void 0 : _d.data) == null ? void 0 : _e.data) == null ? void 0 : _f.code);
+            console.error(`[replication:push] Error (status=${status}, pgCode=${pgCode}):`, doc[primaryKeyField], (_g = err == null ? void 0 : err.response) == null ? void 0 : _g.data);
+            const isInsert = row.assumedMasterState == null;
+            if (status === 409 || pgCode === "23505") {
+              try {
+                const response = await apiClient.get(
+                  `/input-table-v2/${solutionId}/rows/${tableName}`,
+                  {
+                    params: { [primaryKeyField]: `eq.${doc[primaryKeyField]}` }
+                  }
+                );
+                const serverRows = response.data ?? [];
+                if (serverRows.length > 0) {
+                  conflicts.push(stripNullsAndCoercePk(serverRows[0], primaryKeyField));
+                } else if (isInsert) {
+                  console.error(`[replication:push] Unique violation on non-PK column, removing doc:`, doc[primaryKeyField]);
+                  const localDoc = await collection.findOne(String(doc[primaryKeyField])).exec();
+                  if (localDoc) await localDoc.remove();
+                }
+              } catch {
+              }
+            } else if (pgCode === "23503" || status === 400 || status === 404) {
+              if (isInsert) {
+                console.error(`[replication:push] Removing invalid doc (${pgCode ?? status}):`, doc[primaryKeyField]);
+                try {
+                  const localDoc = await collection.findOne(String(doc[primaryKeyField])).exec();
+                  if (localDoc) await localDoc.remove();
+                } catch {
+                }
+              } else {
+                console.error(`[replication:push] Reverting doc to server state (${pgCode ?? status}):`, doc[primaryKeyField]);
+                try {
+                  const response = await apiClient.get(
+                    `/input-table-v2/${solutionId}/rows/${tableName}`,
+                    {
+                      params: { [primaryKeyField]: `eq.${doc[primaryKeyField]}` }
+                    }
+                  );
+                  const serverRows = response.data ?? [];
+                  if (serverRows.length > 0) {
+                    conflicts.push(stripNullsAndCoercePk(serverRows[0], primaryKeyField));
+                  }
+                } catch {
+                }
+              }
+            } else {
+              throw err;
+            }
+          }
+        }
+        return conflicts;
+      },
+      batchSize: PUSH_BATCH_SIZE
+    }
+  });
+  return {
+    state,
+    pullStream$,
+    cancel: async () => {
+      pullStream$.complete();
+      await state.cancel();
+    }
+  };
+}
+function createRealtimeBinding(provider, replicationState, workspaceId, solutionId, tableName) {
+  const channel = `public-input-table-v2-${workspaceId}-${solutionId}-${tableName}`;
+  function handleChangeNotification() {
+    replicationState.reSync();
+  }
+  provider.bind(channel, "INSERT", handleChangeNotification);
+  provider.bind(channel, "UPDATE", handleChangeNotification);
+  provider.bind(channel, "DELETE", handleChangeNotification);
+  return {
+    cleanup: () => {
+      provider.unbind(channel, "INSERT");
+      provider.unbind(channel, "UPDATE");
+      provider.unbind(channel, "DELETE");
+    }
+  };
+}
+const activeCollections = /* @__PURE__ */ new Map();
+const pendingCollections = /* @__PURE__ */ new Map();
+function collectionKey(workspaceId, solutionId, tableName) {
+  return `${workspaceId}:${toCollectionName(solutionId, tableName)}`;
+}
+async function getOrCreateCollection(solutionId, tableDef, workspaceId, websocketProvider) {
+  const key = collectionKey(workspaceId, solutionId, tableDef.name);
+  const existing = activeCollections.get(key);
+  if (existing) {
+    existing.lastAccessed = Date.now();
+    return existing;
+  }
+  if (pendingCollections.has(key)) {
+    return pendingCollections.get(key);
+  }
+  const pending = createCollectionInternal(
+    key,
+    solutionId,
+    tableDef,
+    workspaceId,
+    websocketProvider
+  );
+  pendingCollections.set(key, pending);
+  try {
+    return await pending;
+  } finally {
+    pendingCollections.delete(key);
+  }
+}
+async function createCollectionInternal(key, solutionId, tableDef, workspaceId, websocketProvider) {
+  var _a, _b;
+  if (activeCollections.size >= MAX_COLLECTIONS) {
+    await evictLeastRecentlyUsed();
+  }
+  const db = await getInputTableDatabase();
+  const schema = buildRxdbSchema(tableDef);
+  const collName = toCollectionName(solutionId, tableDef.name);
+  const pkField = ((_a = tableDef.columns.find((c) => c.primary_key)) == null ? void 0 : _a.name) ?? "id";
+  let collection;
+  const collectionConfig = {
+    schema,
+    conflictHandler: {
+      isEqual: (a, b) => a[CHECKPOINT_FIELD] === b[CHECKPOINT_FIELD],
+      resolve: (i) => i.realMasterState
+      // server wins
+    }
+  };
+  const existingCollection = db[collName];
+  if (existingCollection) {
+    collection = existingCollection;
+  } else {
+    try {
+      const collections = await db.addCollections({ [collName]: collectionConfig });
+      collection = collections[collName];
+    } catch (err) {
+      if ((err == null ? void 0 : err.code) === "DB6") {
+        const previousSchema = (_b = err == null ? void 0 : err.parameters) == null ? void 0 : _b.previousSchema;
+        if (previousSchema) {
+          await db.removeCollectionDoc(collName, previousSchema);
+        }
+        const collections = await db.addCollections({ [collName]: collectionConfig });
+        collection = collections[collName];
+      } else {
+        throw err;
+      }
+    }
+  }
+  const replication = createReplication(collection, solutionId, tableDef.name, pkField);
+  let realtimeBinding = null;
+  if (websocketProvider) {
+    realtimeBinding = createRealtimeBinding(
+      websocketProvider,
+      replication.state,
+      workspaceId,
+      solutionId,
+      tableDef.name
+    );
+  }
+  const managed = {
+    collection,
+    replication,
+    realtimeBinding,
+    tableName: tableDef.name,
+    solutionId,
+    workspaceId,
+    primaryKeyField: pkField,
+    lastAccessed: Date.now(),
+    refCount: 0
+  };
+  activeCollections.set(key, managed);
+  return managed;
+}
+async function closeAllCollections(solutionId) {
+  var _a;
+  const toClose = [...activeCollections.entries()];
+  for (const [key, managed] of toClose) {
+    (_a = managed.realtimeBinding) == null ? void 0 : _a.cleanup();
+    await managed.replication.cancel();
+    await managed.collection.close();
+    activeCollections.delete(key);
+  }
+}
+async function evictLeastRecentlyUsed() {
+  var _a;
+  let oldest = null;
+  for (const entry of activeCollections.entries()) {
+    if (entry[1].refCount > 0) continue;
+    if (!oldest || entry[1].lastAccessed < oldest[1].lastAccessed) {
+      oldest = entry;
+    }
+  }
+  if (oldest) {
+    (_a = oldest[1].realtimeBinding) == null ? void 0 : _a.cleanup();
+    await oldest[1].replication.cancel();
+    await oldest[1].collection.close();
+    activeCollections.delete(oldest[0]);
+  } else {
+    console.warn(
+      `[copaInputTableDb] All ${MAX_COLLECTIONS} collections have active subscribers. Cannot evict.`
+    );
+  }
+}
+const SOLUTION_COOKIE_NAME = "x-bluecopa-solution-id";
+function getSolutionId() {
+  const config = getConfig();
+  if (config.solutionId) {
+    return validateIdentifier(config.solutionId, "solutionId");
+  }
+  try {
+    const cookie = document.cookie.split(";").map((c) => c.trim()).find((c) => c.startsWith(`${SOLUTION_COOKIE_NAME}=`));
+    if (cookie) {
+      const value = decodeURIComponent(cookie.split("=").slice(1).join("="));
+      return validateIdentifier(value, "solutionId (cookie)");
+    }
+  } catch {
+  }
+  throw new InputTableError(
+    "[copaInputTableDb] No solutionId configured. Set via copaSetConfig({ solutionId }) or cookie.",
+    400
+  );
+}
+const _InputTableDBImpl = class _InputTableDBImpl {
+  constructor() {
+    this.schemaCache = /* @__PURE__ */ new Map();
+    this.schemaPending = /* @__PURE__ */ new Map();
+    this.wsWarned = false;
+    this.generation = 0;
+  }
+  setWebsocketProvider(provider) {
+    this.wsProvider = provider;
+  }
+  getProvider() {
+    return this.wsProvider ?? getConfig().websocketProvider;
+  }
+  collection(name) {
+    const provider = this.getProvider();
+    if (!provider && !this.wsWarned) {
+      this.wsWarned = true;
+      console.warn(
+        "[copaInputTableDb] No WebSocket provider configured. Realtime sync is disabled. Set via copaSetConfig({ websocketProvider }) or copaInputTableDb.setWebsocketProvider(ws)."
+      );
+    }
+    return new LazyCollectionRef(() => this.resolveCollection(name));
+  }
+  /** Force-clear the schema cache. Call after schema changes. */
+  clearSchemaCache() {
+    this.schemaCache.clear();
+    this.schemaPending.clear();
+  }
+  async resolveCollection(tableName) {
+    const gen = this.generation;
+    const solutionId = getSolutionId();
+    const validatedTableName = validateIdentifier(tableName, "tableName");
+    const workspaceId = getConfig().workspaceId;
+    const tables = await this.fetchTableList(solutionId);
+    if (gen !== this.generation) throw new InputTableError("InputTableDB was destroyed", 410);
+    const tableItem = tables.find((t) => t.name === validatedTableName);
+    if (!(tableItem == null ? void 0 : tableItem.appliedSchema)) {
+      throw new InputTableError(`Collection "${validatedTableName}" not found`, 404);
+    }
+    const managed = await getOrCreateCollection(
+      solutionId,
+      tableItem.appliedSchema,
+      workspaceId,
+      this.getProvider()
+    );
+    if (gen !== this.generation) throw new InputTableError("InputTableDB was destroyed", 410);
+    const pkColumn = tableItem.appliedSchema.columns.find((c) => c.primary_key);
+    return new CollectionRefImpl(
+      managed.collection,
+      solutionId,
+      validatedTableName,
+      managed.primaryKeyField,
+      pkColumn,
+      managed.replication.state,
+      () => this.getProvider()
+    );
+  }
+  fetchTableList(solutionId) {
+    const cached = this.schemaCache.get(solutionId);
+    if (cached && Date.now() - cached.fetchedAt < _InputTableDBImpl.SCHEMA_CACHE_TTL) {
+      return Promise.resolve(cached.tables);
+    }
+    if (this.schemaPending.has(solutionId)) {
+      return this.schemaPending.get(solutionId);
+    }
+    const pending = apiClient.get(`/input-table-v2/${solutionId}/tables`).then((res) => {
+      const tables = res.data ?? [];
+      this.schemaCache.set(solutionId, { tables, fetchedAt: Date.now() });
+      this.schemaPending.delete(solutionId);
+      return tables;
+    }).catch((err) => {
+      this.schemaPending.delete(solutionId);
+      throw err;
+    });
+    this.schemaPending.set(solutionId, pending);
+    return pending;
+  }
+  async destroy() {
+    this.generation++;
+    await closeAllCollections();
+    await closeInputTableDatabase();
+    this.schemaCache.clear();
+    this.schemaPending.clear();
+    this.wsWarned = false;
+  }
+};
+_InputTableDBImpl.SCHEMA_CACHE_TTL = 5 * 60 * 1e3;
+let InputTableDBImpl = _InputTableDBImpl;
+class LazyCollectionRef {
+  constructor(resolve) {
+    this.resolve = resolve;
+    this.resolvedRef = null;
+  }
+  getRef() {
+    if (!this.resolvedRef) {
+      this.resolvedRef = this.resolve();
+    }
+    return this.resolvedRef;
+  }
+  where(field, op, value) {
+    return new LazyQueryBuilder(
+      () => this.getRef().then((ref) => ref.where(field, op, value))
+    );
+  }
+  orderBy(field, direction = "asc") {
+    return new LazyQueryBuilder(
+      () => this.getRef().then((ref) => ref.orderBy(field, direction))
+    );
+  }
+  limit(count) {
+    return new LazyQueryBuilder(() => this.getRef().then((ref) => ref.limit(count)));
+  }
+  skip(count) {
+    return new LazyQueryBuilder(() => this.getRef().then((ref) => ref.skip(count)));
+  }
+  doc(id) {
+    return new LazyDocRef(id, () => this.getRef().then((ref) => ref.doc(id)));
+  }
+  async add(data) {
+    const ref = await this.getRef();
+    return ref.add(data);
+  }
+  subscribe(callback) {
+    return deferSubscription(
+      () => this.getRef().then((ref) => (cb) => ref.subscribe(cb)),
+      callback,
+      []
+    );
+  }
+  async get() {
+    try {
+      const ref = await this.getRef();
+      return ref.get();
+    } catch (err) {
+      console.error("[copaInputTableDb]", err);
+      return [];
+    }
+  }
+  count(callback) {
+    return deferSubscription(
+      () => this.getRef().then((ref) => (cb) => ref.count(cb)),
+      callback,
+      0
+    );
+  }
+}
+class LazyQueryBuilder {
+  constructor(resolveBase) {
+    this.resolveBase = resolveBase;
+    this.pendingOps = [];
+  }
+  chain(op) {
+    this.pendingOps.push(op);
+    return this;
+  }
+  where(field, op, value) {
+    return this.chain((qb) => qb.where(field, op, value));
+  }
+  orderBy(field, direction = "asc") {
+    return this.chain((qb) => qb.orderBy(field, direction));
+  }
+  limit(count) {
+    return this.chain((qb) => qb.limit(count));
+  }
+  skip(count) {
+    return this.chain((qb) => qb.skip(count));
+  }
+  async resolveWithOps() {
+    let qb = await this.resolveBase();
+    for (const op of this.pendingOps) {
+      qb = op(qb);
+    }
+    return qb;
+  }
+  subscribe(callback) {
+    return deferSubscription(
+      () => this.resolveWithOps().then((qb) => (cb) => qb.subscribe(cb)),
+      callback,
+      []
+    );
+  }
+  async get() {
+    try {
+      const qb = await this.resolveWithOps();
+      return qb.get();
+    } catch (err) {
+      console.error("[copaInputTableDb]", err);
+      return [];
+    }
+  }
+}
+class LazyDocRef {
+  constructor(id, resolve) {
+    this.id = id;
+    this.resolve = resolve;
+  }
+  async get() {
+    const ref = await this.resolve();
+    return ref.get();
+  }
+  async update(data) {
+    const ref = await this.resolve();
+    return ref.update(data);
+  }
+  async delete() {
+    const ref = await this.resolve();
+    return ref.delete();
+  }
+  onSnapshot(callback) {
+    return deferSubscription(
+      () => this.resolve().then((ref) => (cb) => ref.onSnapshot(cb)),
+      callback,
+      null
+    );
+  }
+}
+const copaInputTableDb = new InputTableDBImpl();
 const bluecopaTailwindConfig = {
   darkMode: "class",
   important: true,
@@ -12001,8 +12850,11 @@ const bluecopaTailwindConfig = {
   }
 };
 export {
+  InputTableColumnType,
+  InputTableError,
   index as copaApi,
   getConfig as copaGetConfig,
+  copaInputTableDb,
   setConfig as copaSetConfig,
   bluecopaTailwindConfig as copaTailwindConfig,
   index$i as copaUtils