local-lite 0.0.4 → 0.0.5

package/dist/react/index.js

@@ -17,6 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SyncIndicator = exports.SyncInspector = void 0;
 exports.clearLiveQueryCache = clearLiveQueryCache;
 exports.useLiveQuery = useLiveQuery;
+exports.useLiveQueries = useLiveQueries;
 exports.useLiveRow = useLiveRow;
 exports.useLiveInfiniteQuery = useLiveInfiniteQuery;
 exports.useMutations = useMutations;
@@ -32,10 +33,14 @@ function areRowsEqual(a, b) {
     if (aObj.id !== undefined && bObj.id !== undefined && aObj.id !== bObj.id) {
         return false;
     }
-    if (aObj.updated_at !== undefined &&
-        bObj.updated_at !== undefined &&
-        aObj.updated_at !== bObj.updated_at) {
-        return false;
+    // Fast path: if both records have an identical updated_at timestamp, they are equal.
+    // This bypasses expensive Object.keys loops and JSON.stringify on large metadata columns.
+    if (aObj.id !== undefined &&
+        bObj.id !== undefined &&
+        aObj.id === bObj.id &&
+        aObj.updated_at !== undefined &&
+        bObj.updated_at !== undefined) {
+        return aObj.updated_at === bObj.updated_at;
     }
     const aKeys = Object.keys(aObj);
     const bKeys = Object.keys(bObj);
@@ -171,6 +176,186 @@ function useLiveQuery(client, tableName, queryOrOptions) {
     }, [client, tableName, queryKey, refetch, scheduleRefetch]);
     return { data, refetch, loading };
 }
+function normalizeMultiQueries(input) {
+    const items = [];
+    if (Array.isArray(input)) {
+        for (const item of input) {
+            if (typeof item === 'string') {
+                items.push({
+                    key: item,
+                    table: item,
+                    queryKey: 'all',
+                    cacheKey: `${item}:all`,
+                });
+            }
+            else if (typeof item === 'object' && item !== null && item.table) {
+                const { table, ...options } = item;
+                const qKey = JSON.stringify(options);
+                items.push({
+                    key: table,
+                    table,
+                    queryKey: qKey,
+                    cacheKey: `${table}:${qKey}`,
+                    options,
+                });
+            }
+        }
+    }
+    else if (typeof input === 'object' && input !== null) {
+        for (const [key, spec] of Object.entries(input)) {
+            if (typeof spec === 'string') {
+                items.push({
+                    key,
+                    table: spec,
+                    queryKey: 'all',
+                    cacheKey: `${spec}:all`,
+                });
+            }
+            else if (typeof spec === 'function') {
+                items.push({
+                    key,
+                    table: key,
+                    queryKey: 'custom',
+                    cacheKey: `${key}:custom`,
+                    fn: spec,
+                });
+            }
+            else if (typeof spec === 'object' && spec !== null) {
+                const table = spec.table || key;
+                const options = { ...spec };
+                delete options.table;
+                const qKey = JSON.stringify(options);
+                items.push({
+                    key,
+                    table,
+                    queryKey: qKey,
+                    cacheKey: `${table}:${qKey}`,
+                    options,
+                });
+            }
+        }
+    }
+    return items;
+}
+/**
+ * Reactive multi-table live query hook that loads data from multiple tables concurrently.
+ *
+ * Benefits:
+ * - Parallel fetching: queries SQLite tables concurrently via Promise.all.
+ * - Single atomic React commit: coalesces multiple table results into a single state update,
+ *   preventing cascading re-renders and UI freezing.
+ * - Multi-table event coordination: listens to mutations across all requested tables,
+ *   coalescing updates so downstream calculations only run once.
+ * - Zero-latency cache read-through: returns instant cached rows on mount.
+ *
+ * Usage with dictionary:
+ * ```ts
+ * const { data, loading } = useLiveQueries(client, {
+ *   projects: 'projects',
+ *   tasks: { where: { project_id: '123' }, orderBy: 'created_at' },
+ *   tags: { table: 'labels' }
+ * });
+ * // data.projects, data.tasks, data.tags
+ * ```
+ *
+ * Usage with array:
+ * ```ts
+ * const { data, loading } = useLiveQueries(client, ['projects', 'tasks', 'tags']);
+ * // data.projects, data.tasks, data.tags
+ * ```
+ */
+function useLiveQueries(client, queries) {
+    const signature = (0, react_1.useMemo)(() => {
+        return JSON.stringify(queries, (_, val) => (typeof val === 'function' ? 'fn' : val));
+    }, [queries]);
+    const items = (0, react_1.useMemo)(() => normalizeMultiQueries(queries), [signature]);
+    const [data, setData] = (0, react_1.useState)(() => {
+        const initial = {};
+        for (const item of items) {
+            const cached = queryCache.get(item.cacheKey);
+            initial[item.key] = cached ? cached : [];
+        }
+        return initial;
+    });
+    const [loading, setLoading] = (0, react_1.useState)(() => {
+        if (items.length === 0)
+            return false;
+        for (const item of items) {
+            if (!queryCache.has(item.cacheKey))
+                return true;
+        }
+        return false;
+    });
+    const refetch = (0, react_1.useCallback)(async () => {
+        if (!client || !client.db || items.length === 0)
+            return;
+        try {
+            const results = await Promise.all(items.map(async (item) => {
+                let inFlight = inFlightQueries.get(item.cacheKey);
+                if (!inFlight) {
+                    inFlight = (async () => {
+                        if (item.fn) {
+                            return (await item.fn(client)) || [];
+                        }
+                        else if (item.options) {
+                            return await client.findMany(item.table, item.options);
+                        }
+                        else {
+                            return await client.findMany(item.table);
+                        }
+                    })();
+                    inFlightQueries.set(item.cacheKey, inFlight);
+                    inFlight.finally(() => {
+                        inFlightQueries.delete(item.cacheKey);
+                    });
+                }
+                try {
+                    const rows = (await inFlight) || [];
+                    queryCache.set(item.cacheKey, rows);
+                    return { key: item.key, rows };
+                }
+                catch (err) {
+                    const msg = String(err?.message || err || '');
+                    if (msg.includes('no such column') || msg.includes('no such table')) {
+                        return { key: item.key, rows: [] };
+                    }
+                    console.error(`Error in useLiveQueries("${item.table}"):`, err);
+                    return { key: item.key, rows: [] };
+                }
+            }));
+            setData((prev) => {
+                let changed = false;
+                const next = { ...prev };
+                for (const res of results) {
+                    if (!areRowArraysEqual(prev[res.key], res.rows)) {
+                        next[res.key] = res.rows;
+                        changed = true;
+                    }
+                }
+                return changed ? next : prev;
+            });
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [client, items]);
+    const scheduleRefetch = (0, runner_js_1.useCoalescedRunner)(refetch);
+    (0, react_1.useEffect)(() => {
+        if (!client || !client.db || items.length === 0)
+            return;
+        refetch();
+        const tables = Array.from(new Set(items.map((i) => i.table).filter(Boolean)));
+        const unsubs = tables.map((tbl) => client.events.on(tbl, () => {
+            scheduleRefetch();
+        }));
+        return () => {
+            for (const unsub of unsubs) {
+                unsub();
+            }
+        };
+    }, [client, signature, refetch, scheduleRefetch]);
+    return { data, loading, refetch };
+}
 /**
  * Reactive hook to query a single record by primary key with 0ms cache read-through.
  * Automatically re-renders only when this specific row or table changes.

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "local-lite",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "Never let a lost connection break a promise. Local-first sync that faithfully keeps data safe until you're back online.",
   "license": "MIT",
   "main": "dist/index.js",
@@ -26,6 +26,11 @@
       "import": "./dist/config/index.js",
       "default": "./dist/config/index.js"
     },
+    "./schema": {
+      "types": "./dist/schema/index.d.ts",
+      "import": "./dist/schema/index.js",
+      "default": "./dist/schema/index.js"
+    },
     "./supabase": {
       "types": "./dist/adapters/remote/supabase.d.ts",
       "import": "./dist/adapters/remote/supabase.js",
@@ -127,7 +132,7 @@
     "@supabase/supabase-js": "^2.118.0",
     "@types/react": "^19.3.0",
     "@types/uuid": "^11.0.0",
-    "expo-sqlite": "^57.0.4",
+    "expo-sqlite": "^58.0.13",
     "react": "^19.3.1",
     "typescript": "^7.0.2",
     "vitest": "^5.0.5"