local-lite 0.0.2 → 0.0.4

package/dist/core/table-manager.js

@@ -4,6 +4,15 @@ exports.TableManager = void 0;
 const sql_js_1 = require("../utils/sql.js");
 const schema_manager_js_1 = require("./schema-manager.js");
 const defaultSchemaManager = new schema_manager_js_1.SchemaManager();
+function formatPayload(payload) {
+    const formatted = {};
+    if (payload && typeof payload === 'object') {
+        for (const [k, v] of Object.entries(payload)) {
+            formatted[k] = (0, schema_manager_js_1.formatValueForStorage)(v);
+        }
+    }
+    return formatted;
+}
 class TableManager {
     /**
      * Applies an insert, update, or delete mutation on a local data table.
@@ -21,40 +30,28 @@ class TableManager {
             await tx.execute(`DELETE FROM ${safeTable} WHERE ${safePk} = ?`, [rowId]);
             return;
         }
-        let rowData;
-        if (options?.autoSchema) {
-            const formatted = await sm.ensureColumns(tx, tableName, payload, primaryKey);
-            rowData = { ...formatted, [primaryKey]: rowId };
-        }
-        else {
-            const formatted = {};
-            if (payload && typeof payload === 'object') {
-                for (const k of Object.keys(payload)) {
-                    formatted[k] = (0, schema_manager_js_1.formatValueForStorage)(payload[k]);
-                }
-            }
-            rowData = { ...formatted, [primaryKey]: rowId };
-        }
+        const formatted = options?.autoSchema
+            ? await sm.ensureColumns(tx, tableName, payload, primaryKey)
+            : formatPayload(payload);
+        const rowData = { ...formatted, [primaryKey]: rowId };
         const keys = Object.keys(rowData);
         if (keys.length === 0)
             return;
-        const existing = await tx.execute(`SELECT 1 FROM ${safeTable} WHERE ${safePk} = ? LIMIT 1`, [rowId]);
-        if (existing && existing.length > 0) {
-            // Row exists -> perform UPDATE
-            const updateKeys = keys.filter((k) => k !== primaryKey);
-            if (updateKeys.length > 0) {
-                const setClause = updateKeys.map((k) => `${(0, sql_js_1.escapeIdentifier)(k)} = ?`).join(', ');
-                const values = updateKeys.map((k) => rowData[k]);
-                values.push(rowId);
-                await tx.execute(`UPDATE ${safeTable} SET ${setClause} WHERE ${safePk} = ?`, values);
-            }
+        // Use atomic SQLite UPSERT (INSERT ... ON CONFLICT DO UPDATE) for both INSERT and UPDATE.
+        // Handles missing rows, existing rows, and partial updates in a single SQL round-trip,
+        // completely eliminating the redundant SELECT 1 pre-check on every mutation!
+        const updateKeys = keys.filter((k) => k !== primaryKey);
+        const cols = keys.map((k) => (0, sql_js_1.escapeIdentifier)(k)).join(', ');
+        const placeholders = keys.map(() => '?').join(', ');
+        const values = keys.map((k) => rowData[k]);
+        if (updateKeys.length > 0) {
+            const updateClause = updateKeys
+                .map((k) => `${(0, sql_js_1.escapeIdentifier)(k)} = excluded.${(0, sql_js_1.escapeIdentifier)(k)}`)
+                .join(', ');
+            await tx.execute(`INSERT INTO ${safeTable} (${cols}) VALUES (${placeholders}) ON CONFLICT (${safePk}) DO UPDATE SET ${updateClause}`, values);
         }
         else {
-            // Row does not exist -> perform INSERT
-            const cols = keys.map((k) => (0, sql_js_1.escapeIdentifier)(k)).join(', ');
-            const placeholders = keys.map(() => '?').join(', ');
-            const values = keys.map((k) => rowData[k]);
-            await tx.execute(`INSERT INTO ${safeTable} (${cols}) VALUES (${placeholders})`, values);
+            await tx.execute(`INSERT OR IGNORE INTO ${safeTable} (${cols}) VALUES (${placeholders})`, values);
         }
     }
     /**

package/dist/core/types.d.ts

@@ -8,6 +8,12 @@ export interface SyncOperation {
     payload: Record<string, any> | null;
     timestamp: number;
 }
+export interface PushResult {
+    success?: boolean;
+    successfulIds?: string[];
+    failedIds?: string[];
+    errors?: Record<string, string>;
+}
 export interface OutboxRecord extends SyncOperation {
     status: OutboxStatus;
     retryCount: number;
@@ -90,11 +96,13 @@ export type WhereFilter = Record<string, FieldFilter> | ((row: Record<string, an
     [key: string]: any;
 };
 export interface QueryOptions {
+    select?: string[];
     where?: WhereFilter;
     orderBy?: string;
     order?: 'asc' | 'desc' | 'ASC' | 'DESC';
     limit?: number;
     offset?: number;
+    includeDeleted?: boolean;
 }
 /**
  * Individual mutation descriptor for atomic batch execution.

package/dist/index.d.ts

@@ -12,7 +12,7 @@ export * from './adapters/local/index.js';
 export * from './adapters/remote/index.js';
 export * from './adapters/network/index.js';
 export * from './config/index.js';
-export * from './react/index.js';
+export type * from './react/index.js';
 export * from './utils/uuid.js';
 export * from './utils/sql.js';
 export * from './utils/logger.js';

package/dist/index.js

@@ -28,7 +28,6 @@ __exportStar(require("./adapters/local/index.js"), exports);
 __exportStar(require("./adapters/remote/index.js"), exports);
 __exportStar(require("./adapters/network/index.js"), exports);
 __exportStar(require("./config/index.js"), exports);
-__exportStar(require("./react/index.js"), exports);
 __exportStar(require("./utils/uuid.js"), exports);
 __exportStar(require("./utils/sql.js"), exports);
 __exportStar(require("./utils/logger.js"), exports);

package/dist/react/BenchmarkModal.d.ts

@@ -0,0 +1,32 @@
+import React from 'react';
+import { LocalFirstClient } from '../core/client.js';
+import { type SyncThemeColors } from './theme.js';
+export interface BuiltinBenchmarkResult {
+    name: string;
+    category: 'Local-Lite Client' | 'ACID / Transactions' | 'Outbox / Sync' | 'Memory / JSON';
+    description: string;
+    operations: number;
+    durationMs: number;
+    opsPerSec: number;
+    status: 'pending' | 'running' | 'success' | 'failed';
+    note?: string;
+}
+export interface BenchmarkModalProps {
+    client: LocalFirstClient | null | undefined;
+    visible: boolean;
+    onDismiss: () => void;
+    theme?: 'auto' | 'dark' | 'light' | Partial<SyncThemeColors>;
+}
+/**
+ * Executes a comprehensive performance & ACID test suite
+ * directly testing local-lite client APIs:
+ * client.batch(), client.insert(), client.update(), client.findById(),
+ * client.findMany() with SQL pushdown ($gt, $contains), client.transaction() rollbacks,
+ * client.trackMutation() outbox pipeline, and client.delete().
+ */
+export declare function runSQLiteBenchmark(clientOrDb: any, onProgress?: (step: string, progress: number) => void): Promise<BuiltinBenchmarkResult[]>;
+/**
+ * Pure package-driven, full-height Performance Benchmark Modal.
+ * Opens full-height with zero screen flickering or dynamic jumping.
+ */
+export declare function BenchmarkModal({ client, visible, onDismiss, theme }: BenchmarkModalProps): React.JSX.Element | null;