@basictech/react 0.7.0-beta.6 → 0.7.0

package/dist/index.js

@@ -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,12 +20,160 @@ 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/config.ts
+var log;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    log = (...args) => {
+      try {
+        if (localStorage.getItem("basic_debug") === "true") {
+          console.log("[basic]", ...args);
+        }
+      } catch (e) {
+      }
+    };
+  }
+});
+
+// src/sync/syncProtocol.js
+var syncProtocol_exports = {};
+__export(syncProtocol_exports, {
+  syncProtocol: () => syncProtocol
+});
+var import_dexie, syncProtocol;
+var init_syncProtocol = __esm({
+  "src/sync/syncProtocol.js"() {
+    "use strict";
+    "use client";
+    import_dexie = require("dexie");
+    init_config();
+    syncProtocol = function() {
+      log("Initializing syncProtocol");
+      var RECONNECT_DELAY = 5e3;
+      import_dexie.Dexie.Syncable.registerSyncProtocol("websocket", {
+        sync: function(context, url, options, baseRevision, syncedRevision, changes, partial, applyRemoteChanges, onChangesAccepted, onSuccess, onError) {
+          var requestId = 0;
+          var acceptCallbacks = {};
+          log("Connecting to", url);
+          var ws = new WebSocket(url);
+          function sendChanges(changes2, baseRevision2, partial2, onChangesAccepted2) {
+            log("sendChanges", changes2.length, baseRevision2);
+            ++requestId;
+            acceptCallbacks[requestId.toString()] = onChangesAccepted2;
+            ws.send(
+              JSON.stringify({
+                type: "changes",
+                changes: changes2,
+                partial: partial2,
+                baseRevision: baseRevision2,
+                requestId
+              })
+            );
+          }
+          ws.onopen = function(event) {
+            log("Opening socket - sending clientIdentity", context.clientIdentity);
+            ws.send(
+              JSON.stringify({
+                type: "clientIdentity",
+                clientIdentity: context.clientIdentity || null,
+                authToken: options.authToken,
+                schema: options.schema
+              })
+            );
+          };
+          ws.onerror = function(event) {
+            ws.close();
+            log("ws.onerror", event);
+            onError(event?.message, RECONNECT_DELAY);
+          };
+          ws.onclose = function(event) {
+            onError("Socket closed: " + event.reason, RECONNECT_DELAY);
+          };
+          var isFirstRound = true;
+          ws.onmessage = function(event) {
+            try {
+              var requestFromServer = JSON.parse(event.data);
+              log("requestFromServer", requestFromServer, { acceptCallback, isFirstRound });
+              if (requestFromServer.type == "clientIdentity") {
+                context.clientIdentity = requestFromServer.clientIdentity;
+                context.save();
+                sendChanges(changes, baseRevision, partial, onChangesAccepted);
+                ws.send(
+                  JSON.stringify({
+                    type: "subscribe",
+                    syncedRevision
+                  })
+                );
+              } else if (requestFromServer.type == "changes") {
+                applyRemoteChanges(
+                  requestFromServer.changes,
+                  requestFromServer.currentRevision,
+                  requestFromServer.partial
+                );
+                if (isFirstRound && !requestFromServer.partial) {
+                  onSuccess({
+                    // Specify a react function that will react on additional client changes
+                    react: function(changes2, baseRevision2, partial2, onChangesAccepted2) {
+                      sendChanges(
+                        changes2,
+                        baseRevision2,
+                        partial2,
+                        onChangesAccepted2
+                      );
+                    },
+                    // Specify a disconnect function that will close our socket so that we dont continue to monitor changes.
+                    disconnect: function() {
+                      ws.close();
+                    }
+                  });
+                  isFirstRound = false;
+                }
+              } else if (requestFromServer.type == "ack") {
+                var requestId2 = requestFromServer.requestId;
+                var acceptCallback = acceptCallbacks[requestId2.toString()];
+                acceptCallback();
+                delete acceptCallbacks[requestId2.toString()];
+              } else if (requestFromServer.type == "error") {
+                var requestId2 = requestFromServer.requestId;
+                ws.close();
+                onError(requestFromServer.message, Infinity);
+              } else {
+                log("unknown message", requestFromServer);
+                ws.close();
+                onError("unknown message", Infinity);
+              }
+            } catch (e) {
+              ws.close();
+              log("caught error", e);
+              onError(e, Infinity);
+            }
+          };
+        }
+      });
+    };
+  }
+});
+
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
   BasicProvider: () => BasicProvider,
+  NotAuthenticatedError: () => NotAuthenticatedError,
+  RemoteCollection: () => RemoteCollection,
+  RemoteDB: () => RemoteDB,
+  RemoteDBError: () => RemoteDBError,
+  STORAGE_KEYS: () => STORAGE_KEYS,
   useBasic: () => useBasic,
   useQuery: () => import_dexie_react_hooks.useLiveQuery
 });
@@ -33,131 +186,32 @@ var import_jwt_decode = require("jwt-decode");
 // src/sync/index.ts
 var import_uuid = require("uuid");
 var import_dexie2 = require("dexie");
-var import_dexie_syncable = require("dexie-syncable");
-var import_dexie_observable = require("dexie-observable");
-
-// src/sync/syncProtocol.js
-var import_dexie = require("dexie");
-
-// src/config.ts
-var log = (...args) => {
-  try {
-    if (localStorage.getItem("basic_debug") === "true") {
-      console.log("[basic]", ...args);
-    }
-  } catch (e) {
-  }
-};
-
-// src/sync/syncProtocol.js
-var syncProtocol = function() {
-  log("Initializing syncProtocol");
-  var RECONNECT_DELAY = 5e3;
-  import_dexie.Dexie.Syncable.registerSyncProtocol("websocket", {
-    sync: function(context, url, options, baseRevision, syncedRevision, changes, partial, applyRemoteChanges, onChangesAccepted, onSuccess, onError) {
-      var requestId = 0;
-      var acceptCallbacks = {};
-      log("Connecting to", url);
-      var ws = new WebSocket(url);
-      function sendChanges(changes2, baseRevision2, partial2, onChangesAccepted2) {
-        log("sendChanges", changes2.length, baseRevision2);
-        ++requestId;
-        acceptCallbacks[requestId.toString()] = onChangesAccepted2;
-        ws.send(
-          JSON.stringify({
-            type: "changes",
-            changes: changes2,
-            partial: partial2,
-            baseRevision: baseRevision2,
-            requestId
-          })
-        );
-      }
-      ws.onopen = function(event) {
-        log("Opening socket - sending clientIdentity", context.clientIdentity);
-        ws.send(
-          JSON.stringify({
-            type: "clientIdentity",
-            clientIdentity: context.clientIdentity || null,
-            authToken: options.authToken,
-            schema: options.schema
-          })
-        );
-      };
-      ws.onerror = function(event) {
-        ws.close();
-        log("ws.onerror", event);
-        onError(event?.message, RECONNECT_DELAY);
-      };
-      ws.onclose = function(event) {
-        onError("Socket closed: " + event.reason, RECONNECT_DELAY);
-      };
-      var isFirstRound = true;
-      ws.onmessage = function(event) {
-        try {
-          var requestFromServer = JSON.parse(event.data);
-          log("requestFromServer", requestFromServer, { acceptCallback, isFirstRound });
-          if (requestFromServer.type == "clientIdentity") {
-            context.clientIdentity = requestFromServer.clientIdentity;
-            context.save();
-            sendChanges(changes, baseRevision, partial, onChangesAccepted);
-            ws.send(
-              JSON.stringify({
-                type: "subscribe",
-                syncedRevision
-              })
-            );
-          } else if (requestFromServer.type == "changes") {
-            applyRemoteChanges(
-              requestFromServer.changes,
-              requestFromServer.currentRevision,
-              requestFromServer.partial
-            );
-            if (isFirstRound && !requestFromServer.partial) {
-              onSuccess({
-                // Specify a react function that will react on additional client changes
-                react: function(changes2, baseRevision2, partial2, onChangesAccepted2) {
-                  sendChanges(
-                    changes2,
-                    baseRevision2,
-                    partial2,
-                    onChangesAccepted2
-                  );
-                },
-                // Specify a disconnect function that will close our socket so that we dont continue to monitor changes.
-                disconnect: function() {
-                  ws.close();
-                }
-              });
-              isFirstRound = false;
-            }
-          } else if (requestFromServer.type == "ack") {
-            var requestId2 = requestFromServer.requestId;
-            var acceptCallback = acceptCallbacks[requestId2.toString()];
-            acceptCallback();
-            delete acceptCallbacks[requestId2.toString()];
-          } else if (requestFromServer.type == "error") {
-            var requestId2 = requestFromServer.requestId;
-            ws.close();
-            onError(requestFromServer.message, Infinity);
-          } else {
-            log("unknown message", requestFromServer);
-            ws.close();
-            onError("unknown message", Infinity);
-          }
-        } catch (e) {
-          ws.close();
-          log("caught error", e);
-          onError(e, Infinity);
-        }
-      };
-    }
-  });
-};
-
-// src/sync/index.ts
+init_config();
 var import_schema = require("@basictech/schema");
-syncProtocol();
+var dexieExtensionsLoaded = false;
+var initPromise = null;
+async function initDexieExtensions() {
+  if (dexieExtensionsLoaded)
+    return;
+  if (typeof window === "undefined")
+    return;
+  if (initPromise)
+    return initPromise;
+  initPromise = (async () => {
+    try {
+      await import("dexie-syncable");
+      await import("dexie-observable");
+      const { syncProtocol: syncProtocol2 } = await Promise.resolve().then(() => (init_syncProtocol(), syncProtocol_exports));
+      syncProtocol2();
+      dexieExtensionsLoaded = true;
+      log("Dexie extensions loaded successfully");
+    } catch (error) {
+      console.error("Failed to load Dexie extensions:", error);
+      throw error;
+    }
+  })();
+  return initPromise;
+}
 var BasicSync = class extends import_dexie2.Dexie {
   basic_schema;
   constructor(name, options) {
@@ -223,63 +277,388 @@ var BasicSync = class extends import_dexie2.Dexie {
     return this.syncable;
   }
   collection(name) {
+    if (this.basic_schema?.tables && !this.basic_schema.tables[name]) {
+      throw new Error(`Table "${name}" not found in schema`);
+    }
+    const table = this.table(name);
     return {
       /**
        * Returns the underlying Dexie table
        * @type {Dexie.Table}
        */
-      ref: this.table(name),
+      ref: table,
       // --- WRITE ---- // 
-      add: (data) => {
+      /**
+       * Add a new record - returns the full object with generated id
+       */
+      add: async (data) => {
         const valid = (0, import_schema.validateData)(this.basic_schema, name, data);
         if (!valid.valid) {
           log("Invalid data", valid);
-          return Promise.reject({ ...valid });
+          throw new Error(valid.message || "Data validation failed");
         }
-        return this.table(name).add({
-          id: (0, import_uuid.v7)(),
-          ...data
-        });
+        const id = (0, import_uuid.v7)();
+        const fullData = { id, ...data };
+        await table.add(fullData);
+        return fullData;
       },
-      put: (data) => {
+      /**
+       * Put (upsert) a record - returns the full object
+       */
+      put: async (data) => {
+        if (!data.id) {
+          throw new Error("put() requires an id field");
+        }
         const valid = (0, import_schema.validateData)(this.basic_schema, name, data);
         if (!valid.valid) {
           log("Invalid data", valid);
-          return Promise.reject({ ...valid });
+          throw new Error(valid.message || "Data validation failed");
         }
-        return this.table(name).put({
-          id: (0, import_uuid.v7)(),
-          ...data
-        });
+        await table.put(data);
+        return data;
       },
-      update: (id, data) => {
+      /**
+       * Update an existing record - returns updated object or null
+       */
+      update: async (id, data) => {
+        if (!id) {
+          throw new Error("update() requires an id");
+        }
         const valid = (0, import_schema.validateData)(this.basic_schema, name, data, false);
         if (!valid.valid) {
           log("Invalid data", valid);
-          return Promise.reject({ ...valid });
+          throw new Error(valid.message || "Data validation failed");
+        }
+        const updated = await table.update(id, data);
+        if (updated === 0) {
+          return null;
         }
-        return this.table(name).update(id, data);
+        const record = await table.get(id);
+        return record || null;
       },
-      delete: (id) => {
-        return this.table(name).delete(id);
+      /**
+       * Delete a record - returns true if deleted, false if not found
+       */
+      delete: async (id) => {
+        if (!id) {
+          throw new Error("delete() requires an id");
+        }
+        const exists = await table.get(id);
+        if (!exists) {
+          return false;
+        }
+        await table.delete(id);
+        return true;
       },
       // --- READ ---- // 
+      /**
+       * Get a single record by id - returns null if not found
+       */
       get: async (id) => {
-        return this.table(name).get(id);
+        if (!id) {
+          throw new Error("get() requires an id");
+        }
+        const record = await table.get(id);
+        return record || null;
       },
+      /**
+       * Get all records in the collection
+       */
       getAll: async () => {
-        return this.table(name).toArray();
+        return table.toArray();
       },
       // --- QUERY ---- // 
-      // TODO: lots to do here. simplifing creating querie,  filtering/ordering/limit, and execute
-      query: () => this.table(name),
-      filter: (fn) => this.table(name).filter(fn).toArray()
+      /**
+       * Filter records using a predicate function
+       */
+      filter: async (fn) => {
+        return table.filter(fn).toArray();
+      },
+      /**
+       * Get the raw Dexie table for advanced queries
+       * @deprecated Use ref instead
+       */
+      query: () => table
     };
   }
 };
 
+// src/core/db/types.ts
+var RemoteDBError = class extends Error {
+  status;
+  response;
+  constructor(message, status, response) {
+    super(message);
+    this.name = "RemoteDBError";
+    this.status = status;
+    this.response = response;
+  }
+};
+
+// src/core/db/RemoteCollection.ts
+var import_schema2 = require("@basictech/schema");
+var NotAuthenticatedError = class extends Error {
+  constructor(message = "Not authenticated") {
+    super(message);
+    this.name = "NotAuthenticatedError";
+  }
+};
+var RemoteCollection = class {
+  tableName;
+  config;
+  constructor(tableName, config) {
+    this.tableName = tableName;
+    this.config = config;
+  }
+  log(...args) {
+    if (this.config.debug) {
+      console.log("[RemoteDB]", ...args);
+    }
+  }
+  /**
+   * Check if an error is a "not authenticated" error
+   */
+  isNotAuthenticatedError(error) {
+    if (error instanceof Error) {
+      const message = error.message.toLowerCase();
+      return message.includes("no token") || message.includes("not authenticated") || message.includes("please sign in");
+    }
+    return false;
+  }
+  /**
+   * Helper to make authenticated API requests
+   * Automatically retries once on 401 (token expired) by refreshing the token
+   */
+  async request(method, path, body, isRetry = false) {
+    const token = await this.config.getToken();
+    const url = `${this.config.serverUrl}${path}`;
+    this.log(`${method} ${url}`, body ? JSON.stringify(body) : "");
+    const response = await fetch(url, {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${token}`
+      },
+      ...body ? { body: JSON.stringify(body) } : {}
+    });
+    const responseData = await response.json().catch(() => ({}));
+    if (!response.ok) {
+      if (response.status === 401 && !isRetry) {
+        this.log("Got 401, retrying with fresh token...");
+        return this.request(method, path, body, true);
+      }
+      if (this.config.debug) {
+        console.error(`[RemoteDB] Error ${response.status}:`, responseData);
+      }
+      if (response.status === 401 && this.config.onAuthError) {
+        this.config.onAuthError({
+          status: response.status,
+          message: "Authentication failed",
+          response: responseData
+        });
+      }
+      const errorMessage = responseData.message || responseData.error || responseData.detail || (typeof responseData === "string" ? responseData : `API request failed: ${response.status}`);
+      throw new RemoteDBError(errorMessage, response.status, responseData);
+    }
+    this.log("Response:", responseData);
+    return responseData;
+  }
+  /**
+   * Validate data against schema if available
+   */
+  validateData(data, checkRequired = true) {
+    if (this.config.schema) {
+      const result = (0, import_schema2.validateData)(this.config.schema, this.tableName, data, checkRequired);
+      if (!result.valid) {
+        throw new Error(result.message || "Data validation failed");
+      }
+    }
+  }
+  /**
+   * Get the base path for this collection
+   */
+  get basePath() {
+    return `/account/${this.config.projectId}/db/${this.tableName}`;
+  }
+  /**
+   * Add a new record to the collection
+   * The server generates the ID
+   * Requires authentication - throws NotAuthenticatedError if not signed in
+   */
+  async add(data) {
+    this.validateData(data, true);
+    try {
+      const result = await this.request(
+        "POST",
+        this.basePath,
+        { value: data }
+      );
+      return result.data;
+    } catch (error) {
+      if (this.isNotAuthenticatedError(error)) {
+        throw new NotAuthenticatedError("Sign in required to add items");
+      }
+      throw error;
+    }
+  }
+  /**
+   * Put (upsert) a record - requires id
+   * Requires authentication - throws NotAuthenticatedError if not signed in
+   */
+  async put(data) {
+    if (!data.id) {
+      throw new Error("put() requires an id field");
+    }
+    const { id, ...rest } = data;
+    this.validateData(rest, true);
+    try {
+      const result = await this.request(
+        "PUT",
+        `${this.basePath}/${id}`,
+        { value: rest }
+      );
+      return result.data || data;
+    } catch (error) {
+      if (this.isNotAuthenticatedError(error)) {
+        throw new NotAuthenticatedError("Sign in required to update items");
+      }
+      throw error;
+    }
+  }
+  /**
+   * Update an existing record by id
+   * Requires authentication - throws NotAuthenticatedError if not signed in
+   */
+  async update(id, data) {
+    if (!id) {
+      throw new Error("update() requires an id");
+    }
+    this.validateData(data, false);
+    try {
+      const result = await this.request(
+        "PATCH",
+        `${this.basePath}/${id}`,
+        { value: data }
+      );
+      return result.data || null;
+    } catch (error) {
+      if (error instanceof RemoteDBError && error.status === 404) {
+        return null;
+      }
+      if (this.isNotAuthenticatedError(error)) {
+        throw new NotAuthenticatedError("Sign in required to update items");
+      }
+      throw error;
+    }
+  }
+  /**
+   * Delete a record by id
+   * Requires authentication - throws NotAuthenticatedError if not signed in
+   */
+  async delete(id) {
+    if (!id) {
+      throw new Error("delete() requires an id");
+    }
+    try {
+      await this.request(
+        "DELETE",
+        `${this.basePath}/${id}`
+      );
+      return true;
+    } catch (error) {
+      if (error instanceof RemoteDBError && error.status === 404) {
+        return false;
+      }
+      if (this.isNotAuthenticatedError(error)) {
+        throw new NotAuthenticatedError("Sign in required to delete items");
+      }
+      throw error;
+    }
+  }
+  /**
+   * Get a single record by id
+   * Returns null if not authenticated (graceful degradation for read operations)
+   */
+  async get(id) {
+    if (!id) {
+      throw new Error("get() requires an id");
+    }
+    try {
+      const result = await this.request(
+        "GET",
+        `${this.basePath}?id=${id}`
+      );
+      return result.data?.[0] || null;
+    } catch (error) {
+      if (this.isNotAuthenticatedError(error)) {
+        this.log("Not authenticated - returning null for get()");
+      }
+      return null;
+    }
+  }
+  /**
+   * Get all records in the collection
+   * Returns empty array if not authenticated (graceful degradation for read operations)
+   */
+  async getAll() {
+    try {
+      const result = await this.request(
+        "GET",
+        this.basePath
+      );
+      return result.data || [];
+    } catch (error) {
+      if (this.isNotAuthenticatedError(error)) {
+        this.log("Not authenticated - returning empty array for getAll()");
+        return [];
+      }
+      throw error;
+    }
+  }
+  /**
+   * Filter records using a predicate function
+   * Note: This fetches all records and filters client-side
+   * Returns empty array if not authenticated (graceful degradation for read operations)
+   */
+  async filter(fn) {
+    const all = await this.getAll();
+    return all.filter(fn);
+  }
+  /**
+   * ref is not available for remote collections
+   */
+  ref = void 0;
+};
+
+// src/core/db/RemoteDB.ts
+var RemoteDB = class {
+  config;
+  collections = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Get a collection by name
+   * Collections are cached for reuse
+   */
+  collection(name) {
+    if (this.collections.has(name)) {
+      return this.collections.get(name);
+    }
+    if (this.config.schema?.tables && !this.config.schema.tables[name]) {
+      throw new Error(`Table "${name}" not found in schema`);
+    }
+    const collection = new RemoteCollection(name, this.config);
+    this.collections.set(name, collection);
+    return collection;
+  }
+};
+
+// src/AuthContext.tsx
+init_config();
+
 // package.json
-var version = "0.7.0-beta.4";
+var version = "0.7.0-beta.6";
 
 // src/updater/versionUpdater.ts
 var VersionUpdater = class {
@@ -461,6 +840,7 @@ function clearCookie(name) {
 }
 
 // src/utils/network.ts
+init_config();
 function isDevelopment(debug) {
   return window.location.hostname === "localhost" || window.location.hostname === "127.0.0.1" || window.location.hostname.includes("localhost") || window.location.hostname.includes("127.0.0.1") || window.location.hostname.includes(".local") || process.env.NODE_ENV === "development" || debug === true;
 }
@@ -523,10 +903,11 @@ function getSyncStatus(statusCode) {
 }
 
 // src/utils/schema.ts
-var import_schema2 = require("@basictech/schema");
+var import_schema3 = require("@basictech/schema");
+init_config();
 async function getSchemaStatus(schema) {
   const projectId = schema.project_id;
-  const valid = (0, import_schema2.validateSchema)(schema);
+  const valid = (0, import_schema3.validateSchema)(schema);
   if (!valid.valid) {
     console.warn("BasicDB Error: your local schema is invalid. Please fix errors and try again - sync is disabled");
     return {
@@ -565,7 +946,7 @@ async function getSchemaStatus(schema) {
       latest: latestSchema
     };
   } else if (latestSchema.version === schema.version) {
-    const changes = (0, import_schema2.compareSchemas)(schema, latestSchema);
+    const changes = (0, import_schema3.compareSchemas)(schema, latestSchema);
     if (changes.valid) {
       return {
         valid: true,
@@ -589,7 +970,7 @@ async function getSchemaStatus(schema) {
   }
 }
 async function validateAndCheckSchema(schema) {
-  const valid = (0, import_schema2.validateSchema)(schema);
+  const valid = (0, import_schema3.validateSchema)(schema);
   if (!valid.valid) {
     log("Basic Schema is invalid!", valid.errors);
     console.group("Schema Errors");
@@ -626,29 +1007,44 @@ var DEFAULT_AUTH_CONFIG = {
   server_url: "https://api.basic.tech",
   ws_url: "wss://pds.basic.id/ws"
 };
+var noDb = {
+  collection: () => {
+    throw new Error("no basicdb found - initialization failed. double check your schema.");
+  }
+};
 var BasicContext = (0, import_react.createContext)({
-  unicorn: "\u{1F984}",
-  isAuthReady: false,
+  // Auth state
+  isReady: false,
   isSignedIn: false,
   user: null,
-  signout: () => Promise.resolve(),
+  // Auth actions
+  signIn: () => Promise.resolve(),
+  signOut: () => Promise.resolve(),
+  signInWithCode: () => Promise.resolve({ success: false }),
+  // Token management
+  getToken: () => Promise.reject(new Error("no token")),
+  getSignInUrl: () => Promise.resolve(""),
+  // DB access
+  db: noDb,
+  dbStatus: "LOADING" /* LOADING */,
+  dbMode: "sync",
+  // Legacy aliases
+  isAuthReady: false,
   signin: () => Promise.resolve(),
-  signinWithCode: () => new Promise(() => {
-  }),
-  getToken: () => new Promise(() => {
-  }),
-  getSignInLink: () => Promise.resolve(""),
-  db: {},
-  dbStatus: "LOADING" /* LOADING */
+  signout: () => Promise.resolve(),
+  signinWithCode: () => Promise.resolve({ success: false }),
+  getSignInLink: () => Promise.resolve("")
 });
 function BasicProvider({
   children,
-  project_id,
+  project_id: project_id_prop,
   schema,
   debug = false,
   storage,
-  auth
+  auth,
+  dbMode = "sync"
 }) {
+  const project_id = schema?.project_id || project_id_prop;
   const [isAuthReady, setIsAuthReady] = (0, import_react.useState)(false);
   const [isSignedIn, setIsSignedIn] = (0, import_react.useState)(false);
   const [token, setToken] = (0, import_react.useState)(null);
@@ -660,6 +1056,7 @@ function BasicProvider({
   const [isOnline, setIsOnline] = (0, import_react.useState)(navigator.onLine);
   const [pendingRefresh, setPendingRefresh] = (0, import_react.useState)(false);
   const syncRef = (0, import_react.useRef)(null);
+  const remoteDbRef = (0, import_react.useRef)(null);
   const storageAdapter = storage || new LocalStorageAdapter();
   const authConfig = {
     scopes: auth?.scopes || DEFAULT_AUTH_CONFIG.scopes,
@@ -699,9 +1096,10 @@ function BasicProvider({
     };
   }, [pendingRefresh, token]);
   (0, import_react.useEffect)(() => {
-    function initDb(options) {
+    async function initSyncDb(options) {
       if (!syncRef.current) {
-        log("Initializing Basic DB");
+        log("Initializing Basic Sync DB");
+        await initDexieExtensions();
         syncRef.current = new BasicSync("basicdb", { schema });
         syncRef.current.syncable.on("statusChanged", (status, url) => {
           setDbStatus(getSyncStatus(status));
@@ -714,6 +1112,33 @@ function BasicProvider({
         setIsReady(true);
       }
     }
+    function initRemoteDb() {
+      if (!remoteDbRef.current) {
+        if (!project_id) {
+          setError({
+            code: "missing_project_id",
+            title: "Project ID Required",
+            message: "Remote mode requires a project_id. Provide it via schema.project_id or the project_id prop."
+          });
+          setIsReady(true);
+          return;
+        }
+        log("Initializing Basic Remote DB");
+        remoteDbRef.current = new RemoteDB({
+          serverUrl: authConfig.server_url,
+          projectId: project_id,
+          getToken,
+          schema,
+          debug,
+          onAuthError: (error2) => {
+            log("RemoteDB auth error:", error2);
+            signout();
+          }
+        });
+        setDbStatus("ONLINE" /* ONLINE */);
+        setIsReady(true);
+      }
+    }
     async function checkSchema() {
       const result = await validateAndCheckSchema(schema);
       if (!result.isValid) {
@@ -732,18 +1157,26 @@ function BasicProvider({
         setIsReady(true);
         return null;
       }
-      if (result.schemaStatus.valid) {
-        initDb({ shouldConnect: true });
+      if (dbMode === "remote") {
+        initRemoteDb();
       } else {
-        log("Schema is invalid!", result.schemaStatus);
-        initDb({ shouldConnect: false });
+        if (result.schemaStatus.valid) {
+          await initSyncDb({ shouldConnect: true });
+        } else {
+          log("Schema is invalid!", result.schemaStatus);
+          await initSyncDb({ shouldConnect: false });
+        }
       }
       checkForNewVersion();
     }
     if (schema) {
       checkSchema();
     } else {
-      setIsReady(true);
+      if (dbMode === "remote" && project_id) {
+        initRemoteDb();
+      } else {
+        setIsReady(true);
+      }
     }
   }, []);
   (0, import_react.useEffect)(() => {
@@ -890,8 +1323,14 @@ function BasicProvider({
       const isExpired = decoded.exp && decoded.exp < Date.now() / 1e3 + expirationBuffer;
       if (isExpired) {
         log("token is expired - refreshing ...");
+        const refreshToken = token?.refresh_token;
+        if (!refreshToken) {
+          log("Error: No refresh token available for expired token");
+          setIsAuthReady(true);
+          return;
+        }
         try {
-          const newToken = await fetchToken(token?.refresh_token || "", true);
+          const newToken = await fetchToken(refreshToken, true);
           fetchUser(newToken?.access_token || "");
         } catch (error2) {
           log("Failed to refresh token in checkToken:", error2);
@@ -1098,6 +1537,11 @@ function BasicProvider({
     return token?.access_token || "";
   };
   const fetchToken = async (codeOrRefreshToken, isRefreshToken = false) => {
+    if (!codeOrRefreshToken || codeOrRefreshToken.trim() === "") {
+      const errorMsg = isRefreshToken ? "Refresh token is empty or undefined" : "Authorization code is empty or undefined";
+      log("Error:", errorMsg);
+      throw new Error(errorMsg);
+    }
     if (isRefreshToken && refreshPromiseRef.current) {
       log("Reusing in-flight refresh token request");
       return refreshPromiseRef.current;
@@ -1210,24 +1654,36 @@ function BasicProvider({
     }
     return refreshPromise;
   };
-  const noDb = {
-    collection: () => {
-      throw new Error("no basicdb found - initialization failed. double check your schema.");
+  const getCurrentDb = () => {
+    if (dbMode === "remote") {
+      return remoteDbRef.current || noDb;
     }
+    return syncRef.current || noDb;
   };
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(BasicContext.Provider, { value: {
-    unicorn: "\u{1F984}",
-    isAuthReady,
+  const contextValue = {
+    // Auth state (new naming)
+    isReady: isAuthReady,
     isSignedIn,
     user,
-    signout,
+    // Auth actions (new camelCase naming)
+    signIn: signin,
+    signOut: signout,
+    signInWithCode: signinWithCode,
+    // Token management
+    getToken,
+    getSignInUrl: getSignInLink,
+    // DB access
+    db: getCurrentDb(),
+    dbStatus,
+    dbMode,
+    // Legacy aliases (deprecated)
+    isAuthReady,
     signin,
+    signout,
     signinWithCode,
-    getToken,
-    getSignInLink,
-    db: syncRef.current ? syncRef.current : noDb,
-    dbStatus
-  }, children: [
+    getSignInLink
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(BasicContext.Provider, { value: contextValue, children: [
     error && isDevMode() && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ErrorDisplay, { error }),
     isReady && children
   ] });
@@ -1264,6 +1720,11 @@ var import_dexie_react_hooks = require("dexie-react-hooks");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BasicProvider,
+  NotAuthenticatedError,
+  RemoteCollection,
+  RemoteDB,
+  RemoteDBError,
+  STORAGE_KEYS,
   useBasic,
   useQuery
 });