@basictech/react 0.7.0-beta.6 → 0.7.0-beta.7

package/src/core/db/types.ts

@@ -0,0 +1,128 @@
+/**
+ * Core DB types for Basic SDK
+ * These interfaces are implemented by both SyncDB (Dexie-based) and RemoteDB (REST-based)
+ */
+
+/**
+ * Collection interface for CRUD operations on a table
+ * All write operations return the full object (not just the id)
+ */
+export interface Collection<T extends { id: string } = Record<string, any> & { id: string }> {
+  /**
+   * Add a new record to the collection
+   * @param data - The data to add (without id, which will be generated)
+   * @returns The created object with its generated id
+   */
+  add(data: Omit<T, 'id'>): Promise<T>
+
+  /**
+   * Put (upsert) a record - requires id
+   * @param data - The full object including id
+   * @returns The upserted object
+   */
+  put(data: T): Promise<T>
+
+  /**
+   * Update an existing record by id
+   * @param id - The record id to update
+   * @param data - Partial data to merge
+   * @returns The updated object, or null if not found
+   */
+  update(id: string, data: Partial<Omit<T, 'id'>>): Promise<T | null>
+
+  /**
+   * Delete a record by id
+   * @param id - The record id to delete
+   * @returns true if deleted, false if not found
+   */
+  delete(id: string): Promise<boolean>
+
+  /**
+   * Get a single record by id
+   * @param id - The record id to fetch
+   * @returns The object or null if not found
+   */
+  get(id: string): Promise<T | null>
+
+  /**
+   * Get all records in the collection
+   * @returns Array of all objects
+   */
+  getAll(): Promise<T[]>
+
+  /**
+   * Filter records using a predicate function
+   * @param fn - Filter function that returns true for matches
+   * @returns Array of matching objects
+   */
+  filter(fn: (item: T) => boolean): Promise<T[]>
+
+  /**
+   * Direct access to underlying storage (optional)
+   * For sync mode: Dexie table reference
+   * For remote mode: undefined
+   */
+  ref?: any
+}
+
+/**
+ * BasicDB interface - factory for creating collections
+ */
+export interface BasicDB {
+  /**
+   * Get a collection by name
+   * @param name - The table/collection name (must match schema)
+   * @returns A Collection instance for CRUD operations
+   */
+  collection<T extends { id: string } = Record<string, any> & { id: string }>(name: string): Collection<T>
+}
+
+/**
+ * Database mode - determines which implementation is used
+ * - 'sync': Uses Dexie + WebSocket for local-first sync (default)
+ * - 'remote': Uses REST API calls directly to server
+ */
+export type DBMode = 'sync' | 'remote'
+
+/**
+ * Auth error information passed to onAuthError callback
+ */
+export interface AuthError {
+  status: number
+  message: string
+  response?: any
+}
+
+/**
+ * Custom error class for Remote DB API errors
+ * Includes HTTP status code for reliable error handling
+ */
+export class RemoteDBError extends Error {
+  status: number
+  response?: any
+
+  constructor(message: string, status: number, response?: any) {
+    super(message)
+    this.name = 'RemoteDBError'
+    this.status = status
+    this.response = response
+  }
+}
+
+/**
+ * Configuration for RemoteDB
+ */
+export interface RemoteDBConfig {
+  serverUrl: string
+  projectId: string
+  getToken: () => Promise<string>
+  schema?: any
+  /** Enable debug logging (default: false) */
+  debug?: boolean
+  /**
+   * Optional callback when authentication fails (401 error after retry)
+   * Use this to show login UI or redirect to sign-in
+   */
+  onAuthError?: (error: AuthError) => void
+}
+

package/src/index.ts

@@ -1,13 +1,29 @@
-import { useState } from "react";
-import { useBasic, BasicProvider, BasicStorage, LocalStorageAdapter, AuthConfig, BasicProviderProps } from "./AuthContext";
+import { useBasic, BasicProvider } from "./AuthContext";
 import { useLiveQuery as useQuery } from "dexie-react-hooks";
-// import { createVersionUpdater, VersionUpdater, Migration } from "./versionUpdater";
 
+// Re-export from AuthContext
+export { useBasic, BasicProvider, useQuery }
 
-export {
-    useBasic, BasicProvider, useQuery
-}
+// Type exports
+export type { 
+    AuthConfig, 
+    BasicStorage, 
+    LocalStorageAdapter, 
+    BasicProviderProps,
+    BasicContextType,
+    AuthResult
+} from "./AuthContext"
 
-export type {
-    AuthConfig, BasicStorage, LocalStorageAdapter, BasicProviderProps
-}
+// Core DB exports
+export type { 
+    DBMode, 
+    BasicDB, 
+    Collection, 
+    RemoteDBConfig,
+    AuthError
+} from "./core/db"
+
+export { RemoteDB, RemoteCollection, RemoteDBError, NotAuthenticatedError } from "./core/db"
+
+// Storage utilities
+export { STORAGE_KEYS } from "./utils/storage"

package/src/sync/index.ts

@@ -1,28 +1,55 @@
 "use client"
 
 import { v7 as uuidv7 } from 'uuid';
-import { Dexie, PromiseExtended } from 'dexie';
-import 'dexie-syncable';
-import 'dexie-observable';
-
-import { syncProtocol } from './syncProtocol'
-import {  log } from '../config'
+import { Dexie } from 'dexie';
 
+import { log } from '../config'
 import { validateSchema, validateData } from '@basictech/schema'
-syncProtocol()
-
-
-// const DexieSyncStatus = {
-//   "-1": "ERROR",
-//   "0": "OFFLINE",
-//   "1": "CONNECTING",
-//   "2": "ONLINE",
-//   "3": "SYNCING",
-//   "4": "ERROR_WILL_RETRY"
-// }
 
+// Track initialization state
+let dexieExtensionsLoaded = false;
+let initPromise: Promise<void> | null = null;
+
+/**
+ * Initialize Dexie extensions (syncable and observable)
+ * This must be called before creating a BasicSync instance
+ * Safe to call multiple times - will only load once
+ */
+export async function initDexieExtensions(): Promise<void> {
+  // Return early if already loaded or not in browser
+  if (dexieExtensionsLoaded) return;
+  if (typeof window === 'undefined') return;
+  
+  // If already initializing, wait for that promise
+  if (initPromise) return initPromise;
+  
+  initPromise = (async () => {
+    try {
+      // Dynamic imports - only loaded in browser
+      await import('dexie-syncable');
+      await import('dexie-observable');
+      
+      // Import and register sync protocol
+      const { syncProtocol } = await import('./syncProtocol');
+      syncProtocol();
+      
+      dexieExtensionsLoaded = true;
+      log('Dexie extensions loaded successfully');
+    } catch (error) {
+      console.error('Failed to load Dexie extensions:', error);
+      throw error;
+    }
+  })();
+  
+  return initPromise;
+}
 
-// const SERVER_URL = "https://pds.basic.id"
+/**
+ * Check if Dexie extensions are loaded
+ */
+export function isDexieReady(): boolean {
+  return dexieExtensionsLoaded;
+}
 
 
 export class BasicSync extends Dexie {
@@ -141,83 +168,135 @@ export class BasicSync extends Dexie {
     return this.syncable
   }
 
-  collection(name: string) {
-    // TODO: check against schema
+  collection<T extends { id: string } = Record<string, any> & { id: string }>(name: string) {
+    // Validate table exists in schema
+    if (this.basic_schema?.tables && !this.basic_schema.tables[name]) {
+      throw new Error(`Table "${name}" not found in schema`)
+    }
+
+    const table = this.table(name)
 
     return {
-
       /**
        * Returns the underlying Dexie table
        * @type {Dexie.Table}
        */
-      ref: this.table(name),
+      ref: table,
 
       // --- WRITE ---- // 
-      add: (data: any) => {
-        // log("Adding data to", name, data)
 
+      /**
+       * Add a new record - returns the full object with generated id
+       */
+      add: async (data: Omit<T, 'id'>): Promise<T> => {
         const valid = validateData(this.basic_schema, name, data)
         if (!valid.valid) {
           log('Invalid data', valid)
-          return Promise.reject({ ... valid })
+          throw new Error(valid.message || 'Data validation failed')
         }
 
-        return this.table(name).add({
-          id: uuidv7(),
-          ...data
-        })
-
+        const id = uuidv7()
+        const fullData = { id, ...data } as T
+        
+        await table.add(fullData)
+        return fullData
       },
 
-      put: (data: any) => {
+      /**
+       * Put (upsert) a record - returns the full object
+       */
+      put: async (data: T): Promise<T> => {
+        if (!data.id) {
+          throw new Error('put() requires an id field')
+        }
+
         const valid = validateData(this.basic_schema, name, data)
         if (!valid.valid) {
           log('Invalid data', valid)
-          return Promise.reject({ ... valid })
+          throw new Error(valid.message || 'Data validation failed')
         }
 
-        return this.table(name).put({
-          id: uuidv7(),
-          ...data
-        })
+        await table.put(data)
+        return data
       },
 
-      update: (id: string, data: any) => {
+      /**
+       * Update an existing record - returns updated object or null
+       */
+      update: async (id: string, data: Partial<Omit<T, 'id'>>): Promise<T | null> => {
+        if (!id) {
+          throw new Error('update() requires an id')
+        }
+
         const valid = validateData(this.basic_schema, name, data, false)
         if (!valid.valid) {
           log('Invalid data', valid)
-          return Promise.reject({ ... valid })
+          throw new Error(valid.message || 'Data validation failed')
         }
 
-        return this.table(name).update(id, data)
-      },
+        const updated = await table.update(id, data)
+        if (updated === 0) {
+          return null
+        }
 
-      delete: (id: string) => {
-        return this.table(name).delete(id)
+        // Fetch and return the updated record
+        const record = await table.get(id)
+        return (record as T) || null
       },
 
+      /**
+       * Delete a record - returns true if deleted, false if not found
+       */
+      delete: async (id: string): Promise<boolean> => {
+        if (!id) {
+          throw new Error('delete() requires an id')
+        }
+
+        // Check if record exists first
+        const exists = await table.get(id)
+        if (!exists) {
+          return false
+        }
+
+        await table.delete(id)
+        return true
+      },
 
       // --- READ ---- // 
 
-      get: async (id: string) => {
-        return this.table(name).get(id) 
+      /**
+       * Get a single record by id - returns null if not found
+       */
+      get: async (id: string): Promise<T | null> => {
+        if (!id) {
+          throw new Error('get() requires an id')
+        }
+
+        const record = await table.get(id)
+        return (record as T) || null
       },
 
-      getAll: async () => {
-        return this.table(name).toArray();
+      /**
+       * Get all records in the collection
+       */
+      getAll: async (): Promise<T[]> => {
+        return table.toArray() as Promise<T[]>
       },
 
       // --- QUERY ---- // 
-      // TODO: lots to do here. simplifing creating querie,  filtering/ordering/limit, and execute
-
-      query: () => this.table(name),
 
-      filter: (fn: any) => this.table(name).filter(fn).toArray(),
+      /**
+       * Filter records using a predicate function
+       */
+      filter: async (fn: (item: T) => boolean): Promise<T[]> => {
+        return table.filter(fn).toArray() as Promise<T[]>
+      },
 
+      /**
+       * Get the raw Dexie table for advanced queries
+       * @deprecated Use ref instead
+       */
+      query: () => table,
     }
   }
 }
-
-class QueryMethod { 
-
-}

package/src/db.ts

@@ -1,55 +0,0 @@
-//@ts-nocheck
-
-const baseUrl = 'https://api.basic.tech';
-// const baseUrl = 'http://localhost:3000';
-
-
-async function get({ projectId, accountId, tableName, token }) {
-    const url = `${baseUrl}/project/${projectId}/db/${accountId}/${tableName}`;
-    const response = await fetch(url, {
-        headers: {
-            'Authorization': `Bearer ${token}`
-        }
-    });
-    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: id, value: 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}`
-        }
-    });
-    return response.json();
-}
-
-export { get, add, update, deleteRecord };
-