local-lite 0.0.4 → 0.0.6

package/dist/core/client.js

@@ -10,6 +10,44 @@ const schema_manager_js_1 = require("./schema-manager.js");
 const uuid_js_1 = require("../utils/uuid.js");
 const sql_js_1 = require("../utils/sql.js");
 const query_js_1 = require("./query.js");
+const query_builder_js_1 = require("./query-builder.js");
+async function executeFindById(db, tableName, id, primaryKey, hydrateRow, includeDeleted) {
+    const safeTable = (0, sql_js_1.escapeIdentifier)(tableName);
+    const safePk = (0, sql_js_1.escapeIdentifier)(primaryKey);
+    try {
+        const rows = await db.execute(`SELECT * FROM ${safeTable} WHERE ${safePk} = ? LIMIT 1`, [id]);
+        if (!rows || rows.length === 0)
+            return null;
+        const row = hydrateRow(tableName, rows[0]);
+        return !includeDeleted && (0, query_js_1.isDeletedRecord)(row) ? null : row;
+    }
+    catch (err) {
+        const msg = String(err?.message || err || '');
+        if (msg.includes('no such table') || msg.includes('no such column'))
+            return null;
+        throw err;
+    }
+}
+async function executeFindByIds(db, tableName, ids, primaryKey, hydrateRow, includeDeleted) {
+    if (!ids || ids.length === 0)
+        return [];
+    const safeTable = (0, sql_js_1.escapeIdentifier)(tableName);
+    const safePk = (0, sql_js_1.escapeIdentifier)(primaryKey);
+    const placeholders = ids.map(() => '?').join(', ');
+    try {
+        const rows = await db.execute(`SELECT * FROM ${safeTable} WHERE ${safePk} IN (${placeholders})`, ids);
+        if (!rows || rows.length === 0)
+            return [];
+        const hydrated = rows.map((r) => hydrateRow(tableName, r));
+        return !includeDeleted ? hydrated.filter((r) => !(0, query_js_1.isDeletedRecord)(r)) : hydrated;
+    }
+    catch (err) {
+        const msg = String(err?.message || err || '');
+        if (msg.includes('no such table') || msg.includes('no such column'))
+            return [];
+        throw err;
+    }
+}
 class TransactionalClient {
     parent;
     tx;
@@ -73,44 +111,20 @@ class TransactionalClient {
         await this.mutate(tableName, rowId, 'DELETE', null, options);
     }
     async findById(tableName, id, options) {
-        const safeTable = (0, sql_js_1.escapeIdentifier)(tableName);
-        const safePk = (0, sql_js_1.escapeIdentifier)(this.parent.getPrimaryKey());
-        try {
-            const rows = await this.tx.execute(`SELECT * FROM ${safeTable} WHERE ${safePk} = ? LIMIT 1`, [id]);
-            if (!rows || rows.length === 0)
-                return null;
-            const row = this.parent.hydrateRow(tableName, rows[0]);
-            if (!options?.includeDeleted && (0, query_js_1.isDeletedRecord)(row)) {
-                return null;
-            }
-            return row;
-        }
-        catch {
-            return null;
-        }
+        return executeFindById(this.tx, tableName, id, this.parent.getPrimaryKey(), (t, r) => this.parent.hydrateRow(t, r), options?.includeDeleted);
     }
     async findByIds(tableName, ids, options) {
-        if (!ids || ids.length === 0)
-            return [];
-        const safeTable = (0, sql_js_1.escapeIdentifier)(tableName);
-        const safePk = (0, sql_js_1.escapeIdentifier)(this.parent.getPrimaryKey());
-        const placeholders = ids.map(() => '?').join(', ');
-        try {
-            const rows = await this.tx.execute(`SELECT * FROM ${safeTable} WHERE ${safePk} IN (${placeholders})`, ids);
-            if (!rows || rows.length === 0)
-                return [];
-            const hydrated = rows.map((r) => this.parent.hydrateRow(tableName, r));
-            if (!options?.includeDeleted) {
-                return hydrated.filter((r) => !(0, query_js_1.isDeletedRecord)(r));
-            }
-            return hydrated;
-        }
-        catch {
-            return [];
-        }
+        return executeFindByIds(this.tx, tableName, ids, this.parent.getPrimaryKey(), (t, r) => this.parent.hydrateRow(t, r), options?.includeDeleted);
     }
     async findMany(tableName, options) {
-        return this.parent.findManyInternal(this.tx, tableName, options);
+        const rows = await this.from(tableName).applyOptions(options).execute();
+        return (0, query_js_1.applyQueryOptions)(rows, options);
+    }
+    async query(sql, params = []) {
+        return (await this.tx.execute(sql, params));
+    }
+    from(tableName) {
+        return new query_builder_js_1.QueryBuilder(this, tableName);
     }
     get rawTx() {
         return this.tx;
@@ -266,6 +280,15 @@ class LocalFirstClient {
         await this.initialization;
     }
     async initializeStorage() {
+        try {
+            await this.db.execute('PRAGMA journal_mode = WAL;');
+            await this.db.execute('PRAGMA synchronous = NORMAL;');
+            await this.db.execute('PRAGMA busy_timeout = 5000;');
+            await this.db.execute('PRAGMA cache_size = -64000;');
+        }
+        catch {
+            // Ignored for drivers, mock DBs, or in-memory modes that do not support PRAGMAs
+        }
         await outbox_store_js_1.OutboxStore.ensureSchema(this.db);
         await meta_store_js_1.MetaStore.ensureSchema(this.db);
         await outbox_store_js_1.OutboxStore.resetStaleProcessing(this.db);
@@ -336,6 +359,7 @@ class LocalFirstClient {
         const generatedIds = [];
         const queuedEvents = [];
         const queuedOutboxIds = [];
+        const pendingOutboxOps = [];
         const executeInTx = async (tx) => {
             for (const m of mutations) {
                 const pk = m.primaryKey ?? options.primaryKey ?? this.primaryKey;
@@ -352,8 +376,22 @@ class LocalFirstClient {
                 const skipOutbox = m.skipOutbox ?? options.skipOutbox ?? false;
                 if (!skipOutbox) {
                     const timestamp = m.customTimestamp ?? options.customTimestamp ?? Date.now();
-                    const outboxId = await this.recordOutboxMutation(tx, m.tableName, rowId, m.operation, payload, timestamp);
-                    if (outboxId) {
+                    if (this.coalesceOutbox && m.operation !== 'INSERT') {
+                        const outboxId = await this.recordOutboxMutation(tx, m.tableName, rowId, m.operation, payload, timestamp);
+                        if (outboxId) {
+                            queuedOutboxIds.push(outboxId);
+                        }
+                    }
+                    else {
+                        const outboxId = (0, uuid_js_1.generateUUID)();
+                        pendingOutboxOps.push({
+                            id: outboxId,
+                            tableName: m.tableName,
+                            rowId,
+                            operation: m.operation,
+                            payload,
+                            timestamp,
+                        });
                         queuedOutboxIds.push(outboxId);
                     }
                 }
@@ -367,6 +405,9 @@ class LocalFirstClient {
                     },
                 });
             }
+            if (pendingOutboxOps.length > 0) {
+                await outbox_store_js_1.OutboxStore.insertRecords(tx, pendingOutboxOps);
+            }
         };
         if (options.tx) {
             await executeInTx(options.tx);
@@ -492,142 +533,137 @@ class LocalFirstClient {
      * Pushes simple equality where clauses down to SQLite for high performance, with memory fallback.
      * Gracefully returns [] if table or columns have not been populated yet on empty schemas.
      *
+    /**
+     * Executes a raw relational SQL query with parameters directly against SQLite.
+     * Enables complex multi-table JOINs, GROUP BY aggregations (COUNT, SUM, AVG), CTEs, and window functions.
+     */
+    async query(sql, params = []) {
+        return (await this.db.execute(sql, params));
+    }
+    /**
+     * Returns a fluent SQL QueryBuilder for the specified table.
+     * Allows writing clean JavaScript method chains (select, join, leftJoin, where, orderBy, groupBy)
+     * that automatically compile into optimized native SQLite queries.
+     *
      * Example:
-     * const tenants = await client.findMany('tenants', { where: { status: 'ACTIVE' }, orderBy: 'name' });
-     * const expensive = await client.findMany('properties', { where: { rent: { $gte: 2000 } } });
+     * const activeRentals = await client
+     *   .from('contracts')
+     *   .join('houses', 'contracts.house_id', 'houses.id')
+     *   .leftJoin('tenants', 'contracts.tenant_id', 'tenants.id')
+     *   .where({ 'contracts.business_id': bizId, 'contracts.status': 'ACTIVE' })
+     *   .select('contracts.id', 'contracts.rent_amount', 'houses.house_number', 'tenants.name')
+     *   .execute();
      */
-    async findMany(tableName, options) {
-        return this.findManyInternal(this.db, tableName, options);
+    from(tableName) {
+        return new query_builder_js_1.QueryBuilder(this, tableName);
     }
     /**
-     * Internal findMany implementation shared between LocalFirstClient and TransactionalClient.
+     * Executes a native SQLite COUNT(*) query and returns the count directly.
      */
-    async findManyInternal(db, tableName, options) {
-        await this.schemaManager.ensureTableIntrospected(db, tableName);
-        const safeTable = (0, sql_js_1.escapeIdentifier)(tableName);
-        let rows;
-        const projection = options?.select && Array.isArray(options.select) && options.select.length > 0
-            ? options.select.map(sql_js_1.escapeIdentifier).join(', ')
-            : '*';
-        let sql = `SELECT ${projection} FROM ${safeTable}`;
-        const params = [];
-        const whereClauses = [];
-        // Automatically push down soft-delete filter if table has deleted column and not explicitly overridden
-        const hasDeletedClause = options?.where && typeof options.where === 'object' && (0, query_js_1.hasExplicitDeletedFilter)(options.where);
-        if (!options?.includeDeleted && !hasDeletedClause && this.schemaManager.hasColumn(tableName, 'deleted')) {
-            const safeDel = (0, sql_js_1.escapeIdentifier)('deleted');
-            whereClauses.push(`(${safeDel} IS NULL OR (${safeDel} != 1 AND ${safeDel} != 'true'))`);
-        }
-        // Push down where conditions to SQLite
-        if (options?.where && typeof options.where === 'object' && !Array.isArray(options.where)) {
-            for (const [col, filter] of Object.entries(options.where)) {
-                if (col === '$or' || col === '$and')
-                    continue;
-                const safeCol = (0, sql_js_1.escapeIdentifier)(col);
-                if (filter === null) {
-                    whereClauses.push(`${safeCol} IS NULL`);
-                }
-                else if (typeof filter === 'boolean') {
-                    whereClauses.push(`${safeCol} = ?`);
-                    params.push(filter ? 1 : 0);
-                }
-                else if (typeof filter === 'string' || typeof filter === 'number') {
-                    whereClauses.push(`${safeCol} = ?`);
-                    params.push(filter);
-                }
-                else if (typeof filter === 'object' && !Array.isArray(filter)) {
-                    const ops = filter;
-                    if (ops.$eq !== undefined) {
-                        whereClauses.push(`${safeCol} = ?`);
-                        params.push(typeof ops.$eq === 'boolean' ? (ops.$eq ? 1 : 0) : ops.$eq);
-                    }
-                    if (ops.$ne !== undefined) {
-                        whereClauses.push(`${safeCol} != ?`);
-                        params.push(typeof ops.$ne === 'boolean' ? (ops.$ne ? 1 : 0) : ops.$ne);
-                    }
-                    if (ops.$gt !== undefined) {
-                        whereClauses.push(`${safeCol} > ?`);
-                        params.push(ops.$gt);
-                    }
-                    if (ops.$gte !== undefined) {
-                        whereClauses.push(`${safeCol} >= ?`);
-                        params.push(ops.$gte);
-                    }
-                    if (ops.$lt !== undefined) {
-                        whereClauses.push(`${safeCol} < ?`);
-                        params.push(ops.$lt);
-                    }
-                    if (ops.$lte !== undefined) {
-                        whereClauses.push(`${safeCol} <= ?`);
-                        params.push(ops.$lte);
-                    }
-                    if (Array.isArray(ops.$in) && ops.$in.length > 0) {
-                        const placeholders = ops.$in.map(() => '?').join(', ');
-                        whereClauses.push(`${safeCol} IN (${placeholders})`);
-                        params.push(...ops.$in.map((v) => (typeof v === 'boolean' ? (v ? 1 : 0) : v)));
-                    }
-                    if (Array.isArray(ops.$nin) && ops.$nin.length > 0) {
-                        const placeholders = ops.$nin.map(() => '?').join(', ');
-                        whereClauses.push(`${safeCol} NOT IN (${placeholders})`);
-                        params.push(...ops.$nin.map((v) => (typeof v === 'boolean' ? (v ? 1 : 0) : v)));
-                    }
-                    if (ops.$null !== undefined) {
-                        whereClauses.push(ops.$null ? `${safeCol} IS NULL` : `${safeCol} IS NOT NULL`);
-                    }
-                    if (ops.$contains !== undefined) {
-                        whereClauses.push(`${safeCol} LIKE ?`);
-                        params.push(`%${ops.$contains}%`);
-                    }
-                    if (ops.$startsWith !== undefined) {
-                        whereClauses.push(`${safeCol} LIKE ?`);
-                        params.push(`${ops.$startsWith}%`);
-                    }
-                    if (ops.$endsWith !== undefined) {
-                        whereClauses.push(`${safeCol} LIKE ?`);
-                        params.push(`%${ops.$endsWith}`);
-                    }
-                }
+    async count(tableName, options) {
+        const qb = this.from(tableName);
+        if (options?.where)
+            qb.where(options.where);
+        return qb.count();
+    }
+    /**
+     * Executes a native SQLite SUM(column) query and returns the sum directly.
+     */
+    async sum(tableName, column, options) {
+        const qb = this.from(tableName);
+        if (options?.where)
+            qb.where(options.where);
+        return qb.sum(column);
+    }
+    /**
+     * Executes a native SQLite AVG(column) query and returns the average directly.
+     */
+    async avg(tableName, column, options) {
+        const qb = this.from(tableName);
+        if (options?.where)
+            qb.where(options.where);
+        return qb.avg(column);
+    }
+    /**
+     * Executes native multi-metric SQLite aggregation in a single query.
+     *
+     * Example:
+     * const stats = await client.aggregate('receipts', {
+     *   where: { business_id: bizId },
+     *   count: true,
+     *   sum: ['amount', 'refunded_amount'],
+     *   avg: ['amount']
+     * });
+     */
+    async aggregate(tableName, spec) {
+        const projections = [];
+        if (spec.count) {
+            projections.push('COUNT(*) AS "_count"');
+        }
+        if (spec.sum) {
+            for (const col of spec.sum) {
+                projections.push(`COALESCE(SUM("${col.replace(/"/g, '""')}"), 0) AS "sum_${col}"`);
+            }
+        }
+        if (spec.avg) {
+            for (const col of spec.avg) {
+                projections.push(`AVG("${col.replace(/"/g, '""')}") AS "avg_${col}"`);
             }
-            if (whereClauses.length > 0) {
-                sql += ` WHERE ${whereClauses.join(' AND ')}`;
+        }
+        if (spec.min) {
+            for (const col of spec.min) {
+                projections.push(`MIN("${col.replace(/"/g, '""')}") AS "min_${col}"`);
             }
         }
-        // Push down ORDER BY
-        if (options?.orderBy && typeof options.orderBy === 'string') {
-            const safeCol = (0, sql_js_1.escapeIdentifier)(options.orderBy);
-            const dir = options.order && String(options.order).toLowerCase() === 'desc' ? 'DESC' : 'ASC';
-            sql += ` ORDER BY ${safeCol} ${dir}`;
-        }
-        // Push down LIMIT & OFFSET
-        if (typeof options?.limit === 'number' && options.limit > 0) {
-            sql += ` LIMIT ?`;
-            params.push(options.limit);
-            if (typeof options.offset === 'number' && options.offset > 0) {
-                sql += ` OFFSET ?`;
-                params.push(options.offset);
+        if (spec.max) {
+            for (const col of spec.max) {
+                projections.push(`MAX("${col.replace(/"/g, '""')}") AS "max_${col}"`);
             }
         }
-        try {
-            rows = await db.execute(sql, params);
+        if (projections.length === 0) {
+            return {};
         }
-        catch (err) {
-            const msg = String(err?.message || err || '');
-            if (msg.includes('no such table') || msg.includes('no such column')) {
-                return [];
+        const qb = this.from(tableName).select(...projections);
+        if (spec.where) {
+            qb.where(spec.where);
+        }
+        const rows = await qb.execute();
+        const row = rows[0] || {};
+        const result = {};
+        if (spec.count) {
+            result.count = typeof row._count === 'number' ? row._count : Number(row._count) || 0;
+        }
+        if (spec.sum) {
+            result.sum = {};
+            for (const col of spec.sum) {
+                const val = row[`sum_${col}`];
+                result.sum[col] = typeof val === 'number' ? val : Number(val) || 0;
             }
-            // Fallback to select * if pushdown syntax differs
-            try {
-                rows = await db.execute(`SELECT * FROM ${safeTable}`);
+        }
+        if (spec.avg) {
+            result.avg = {};
+            for (const col of spec.avg) {
+                const val = row[`avg_${col}`];
+                result.avg[col] = val === null || val === undefined ? null : Number(val) || 0;
             }
-            catch {
-                return [];
+        }
+        if (spec.min) {
+            result.min = {};
+            for (const col of spec.min) {
+                result.min[col] = row[`min_${col}`];
             }
         }
-        const hasJsonConfig = Boolean(this.jsonColumns[tableName] || this.autoHydrateJSON);
-        const hydratedRows = hasJsonConfig
-            ? rows.map((r) => this.hydrateRow(tableName, r))
-            : rows;
-        return (0, query_js_1.applyQueryOptions)(hydratedRows, options);
+        if (spec.max) {
+            result.max = {};
+            for (const col of spec.max) {
+                result.max[col] = row[`max_${col}`];
+            }
+        }
+        return result;
+    }
+    async findMany(tableName, options) {
+        const rows = await this.from(tableName).applyOptions(options).execute();
+        return (0, query_js_1.applyQueryOptions)(rows, options);
     }
     /**
      * Finds a single record by primary key.
@@ -636,59 +672,10 @@ class LocalFirstClient {
      * const tenant = await client.findById('tenants', 'ten-1');
      */
     async findById(tableName, id, options) {
-        // Primary-key lookup in SQLite instead of loading the whole table into JS.
-        const safeTable = (0, sql_js_1.escapeIdentifier)(tableName);
-        const safePk = (0, sql_js_1.escapeIdentifier)(this.primaryKey);
-        try {
-            const rows = await this.db.execute(`SELECT * FROM ${safeTable} WHERE ${safePk} = ? LIMIT 1`, [id]);
-            if (!rows || rows.length === 0)
-                return null;
-            const row = this.hydrateRow(tableName, rows[0]);
-            if (!options?.includeDeleted && (0, query_js_1.isDeletedRecord)(row)) {
-                return null;
-            }
-            return row;
-        }
-        catch (err) {
-            const msg = String(err?.message || err || '');
-            if (msg.includes('no such table') || msg.includes('no such column')) {
-                return null;
-            }
-            throw err;
-        }
+        return executeFindById(this.db, tableName, id, this.primaryKey, (t, r) => this.hydrateRow(t, r), options?.includeDeleted);
     }
-    /**
-     * Finds multiple records by primary keys in a single batched SQL query.
-     * Eliminates the N-roundtrip bridge overhead of multiple findById calls.
-     * Automatically omits soft-deleted records unless includeDeleted: true.
-     *
-     * Example:
-     * const tenants = await client.findByIds('tenants', ['ten-1', 'ten-2', 'ten-3']);
-     */
     async findByIds(tableName, ids, options) {
-        if (!ids || ids.length === 0)
-            return [];
-        const safeTable = (0, sql_js_1.escapeIdentifier)(tableName);
-        const safePk = (0, sql_js_1.escapeIdentifier)(this.primaryKey);
-        const placeholders = ids.map(() => '?').join(', ');
-        try {
-            const rows = await this.db.execute(`SELECT * FROM ${safeTable} WHERE ${safePk} IN (${placeholders})`, ids);
-            if (!rows || rows.length === 0)
-                return [];
-            const hasJsonConfig = Boolean(this.jsonColumns[tableName] || this.autoHydrateJSON);
-            const hydrated = hasJsonConfig ? rows.map((r) => this.hydrateRow(tableName, r)) : rows;
-            if (!options?.includeDeleted) {
-                return hydrated.filter((r) => !(0, query_js_1.isDeletedRecord)(r));
-            }
-            return hydrated;
-        }
-        catch (err) {
-            const msg = String(err?.message || err || '');
-            if (msg.includes('no such table') || msg.includes('no such column')) {
-                return [];
-            }
-            throw err;
-        }
+        return executeFindByIds(this.db, tableName, ids, this.primaryKey, (t, r) => this.hydrateRow(t, r), options?.includeDeleted);
     }
     /**
      * Tracks an existing mutation into sync_outbox without modifying the table.

package/dist/core/index.d.ts

@@ -7,6 +7,7 @@ export * from './outbox-store.js';
 export * from './meta-store.js';
 export * from './table-manager.js';
 export * from './schema-manager.js';
+export * from './query-builder.js';
 export * from '../reactive/event-emitter.js';
 export * from '../adapters/network/index.js';
 export type { LocalDBAdapter, LocalTransaction } from '../adapters/local/index.js';

package/dist/core/index.js

@@ -24,6 +24,7 @@ __exportStar(require("./outbox-store.js"), exports);
 __exportStar(require("./meta-store.js"), exports);
 __exportStar(require("./table-manager.js"), exports);
 __exportStar(require("./schema-manager.js"), exports);
+__exportStar(require("./query-builder.js"), exports);
 __exportStar(require("../reactive/event-emitter.js"), exports);
 __exportStar(require("../adapters/network/index.js"), exports);
 __exportStar(require("../utils/logger.js"), exports);

package/dist/core/outbox-store.d.ts

@@ -21,6 +21,11 @@ export declare class OutboxStore {
      * Finds the latest pending outbox record for a given table and row.
      */
     static findPendingByRow(tx: LocalTransaction, tableName: string, rowId: string): Promise<OutboxRecord | undefined>;
+    /**
+     * Retrieves active (non-FAILED) pending outbox records indexed by `${table_name}:${row_id}`.
+     * Enables O(1) in-memory conflict lookup during delta ingestion, eliminating N+1 queries.
+     */
+    static getActivePendingMap(tx: LocalTransaction): Promise<Map<string, OutboxRecord>>;
     /**
      * Marks a batch of outbox IDs as 'PROCESSING'.
      */

package/dist/core/outbox-store.js

@@ -36,6 +36,7 @@ class OutboxStore {
         // Indexes for the hot paths: pending scans (push), per-row conflict lookups (pull),
         // and status counts (telemetry). Executed separately: many drivers prepare one statement.
         await db.execute(`CREATE INDEX IF NOT EXISTS idx_sync_outbox_status_ts ON sync_outbox (status, timestamp);`);
+        await db.execute(`CREATE INDEX IF NOT EXISTS idx_sync_outbox_status_retry ON sync_outbox (status, retry_count, timestamp);`);
         await db.execute(`CREATE INDEX IF NOT EXISTS idx_sync_outbox_row ON sync_outbox (table_name, row_id, timestamp);`);
     }
     /**
@@ -107,6 +108,30 @@ class OutboxStore {
             return undefined;
         return mapOutboxRow(rows[0]);
     }
+    /**
+     * Retrieves active (non-FAILED) pending outbox records indexed by `${table_name}:${row_id}`.
+     * Enables O(1) in-memory conflict lookup during delta ingestion, eliminating N+1 queries.
+     */
+    static async getActivePendingMap(tx) {
+        const map = new Map();
+        try {
+            const rows = await tx.execute(`SELECT * FROM sync_outbox WHERE status != 'FAILED' ORDER BY timestamp DESC`);
+            if (!rows || rows.length === 0)
+                return map;
+            for (const r of rows) {
+                const record = mapOutboxRow(r);
+                const key = `${record.tableName}:${record.rowId}`;
+                // Preserve the latest record for each table_name:row_id
+                if (!map.has(key)) {
+                    map.set(key, record);
+                }
+            }
+            return map;
+        }
+        catch {
+            return map;
+        }
+    }
     /**
      * Marks a batch of outbox IDs as 'PROCESSING'.
      */
@@ -216,8 +241,8 @@ class OutboxStore {
                 return ids.length;
             }
             else {
-                const failedRecords = await db.execute(`SELECT id FROM sync_outbox WHERE status = 'FAILED'`);
-                const count = failedRecords?.length || 0;
+                const rows = await db.execute(`SELECT COUNT(*) AS count FROM sync_outbox WHERE status = 'FAILED'`);
+                const count = Number(rows?.[0]?.count ?? (Array.isArray(rows) ? rows.length : 0));
                 if (count > 0) {
                     await db.execute(`UPDATE sync_outbox SET status = 'PENDING', retry_count = 0, last_error = NULL WHERE status = 'FAILED'`);
                 }
@@ -239,8 +264,8 @@ class OutboxStore {
                 return ids.length;
             }
             else {
-                const failedRecords = await db.execute(`SELECT id FROM sync_outbox WHERE status = 'FAILED'`);
-                const count = failedRecords?.length || 0;
+                const rows = await db.execute(`SELECT COUNT(*) AS count FROM sync_outbox WHERE status = 'FAILED'`);
+                const count = Number(rows?.[0]?.count ?? (Array.isArray(rows) ? rows.length : 0));
                 if (count > 0) {
                     await db.execute(`DELETE FROM sync_outbox WHERE status = 'FAILED'`);
                 }