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

package/src/index.ts

@@ -1,38 +1,13 @@
 import { useState } from "react";
 import { useBasic, BasicProvider, BasicStorage, LocalStorageAdapter } from "./AuthContext";
 import { useLiveQuery as useQuery } from "dexie-react-hooks";
-
-// const useQuery = (queryable: any) => {
-//     const [loading, setLoading] = useState(true)
-//     const [error, setError] = useState<Error | null>(null)
-
-//     const result = useLiveQuery(async () => {
-//         try {
-//             setLoading(true)
-//             setError(null)
-            
-//             // if (typeof queryable === 'function') {
-//             //     return await queryable()
-//             // }
-//             return queryable
-            
-//         } catch (err) {
-//             setError(err instanceof Error ? err : new Error('Unknown error'))
-//             return undefined
-//         } finally {
-//             setLoading(false)
-//         }
-//     }, [queryable])
-
-//     return {
-//         data: result,
-//         loading,
-//         error
-//     }
-// }
-
+// import { createVersionUpdater, VersionUpdater, Migration } from "./versionUpdater";
 
 
 export {
-    useBasic, BasicProvider, useQuery, BasicStorage, LocalStorageAdapter
+    useBasic, BasicProvider, useQuery
 }
+
+// export type {
+//     VersionUpdater, Migration
+// }

package/src/sync/index.ts

@@ -8,7 +8,7 @@ import 'dexie-observable';
 import { syncProtocol } from './syncProtocol'
 import {  log } from '../config'
 
-import { validateSchema, validateData } from '../schema'
+import { validateSchema, validateData } from '@basictech/schema'
 syncProtocol()
 
 

package/src/updater/updateMigrations.ts

@@ -0,0 +1,22 @@
+import { BasicStorage } from '../utils/storage'
+import { Migration } from './versionUpdater'
+
+
+export const addMigrationTimestamp: Migration = {
+  fromVersion: '0.6.0', 
+  toVersion: '0.7.0',
+  async migrate(storage: BasicStorage) {
+    console.log('Running test migration')
+    storage.set('test_migration', 'true')
+  }
+}
+
+
+/**
+ * Get all available migrations
+ */
+export function getMigrations(): Migration[] {
+  return [
+    addMigrationTimestamp
+  ]
+}

package/src/updater/versionUpdater.ts

@@ -0,0 +1,160 @@
+import { BasicStorage } from '../utils/storage'
+
+export interface VersionInfo {
+  version: string
+  lastUpdated: number
+}
+
+export interface Migration {
+  fromVersion: string
+  toVersion: string
+  migrate: (storage: BasicStorage) => Promise<void>
+}
+
+export class VersionUpdater {
+  private storage: BasicStorage
+  private currentVersion: string
+  private migrations: Migration[]
+  private versionKey = 'basic_app_version'
+
+  constructor(storage: BasicStorage, currentVersion: string, migrations: Migration[] = []) {
+    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(): Promise<{ updated: boolean; fromVersion?: string; toVersion: string }> {
+    const storedVersion = await this.getStoredVersion()
+    
+    if (!storedVersion) {
+      // First time setup
+      await this.setStoredVersion(this.currentVersion)
+      return { updated: false, toVersion: this.currentVersion }
+    }
+
+    if (storedVersion === this.currentVersion) {
+      return { updated: false, toVersion: this.currentVersion }
+    }
+
+    // Need to run migrations
+    const migrationsToRun = this.getMigrationsToRun(storedVersion, this.currentVersion)
+    
+    if (migrationsToRun.length === 0) {
+      // No migrations needed, just update version
+      await this.setStoredVersion(this.currentVersion)
+      return { updated: true, fromVersion: storedVersion, toVersion: this.currentVersion }
+    }
+
+    // Run migrations
+    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}`)
+      }
+    }
+
+    // Update to current version
+    await this.setStoredVersion(this.currentVersion)
+    return { updated: true, fromVersion: storedVersion, toVersion: this.currentVersion }
+  }
+
+  private async getStoredVersion(): Promise<string | null> {
+    try {
+      const versionData = await this.storage.get(this.versionKey)
+      if (!versionData) return null
+      
+      const versionInfo: VersionInfo = JSON.parse(versionData)
+      return versionInfo.version
+    } catch (error) {
+      console.warn('Failed to get stored version:', error)
+      return null
+    }
+  }
+
+  private async setStoredVersion(version: string): Promise<void> {
+    const versionInfo: VersionInfo = {
+      version,
+      lastUpdated: Date.now()
+    }
+    await this.storage.set(this.versionKey, JSON.stringify(versionInfo))
+  }
+
+  private getMigrationsToRun(fromVersion: string, toVersion: string): Migration[] {
+    return this.migrations.filter(migration => {
+      // Migration should run if we're crossing the version boundary
+      // i.e., stored version is less than migration.toVersion AND current version is >= migration.toVersion
+      const storedLessThanMigrationTo = this.compareVersions(fromVersion, migration.toVersion) < 0
+      const currentGreaterThanOrEqualMigrationTo = this.compareVersions(toVersion, migration.toVersion) >= 0
+      
+      console.log(`Checking migration ${migration.fromVersion} → ${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
+   */
+  private compareVersions(a: string, b: string): number {
+    // Extract major.minor from version strings, ignoring beta/prerelease parts
+    const aMajorMinor = this.extractMajorMinor(a)
+    const bMajorMinor = this.extractMajorMinor(b)
+    
+    // Compare major version first
+    if (aMajorMinor.major !== bMajorMinor.major) {
+      return aMajorMinor.major - bMajorMinor.major
+    }
+    
+    // Then compare minor version
+    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}
+   */
+  private extractMajorMinor(version: string): { major: number, minor: number } {
+    // Remove beta/prerelease parts and split by dots
+    const cleanVersion = version.split('-')[0]?.split('+')[0] || version
+    const parts = cleanVersion.split('.').map(Number)
+    
+    return {
+      major: parts[0] || 0,
+      minor: parts[1] || 0
+    }
+  }
+
+  /**
+   * Add a migration to the updater
+   */
+  addMigration(migration: Migration): void {
+    this.migrations.push(migration)
+    this.migrations.sort((a, b) => this.compareVersions(a.fromVersion, b.fromVersion))
+  }
+}
+
+/**
+ * Create a simple version updater instance
+ */
+export function createVersionUpdater(
+  storage: BasicStorage, 
+  currentVersion: string, 
+  migrations: Migration[] = []
+): VersionUpdater {
+  return new VersionUpdater(storage, currentVersion, migrations)
+}

package/src/utils/network.ts

@@ -0,0 +1,82 @@
+// Network utilities for Basic React package
+import { log } from '../config'
+import { version as currentVersion } from '../../package.json'
+
+export function isDevelopment(debug?: boolean): boolean {
+    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
+    )
+}
+
+export async function checkForNewVersion(): Promise<{ 
+    hasNewVersion: boolean, 
+    latestVersion: string | null, 
+    currentVersion: string | null 
+}> {
+    try {
+        const isBeta = currentVersion.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 !== currentVersion) {
+            console.warn('[basic] New version available:', latestVersion, `\nrun "npm install @basictech/react@${latestVersion}" to update`);
+        }
+        if (isBeta) {
+            log('thank you for being on basictech/react beta :)')
+        }
+     
+        return {
+            hasNewVersion: currentVersion !== latestVersion,
+            latestVersion,
+            currentVersion
+        };
+    } catch (error) {
+        log('Error checking for new version:', error);
+        return {
+            hasNewVersion: false,
+            latestVersion: null, 
+            currentVersion: null
+        };
+    }
+}
+
+export function cleanOAuthParamsFromUrl(): void {
+    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')
+    }
+}
+
+export function getSyncStatus(statusCode: number): string {
+    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";
+    }
+}

package/src/utils/schema.ts

@@ -0,0 +1,120 @@
+// Schema utilities for Basic React package
+import { validateSchema, compareSchemas } from '@basictech/schema'
+import { log } from '../config'
+
+export async function getSchemaStatus(schema: any): Promise<{
+    valid: boolean,
+    status: string,
+    latest: any
+}> {
+    const projectId = schema.project_id
+    const valid = validateSchema(schema)
+
+    if (!valid.valid) {
+        console.warn('BasicDB Error: your local schema is invalid. Please fix errors and try again - sync is disabled')
+        return { 
+            valid: false, 
+            status: 'invalid',
+            latest: null
+        }
+    }
+
+    const latestSchema = await fetch(`https://api.basic.tech/project/${projectId}/schema`)
+    .then(res => res.json())
+    .then(data => data.data[0].schema)
+    .catch(err => {
+        return { 
+            valid: false, 
+            status: 'error',
+            latest: null
+        }
+    })
+
+    console.log('latestSchema', latestSchema)
+
+    if (!latestSchema.version) {
+        return { 
+            valid: false, 
+            status: 'error',
+            latest: null
+        }
+    }
+
+    if (latestSchema.version > schema.version) {
+        // error_code: schema_behind
+        console.warn('BasicDB Error: your local schema version is behind the latest. Found version:', schema.version, 'but expected', latestSchema.version, " - sync is disabled")
+        return { 
+            valid: false, 
+            status: 'behind', 
+            latest: latestSchema
+        }
+    } else if (latestSchema.version < schema.version) {
+        // error_code: schema_ahead
+        console.warn('BasicDB Error: your local schema version is ahead of the latest. Found version:', schema.version, 'but expected', latestSchema.version, " - sync is disabled")
+        return { 
+            valid: false, 
+            status: 'ahead', 
+            latest: latestSchema
+        }
+    } else if (latestSchema.version === schema.version) {
+        const changes = compareSchemas(schema, latestSchema)
+        if (changes.valid) {
+            return { 
+                valid: true,
+                status: 'current',
+                latest: latestSchema
+            }
+        } else {
+            // error_code: schema_conflict
+            console.warn('BasicDB Error: your local schema is conflicting with the latest. Your version:', schema.version, 'does not match origin version', latestSchema.version, " - sync is disabled")
+            return { 
+                valid: false, 
+                status: 'conflict',
+                latest: latestSchema
+            }
+        }
+    } else { 
+        return { 
+            valid: false, 
+            status: 'error',
+            latest: null
+        }
+    }
+}
+
+export async function validateAndCheckSchema(schema: any): Promise<{
+    isValid: boolean,
+    schemaStatus: { valid: boolean, status?: string, latest?: any },
+    errors?: any[]
+}> {
+    const valid = validateSchema(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}\n`
+        })
+        console.groupEnd()
+        
+        return {
+            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
+    }
+}

package/src/utils/storage.ts

@@ -0,0 +1,62 @@
+// Storage utilities for Basic React package
+export interface BasicStorage {
+    get(key: string): Promise<string | null>
+    set(key: string, value: string): Promise<void>
+    remove(key: string): Promise<void>
+}
+
+export class LocalStorageAdapter implements BasicStorage {
+    async get(key: string): Promise<string | null> {
+        return localStorage.getItem(key)
+    }
+    
+    async set(key: string, value: string): Promise<void> {
+        localStorage.setItem(key, value)
+    }
+    
+    async remove(key: string): Promise<void> {
+        localStorage.removeItem(key)
+    }
+}
+
+export const STORAGE_KEYS = {
+    REFRESH_TOKEN: 'basic_refresh_token',
+    USER_INFO: 'basic_user_info',
+    AUTH_STATE: 'basic_auth_state',
+    DEBUG: 'basic_debug'
+} as const
+
+export function getCookie(name: string): string {
+    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;
+}
+
+export function setCookie(name: string, value: string, options?: { secure?: boolean, sameSite?: string, httpOnly?: boolean }): void {
+    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;
+}
+
+export function clearCookie(name: string): void {
+    document.cookie = `${name}=; Secure; SameSite=Strict`;
+}

package/src/schema.ts

@@ -1,159 +0,0 @@
-// Basic Schema Library
-// utils for validating and interacting with Basic schemas
-import Ajv, { ErrorObject } from 'ajv'
-
-const 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"]
-  }
-const ajv = new Ajv()
-const validator = ajv.compile(basicJsonSchema)
-
-type Schema = typeof basicJsonSchema
-
-function generateEmptySchema() {
-   
-}
-
-
-/**
- * Validate a schema
- * only checks if the schema is formatted correctly, not if can be published
- * @param schema - The schema to validate
- * @returns {valid: boolean, errors: any[]} - The validation result
- */
-function validateSchema(schema: Schema) : {valid: boolean, errors: ErrorObject[]} {
-    const v = validator(schema)
-    return { 
-        valid: v,
-        errors: validator.errors || []
-    }
-}
-
-// type ErrorObject = {
-//     keyword: string;
-//     instancePath: string; 
-//     schemaPath: string;
-//     params: Record<string, any>;
-//     propertyName?: string;
-//     message?: string;
-//     schema?: any;
-//     parentSchema?: any;
-//     data?: any;
-// }
-
-
-function validateData(schema: any, table: string, data: Record<string, any>, checkRequired: boolean = 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 as { required?: boolean }).required && !data[fieldName]) {
-                return { valid: false, errors: [{ message: `Field ${fieldName} is required` }], message: "Required field missing" }
-            }
-        }
-    }
-
-    return { valid: true, errors: [] }
-}
-
-
-export {
-    validateSchema,
-    validateData,
-    generateEmptySchema
-}
-