local-lite 0.0.3 → 0.0.5

package/dist/react/status.d.ts

@@ -0,0 +1,24 @@
+import { LocalFirstClient } from '../core/client.js';
+import { SyncMetrics } from '../core/types.js';
+export interface UseSyncStatusResult {
+    isOnline: boolean;
+    isPushing: boolean;
+    isPulling: boolean;
+    isSyncing: boolean;
+    pendingCount: number;
+    pendingRecords: any[];
+    lastSyncedAt: number | null;
+    refresh: () => Promise<void>;
+}
+/**
+ * Consolidated hook that tracks real-time sync connectivity, sync worker activity
+ * (pushing/pulling/syncing), and pending items in the local SQLite outbox queue.
+ */
+export declare function useSyncStatus(client: LocalFirstClient | null | undefined): UseSyncStatusResult;
+/**
+ * Hook that provides real-time sync telemetry and engine performance metrics.
+ */
+export declare function useSyncMetrics(client: LocalFirstClient | null | undefined, pollIntervalMs?: number): {
+    metrics: SyncMetrics | null;
+    refresh: () => Promise<void>;
+};

package/dist/react/status.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSyncStatus = useSyncStatus;
+exports.useSyncMetrics = useSyncMetrics;
+const react_1 = require("react");
+const runner_js_1 = require("./runner.js");
+/**
+ * Consolidated hook that tracks real-time sync connectivity, sync worker activity
+ * (pushing/pulling/syncing), and pending items in the local SQLite outbox queue.
+ */
+function useSyncStatus(client) {
+    const [isOnline, setIsOnline] = (0, react_1.useState)(true);
+    const [isPushing, setIsPushing] = (0, react_1.useState)(false);
+    const [isPulling, setIsPulling] = (0, react_1.useState)(false);
+    const [pendingCount, setPendingCount] = (0, react_1.useState)(0);
+    const [pendingRecords, setPendingRecords] = (0, react_1.useState)([]);
+    const [lastSyncedAt, setLastSyncedAt] = (0, react_1.useState)(null);
+    const refresh = (0, react_1.useCallback)(async () => {
+        if (!client || !client.db)
+            return;
+        try {
+            const [metrics, records, lastSynced] = await Promise.all([
+                client.getMetrics().catch(() => null),
+                client.getOutboxRecords({ limit: 50 }).catch(() => []),
+                client.getLastSyncedAt().catch(() => null),
+            ]);
+            if (metrics) {
+                setIsOnline(metrics.isOnline);
+                setIsPushing(metrics.isPushing);
+                setIsPulling(metrics.isPulling);
+            }
+            if (records) {
+                setPendingRecords(records);
+                const activeCount = metrics
+                    ? metrics.outboxPendingCount + metrics.outboxProcessingCount + metrics.outboxFailedCount
+                    : records.length;
+                setPendingCount(activeCount);
+            }
+            if (lastSynced !== null && lastSynced !== undefined) {
+                setLastSyncedAt(lastSynced > 0 ? lastSynced : null);
+            }
+        }
+        catch {
+            // Ignored if client is stopping or tables initializing
+        }
+    }, [client]);
+    const scheduleRefresh = (0, runner_js_1.useCoalescedRunner)(refresh);
+    (0, react_1.useEffect)(() => {
+        if (!client || !client.db)
+            return;
+        refresh();
+        const unsubStatus = client.events.on('sync:status', (e) => {
+            setIsOnline(e.isOnline);
+            setIsPushing(e.isPushing);
+            setIsPulling(e.isPulling);
+            setPendingCount(e.pendingCount);
+        });
+        const unsubOutbox = client.events.on('sync_outbox', () => {
+            scheduleRefresh();
+        });
+        const unsubPush = client.events.on('sync:push', () => {
+            scheduleRefresh();
+        });
+        const unsubPull = client.events.on('sync:pull', () => {
+            scheduleRefresh();
+        });
+        return () => {
+            unsubStatus();
+            unsubOutbox();
+            unsubPush();
+            unsubPull();
+        };
+    }, [client, refresh, scheduleRefresh]);
+    return {
+        isOnline,
+        isPushing,
+        isPulling,
+        isSyncing: isPushing || isPulling,
+        pendingCount,
+        pendingRecords,
+        lastSyncedAt,
+        refresh,
+    };
+}
+/**
+ * Hook that provides real-time sync telemetry and engine performance metrics.
+ */
+function useSyncMetrics(client, pollIntervalMs = 3000) {
+    const [metrics, setMetrics] = (0, react_1.useState)(null);
+    const refresh = (0, react_1.useCallback)(async () => {
+        if (!client)
+            return;
+        try {
+            const data = await client.getMetrics();
+            setMetrics(data);
+        }
+        catch {
+            // Ignored
+        }
+    }, [client]);
+    const scheduleRefresh = (0, runner_js_1.useCoalescedRunner)(refresh);
+    (0, react_1.useEffect)(() => {
+        if (!client)
+            return;
+        refresh();
+        // Listen to sync events for immediate (coalesced) refresh
+        const unsubs = [
+            client.events.on('sync:push', () => scheduleRefresh()),
+            client.events.on('sync:pull', () => scheduleRefresh()),
+            client.events.on('sync:status', () => scheduleRefresh()),
+        ];
+        let timer;
+        if (pollIntervalMs > 0) {
+            timer = setInterval(scheduleRefresh, pollIntervalMs);
+        }
+        return () => {
+            unsubs.forEach((u) => u());
+            if (timer)
+                clearInterval(timer);
+        };
+    }, [client, refresh, scheduleRefresh, pollIntervalMs]);
+    return { metrics, refresh };
+}

package/dist/react/theme.d.ts

@@ -0,0 +1,18 @@
+export interface SyncThemeColors {
+    isDark: boolean;
+    bg: string;
+    surface: string;
+    surfaceSubtle: string;
+    card: string;
+    border: string;
+    borderSubtle: string;
+    text: string;
+    textSecondary: string;
+    textMuted: string;
+    actionBg: string;
+    actionText: string;
+    accent: string;
+}
+export declare const darkTheme: SyncThemeColors;
+export declare const lightTheme: SyncThemeColors;
+export declare function resolveSyncTheme(themeProp?: 'auto' | 'dark' | 'light' | Partial<SyncThemeColors>, systemColorScheme?: 'dark' | 'light' | null): SyncThemeColors;

package/dist/react/theme.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lightTheme = exports.darkTheme = void 0;
+exports.resolveSyncTheme = resolveSyncTheme;
+exports.darkTheme = {
+    isDark: true,
+    bg: '#111827',
+    surface: '#1F2937',
+    surfaceSubtle: '#1F293780',
+    card: '#1F2937',
+    border: '#374151',
+    borderSubtle: '#37415160',
+    text: '#F9FAFB',
+    textSecondary: '#D1D5DB',
+    textMuted: '#9CA3AF',
+    actionBg: '#374151',
+    actionText: '#F9FAFB',
+    accent: '#8B5CF6',
+};
+exports.lightTheme = {
+    isDark: false,
+    bg: '#F9FAFB',
+    surface: '#FFFFFF',
+    surfaceSubtle: '#F3F4F6',
+    card: '#FFFFFF',
+    border: '#E5E7EB',
+    borderSubtle: '#E5E7EB80',
+    text: '#111827',
+    textSecondary: '#374151',
+    textMuted: '#6B7280',
+    actionBg: '#E5E7EB',
+    actionText: '#1F2937',
+    accent: '#7C3AED',
+};
+function resolveSyncTheme(themeProp, systemColorScheme) {
+    if (typeof themeProp === 'object' && themeProp !== null) {
+        const base = themeProp.isDark === false ? exports.lightTheme : exports.darkTheme;
+        return { ...base, ...themeProp };
+    }
+    const mode = themeProp && themeProp !== 'auto'
+        ? themeProp
+        : systemColorScheme === 'light'
+            ? 'light'
+            : 'dark';
+    return mode === 'light' ? exports.lightTheme : exports.darkTheme;
+}

package/dist/schema/generator.d.ts

@@ -0,0 +1,49 @@
+export interface SchemaIndexDefinition {
+    table: string;
+    columns: string[];
+    isOneToOne: boolean;
+    sql: string;
+    referencedRelation?: string;
+    referencedColumns?: string[];
+    comment?: string;
+}
+export interface GenerateSchemaIndexesOptions {
+    /**
+     * Path to the Supabase database.types.ts file.
+     */
+    typesPath?: string;
+    /**
+     * Raw string content of the database.types.ts file.
+     */
+    typesContent?: string;
+    /**
+     * Target path where the generated TypeScript file should be written.
+     */
+    outputPath?: string;
+    /**
+     * Whether to also generate composite sync indexes for tables with business_id and deleted.
+     * Default: true
+     */
+    includeBusinessSyncIndexes?: boolean;
+}
+export interface GenerateSchemaIndexesResult {
+    indexes: SchemaIndexDefinition[];
+    code: string;
+    written: boolean;
+    outputPath?: string;
+}
+/**
+ * Parses raw Supabase database.types.ts content and extracts foreign-key index definitions.
+ */
+export declare function parseSchemaIndexes(content: string, options?: {
+    includeBusinessSyncIndexes?: boolean;
+}): SchemaIndexDefinition[];
+/**
+ * Generates TypeScript source code containing index definitions and an applicator helper.
+ */
+export declare function formatSchemaIndexesCode(indexes: SchemaIndexDefinition[]): string;
+/**
+ * Core generator function.
+ * Accepts the path or content of database.types.ts and generates schema indexes.
+ */
+export declare function generateSchemaIndexes(typesPathOrOptions: string | GenerateSchemaIndexesOptions, maybeOutputPath?: string): Promise<GenerateSchemaIndexesResult>;

package/dist/schema/generator.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSchemaIndexes = parseSchemaIndexes;
+exports.formatSchemaIndexesCode = formatSchemaIndexesCode;
+exports.generateSchemaIndexes = generateSchemaIndexes;
+async function getNodeModules() {
+    try {
+        const fsModName = 'node:fs';
+        const pathModName = 'node:path';
+        const fsMod = await import(/* @vite-ignore */ fsModName);
+        const pathMod = await import(/* @vite-ignore */ pathModName);
+        return {
+            fs: (fsMod.default || fsMod),
+            path: (pathMod.default || pathMod),
+        };
+    }
+    catch {
+        const req = typeof require !== 'undefined' ? require : null;
+        if (req) {
+            return {
+                fs: req('fs'),
+                path: req('path'),
+            };
+        }
+        throw new Error('Node.js filesystem (fs) and path modules are not available in this environment.');
+    }
+}
+/**
+ * Parses raw Supabase database.types.ts content and extracts foreign-key index definitions.
+ */
+function parseSchemaIndexes(content, options = {}) {
+    const lines = content.split(/\r?\n/);
+    const includeBusiness = options.includeBusinessSyncIndexes ?? true;
+    let currentTable = null;
+    let inRow = false;
+    let inRelationships = false;
+    let relLines = [];
+    const tableColumns = new Map();
+    const relationships = [];
+    for (const line of lines) {
+        // Detect table definition: "      <table_name>: {"
+        const tableMatch = line.match(/^\s{6}([a-z0-9_]+):\s*\{/);
+        if (tableMatch && !['Row', 'Insert', 'Update'].includes(tableMatch[1])) {
+            currentTable = tableMatch[1];
+            if (!tableColumns.has(currentTable)) {
+                tableColumns.set(currentTable, new Set());
+            }
+        }
+        // Track column names in Row: { ... }
+        if (line.includes('Row: {')) {
+            inRow = true;
+            continue;
+        }
+        if (inRow) {
+            if (line.trim() === '};' || line.trim() === '}') {
+                inRow = false;
+            }
+            else if (currentTable) {
+                const colMatch = line.match(/^\s{10}([a-z0-9_]+):/);
+                if (colMatch) {
+                    tableColumns.get(currentTable)?.add(colMatch[1]);
+                }
+            }
+        }
+        // Skip empty relationships
+        if (line.includes('Relationships: [];') || line.includes('Relationships: []')) {
+            continue;
+        }
+        if (line.includes('Relationships: [')) {
+            inRelationships = true;
+            relLines = [];
+            continue;
+        }
+        if (inRelationships) {
+            if (line.trim() === '];' || line.trim() === ']') {
+                inRelationships = false;
+                if (currentTable) {
+                    const block = relLines.join('\n');
+                    const itemRegex = /foreignKeyName:\s*['"]([^'"]+)['"][\s\S]*?columns:\s*\[([^\]]+)\][\s\S]*?isOneToOne:\s*(true|false)[\s\S]*?referencedRelation:\s*['"]([^'"]+)['"](?:[\s\S]*?referencedColumns:\s*\[([^\]]+)\])?/g;
+                    const matches = [...block.matchAll(itemRegex)];
+                    for (const m of matches) {
+                        const columns = m[2].split(',').map(c => c.trim().replace(/['"]/g, ''));
+                        const isOneToOne = m[3] === 'true';
+                        const referencedRelation = m[4];
+                        const referencedColumns = m[5]
+                            ? m[5].split(',').map(c => c.trim().replace(/['"]/g, ''))
+                            : undefined;
+                        const isUnique = isOneToOne ? 'UNIQUE ' : '';
+                        const colSql = columns.map(c => `"${c}"`).join(', ');
+                        const colSlug = columns.join('_');
+                        const indexName = `idx_${currentTable}_${colSlug}`;
+                        relationships.push({
+                            table: currentTable,
+                            columns,
+                            isOneToOne,
+                            referencedRelation,
+                            referencedColumns,
+                            sql: `CREATE ${isUnique}INDEX IF NOT EXISTS "${indexName}" ON "${currentTable}" (${colSql});`,
+                            comment: referencedRelation
+                                ? `References ${referencedRelation}${referencedColumns ? `(${referencedColumns.join(', ')})` : ''}`
+                                : undefined,
+                        });
+                    }
+                }
+                continue;
+            }
+            relLines.push(line);
+        }
+    }
+    // Optionally append composite business sync indexes
+    if (includeBusiness) {
+        for (const [table, cols] of tableColumns.entries()) {
+            if (cols.has('business_id') && cols.has('deleted')) {
+                const idxName = `idx_${table}_biz_del`;
+                if (!relationships.some(r => r.table === table &&
+                    r.columns.length === 2 &&
+                    r.columns.includes('business_id') &&
+                    r.columns.includes('deleted'))) {
+                    relationships.push({
+                        table,
+                        columns: ['business_id', 'deleted'],
+                        isOneToOne: false,
+                        sql: `CREATE INDEX IF NOT EXISTS "${idxName}" ON "${table}" ("business_id", "deleted");`,
+                        comment: 'Composite business partition index for zero-latency local queries',
+                    });
+                }
+            }
+        }
+    }
+    return relationships;
+}
+/**
+ * Generates TypeScript source code containing index definitions and an applicator helper.
+ */
+function formatSchemaIndexesCode(indexes) {
+    const sqlStatements = indexes.map(i => i.sql).join('\n');
+    return `/**
+ * AUTO-GENERATED FILE - DO NOT EDIT MANUALLY.
+ * Generated by local-lite schema index generator.
+ */
+
+/**
+ * SQLite index statements extracted from Supabase database schema.
+ * Total indexes: ${indexes.length}
+ */
+export const SCHEMA_INDEXES: readonly string[] = \`
+${sqlStatements}
+\`.trim().split('\\n');
+
+/**
+ * Applies all schema indexes into SQLite to ensure zero-latency local reads.
+ * Executes each statement safely, ignoring errors if tables are not yet created.
+ */
+export async function ensureSchemaIndexes(db: {
+  execute: (query: string, params?: any[]) => Promise<any>;
+}): Promise<void> {
+  for (const sql of SCHEMA_INDEXES) {
+    try {
+      await db.execute(sql);
+    } catch {
+      // Safe fallback if table has not been created yet
+    }
+  }
+}
+`;
+}
+/**
+ * Core generator function.
+ * Accepts the path or content of database.types.ts and generates schema indexes.
+ */
+async function generateSchemaIndexes(typesPathOrOptions, maybeOutputPath) {
+    const options = typeof typesPathOrOptions === 'string'
+        ? { typesPath: typesPathOrOptions, outputPath: maybeOutputPath }
+        : typesPathOrOptions;
+    let content = options.typesContent;
+    if (!content && options.typesPath) {
+        const { fs, path } = await getNodeModules();
+        const resolvedPath = path.resolve(options.typesPath);
+        if (!fs.existsSync(resolvedPath)) {
+            throw new Error(`Types file not found at: ${resolvedPath}`);
+        }
+        content = fs.readFileSync(resolvedPath, 'utf8');
+    }
+    if (!content) {
+        throw new Error('Either typesPath or typesContent must be provided to generateSchemaIndexes.');
+    }
+    const indexes = parseSchemaIndexes(content, {
+        includeBusinessSyncIndexes: options.includeBusinessSyncIndexes,
+    });
+    const code = formatSchemaIndexesCode(indexes);
+    let written = false;
+    let resolvedOutputPath;
+    if (options.outputPath) {
+        const { fs, path } = await getNodeModules();
+        resolvedOutputPath = path.resolve(options.outputPath);
+        const parentDir = path.dirname(resolvedOutputPath);
+        if (!fs.existsSync(parentDir)) {
+            fs.mkdirSync(parentDir, { recursive: true });
+        }
+        fs.writeFileSync(resolvedOutputPath, code, 'utf8');
+        written = true;
+    }
+    return {
+        indexes,
+        code,
+        written,
+        outputPath: resolvedOutputPath,
+    };
+}

package/dist/schema/index.d.ts

@@ -0,0 +1 @@
+export * from './generator.js';

package/dist/schema/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./generator.js"), exports);

package/dist/utils/logger.d.ts

@@ -28,6 +28,10 @@ export declare class SyncLogger {
  * Global default logger instance.
  */
 export declare const defaultLogger: SyncLogger;
+/**
+ * Factory to create or resolve a SyncLogger from boolean, config, or existing logger.
+ */
+export declare function createSyncLogger(logger?: SyncLogger | CustomLogger | boolean, logLevel?: LogLevel): SyncLogger;
 /**
  * Translates PostgreSQL / Supabase PostgREST error codes into actionable, human-readable explanations.
  */

package/dist/utils/logger.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultLogger = exports.SyncLogger = void 0;
+exports.createSyncLogger = createSyncLogger;
 exports.formatSupabaseError = formatSupabaseError;
 exports.formatFirestoreError = formatFirestoreError;
 exports.formatConvexError = formatConvexError;
@@ -75,6 +76,10 @@ class SyncLogger {
     error(message, ...args) {
         if (!this.shouldLog('error'))
             return;
+        if (message.includes('Network Offline') || message.includes('Failed to reach')) {
+            this.warn(message, ...args);
+            return;
+        }
         if (this.customLogger?.error) {
             this.customLogger.error(message, ...args);
         }
@@ -88,6 +93,21 @@ exports.SyncLogger = SyncLogger;
  * Global default logger instance.
  */
 exports.defaultLogger = new SyncLogger();
+/**
+ * Factory to create or resolve a SyncLogger from boolean, config, or existing logger.
+ */
+function createSyncLogger(logger, logLevel) {
+    if (logger instanceof SyncLogger) {
+        return logger;
+    }
+    if (typeof logger === 'boolean') {
+        return new SyncLogger({ enabled: logger, level: logLevel });
+    }
+    if (logger && typeof logger === 'object') {
+        return new SyncLogger({ customLogger: logger, level: logLevel });
+    }
+    return logLevel ? new SyncLogger({ level: logLevel }) : exports.defaultLogger;
+}
 /**
  * Translates PostgreSQL / Supabase PostgREST error codes into actionable, human-readable explanations.
  */