@basictech/react 0.7.0-beta.0 → 0.7.0-beta.2

package/dist/index.mjs

@@ -250,78 +250,607 @@ 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}`
+// src/db_ts.ts
+var DBError = class extends Error {
+  constructor(message, status, response, originalError) {
+    super(message);
+    this.status = status;
+    this.response = response;
+    this.originalError = originalError;
+    this.name = "DBError";
+  }
+};
+var QueryBuilder = class {
+  constructor(tableClient, tableSchema) {
+    this.tableClient = tableClient;
+    this.tableSchema = tableSchema;
+  }
+  params = {};
+  // Reserved fields that are always allowed
+  reservedFields = ["created_at", "updated_at", "id"];
+  // Validate field existence in schema
+  validateField(field) {
+    if (this.tableSchema && !this.reservedFields.includes(field)) {
+      if (!this.tableSchema.fields || !(field in this.tableSchema.fields)) {
+        throw new Error(`Invalid field: "${field}". Field does not exist in table schema.`);
+      }
     }
-  });
-  return response.json();
+  }
+  // Validate operator based on field type
+  validateOperator(field, operator, value) {
+    if (!this.tableSchema || this.reservedFields.includes(field)) {
+      return;
+    }
+    const fieldInfo = this.tableSchema.fields[field];
+    if (!fieldInfo)
+      return;
+    switch (operator) {
+      case "gt":
+      case "gte":
+      case "lt":
+      case "lte":
+        if (fieldInfo.type !== "number" && fieldInfo.type !== "string") {
+          throw new Error(`Operator "${operator}" can only be used with number or string fields. Field "${field}" is type "${fieldInfo.type}".`);
+        }
+        break;
+      case "like":
+      case "ilike":
+        if (fieldInfo.type !== "string") {
+          throw new Error(`Operator "${operator}" can only be used with string fields. Field "${field}" is type "${fieldInfo.type}".`);
+        }
+        if (typeof value !== "string") {
+          throw new Error(`Operator "${operator}" requires a string value. Received: ${typeof value}`);
+        }
+        break;
+      case "in":
+        if (!Array.isArray(value)) {
+          throw new Error(`Operator "in" requires an array value. Received: ${typeof value}`);
+        }
+        break;
+      case "is":
+        if (value !== null && typeof value !== "boolean") {
+          throw new Error(`Operator "is" requires null or boolean. Received: ${typeof value}`);
+        }
+        break;
+    }
+  }
+  // Add ordering to query with schema validation
+  order(field, direction = "asc") {
+    this.validateField(field);
+    this.params.order = `${field}.${direction}`;
+    return this;
+  }
+  // Add filtering to query
+  filter(conditions) {
+    if (!this.params.filters) {
+      this.params.filters = {};
+    }
+    for (const [field, condition] of Object.entries(conditions)) {
+      this.validateField(field);
+      if (condition === null || typeof condition !== "object") {
+        this.params.filters[field] = condition;
+      } else {
+        this.params.filters[field] = condition;
+      }
+    }
+    return this;
+  }
+  // Add limit to query
+  limit(count) {
+    this.params.limit = count;
+    return this;
+  }
+  // Add offset to query for pagination
+  offset(count) {
+    this.params.offset = count;
+    return this;
+  }
+  // Auto-execute when awaited
+  then(onfulfilled, onrejected) {
+    return this.tableClient.executeQuery(this.params).then(onfulfilled, onrejected);
+  }
+  // Auto-execute when awaited with catch
+  catch(onrejected) {
+    return this.tableClient.executeQuery(this.params).catch(onrejected);
+  }
+  // Auto-execute when awaited with finally
+  finally(onfinally) {
+    return this.tableClient.executeQuery(this.params).finally(onfinally);
+  }
+};
+var TableClient = class {
+  constructor(baseUrl, projectId, token, table, getToken, schema) {
+    this.baseUrl = baseUrl;
+    this.projectId = projectId;
+    this.token = token;
+    this.table = table;
+    this.getToken = getToken;
+    this.schema = schema;
+    if (schema && schema.tables && schema.tables[table]) {
+      this.tableSchema = schema.tables[table];
+    }
+  }
+  tableSchema;
+  async headers() {
+    const token = await this.getToken();
+    return {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json"
+    };
+  }
+  async handleRequest(request) {
+    try {
+      const res = await request;
+      if (!res.ok) {
+        let errorMessage = `Request failed with status ${res.status}`;
+        let errorData;
+        try {
+          const json2 = await res.json();
+          errorData = json2;
+          if (json2.error || json2.message) {
+            const errorDetails = typeof json2.error === "object" ? JSON.stringify(json2.error) : json2.error;
+            const messageDetails = typeof json2.message === "object" ? JSON.stringify(json2.message) : json2.message;
+            errorMessage = `${res.status} ${res.statusText}: ${messageDetails || errorDetails || "Unknown error"}`;
+          }
+        } catch (e) {
+          console.log("Failed to parse error response:", e);
+          errorMessage = `${res.status} ${res.statusText}`;
+        }
+        throw new DBError(
+          errorMessage,
+          res.status,
+          errorData
+        );
+      }
+      const json = await res.json();
+      return json.data;
+    } catch (error) {
+      console.log("Caught error:", error);
+      if (error instanceof Error) {
+        console.log("Error type:", error.constructor.name);
+        console.log("Error stack:", error.stack);
+      }
+      if (error instanceof DBError) {
+        throw error;
+      }
+      if (error instanceof TypeError && error.message === "Network request failed") {
+        throw new DBError(
+          "Network request failed. Please check your internet connection and try again.",
+          void 0,
+          void 0,
+          error
+        );
+      }
+      throw new DBError(
+        `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        void 0,
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  // Build query string from query options
+  buildQueryParams(query) {
+    if (!query)
+      return "";
+    const params = [];
+    if (query.id) {
+      params.push(`id=${query.id}`);
+    }
+    if (query.filters) {
+      for (const [field, condition] of Object.entries(query.filters)) {
+        this.addFilterParam(params, field, condition);
+      }
+    }
+    if (query.order) {
+      params.push(`order=${query.order}`);
+    }
+    if (query.limit !== void 0 && query.limit >= 0) {
+      params.push(`limit=${query.limit}`);
+    }
+    if (query.offset !== void 0 && query.offset >= 0) {
+      params.push(`offset=${query.offset}`);
+    }
+    return params.length > 0 ? `?${params.join("&")}` : "";
+  }
+  // Helper method to build filter parameters
+  addFilterParam(params, field, condition, negate = false) {
+    if (condition === null || typeof condition !== "object") {
+      if (condition === null) {
+        params.push(`${field}=${negate ? "not." : ""}is.null`);
+      } else if (typeof condition === "boolean") {
+        params.push(`${field}=${negate ? "not." : ""}is.${condition}`);
+      } else if (typeof condition === "number") {
+        params.push(`${field}=${negate ? "not." : ""}eq.${condition}`);
+      } else {
+        params.push(`${field}=${negate ? "not." : ""}eq.${encodeURIComponent(String(condition))}`);
+      }
+      return;
+    }
+    const operatorObj = condition;
+    if (operatorObj.not) {
+      this.addFilterParam(params, field, operatorObj.not, true);
+      return;
+    }
+    for (const [op, value] of Object.entries(operatorObj)) {
+      if (op === "not")
+        continue;
+      const operator = op;
+      if (value === null) {
+        params.push(`${field}=${negate ? "not." : ""}is.null`);
+      } else if (operator === "in" && Array.isArray(value)) {
+        params.push(`${field}=${negate ? "not." : ""}in.${value.join(",")}`);
+      } else if (operator === "is") {
+        if (typeof value === "boolean") {
+          params.push(`${field}=${negate ? "not." : ""}is.${value}`);
+        } else {
+          params.push(`${field}=${negate ? "not." : ""}is.null`);
+        }
+      } else {
+        const paramValue = typeof value === "string" ? encodeURIComponent(value) : String(value);
+        params.push(`${field}=${negate ? "not." : ""}${operator}.${paramValue}`);
+      }
+    }
+  }
+  // Internal method to execute a query with options
+  async executeQuery(options) {
+    const params = this.buildQueryParams(options);
+    const headers = await this.headers();
+    return this.handleRequest(
+      fetch(`${this.baseUrl}/account/${this.projectId}/db/${this.table}${params}`, {
+        headers
+      })
+    );
+  }
+  // Public method to start building a query
+  getAll() {
+    return new QueryBuilder(this, this.tableSchema);
+  }
+  // Get a specific item by ID
+  async get(id) {
+    const headers = await this.headers();
+    return this.handleRequest(
+      fetch(`${this.baseUrl}/account/${this.projectId}/db/${this.table}/${id}`, {
+        headers
+      })
+    );
+  }
+  async create(value) {
+    const headers = await this.headers();
+    return this.handleRequest(
+      fetch(`${this.baseUrl}/account/${this.projectId}/db/${this.table}`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ value })
+      })
+    );
+  }
+  async update(id, value) {
+    const headers = await this.headers();
+    return this.handleRequest(
+      fetch(`${this.baseUrl}/account/${this.projectId}/db/${this.table}/${id}`, {
+        method: "PATCH",
+        headers,
+        body: JSON.stringify({ value })
+      })
+    );
+  }
+  async replace(id, value) {
+    const headers = await this.headers();
+    return this.handleRequest(
+      fetch(`${this.baseUrl}/account/${this.projectId}/db/${this.table}/${id}`, {
+        method: "PUT",
+        headers,
+        body: JSON.stringify({ value })
+      })
+    );
+  }
+  async delete(id) {
+    const token = await this.getToken();
+    const headers = {
+      Authorization: `Bearer ${token}`
+    };
+    return this.handleRequest(
+      fetch(`${this.baseUrl}/account/${this.projectId}/db/${this.table}/${id}`, {
+        method: "DELETE",
+        headers
+      })
+    );
+  }
+};
+var BasicDBSDK = class {
+  projectId;
+  getToken;
+  baseUrl;
+  schema;
+  tableNames;
+  constructor(config) {
+    this.projectId = config.project_id;
+    if (config.getToken) {
+      this.getToken = config.getToken;
+    } else if (config.token) {
+      this.getToken = async () => config.token;
+    } else {
+      throw new Error("Either token or getToken must be provided");
+    }
+    this.baseUrl = config.baseUrl || "https://api.basic.tech";
+    this.schema = config.schema;
+    this.tableNames = Object.keys(this.schema.tables);
+  }
+  // Primary method - table access
+  table(name) {
+    if (!this.tableNames.includes(name)) {
+      throw new Error(`Table '${name}' not found in schema. Available tables: ${this.tableNames.join(", ")}`);
+    }
+    return new TableClient(
+      this.baseUrl,
+      this.projectId,
+      "",
+      // Empty placeholder, will be replaced in headers() method
+      name,
+      this.getToken,
+      this.schema
+      // Pass the entire schema to the TableClient
+    );
+  }
+  get tables() {
+    return {};
+  }
+  fields(table) {
+    const tableSchema = this.schema.tables[table];
+    if (!tableSchema) {
+      throw new Error(`Table '${table}' not found in schema`);
+    }
+    return Object.keys(tableSchema.fields);
+  }
+};
+
+// package.json
+var version = "0.7.0-beta.1";
+
+// 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 };
+    }
+    if (storedVersion === this.currentVersion) {
+      return { updated: false, toVersion: this.currentVersion };
+    }
+    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);
 }
-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();
+
+// 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
+  ];
 }
-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();
+
+// src/utils/storage.ts
+var LocalStorageAdapter = class {
+  async get(key) {
+    return localStorage.getItem(key);
+  }
+  async set(key, value) {
+    localStorage.setItem(key, value);
+  }
+  async remove(key) {
+    localStorage.removeItem(key);
+  }
+};
+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 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}`
+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");
     }
-  });
-  return response.json();
+    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/AuthContext.tsx
+// src/utils/schema.ts
 import { validateSchema as validateSchema2, compareSchemas } from "@basictech/schema";
-
-// package.json
-var version = "0.6.0";
-
-// src/AuthContext.tsx
-import { jsx, jsxs } from "react/jsx-runtime";
-var BasicContext = createContext({
-  unicorn: "\u{1F984}",
-  isAuthReady: false,
-  isSignedIn: false,
-  user: null,
-  signout: () => {
-  },
-  signin: () => {
-  },
-  getToken: () => new Promise(() => {
-  }),
-  getSignInLink: () => "",
-  db: {},
-  dbStatus: "LOADING" /* LOADING */
-});
 async function getSchemaStatus(schema) {
   const projectId = schema.project_id;
-  let status = "";
   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");
@@ -384,55 +913,62 @@ 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 :)");
-    }
+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: version !== latestVersion,
-      latestVersion,
-      currentVersion: version
-    };
-  } catch (error) {
-    log("Error checking for new version:", error);
-    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
+  };
 }
-function BasicProvider({ children, project_id, schema, debug = false }) {
+
+// 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: {},
+  remoteDb: {},
+  dbStatus: "LOADING" /* LOADING */
+});
+function BasicProvider({
+  children,
+  project_id,
+  schema,
+  debug = false,
+  storage
+}) {
   const [isAuthReady, setIsAuthReady] = useState(false);
   const [isSignedIn, setIsSignedIn] = useState(false);
   const [token, setToken] = useState(null);
@@ -441,7 +977,41 @@ function BasicProvider({ children, project_id, schema, debug = false }) {
   const [isReady, setIsReady] = useState(false);
   const [dbStatus, setDbStatus] = useState("OFFLINE" /* OFFLINE */);
   const [error, setError] = useState(null);
+  const [isOnline, setIsOnline] = useState(navigator.onLine);
+  const [pendingRefresh, setPendingRefresh] = useState(false);
   const syncRef = useRef(null);
+  const remoteDbRef = useRef(null);
+  const storageAdapter = storage || new LocalStorageAdapter();
+  const isDevMode = () => isDevelopment(debug);
+  const cleanOAuthParams = () => cleanOAuthParamsFromUrl();
+  useEffect(() => {
+    const handleOnline = () => {
+      log("Network came back online");
+      setIsOnline(true);
+      if (pendingRefresh) {
+        log("Retrying pending token refresh");
+        setPendingRefresh(false);
+        if (token) {
+          const refreshToken = token.refresh_token || localStorage.getItem("basic_refresh_token");
+          if (refreshToken) {
+            fetchToken(refreshToken).catch((error2) => {
+              log("Retry refresh failed:", error2);
+            });
+          }
+        }
+      }
+    };
+    const handleOffline = () => {
+      log("Network went offline");
+      setIsOnline(false);
+    };
+    window.addEventListener("online", handleOnline);
+    window.addEventListener("offline", handleOffline);
+    return () => {
+      window.removeEventListener("online", handleOnline);
+      window.removeEventListener("offline", handleOffline);
+    };
+  }, [pendingRefresh, token]);
   useEffect(() => {
     function initDb(options) {
       if (!syncRef.current) {
@@ -450,9 +1020,6 @@ function BasicProvider({ children, project_id, schema, debug = false }) {
         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 {
@@ -462,17 +1029,15 @@ function BasicProvider({ children, project_id, schema, debug = false }) {
       }
     }
     async function checkSchema() {
-      const valid = validateSchema2(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!",
@@ -481,17 +1046,10 @@ function BasicProvider({ children, project_id, schema, debug = false }) {
         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();
@@ -503,36 +1061,101 @@ function BasicProvider({ children, project_id, schema, debug = false }) {
     }
   }, []);
   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]);
   useEffect(() => {
-    localStorage.setItem("basic_debug", debug ? "true" : "false");
-    try {
-      if (window.location.search.includes("code")) {
-        let code = window.location?.search?.split("code=")[1].split("&")[0];
-        const state = localStorage.getItem("basic_auth_state");
-        if (!state || state !== window.location.search.split("state=")[1].split("&")[0]) {
-          log("error: auth state does not match");
-          setIsAuthReady(true);
-          localStorage.removeItem("basic_auth_state");
-          window.history.pushState({}, document.title, "/");
-          return;
+    if (project_id && schema && token?.access_token && !remoteDbRef.current) {
+      log("Initializing Remote DB SDK");
+      remoteDbRef.current = new BasicDBSDK({
+        project_id,
+        schema,
+        getToken: () => getToken(),
+        baseUrl: "https://api.basic.tech"
+      });
+    }
+  }, [token, project_id, schema]);
+  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`);
         }
-        localStorage.removeItem("basic_auth_state");
-        fetchToken(code);
-      } else {
-        let cookie_token = getCookie("basic_token");
-        if (cookie_token !== "") {
-          setToken(JSON.parse(cookie_token));
+      } catch (error2) {
+        log("Version update failed:", error2);
+      }
+      try {
+        if (window.location.search.includes("code")) {
+          let code = window.location?.search?.split("code=")[1]?.split("&")[0];
+          if (!code)
+            return;
+          const state = await storageAdapter.get(STORAGE_KEYS.AUTH_STATE);
+          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);
+            cleanOAuthParams();
+            return;
+          }
+          await storageAdapter.remove(STORAGE_KEYS.AUTH_STATE);
+          cleanOAuthParams();
+          fetchToken(code).catch((error2) => {
+            log("Error fetching token:", error2);
+          });
         } else {
-          setIsAuthReady(true);
+          const refreshToken = await storageAdapter.get(STORAGE_KEYS.REFRESH_TOKEN);
+          if (refreshToken) {
+            log("Found refresh token in storage, attempting to refresh access token");
+            fetchToken(refreshToken).catch((error2) => {
+              log("Error fetching refresh token:", error2);
+            });
+          } else {
+            let cookie_token = getCookie("basic_token");
+            if (cookie_token !== "") {
+              const tokenData = JSON.parse(cookie_token);
+              setToken(tokenData);
+              if (tokenData.refresh_token) {
+                await storageAdapter.set(STORAGE_KEYS.REFRESH_TOKEN, tokenData.refresh_token);
+              }
+            } else {
+              const cachedUserInfo = await storageAdapter.get(STORAGE_KEYS.USER_INFO);
+              if (cachedUserInfo) {
+                try {
+                  const userData = JSON.parse(cachedUserInfo);
+                  setUser(userData);
+                  setIsSignedIn(true);
+                  log("Loaded cached user info for offline mode");
+                } catch (error2) {
+                  log("Error parsing cached user info:", error2);
+                }
+              }
+              setIsAuthReady(true);
+            }
+          }
         }
+      } catch (e) {
+        log("error getting token", e);
       }
-    } catch (e) {
-      log("error getting cookie", e);
-    }
+    };
+    initializeAuth();
   }, []);
   useEffect(() => {
     async function fetchUser(acc_token) {
@@ -547,10 +1170,13 @@ function BasicProvider({ children, project_id, schema, debug = false }) {
         log("error fetching user", user2.error);
         return;
       } else {
-        document.cookie = `basic_token=${JSON.stringify(token)}; Secure; SameSite=Strict`;
-        if (window.location.search.includes("code")) {
-          window.history.pushState({}, document.title, "/");
+        if (token?.refresh_token) {
+          await storageAdapter.set(STORAGE_KEYS.REFRESH_TOKEN, token.refresh_token);
         }
+        await storageAdapter.set(STORAGE_KEYS.USER_INFO, JSON.stringify(user2));
+        log("Cached user info in storage");
+        setCookie("basic_access_token", token?.access_token || "", { httpOnly: false });
+        setCookie("basic_token", JSON.stringify(token));
         setUser(user2);
         setIsSignedIn(true);
         setIsAuthReady(true);
@@ -566,56 +1192,122 @@ function BasicProvider({ children, project_id, schema, debug = false }) {
       const isExpired = decoded.exp && decoded.exp < Date.now() / 1e3;
       if (isExpired) {
         log("token is expired - refreshing ...");
-        const newToken = await fetchToken(token?.refresh);
-        fetchUser(newToken.access_token);
+        try {
+          const newToken = await fetchToken(token?.refresh_token || "");
+          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 || "");
+          } else {
+            setIsAuthReady(true);
+          }
+        }
       } else {
-        fetchUser(token.access_token);
+        fetchUser(token?.access_token || "");
       }
     }
     if (token) {
       checkToken();
     }
   }, [token]);
-  const connectToDb = async () => {
-    const tok = await getToken();
-    if (!tok) {
-      log("no token found");
-      return;
+  const getSignInLink = async (redirectUri) => {
+    try {
+      log("getting sign in link...");
+      if (!project_id) {
+        throw new Error("Project ID is required to generate sign-in link");
+      }
+      const randomState = Math.random().toString(36).substring(6);
+      await storageAdapter.set(STORAGE_KEYS.AUTH_STATE, randomState);
+      const redirectUrl = redirectUri || window.location.href;
+      if (!redirectUrl || !redirectUrl.startsWith("http://") && !redirectUrl.startsWith("https://")) {
+        throw new Error("Invalid redirect URI provided");
+      }
+      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 baseUrl;
+    } catch (error2) {
+      log("Error generating sign-in link:", error2);
+      throw error2;
     }
-    log("connecting to db...");
-    syncRef.current.connect({ access_token: tok }).catch((e) => {
-      log("error connecting to db", e);
-    });
   };
-  const getSignInLink = () => {
-    log("getting sign in link...");
-    const randomState = Math.random().toString(36).substring(6);
-    localStorage.setItem("basic_auth_state", randomState);
-    let baseUrl2 = "https://api.basic.tech/auth/authorize";
-    baseUrl2 += `?client_id=${project_id}`;
-    baseUrl2 += `&redirect_uri=${encodeURIComponent(window.location.href)}`;
-    baseUrl2 += `&response_type=code`;
-    baseUrl2 += `&scope=profile`;
-    baseUrl2 += `&state=${randomState}`;
-    return baseUrl2;
+  const signin = async () => {
+    try {
+      log("signing in...");
+      if (!project_id) {
+        log("Error: project_id is required for sign-in");
+        throw new Error("Project ID is required for authentication");
+      }
+      const signInLink = await getSignInLink();
+      log("Generated sign-in link:", signInLink);
+      if (!signInLink || !signInLink.startsWith("https://")) {
+        log("Error: Invalid sign-in link generated");
+        throw new Error("Failed to generate valid sign-in URL");
+      }
+      window.location.href = signInLink;
+    } catch (error2) {
+      log("Error during sign-in:", error2);
+      if (isDevMode()) {
+        setError({
+          code: "signin_error",
+          title: "Sign-in Failed",
+          message: error2.message || "An error occurred during sign-in. Please try again."
+        });
+      }
+      throw error2;
+    }
   };
-  const signin = () => {
-    log("signing in: ", getSignInLink());
-    const signInLink = getSignInLink();
-    window.location.href = signInLink;
+  const signinWithCode = async (code, state) => {
+    try {
+      log("signinWithCode called with code:", code);
+      if (!code || typeof code !== "string") {
+        return { success: false, error: "Invalid authorization code" };
+      }
+      if (state) {
+        const storedState = await storageAdapter.get(STORAGE_KEYS.AUTH_STATE);
+        if (storedState && storedState !== state) {
+          log("State parameter mismatch:", { provided: state, stored: storedState });
+          return { success: false, error: "State parameter mismatch" };
+        }
+      }
+      await storageAdapter.remove(STORAGE_KEYS.AUTH_STATE);
+      cleanOAuthParams();
+      const token2 = await fetchToken(code);
+      if (token2) {
+        log("signinWithCode successful");
+        return { success: true };
+      } else {
+        return { success: false, error: "Failed to exchange code for token" };
+      }
+    } catch (error2) {
+      log("signinWithCode error:", error2);
+      return {
+        success: false,
+        error: error2.message || "Authentication failed"
+      };
+    }
   };
-  const signout = () => {
+  const signout = async () => {
     log("signing out!");
     setUser({});
     setIsSignedIn(false);
     setToken(null);
-    document.cookie = `basic_token=; Secure; SameSite=Strict`;
-    localStorage.removeItem("basic_auth_state");
+    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) {
@@ -627,6 +1319,27 @@ function BasicProvider({ children, project_id, schema, debug = false }) {
   const getToken = async () => {
     log("getting token...");
     if (!token) {
+      const refreshToken = await storageAdapter.get(STORAGE_KEYS.REFRESH_TOKEN);
+      if (refreshToken) {
+        log("No token in memory, attempting to refresh from storage");
+        try {
+          const newToken = await fetchToken(refreshToken);
+          if (newToken?.access_token) {
+            return newToken.access_token;
+          }
+        } catch (error2) {
+          log("Failed to refresh token from storage:", error2);
+          if (error2.message.includes("offline") || error2.message.includes("Network")) {
+            log("Network issue - continuing with potentially expired token");
+            const lastToken = localStorage.getItem("basic_access_token");
+            if (lastToken) {
+              return lastToken;
+            }
+            throw new Error("Network offline - authentication will be retried when online");
+          }
+          throw new Error("Authentication expired. Please sign in again.");
+        }
+      }
       log("no token found");
       throw new Error("no token found");
     }
@@ -634,69 +1347,86 @@ function BasicProvider({ children, project_id, schema, debug = false }) {
     const isExpired = decoded.exp && decoded.exp < Date.now() / 1e3;
     if (isExpired) {
       log("token is expired - refreshing ...");
-      const newToken = await fetchToken(token?.refresh);
-      return newToken?.access_token || "";
-    }
-    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;
+      const refreshToken = token?.refresh_token || await storageAdapter.get(STORAGE_KEYS.REFRESH_TOKEN);
+      if (refreshToken) {
+        try {
+          const newToken = await fetchToken(refreshToken);
+          return newToken?.access_token || "";
+        } catch (error2) {
+          log("Failed to refresh expired token:", error2);
+          if (error2.message.includes("offline") || error2.message.includes("Network")) {
+            log("Network issue - using expired token until network is restored");
+            return token.access_token;
+          }
+          throw new Error("Authentication expired. Please sign in again.");
         }
+      } else {
+        throw new Error("no refresh token available");
       }
     }
-    return cookieValue;
-  }
-  const fetchToken = async (code) => {
-    const token2 = await fetch("https://api.basic.tech/auth/token", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({ code })
-    }).then((response) => response.json()).catch((error2) => log("Error:", error2));
-    if (token2.error) {
-      log("error fetching token", token2.error);
-      return;
-    } else {
-      setToken(token2);
-    }
-    return token2;
+    return token?.access_token || "";
   };
-  const db_ = (tableName) => {
-    const checkSignIn = () => {
-      if (!isSignedIn) {
-        throw new Error("cannot use db. user not logged in.");
+  const fetchToken = async (code) => {
+    try {
+      if (!isOnline) {
+        log("Network is offline, marking refresh as pending");
+        setPendingRefresh(true);
+        throw new Error("Network offline - refresh will be retried when online");
       }
-    };
-    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 token2 = await fetch("https://api.basic.tech/auth/token", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ code })
+      }).then((response) => response.json()).catch((error2) => {
+        log("Network error fetching token:", error2);
+        if (!isOnline) {
+          setPendingRefresh(true);
+          throw new Error("Network offline - refresh will be retried when online");
+        }
+        throw new Error("Network error during token refresh");
+      });
+      if (token2.error) {
+        log("error fetching token", token2.error);
+        if (token2.error.includes("network") || token2.error.includes("timeout")) {
+          setPendingRefresh(true);
+          throw new Error("Network issue - refresh will be retried when online");
+        }
+        await storageAdapter.remove(STORAGE_KEYS.REFRESH_TOKEN);
+        await storageAdapter.remove(STORAGE_KEYS.USER_INFO);
+        clearCookie("basic_token");
+        clearCookie("basic_access_token");
+        setUser({});
+        setIsSignedIn(false);
+        setToken(null);
+        setIsAuthReady(true);
+        throw new Error(`Token refresh failed: ${token2.error}`);
+      } else {
+        setToken(token2);
+        setPendingRefresh(false);
+        if (token2.refresh_token) {
+          await storageAdapter.set(STORAGE_KEYS.REFRESH_TOKEN, token2.refresh_token);
+          log("Updated refresh token in storage");
+        }
+        setCookie("basic_access_token", token2.access_token, { httpOnly: false });
+        log("Updated access token in cookie");
       }
-    };
+      return token2;
+    } catch (error2) {
+      log("Token refresh error:", error2);
+      if (!error2.message.includes("offline") && !error2.message.includes("Network")) {
+        await storageAdapter.remove(STORAGE_KEYS.REFRESH_TOKEN);
+        await storageAdapter.remove(STORAGE_KEYS.USER_INFO);
+        clearCookie("basic_token");
+        clearCookie("basic_access_token");
+        setUser({});
+        setIsSignedIn(false);
+        setToken(null);
+        setIsAuthReady(true);
+      }
+      throw error2;
+    }
   };
   const noDb = {
     collection: () => {
@@ -710,12 +1440,14 @@ function BasicProvider({ children, project_id, schema, debug = false }) {
     user,
     signout,
     signin,
+    signinWithCode,
     getToken,
     getSignInLink,
     db: syncRef.current ? syncRef.current : noDb,
+    remoteDb: remoteDbRef.current ? remoteDbRef.current : noDb,
     dbStatus
   }, children: [
-    error && /* @__PURE__ */ jsx(ErrorDisplay, { error }),
+    error && isDevMode() && /* @__PURE__ */ jsx(ErrorDisplay, { error }),
     isReady && children
   ] });
 }
@@ -749,6 +1481,7 @@ function useBasic() {
 // src/index.ts
 import { useLiveQuery as useQuery } from "dexie-react-hooks";
 export {
+  BasicDBSDK,
   BasicProvider,
   useBasic,
   useQuery