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

package/src/updater/versionUpdater.ts

@@ -1,153 +0,0 @@
-import { BasicStorage } from '../utils/storage'
-import { log } from '../config'
-
-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 {
-        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 => {
-      const storedLessThanMigrationTo = this.compareVersions(fromVersion, migration.toVersion) < 0
-      const currentGreaterThanOrEqualMigrationTo = this.compareVersions(toVersion, migration.toVersion) >= 0
-      const shouldRun = storedLessThanMigrationTo && currentGreaterThanOrEqualMigrationTo
-      log(`Migration ${migration.fromVersion} → ${migration.toVersion}: shouldRun=${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

@@ -1,135 +0,0 @@
-// Network utilities for Basic React package
-import semver from 'semver'
-import { log } from '../config'
-import { version as pkgVersion } from '../../package.json'
-
-export function isDevelopment(debug?: boolean): boolean {
-    if (debug === true) return true
-    if (typeof process !== 'undefined' && process.env.NODE_ENV === 'development') return true
-    if (typeof window === 'undefined' || !window.location) return false
-    const host = window.location.hostname
-    return (
-        host === 'localhost' ||
-        host === '127.0.0.1' ||
-        host.includes('localhost') ||
-        host.includes('127.0.0.1') ||
-        host.includes('.local')
-    )
-}
-
-function normalizeVersion(v: string | null | undefined): string | null {
-    if (v == null) return null
-    const t = String(v).trim()
-    return t.length ? t : null
-}
-
-function versionsMatch(a: string, b: string): boolean {
-    const na = a.trim()
-    const nb = b.trim()
-    if (na === nb) return true
-    const va = semver.valid(na)
-    const vb = semver.valid(nb)
-    if (va && vb) return semver.eq(va, vb)
-    return false
-}
-
-/** Use npm `beta` dist-tag when the installed version is a semver prerelease whose first id is `beta`. */
-function usesBetaDistTag(version: string): boolean {
-    const pre = semver.prerelease(version)
-    const id = pre?.[0]
-    return typeof id === 'string' && id.toLowerCase() === 'beta'
-}
-
-type NpmInstallMeta = {
-    'dist-tags'?: { latest?: string; beta?: string }
-}
-
-export async function checkForNewVersion(): Promise<{ 
-    hasNewVersion: boolean, 
-    latestVersion: string | null, 
-    currentVersion: string | null 
-}> {
-    try {
-        const currentVersion = normalizeVersion(pkgVersion)
-        if (!currentVersion) {
-            return { hasNewVersion: false, latestVersion: null, currentVersion: null }
-        }
-
-        const response = await fetch('https://registry.npmjs.org/@basictech/react', {
-            headers: { Accept: 'application/vnd.npm.install-v1+json' },
-        })
-        if (!response.ok) {
-            throw new Error('Failed to fetch version from npm');
-        }
-
-        const data = (await response.json()) as NpmInstallMeta
-        const distTags = data['dist-tags'] ?? {}
-        const rawRegistry =
-            usesBetaDistTag(currentVersion)
-                ? distTags.beta ?? distTags.latest
-                : distTags.latest
-        const latestVersion = normalizeVersion(rawRegistry ?? null)
-        if (!latestVersion) {
-            throw new Error('Missing dist-tags from npm registry')
-        }
-
-        const same = versionsMatch(currentVersion, latestVersion)
-
-        if (!same && isDevelopment()) {
-            log('[basic] version check mismatch:', {
-                currentVersion,
-                registryVersion: latestVersion,
-                channel: usesBetaDistTag(currentVersion) ? 'beta' : 'latest',
-            })
-        }
-
-        if (!same) {
-            console.warn('[basic] New version available:', latestVersion, `\nrun "npm install @basictech/react@${latestVersion}" to update`);
-        }
-        if (usesBetaDistTag(currentVersion)) {
-            log('thank you for being on basictech/react beta :)')
-        }
-     
-        return {
-            hasNewVersion: !same,
-            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.replaceState({}, 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/normalizeClientId.ts

@@ -1,22 +0,0 @@
-const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
-
-/**
- * Normalize a project_id / client_id to the canonical did:web format
- * before sending it to the PDS.
- *
- * - did:web:... -> passthrough (already canonical)
- * - bare UUID   -> did:web:{adminHostname}:projects:{hex}
- * - "self"      -> passthrough
- */
-export function normalizeClientId(projectId: string, adminHostname: string = 'api.basic.tech'): string {
-  if (!projectId) return projectId
-  if (projectId === 'self') return projectId
-  if (projectId.startsWith('did:')) return projectId
-
-  if (UUID_RE.test(projectId)) {
-    const hex = projectId.replace(/-/g, '').toLowerCase()
-    return `did:web:${adminHostname}:projects:${hex}`
-  }
-
-  return projectId
-}

package/src/utils/resolveDid.ts

@@ -1,101 +0,0 @@
-export type ResolvedDid = {
-  did: string
-  handle?: string
-  didDocument: Record<string, unknown>
-  pdsUrl: string
-  authorization_endpoint: string
-  token_endpoint: string
-  userinfo_endpoint: string
-}
-
-/**
- * Convert a did:web DID to the HTTPS URL where its DID document lives.
- *
- * did:web:pds.basic.id:did:abc123 -> https://pds.basic.id/did/abc123/did.json
- * did:web:example.com             -> https://example.com/.well-known/did.json
- */
-export function resolveDidWebUrl(did: string): string | null {
-  if (!did.startsWith('did:web:')) return null
-
-  const rest = did.slice(8) // strip 'did:web:'
-  if (!rest) return null
-  const parts = rest.split(':')
-
-  // Decode the hostname (first part, may contain %3A for port)
-  const hostname = parts[0]!.replace(/%3A/gi, ':')
-
-  if (parts.length === 1) {
-    return `https://${hostname}/.well-known/did.json`
-  }
-
-  const pathParts = parts.slice(1).map(p => decodeURIComponent(p))
-  return `https://${hostname}/${pathParts.join('/')}/did.json`
-}
-
-/**
- * Given a DID document, extract PDS URL and discover OAuth endpoints.
- */
-async function resolveFromDocument(did: string, didDocument: Record<string, unknown>): Promise<ResolvedDid> {
-  const services = didDocument.service as Array<{ id: string; type: string; serviceEndpoint: string }> | undefined
-  const pdsService = services?.find(
-    (s) => s.id === '#basic_pds' || s.id === `${did}#basic_pds`
-  )
-  if (!pdsService) {
-    throw new Error(`DID document has no #basic_pds service entry`)
-  }
-  const pdsUrl = pdsService.serviceEndpoint.replace(/\/+$/, '')
-
-  const oauthRes = await fetch(`${pdsUrl}/auth/.well-known/openid-configuration`)
-  if (!oauthRes.ok) {
-    throw new Error(`Failed to fetch OpenID configuration from ${pdsUrl}: ${oauthRes.status}`)
-  }
-  const oauth = await oauthRes.json()
-
-  return {
-    did,
-    didDocument,
-    pdsUrl,
-    authorization_endpoint: oauth.authorization_endpoint,
-    token_endpoint: oauth.token_endpoint,
-    userinfo_endpoint: oauth.userinfo_endpoint,
-  }
-}
-
-/**
- * Fetch a DID document by DID, extract the PDS URL, and discover OAuth endpoints.
- */
-export async function resolveDid(did: string): Promise<ResolvedDid> {
-  const url = resolveDidWebUrl(did)
-  if (!url) {
-    throw new Error(`Unsupported DID method: ${did}`)
-  }
-
-  const didRes = await fetch(url)
-  if (!didRes.ok) {
-    throw new Error(`Failed to fetch DID document at ${url}: ${didRes.status}`)
-  }
-  const didDocument = await didRes.json()
-
-  return resolveFromDocument(did, didDocument)
-}
-
-/**
- * Resolve a handle (e.g. "alice.basic.id") to a DID and discover PDS + OAuth endpoints.
- *
- * Fetches https://{handle}/.well-known/did.json per the did:web spec.
- */
-export async function resolveHandle(handle: string): Promise<ResolvedDid> {
-  const res = await fetch(`https://${handle}/.well-known/did.json`)
-  if (!res.ok) {
-    throw new Error(`Handle resolution failed for ${handle}: ${res.status}`)
-  }
-  const didDocument = await res.json()
-  const did = didDocument.id as string
-  if (!did) {
-    throw new Error(`Handle response has no 'id' field`)
-  }
-
-  const resolved = await resolveFromDocument(did, didDocument)
-  resolved.handle = handle
-  return resolved
-}

package/src/utils/schema.ts

@@ -1,119 +0,0 @@
-// 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
-        }
-    })
-
-    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: boolean, status?: string, latest?: any } = { valid: false }
-    if (schema.version !== 0) {
-        schemaStatus = await getSchemaStatus(schema)
-        log('schemaStatus', schemaStatus)
-    } else {
-        schemaStatus = { valid: false, status: 'unpublished' }
-        log("schema not published - at version 0")
-    }
-
-    return {
-        isValid: true,
-        schemaStatus
-    }
-}

package/src/utils/storage.ts

@@ -1,67 +0,0 @@
-// 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',
-    REDIRECT_URI: 'basic_redirect_uri',
-    SERVER_URL: 'basic_server_url',
-    PDS_ENDPOINTS: 'basic_pds_endpoints',
-    LAST_CONNECT_REPORT: 'basic_last_connect_report',
-    DEBUG: 'basic_debug',
-    CODE_VERIFIER: 'basic_code_verifier'
-} 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/tsconfig.json

@@ -1,9 +0,0 @@
-{
-    "extends": "@repo/typescript-config/react-library.json",
-    "compilerOptions": {
-      "outDir": "dist"
-    },
-    "include": ["src"],
-    "exclude": ["node_modules", "dist"]
-  }
-  

package/tsup.config.ts

@@ -1,11 +0,0 @@
-import { defineConfig } from 'tsup'
-
-export default defineConfig({
-  entry: ['src/index.ts'],
-  format: ['cjs', 'esm'],
-  dts: true,
-  splitting: false,
-  sourcemap: true,
-  clean: true,
-  noExternal: ['@repo/sync']
-})