@basictech/react 0.7.0-beta.1 → 0.7.0-beta.3

package/dist/index.mjs

@@ -127,116 +127,8 @@ var syncProtocol = function() {
   });
 };
 
-// src/schema.ts
-import Ajv from "ajv";
-var basicJsonSchema = {
-  "$schema": "http://json-schema.org/draft-07/schema#",
-  "type": "object",
-  "properties": {
-    "project_id": {
-      "type": "string"
-    },
-    "namespace": {
-      "type": "string"
-    },
-    "version": {
-      "type": "integer",
-      "minimum": 0
-    },
-    "tables": {
-      "type": "object",
-      "patternProperties": {
-        "^[a-zA-Z0-9_]+$": {
-          "type": "object",
-          "properties": {
-            "name": {
-              "type": "string"
-            },
-            "type": {
-              "type": "string",
-              "enum": ["collection"]
-            },
-            "fields": {
-              "type": "object",
-              "patternProperties": {
-                "^[a-zA-Z0-9_]+$": {
-                  "type": "object",
-                  "properties": {
-                    "type": {
-                      "type": "string",
-                      "enum": ["string", "boolean", "number", "json"]
-                    },
-                    "indexed": {
-                      "type": "boolean"
-                    },
-                    "required": {
-                      "type": "boolean"
-                    }
-                  },
-                  "required": ["type"]
-                }
-              },
-              "additionalProperties": true
-            }
-          },
-          "required": ["fields"]
-        }
-      },
-      "additionalProperties": true
-    }
-  },
-  "required": ["project_id", "version", "tables"]
-};
-var ajv = new Ajv();
-var validator = ajv.compile(basicJsonSchema);
-function validateSchema(schema) {
-  const v = validator(schema);
-  return {
-    valid: v,
-    errors: validator.errors || []
-  };
-}
-function validateData(schema, table, data, checkRequired = true) {
-  const valid = validateSchema(schema);
-  if (!valid.valid) {
-    return { valid: false, errors: valid.errors, message: "Schema is invalid" };
-  }
-  const tableSchema = schema.tables[table];
-  if (!tableSchema) {
-    return { valid: false, errors: [{ message: `Table ${table} not found in schema` }], message: "Table not found" };
-  }
-  for (const [fieldName, fieldValue] of Object.entries(data)) {
-    const fieldSchema = tableSchema.fields[fieldName];
-    if (!fieldSchema) {
-      return {
-        valid: false,
-        errors: [{ message: `Field ${fieldName} not found in schema` }],
-        message: "Invalid field"
-      };
-    }
-    const schemaType = fieldSchema.type;
-    const valueType = typeof fieldValue;
-    if (schemaType === "string" && valueType !== "string" || schemaType === "number" && valueType !== "number" || schemaType === "boolean" && valueType !== "boolean" || schemaType === "json" && valueType !== "object") {
-      return {
-        valid: false,
-        errors: [{
-          message: `Field ${fieldName} should be type ${schemaType}, got ${valueType}`
-        }],
-        message: "invalid type"
-      };
-    }
-  }
-  if (checkRequired) {
-    for (const [fieldName, fieldSchema] of Object.entries(tableSchema.fields)) {
-      if (fieldSchema.required && !data[fieldName]) {
-        return { valid: false, errors: [{ message: `Field ${fieldName} is required` }], message: "Required field missing" };
-      }
-    }
-  }
-  return { valid: true, errors: [] };
-}
-
 // src/sync/index.ts
+import { validateData } from "@basictech/schema";
 syncProtocol();
 var BasicSync = class extends Dexie2 {
   basic_schema;
@@ -358,60 +250,135 @@ var BasicSync = class extends Dexie2 {
   }
 };
 
-// src/db.ts
-var baseUrl = "https://api.basic.tech";
-async function get({ projectId, accountId, tableName, token }) {
-  const url = `${baseUrl}/project/${projectId}/db/${accountId}/${tableName}`;
-  const response = await fetch(url, {
-    headers: {
-      "Authorization": `Bearer ${token}`
+// package.json
+var version = "0.7.0-beta.2";
+
+// src/updater/versionUpdater.ts
+var VersionUpdater = class {
+  storage;
+  currentVersion;
+  migrations;
+  versionKey = "basic_app_version";
+  constructor(storage, currentVersion, migrations = []) {
+    this.storage = storage;
+    this.currentVersion = currentVersion;
+    this.migrations = migrations.sort((a, b) => this.compareVersions(a.fromVersion, b.fromVersion));
+  }
+  /**
+   * Check current stored version and run migrations if needed
+   * Only compares major.minor versions, ignoring beta/prerelease parts
+   * Example: "0.7.0-beta.1" and "0.7.0" are treated as the same version
+   */
+  async checkAndUpdate() {
+    const storedVersion = await this.getStoredVersion();
+    if (!storedVersion) {
+      await this.setStoredVersion(this.currentVersion);
+      return { updated: false, toVersion: this.currentVersion };
     }
-  });
-  return response.json();
-}
-async function add({ projectId, accountId, tableName, value, token }) {
-  const url = `${baseUrl}/project/${projectId}/db/${accountId}/${tableName}`;
-  const response = await fetch(url, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "Authorization": `Bearer ${token}`
-    },
-    body: JSON.stringify({ "value": value })
-  });
-  return response.json();
-}
-async function update({ projectId, accountId, tableName, id, value, token }) {
-  const url = `${baseUrl}/project/${projectId}/db/${accountId}/${tableName}/${id}`;
-  const response = await fetch(url, {
-    method: "PATCH",
-    headers: {
-      "Content-Type": "application/json",
-      "Authorization": `Bearer ${token}`
-    },
-    body: JSON.stringify({ id, value })
-  });
-  return response.json();
-}
-async function deleteRecord({ projectId, accountId, tableName, id, token }) {
-  const url = `${baseUrl}/project/${projectId}/db/${accountId}/${tableName}/${id}`;
-  const response = await fetch(url, {
-    method: "DELETE",
-    headers: {
-      "Authorization": `Bearer ${token}`
+    if (storedVersion === this.currentVersion) {
+      return { updated: false, toVersion: this.currentVersion };
     }
-  });
-  return response.json();
+    const migrationsToRun = this.getMigrationsToRun(storedVersion, this.currentVersion);
+    if (migrationsToRun.length === 0) {
+      await this.setStoredVersion(this.currentVersion);
+      return { updated: true, fromVersion: storedVersion, toVersion: this.currentVersion };
+    }
+    for (const migration of migrationsToRun) {
+      try {
+        console.log(`Running migration from ${migration.fromVersion} to ${migration.toVersion}`);
+        await migration.migrate(this.storage);
+      } catch (error) {
+        console.error(`Migration failed from ${migration.fromVersion} to ${migration.toVersion}:`, error);
+        throw new Error(`Migration failed: ${error}`);
+      }
+    }
+    await this.setStoredVersion(this.currentVersion);
+    return { updated: true, fromVersion: storedVersion, toVersion: this.currentVersion };
+  }
+  async getStoredVersion() {
+    try {
+      const versionData = await this.storage.get(this.versionKey);
+      if (!versionData)
+        return null;
+      const versionInfo = JSON.parse(versionData);
+      return versionInfo.version;
+    } catch (error) {
+      console.warn("Failed to get stored version:", error);
+      return null;
+    }
+  }
+  async setStoredVersion(version2) {
+    const versionInfo = {
+      version: version2,
+      lastUpdated: Date.now()
+    };
+    await this.storage.set(this.versionKey, JSON.stringify(versionInfo));
+  }
+  getMigrationsToRun(fromVersion, toVersion) {
+    return this.migrations.filter((migration) => {
+      const storedLessThanMigrationTo = this.compareVersions(fromVersion, migration.toVersion) < 0;
+      const currentGreaterThanOrEqualMigrationTo = this.compareVersions(toVersion, migration.toVersion) >= 0;
+      console.log(`Checking migration ${migration.fromVersion} \u2192 ${migration.toVersion}:`);
+      console.log(`  stored ${fromVersion} < migration.to ${migration.toVersion}: ${storedLessThanMigrationTo}`);
+      console.log(`  current ${toVersion} >= migration.to ${migration.toVersion}: ${currentGreaterThanOrEqualMigrationTo}`);
+      const shouldRun = storedLessThanMigrationTo && currentGreaterThanOrEqualMigrationTo;
+      console.log(`  Should run: ${shouldRun}`);
+      return shouldRun;
+    });
+  }
+  /**
+   * Simple semantic version comparison (major.minor only, ignoring beta/prerelease)
+   * Returns: -1 if a < b, 0 if a === b, 1 if a > b
+   */
+  compareVersions(a, b) {
+    const aMajorMinor = this.extractMajorMinor(a);
+    const bMajorMinor = this.extractMajorMinor(b);
+    if (aMajorMinor.major !== bMajorMinor.major) {
+      return aMajorMinor.major - bMajorMinor.major;
+    }
+    return aMajorMinor.minor - bMajorMinor.minor;
+  }
+  /**
+   * Extract major.minor from version string, ignoring beta/prerelease
+   * Examples: "0.7.0-beta.1" -> {major: 0, minor: 7}
+   *           "1.2.3" -> {major: 1, minor: 2}
+   */
+  extractMajorMinor(version2) {
+    const cleanVersion = version2.split("-")[0]?.split("+")[0] || version2;
+    const parts = cleanVersion.split(".").map(Number);
+    return {
+      major: parts[0] || 0,
+      minor: parts[1] || 0
+    };
+  }
+  /**
+   * Add a migration to the updater
+   */
+  addMigration(migration) {
+    this.migrations.push(migration);
+    this.migrations.sort((a, b) => this.compareVersions(a.fromVersion, b.fromVersion));
+  }
+};
+function createVersionUpdater(storage, currentVersion, migrations = []) {
+  return new VersionUpdater(storage, currentVersion, migrations);
 }
 
-// src/AuthContext.tsx
-import { validateSchema as validateSchema3, compareSchemas } from "@basictech/schema";
-
-// package.json
-var version = "0.6.0";
+// src/updater/updateMigrations.ts
+var addMigrationTimestamp = {
+  fromVersion: "0.6.0",
+  toVersion: "0.7.0",
+  async migrate(storage) {
+    console.log("Running test migration");
+    storage.set("test_migration", "true");
+  }
+};
+function getMigrations() {
+  return [
+    addMigrationTimestamp
+  ];
+}
 
-// src/AuthContext.tsx
-import { jsx, jsxs } from "react/jsx-runtime";
+// src/utils/storage.ts
 var LocalStorageAdapter = class {
   async get(key) {
     return localStorage.getItem(key);
@@ -423,25 +390,113 @@ var LocalStorageAdapter = class {
     localStorage.removeItem(key);
   }
 };
-var BasicContext = createContext({
-  unicorn: "\u{1F984}",
-  isAuthReady: false,
-  isSignedIn: false,
-  user: null,
-  signout: () => Promise.resolve(),
-  signin: () => Promise.resolve(),
-  signinWithCode: () => new Promise(() => {
-  }),
-  getToken: () => new Promise(() => {
-  }),
-  getSignInLink: () => Promise.resolve(""),
-  db: {},
-  dbStatus: "LOADING" /* LOADING */
-});
+var STORAGE_KEYS = {
+  REFRESH_TOKEN: "basic_refresh_token",
+  USER_INFO: "basic_user_info",
+  AUTH_STATE: "basic_auth_state",
+  DEBUG: "basic_debug"
+};
+function getCookie(name) {
+  let cookieValue = "";
+  if (document.cookie && document.cookie !== "") {
+    const cookies = document.cookie.split(";");
+    for (let i = 0; i < cookies.length; i++) {
+      const cookie = cookies[i]?.trim();
+      if (cookie && cookie.substring(0, name.length + 1) === name + "=") {
+        cookieValue = decodeURIComponent(cookie.substring(name.length + 1));
+        break;
+      }
+    }
+  }
+  return cookieValue;
+}
+function setCookie(name, value, options) {
+  const opts = {
+    secure: true,
+    sameSite: "Strict",
+    httpOnly: false,
+    ...options
+  };
+  let cookieString = `${name}=${value}`;
+  if (opts.secure)
+    cookieString += "; Secure";
+  if (opts.sameSite)
+    cookieString += `; SameSite=${opts.sameSite}`;
+  if (opts.httpOnly)
+    cookieString += "; HttpOnly";
+  document.cookie = cookieString;
+}
+function clearCookie(name) {
+  document.cookie = `${name}=; Secure; SameSite=Strict`;
+}
+
+// src/utils/network.ts
+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;
+}
+async function checkForNewVersion() {
+  try {
+    const isBeta = version.includes("beta");
+    const response = await fetch(`https://registry.npmjs.org/@basictech/react/${isBeta ? "beta" : "latest"}`);
+    if (!response.ok) {
+      throw new Error("Failed to fetch version from npm");
+    }
+    const data = await response.json();
+    const latestVersion = data.version;
+    if (latestVersion !== version) {
+      console.warn("[basic] New version available:", latestVersion, `
+run "npm install @basictech/react@${latestVersion}" to update`);
+    }
+    if (isBeta) {
+      log("thank you for being on basictech/react beta :)");
+    }
+    return {
+      hasNewVersion: version !== latestVersion,
+      latestVersion,
+      currentVersion: version
+    };
+  } catch (error) {
+    log("Error checking for new version:", error);
+    return {
+      hasNewVersion: false,
+      latestVersion: null,
+      currentVersion: null
+    };
+  }
+}
+function cleanOAuthParamsFromUrl() {
+  if (window.location.search.includes("code") || window.location.search.includes("state")) {
+    const url = new URL(window.location.href);
+    url.searchParams.delete("code");
+    url.searchParams.delete("state");
+    window.history.pushState({}, document.title, url.pathname + url.search);
+    log("Cleaned OAuth parameters from URL");
+  }
+}
+function getSyncStatus(statusCode) {
+  switch (statusCode) {
+    case -1:
+      return "ERROR";
+    case 0:
+      return "OFFLINE";
+    case 1:
+      return "CONNECTING";
+    case 2:
+      return "ONLINE";
+    case 3:
+      return "SYNCING";
+    case 4:
+      return "ERROR_WILL_RETRY";
+    default:
+      return "UNKNOWN";
+  }
+}
+
+// src/utils/schema.ts
+import { validateSchema as validateSchema2, compareSchemas } from "@basictech/schema";
 async function getSchemaStatus(schema) {
   const projectId = schema.project_id;
-  let status = "";
-  const valid = validateSchema3(schema);
+  const valid = validateSchema2(schema);
   if (!valid.valid) {
     console.warn("BasicDB Error: your local schema is invalid. Please fix errors and try again - sync is disabled");
     return {
@@ -503,54 +558,54 @@ async function getSchemaStatus(schema) {
     };
   }
 }
-function getSyncStatus(statusCode) {
-  switch (statusCode) {
-    case -1:
-      return "ERROR";
-    case 0:
-      return "OFFLINE";
-    case 1:
-      return "CONNECTING";
-    case 2:
-      return "ONLINE";
-    case 3:
-      return "SYNCING";
-    case 4:
-      return "ERROR_WILL_RETRY";
-    default:
-      return "UNKNOWN";
-  }
-}
-async function checkForNewVersion() {
-  try {
-    const isBeta = version.includes("beta");
-    const response = await fetch(`https://registry.npmjs.org/@basictech/react/${isBeta ? "beta" : "latest"}`);
-    if (!response.ok) {
-      throw new Error("Failed to fetch version from npm");
-    }
-    const data = await response.json();
-    const latestVersion = data.version;
-    if (latestVersion !== version) {
-      console.warn("[basic] New version available:", latestVersion, `
-run "npm install @basictech/react@${latestVersion}" to update`);
-    }
-    if (isBeta) {
-      log("thank you for being on basictech/react beta :)");
-    }
-    return {
-      hasNewVersion: version !== latestVersion,
-      latestVersion,
-      currentVersion: version
-    };
-  } catch (error) {
-    log("Error checking for new version:", error);
+async function validateAndCheckSchema(schema) {
+  const valid = validateSchema2(schema);
+  if (!valid.valid) {
+    log("Basic Schema is invalid!", valid.errors);
+    console.group("Schema Errors");
+    let errorMessage = "";
+    valid.errors.forEach((error, index) => {
+      log(`${index + 1}:`, error.message, ` - at ${error.instancePath}`);
+      errorMessage += `${index + 1}: ${error.message} - at ${error.instancePath}
+`;
+    });
+    console.groupEnd();
     return {
-      hasNewVersion: false,
-      latestVersion: null,
-      currentVersion: null
+      isValid: false,
+      schemaStatus: { valid: false },
+      errors: valid.errors
     };
   }
+  let schemaStatus = { valid: false };
+  if (schema.version !== 0) {
+    schemaStatus = await getSchemaStatus(schema);
+    log("schemaStatus", schemaStatus);
+  } else {
+    log("schema not published - at version 0");
+  }
+  return {
+    isValid: true,
+    schemaStatus
+  };
 }
+
+// src/AuthContext.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var BasicContext = createContext({
+  unicorn: "\u{1F984}",
+  isAuthReady: false,
+  isSignedIn: false,
+  user: null,
+  signout: () => Promise.resolve(),
+  signin: () => Promise.resolve(),
+  signinWithCode: () => new Promise(() => {
+  }),
+  getToken: () => new Promise(() => {
+  }),
+  getSignInLink: () => Promise.resolve(""),
+  db: {},
+  dbStatus: "LOADING" /* LOADING */
+});
 function BasicProvider({
   children,
   project_id,
@@ -570,24 +625,8 @@ function BasicProvider({
   const [pendingRefresh, setPendingRefresh] = useState(false);
   const syncRef = useRef(null);
   const storageAdapter = storage || new LocalStorageAdapter();
-  const STORAGE_KEYS = {
-    REFRESH_TOKEN: "basic_refresh_token",
-    USER_INFO: "basic_user_info",
-    AUTH_STATE: "basic_auth_state",
-    DEBUG: "basic_debug"
-  };
-  const isDevelopment = () => {
-    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;
-  };
-  const cleanOAuthParamsFromUrl = () => {
-    if (window.location.search.includes("code") || window.location.search.includes("state")) {
-      const url = new URL(window.location.href);
-      url.searchParams.delete("code");
-      url.searchParams.delete("state");
-      window.history.pushState({}, document.title, url.pathname + url.search);
-      log("Cleaned OAuth parameters from URL");
-    }
-  };
+  const isDevMode = () => isDevelopment(debug);
+  const cleanOAuthParams = () => cleanOAuthParamsFromUrl();
   useEffect(() => {
     const handleOnline = () => {
       log("Network came back online");
@@ -598,7 +637,7 @@ function BasicProvider({
         if (token) {
           const refreshToken = token.refresh_token || localStorage.getItem("basic_refresh_token");
           if (refreshToken) {
-            fetchToken(refreshToken).catch((error2) => {
+            fetchToken(refreshToken, true).catch((error2) => {
               log("Retry refresh failed:", error2);
             });
           }
@@ -624,9 +663,6 @@ function BasicProvider({
         syncRef.current.syncable.on("statusChanged", (status, url) => {
           setDbStatus(getSyncStatus(status));
         });
-        syncRef.current.syncable.getStatus().then((status) => {
-          setDbStatus(getSyncStatus(status));
-        });
         if (options.shouldConnect) {
           setShouldConnect(true);
         } else {
@@ -636,17 +672,15 @@ function BasicProvider({
       }
     }
     async function checkSchema() {
-      const valid = validateSchema3(schema);
-      if (!valid.valid) {
-        log("Basic Schema is invalid!", valid.errors);
-        console.group("Schema Errors");
+      const result = await validateAndCheckSchema(schema);
+      if (!result.isValid) {
         let errorMessage = "";
-        valid.errors.forEach((error2, index) => {
-          log(`${index + 1}:`, error2.message, ` - at ${error2.instancePath}`);
-          errorMessage += `${index + 1}: ${error2.message} - at ${error2.instancePath}
+        if (result.errors) {
+          result.errors.forEach((error2, index) => {
+            errorMessage += `${index + 1}: ${error2.message} - at ${error2.instancePath}
 `;
-        });
-        console.groupEnd("Schema Errors");
+          });
+        }
         setError({
           code: "schema_invalid",
           title: "Basic Schema is invalid!",
@@ -655,17 +689,10 @@ function BasicProvider({
         setIsReady(true);
         return null;
       }
-      let schemaStatus = { valid: false };
-      if (schema.version !== 0) {
-        schemaStatus = await getSchemaStatus(schema);
-        log("schemaStatus", schemaStatus);
-      } else {
-        log("schema not published - at version 0");
-      }
-      if (schemaStatus.valid) {
+      if (result.schemaStatus.valid) {
         initDb({ shouldConnect: true });
       } else {
-        log("Schema is invalid!", schemaStatus);
+        log("Schema is invalid!", result.schemaStatus);
         initDb({ shouldConnect: false });
       }
       checkForNewVersion();
@@ -677,43 +704,61 @@ function BasicProvider({
     }
   }, []);
   useEffect(() => {
-    if (token && syncRef.current && isSignedIn && shouldConnect) {
-      connectToDb();
+    async function connectToDb() {
+      if (token && syncRef.current && isSignedIn && shouldConnect) {
+        const tok = await getToken();
+        if (!tok) {
+          log("no token found");
+          return;
+        }
+        log("connecting to db...");
+        syncRef.current?.connect({ access_token: tok }).catch((e) => {
+          log("error connecting to db", e);
+        });
+      }
     }
+    connectToDb();
   }, [isSignedIn, shouldConnect]);
-  const connectToDb = async () => {
-    const tok = await getToken();
-    if (!tok) {
-      log("no token found");
-      return;
-    }
-    log("connecting to db...");
-    syncRef.current.connect({ access_token: tok }).catch((e) => {
-      log("error connecting to db", e);
-    });
-  };
   useEffect(() => {
     const initializeAuth = async () => {
       await storageAdapter.set(STORAGE_KEYS.DEBUG, debug ? "true" : "false");
+      try {
+        const versionUpdater = createVersionUpdater(storageAdapter, version, getMigrations());
+        const updateResult = await versionUpdater.checkAndUpdate();
+        if (updateResult.updated) {
+          log(`App updated from ${updateResult.fromVersion} to ${updateResult.toVersion}`);
+        } else {
+          log(`App version ${updateResult.toVersion} is current`);
+        }
+      } catch (error2) {
+        log("Version update failed:", error2);
+      }
       try {
         if (window.location.search.includes("code")) {
-          let code = window.location?.search?.split("code=")[1].split("&")[0];
+          let code = window.location?.search?.split("code=")[1]?.split("&")[0];
+          if (!code)
+            return;
           const state = await storageAdapter.get(STORAGE_KEYS.AUTH_STATE);
-          if (!state || state !== window.location.search.split("state=")[1].split("&")[0]) {
+          const urlState = window.location.search.split("state=")[1]?.split("&")[0];
+          if (!state || state !== urlState) {
             log("error: auth state does not match");
             setIsAuthReady(true);
             await storageAdapter.remove(STORAGE_KEYS.AUTH_STATE);
-            cleanOAuthParamsFromUrl();
+            cleanOAuthParams();
             return;
           }
           await storageAdapter.remove(STORAGE_KEYS.AUTH_STATE);
-          cleanOAuthParamsFromUrl();
-          fetchToken(code);
+          cleanOAuthParams();
+          fetchToken(code, false).catch((error2) => {
+            log("Error fetching token:", error2);
+          });
         } else {
           const refreshToken = await storageAdapter.get(STORAGE_KEYS.REFRESH_TOKEN);
           if (refreshToken) {
             log("Found refresh token in storage, attempting to refresh access token");
-            fetchToken(refreshToken);
+            fetchToken(refreshToken, true).catch((error2) => {
+              log("Error fetching refresh token:", error2);
+            });
           } else {
             let cookie_token = getCookie("basic_token");
             if (cookie_token !== "") {
@@ -762,8 +807,8 @@ function BasicProvider({
         }
         await storageAdapter.set(STORAGE_KEYS.USER_INFO, JSON.stringify(user2));
         log("Cached user info in storage");
-        document.cookie = `basic_access_token=${token.access_token}; Secure; SameSite=Strict; HttpOnly=false`;
-        document.cookie = `basic_token=${JSON.stringify(token)}; Secure; SameSite=Strict`;
+        setCookie("basic_access_token", token?.access_token || "", { httpOnly: false });
+        setCookie("basic_token", JSON.stringify(token));
         setUser(user2);
         setIsSignedIn(true);
         setIsAuthReady(true);
@@ -780,19 +825,19 @@ function BasicProvider({
       if (isExpired) {
         log("token is expired - refreshing ...");
         try {
-          const newToken = await fetchToken(token?.refresh_token);
-          fetchUser(newToken.access_token);
+          const newToken = await fetchToken(token?.refresh_token || "", true);
+          fetchUser(newToken?.access_token || "");
         } catch (error2) {
           log("Failed to refresh token in checkToken:", error2);
           if (error2.message.includes("offline") || error2.message.includes("Network")) {
             log("Network issue - continuing with expired token until online");
-            fetchUser(token.access_token);
+            fetchUser(token?.access_token || "");
           } else {
             setIsAuthReady(true);
           }
         }
       } else {
-        fetchUser(token.access_token);
+        fetchUser(token?.access_token || "");
       }
     }
     if (token) {
@@ -811,14 +856,14 @@ function BasicProvider({
       if (!redirectUrl || !redirectUrl.startsWith("http://") && !redirectUrl.startsWith("https://")) {
         throw new Error("Invalid redirect URI provided");
       }
-      let baseUrl2 = "https://api.basic.tech/auth/authorize";
-      baseUrl2 += `?client_id=${project_id}`;
-      baseUrl2 += `&redirect_uri=${encodeURIComponent(redirectUrl)}`;
-      baseUrl2 += `&response_type=code`;
-      baseUrl2 += `&scope=profile`;
-      baseUrl2 += `&state=${randomState}`;
+      let baseUrl = "https://api.basic.tech/auth/authorize";
+      baseUrl += `?client_id=${project_id}`;
+      baseUrl += `&redirect_uri=${encodeURIComponent(redirectUrl)}`;
+      baseUrl += `&response_type=code`;
+      baseUrl += `&scope=profile`;
+      baseUrl += `&state=${randomState}`;
       log("Generated sign-in link successfully");
-      return baseUrl2;
+      return baseUrl;
     } catch (error2) {
       log("Error generating sign-in link:", error2);
       throw error2;
@@ -840,7 +885,7 @@ function BasicProvider({
       window.location.href = signInLink;
     } catch (error2) {
       log("Error during sign-in:", error2);
-      if (isDevelopment()) {
+      if (isDevMode()) {
         setError({
           code: "signin_error",
           title: "Sign-in Failed",
@@ -864,8 +909,8 @@ function BasicProvider({
         }
       }
       await storageAdapter.remove(STORAGE_KEYS.AUTH_STATE);
-      cleanOAuthParamsFromUrl();
-      const token2 = await fetchToken(code);
+      cleanOAuthParams();
+      const token2 = await fetchToken(code, false);
       if (token2) {
         log("signinWithCode successful");
         return { success: true };
@@ -885,16 +930,16 @@ function BasicProvider({
     setUser({});
     setIsSignedIn(false);
     setToken(null);
-    document.cookie = `basic_token=; Secure; SameSite=Strict`;
-    document.cookie = `basic_access_token=; Secure; SameSite=Strict`;
+    clearCookie("basic_token");
+    clearCookie("basic_access_token");
     await storageAdapter.remove(STORAGE_KEYS.AUTH_STATE);
     await storageAdapter.remove(STORAGE_KEYS.REFRESH_TOKEN);
     await storageAdapter.remove(STORAGE_KEYS.USER_INFO);
     if (syncRef.current) {
       (async () => {
         try {
-          await syncRef.current.close();
-          await syncRef.current.delete({ disableAutoOpen: false });
+          await syncRef.current?.close();
+          await syncRef.current?.delete({ disableAutoOpen: false });
           syncRef.current = null;
           window?.location?.reload();
         } catch (error2) {
@@ -910,7 +955,7 @@ function BasicProvider({
       if (refreshToken) {
         log("No token in memory, attempting to refresh from storage");
         try {
-          const newToken = await fetchToken(refreshToken);
+          const newToken = await fetchToken(refreshToken, true);
           if (newToken?.access_token) {
             return newToken.access_token;
           }
@@ -937,7 +982,7 @@ function BasicProvider({
       const refreshToken = token?.refresh_token || await storageAdapter.get(STORAGE_KEYS.REFRESH_TOKEN);
       if (refreshToken) {
         try {
-          const newToken = await fetchToken(refreshToken);
+          const newToken = await fetchToken(refreshToken, true);
           return newToken?.access_token || "";
         } catch (error2) {
           log("Failed to refresh expired token:", error2);
@@ -953,33 +998,26 @@ function BasicProvider({
     }
     return token?.access_token || "";
   };
-  function getCookie(name) {
-    let cookieValue = "";
-    if (document.cookie && document.cookie !== "") {
-      const cookies = document.cookie.split(";");
-      for (let i = 0; i < cookies.length; i++) {
-        const cookie = cookies[i].trim();
-        if (cookie.substring(0, name.length + 1) === name + "=") {
-          cookieValue = decodeURIComponent(cookie.substring(name.length + 1));
-          break;
-        }
-      }
-    }
-    return cookieValue;
-  }
-  const fetchToken = async (code) => {
+  const fetchToken = async (codeOrRefreshToken, isRefreshToken = false) => {
     try {
       if (!isOnline) {
         log("Network is offline, marking refresh as pending");
         setPendingRefresh(true);
         throw new Error("Network offline - refresh will be retried when online");
       }
+      const requestBody = isRefreshToken ? {
+        grant_type: "refresh_token",
+        refresh_token: codeOrRefreshToken
+      } : {
+        grant_type: "authorization_code",
+        code: codeOrRefreshToken
+      };
       const token2 = await fetch("https://api.basic.tech/auth/token", {
         method: "POST",
         headers: {
           "Content-Type": "application/json"
         },
-        body: JSON.stringify({ code })
+        body: JSON.stringify(requestBody)
       }).then((response) => response.json()).catch((error2) => {
         log("Network error fetching token:", error2);
         if (!isOnline) {
@@ -996,8 +1034,8 @@ function BasicProvider({
         }
         await storageAdapter.remove(STORAGE_KEYS.REFRESH_TOKEN);
         await storageAdapter.remove(STORAGE_KEYS.USER_INFO);
-        document.cookie = `basic_token=; Secure; SameSite=Strict`;
-        document.cookie = `basic_access_token=; Secure; SameSite=Strict`;
+        clearCookie("basic_token");
+        clearCookie("basic_access_token");
         setUser({});
         setIsSignedIn(false);
         setToken(null);
@@ -1010,7 +1048,7 @@ function BasicProvider({
           await storageAdapter.set(STORAGE_KEYS.REFRESH_TOKEN, token2.refresh_token);
           log("Updated refresh token in storage");
         }
-        document.cookie = `basic_access_token=${token2.access_token}; Secure; SameSite=Strict; HttpOnly=false`;
+        setCookie("basic_access_token", token2.access_token, { httpOnly: false });
         log("Updated access token in cookie");
       }
       return token2;
@@ -1019,8 +1057,8 @@ function BasicProvider({
       if (!error2.message.includes("offline") && !error2.message.includes("Network")) {
         await storageAdapter.remove(STORAGE_KEYS.REFRESH_TOKEN);
         await storageAdapter.remove(STORAGE_KEYS.USER_INFO);
-        document.cookie = `basic_token=; Secure; SameSite=Strict`;
-        document.cookie = `basic_access_token=; Secure; SameSite=Strict`;
+        clearCookie("basic_token");
+        clearCookie("basic_access_token");
         setUser({});
         setIsSignedIn(false);
         setToken(null);
@@ -1029,35 +1067,6 @@ function BasicProvider({
       throw error2;
     }
   };
-  const db_ = (tableName) => {
-    const checkSignIn = () => {
-      if (!isSignedIn) {
-        throw new Error("cannot use db. user not logged in.");
-      }
-    };
-    return {
-      get: async () => {
-        checkSignIn();
-        const tok = await getToken();
-        return get({ projectId: project_id, accountId: user.id, tableName, token: tok });
-      },
-      add: async (value) => {
-        checkSignIn();
-        const tok = await getToken();
-        return add({ projectId: project_id, accountId: user.id, tableName, value, token: tok });
-      },
-      update: async (id, value) => {
-        checkSignIn();
-        const tok = await getToken();
-        return update({ projectId: project_id, accountId: user.id, tableName, id, value, token: tok });
-      },
-      delete: async (id) => {
-        checkSignIn();
-        const tok = await getToken();
-        return deleteRecord({ projectId: project_id, accountId: user.id, tableName, id, token: tok });
-      }
-    };
-  };
   const noDb = {
     collection: () => {
       throw new Error("no basicdb found - initialization failed. double check your schema.");
@@ -1076,7 +1085,7 @@ function BasicProvider({
     db: syncRef.current ? syncRef.current : noDb,
     dbStatus
   }, children: [
-    error && isDevelopment() && /* @__PURE__ */ jsx(ErrorDisplay, { error }),
+    error && isDevMode() && /* @__PURE__ */ jsx(ErrorDisplay, { error }),
     isReady && children
   ] });
 }