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

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,490 @@ 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();
-}
-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}`
+  }
+  // Validate operator based on field type
+  validateOperator(field, operator, value) {
+    if (!this.tableSchema || this.reservedFields.includes(field)) {
+      return;
     }
-  });
-  return response.json();
-}
-
-// src/AuthContext.tsx
-import { validateSchema as validateSchema3, compareSchemas } from "@basictech/schema";
+    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.6.0";
+var version = "0.7.0-beta.1";
 
-// src/AuthContext.tsx
-import { jsx, jsxs } from "react/jsx-runtime";
+// 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);
+}
+
+// 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/utils/storage.ts
 var LocalStorageAdapter = class {
   async get(key) {
     return localStorage.getItem(key);
@@ -423,25 +745,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 +913,55 @@ 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: {},
+  remoteDb: {},
+  dbStatus: "LOADING" /* LOADING */
+});
 function BasicProvider({
   children,
   project_id,
@@ -569,25 +980,10 @@ function BasicProvider({
   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 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");
@@ -624,9 +1020,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 +1029,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 +1046,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 +1061,72 @@ 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;
+  useEffect(() => {
+    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"
+      });
     }
-    log("connecting to db...");
-    syncRef.current.connect({ access_token: tok }).catch((e) => {
-      log("error connecting to db", e);
-    });
-  };
+  }, [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`);
+        }
+      } 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).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).catch((error2) => {
+              log("Error fetching refresh token:", error2);
+            });
           } else {
             let cookie_token = getCookie("basic_token");
             if (cookie_token !== "") {
@@ -762,8 +1175,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 +1193,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 || "");
+          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 +1224,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 +1253,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,7 +1277,7 @@ function BasicProvider({
         }
       }
       await storageAdapter.remove(STORAGE_KEYS.AUTH_STATE);
-      cleanOAuthParamsFromUrl();
+      cleanOAuthParams();
       const token2 = await fetchToken(code);
       if (token2) {
         log("signinWithCode successful");
@@ -885,16 +1298,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) {
@@ -953,20 +1366,6 @@ 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) => {
     try {
       if (!isOnline) {
@@ -996,8 +1395,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 +1409,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 +1418,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 +1428,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.");
@@ -1074,9 +1444,10 @@ function BasicProvider({
     getToken,
     getSignInLink,
     db: syncRef.current ? syncRef.current : noDb,
+    remoteDb: remoteDbRef.current ? remoteDbRef.current : noDb,
     dbStatus
   }, children: [
-    error && isDevelopment() && /* @__PURE__ */ jsx(ErrorDisplay, { error }),
+    error && isDevMode() && /* @__PURE__ */ jsx(ErrorDisplay, { error }),
     isReady && children
   ] });
 }
@@ -1110,6 +1481,7 @@ function useBasic() {
 // src/index.ts
 import { useLiveQuery as useQuery } from "dexie-react-hooks";
 export {
+  BasicDBSDK,
   BasicProvider,
   useBasic,
   useQuery