@basictech/react 0.8.0-beta.4 → 0.9.0-beta.0

package/src/core/db/RemoteCollection.ts

@@ -1,308 +0,0 @@
-import { Collection, RemoteDBConfig, RemoteDBError } from './types'
-import { validateData } from '@basictech/schema'
-
-/**
- * Error thrown when user is not authenticated
- */
-export class NotAuthenticatedError extends Error {
-  constructor(message: string = 'Not authenticated') {
-    super(message)
-    this.name = 'NotAuthenticatedError'
-  }
-}
-
-/**
- * RemoteCollection - REST API based implementation of the Collection interface
- * All operations make HTTP calls to the Basic API server
- */
-export class RemoteCollection<T extends { id: string } = Record<string, any> & { id: string }> implements Collection<T> {
-  private tableName: string
-  private config: RemoteDBConfig
-
-  constructor(tableName: string, config: RemoteDBConfig) {
-    this.tableName = tableName
-    this.config = config
-  }
-
-  private log(...args: any[]) {
-    if (this.config.debug) {
-      console.log('[RemoteDB]', ...args)
-    }
-  }
-
-  /**
-   * Check if an error is a "not authenticated" error
-   */
-  private isNotAuthenticatedError(error: unknown): boolean {
-    if (error instanceof Error) {
-      const message = error.message.toLowerCase()
-      return message.includes('no token') || 
-             message.includes('not authenticated') ||
-             message.includes('please sign in')
-    }
-    return false
-  }
-
-  /**
-   * Helper to make authenticated API requests
-   * Automatically retries once on 401 (token expired) by refreshing the token
-   */
-  private async request<R>(
-    method: string,
-    path: string,
-    body?: any,
-    isRetry: boolean = false
-  ): Promise<R> {
-    // Try to get token - may throw if not authenticated
-    const token = await this.config.getToken()
-    const url = `${this.config.serverUrl}${path}`
-
-    this.log(`${method} ${url}`, body ? JSON.stringify(body) : '')
-
-    const headers: Record<string, string> = {
-      'Authorization': `Bearer ${token}`
-    }
-    if (body) {
-      headers['Content-Type'] = 'application/json'
-    }
-
-    const response = await fetch(url, {
-      method,
-      headers,
-      ...(body ? { body: JSON.stringify(body) } : {})
-    })
-
-    const responseData = await response.json().catch(() => ({}))
-
-    if (!response.ok) {
-      // Handle 401 Unauthorized - force refresh then retry once
-      if (response.status === 401 && !isRetry) {
-        this.log('Got 401, forcing token refresh and retrying...')
-        await this.config.getToken({ forceRefresh: true })
-        return this.request<R>(method, path, body, true)
-      }
-
-      if (this.config.debug) {
-        console.error(`[RemoteDB] Error ${response.status}:`, responseData)
-      }
-      
-      // Call onAuthError callback for auth/authz errors
-      if (this.config.onAuthError) {
-        if (response.status === 401) {
-          this.config.onAuthError({
-            status: response.status,
-            message: 'Authentication failed',
-            response: responseData,
-            errorType: 'expired',
-            afterRetry: isRetry,
-          })
-        } else if (response.status === 403) {
-          this.config.onAuthError({
-            status: response.status,
-            message: responseData.message || 'Forbidden - insufficient permissions or missing scope',
-            response: responseData,
-            errorType: 'forbidden',
-            afterRetry: isRetry,
-          })
-        }
-      }
-
-      const errorMessage = responseData.message || responseData.error || responseData.detail || 
-        (typeof responseData === 'string' ? responseData : `API request failed: ${response.status}`)
-      throw new RemoteDBError(errorMessage, response.status, responseData)
-    }
-
-    this.log('Response:', responseData)
-    return responseData
-  }
-
-  /**
-   * Validate data against schema if available
-   */
-  private validateData(data: any, checkRequired: boolean = true): void {
-    if (this.config.schema) {
-      const result = validateData(this.config.schema, this.tableName, data, checkRequired)
-      if (!result.valid) {
-        throw new Error(result.message || 'Data validation failed')
-      }
-    }
-  }
-
-  /**
-   * Get the base path for this collection
-   */
-  private get basePath(): string {
-    return `/account/${this.config.projectId}/db/${this.tableName}`
-  }
-
-  /**
-   * Add a new record to the collection
-   * The server generates the ID
-   * Requires authentication - throws NotAuthenticatedError if not signed in
-   */
-  async add(data: Omit<T, 'id'>): Promise<T> {
-    this.validateData(data, true)
-
-    try {
-      const result = await this.request<{ data: T }>(
-        'POST',
-        this.basePath,
-        { value: data }
-      )
-      // Server returns the created record with the generated ID
-      return result.data
-    } catch (error) {
-      if (this.isNotAuthenticatedError(error)) {
-        throw new NotAuthenticatedError('Sign in required to add items')
-      }
-      throw error
-    }
-  }
-
-  /**
-   * Put (upsert) a record - requires id
-   * Requires authentication - throws NotAuthenticatedError if not signed in
-   */
-  async put(data: T): Promise<T> {
-    if (!data.id) {
-      throw new Error('put() requires an id field')
-    }
-
-    // Extract id from data, send the rest in the body
-    const { id, ...rest } = data
-    this.validateData(rest, true)
-
-    try {
-      const result = await this.request<{ data: T }>(
-        'PUT',
-        `${this.basePath}/${id}`,
-        { value: rest }
-      )
-      return result.data || data
-    } catch (error) {
-      if (this.isNotAuthenticatedError(error)) {
-        throw new NotAuthenticatedError('Sign in required to update items')
-      }
-      throw error
-    }
-  }
-
-  /**
-   * Update an existing record by id
-   * Requires authentication - throws NotAuthenticatedError if not signed in
-   */
-  async update(id: string, data: Partial<Omit<T, 'id'>>): Promise<T | null> {
-    if (!id) {
-      throw new Error('update() requires an id')
-    }
-
-    this.validateData(data, false)
-
-    try {
-      const result = await this.request<{ data: T }>(
-        'PATCH',
-        `${this.basePath}/${id}`,
-        { value: data }
-      )
-
-      return result.data || null
-    } catch (error) {
-      // If record not found, return null instead of throwing
-      if (error instanceof RemoteDBError && error.status === 404) {
-        return null
-      }
-      if (this.isNotAuthenticatedError(error)) {
-        throw new NotAuthenticatedError('Sign in required to update items')
-      }
-      throw error
-    }
-  }
-
-  /**
-   * Delete a record by id
-   * Requires authentication - throws NotAuthenticatedError if not signed in
-   */
-  async delete(id: string): Promise<boolean> {
-    if (!id) {
-      throw new Error('delete() requires an id')
-    }
-
-    try {
-      await this.request<any>(
-        'DELETE',
-        `${this.basePath}/${id}`
-      )
-      return true
-    } catch (error) {
-      // If record not found, return false instead of throwing
-      if (error instanceof RemoteDBError && error.status === 404) {
-        return false
-      }
-      if (this.isNotAuthenticatedError(error)) {
-        throw new NotAuthenticatedError('Sign in required to delete items')
-      }
-      throw error
-    }
-  }
-
-  /**
-   * Get a single record by id
-   * Returns null if not authenticated (graceful degradation for read operations)
-   */
-  async get(id: string): Promise<T | null> {
-    if (!id) {
-      throw new Error('get() requires an id')
-    }
-
-    try {
-      // Use the API's id query parameter for efficient single-record fetch
-      const result = await this.request<{ data: T[] }>(
-        'GET',
-        `${this.basePath}?id=${id}`
-      )
-      return result.data?.[0] || null
-    } catch (error) {
-      // For get(), return null on any error (not found, not authenticated, etc.)
-      if (this.isNotAuthenticatedError(error)) {
-        this.log('Not authenticated - returning null for get()')
-      }
-      return null
-    }
-  }
-
-  /**
-   * Get all records in the collection
-   * Returns empty array if not authenticated (graceful degradation for read operations)
-   */
-  async getAll(): Promise<T[]> {
-    try {
-      const result = await this.request<{ data: T[] }>(
-        'GET',
-        this.basePath
-      )
-      return result.data || []
-    } catch (error) {
-      // If not authenticated, return empty array gracefully
-      if (this.isNotAuthenticatedError(error)) {
-        this.log('Not authenticated - returning empty array for getAll()')
-        return []
-      }
-      throw error
-    }
-  }
-
-  /**
-   * Filter records using a predicate function
-   * Note: This fetches all records and filters client-side
-   * Returns empty array if not authenticated (graceful degradation for read operations)
-   */
-  async filter(fn: (item: T) => boolean): Promise<T[]> {
-    const all = await this.getAll()
-    return all.filter(fn)
-  }
-
-  /**
-   * ref is not available for remote collections
-   */
-  ref = undefined
-}

package/src/core/db/RemoteDB.ts

@@ -1,40 +0,0 @@
-import { BasicDB, Collection, RemoteDBConfig } from './types'
-import { RemoteCollection } from './RemoteCollection'
-
-/**
- * RemoteDB - REST API based implementation of BasicDB
- * Creates RemoteCollection instances for each table
- */
-export class RemoteDB implements BasicDB {
-  private config: RemoteDBConfig
-  private collections: Map<string, RemoteCollection<any>> = new Map()
-
-  constructor(config: RemoteDBConfig) {
-    this.config = config
-  }
-
-  /**
-   * Get a collection by name
-   * Collections are cached for reuse
-   */
-  collection<T extends { id: string } = Record<string, any> & { id: string }>(
-    name: string
-  ): Collection<T> {
-    // Return cached collection if exists
-    if (this.collections.has(name)) {
-      return this.collections.get(name) as RemoteCollection<T>
-    }
-
-    // Validate table exists in schema if schema is provided
-    if (this.config.schema?.tables && !this.config.schema.tables[name]) {
-      throw new Error(`Table "${name}" not found in schema`)
-    }
-
-    // Create and cache new collection
-    const collection = new RemoteCollection<T>(name, this.config)
-    this.collections.set(name, collection)
-
-    return collection
-  }
-}
-

package/src/core/db/index.ts

@@ -1,7 +0,0 @@
-// Core DB exports
-export type { Collection, BasicDB, DBMode, RemoteDBConfig, GetTokenOptions } from './types'
-export type { AuthError } from './types'
-export { RemoteDBError } from './types'
-export { RemoteDB } from './RemoteDB'
-export { RemoteCollection, NotAuthenticatedError } from './RemoteCollection'
-

package/src/core/db/types.ts

@@ -1,140 +0,0 @@
-/**
- * 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
-  /** Classifies the error for UI display (e.g. "session expired" vs "forbidden") */
-  errorType: 'expired' | 'forbidden' | 'revoked' | 'network' | 'unknown'
-  /** True if this error occurred after a retry with a refreshed token */
-  afterRetry: boolean
-}
-
-/**
- * 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
-  }
-}
-
-/**
- * Options for getToken (e.g. force refresh after 401)
- */
-export interface GetTokenOptions {
-  /** When true, refresh the access token before returning (e.g. after server returned 401) */
-  forceRefresh?: boolean
-}
-
-/**
- * Configuration for RemoteDB
- */
-export interface RemoteDBConfig {
-  serverUrl: string
-  projectId: string
-  getToken: (options?: GetTokenOptions) => 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
-}
-