local-lite 0.0.12 → 0.0.14

package/dist/utils/portability.js

@@ -0,0 +1,276 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCsv = parseCsv;
+exports.exportTablesToJson = exportTablesToJson;
+exports.importTablesFromJson = importTablesFromJson;
+exports.exportTableToCsv = exportTableToCsv;
+exports.importTableFromCsv = importTableFromCsv;
+const sql_js_1 = require("./sql.js");
+/**
+ * Escapes a single CSV cell value according to RFC-4180.
+ */
+function escapeCsvValue(val, delimiter) {
+    if (val === null || val === undefined) {
+        return '';
+    }
+    let str;
+    if (typeof val === 'object') {
+        str = JSON.stringify(val);
+    }
+    else {
+        str = String(val);
+    }
+    // Quote if contains delimiter, double quote, or newlines
+    if (str.includes(delimiter) || str.includes('"') || str.includes('\n') || str.includes('\r')) {
+        return `"${str.replace(/"/g, '""')}"`;
+    }
+    return str;
+}
+/**
+ * Robust RFC-4180 CSV parser supporting multiline fields and escaped quotes.
+ */
+function parseCsv(text, delimiter = ',') {
+    const rows = [];
+    let currentRow = [];
+    let currentVal = '';
+    let inQuotes = false;
+    let i = 0;
+    while (i < text.length) {
+        const char = text[i];
+        if (inQuotes) {
+            if (char === '"') {
+                if (i + 1 < text.length && text[i + 1] === '"') {
+                    // Escaped quote
+                    currentVal += '"';
+                    i += 2;
+                    continue;
+                }
+                else {
+                    // End quote
+                    inQuotes = false;
+                    i++;
+                    continue;
+                }
+            }
+            else {
+                currentVal += char;
+                i++;
+                continue;
+            }
+        }
+        if (char === '"') {
+            inQuotes = true;
+            i++;
+            continue;
+        }
+        if (char === delimiter) {
+            currentRow.push(currentVal);
+            currentVal = '';
+            i++;
+            continue;
+        }
+        if (char === '\r') {
+            if (i + 1 < text.length && text[i + 1] === '\n') {
+                i++;
+            }
+            currentRow.push(currentVal);
+            currentVal = '';
+            rows.push(currentRow);
+            currentRow = [];
+            i++;
+            continue;
+        }
+        if (char === '\n') {
+            currentRow.push(currentVal);
+            currentVal = '';
+            rows.push(currentRow);
+            currentRow = [];
+            i++;
+            continue;
+        }
+        currentVal += char;
+        i++;
+    }
+    if (currentVal.length > 0 || currentRow.length > 0) {
+        currentRow.push(currentVal);
+        rows.push(currentRow);
+    }
+    return rows;
+}
+/**
+ * Exports SQLite tables to a structured JSON string.
+ */
+async function exportTablesToJson(client, tables, options = {}) {
+    const targetTables = tables && tables.length > 0 ? tables : client.tables;
+    const result = {
+        version: 1,
+        exportedAt: new Date().toISOString(),
+        tables: {},
+    };
+    for (const table of targetTables) {
+        try {
+            const rows = await client.findMany(table);
+            result.tables[table] = rows;
+        }
+        catch {
+            result.tables[table] = [];
+        }
+    }
+    return JSON.stringify(result, null, options.pretty ? 2 : undefined);
+}
+/**
+ * Imports tables from a JSON export string into the database.
+ */
+async function importTablesFromJson(client, jsonString, options = {}) {
+    let parsed;
+    try {
+        parsed = JSON.parse(jsonString);
+    }
+    catch (err) {
+        throw new Error(`Invalid JSON export format: ${err.message}`);
+    }
+    if (!parsed || typeof parsed.tables !== 'object') {
+        throw new Error('Invalid JSON export format: missing tables object.');
+    }
+    const mode = options.mode ?? 'merge';
+    const skipOutbox = options.skipOutbox ?? false;
+    const filterTables = options.tables ? new Set(options.tables) : null;
+    const pk = client.getPrimaryKey();
+    const importedTables = [];
+    const rowCounts = {};
+    for (const [table, rows] of Object.entries(parsed.tables)) {
+        if (filterTables && !filterTables.has(table)) {
+            continue;
+        }
+        if (!Array.isArray(rows)) {
+            continue;
+        }
+        importedTables.push(table);
+        rowCounts[table] = 0;
+        await client.transaction(async (tx) => {
+            if (mode === 'replace') {
+                const safeTable = (0, sql_js_1.escapeIdentifier)(table);
+                await tx.query(`DELETE FROM ${safeTable}`);
+            }
+            for (const row of rows) {
+                if (!row || typeof row !== 'object')
+                    continue;
+                const id = String(row[pk] ?? row.id ?? row.ID);
+                if (!id)
+                    continue;
+                // Upsert row
+                await tx.mutate(table, id, 'INSERT', row, { primaryKey: pk, skipOutbox });
+                rowCounts[table]++;
+            }
+        });
+    }
+    return { tables: importedTables, rowCounts };
+}
+/**
+ * Exports a single SQLite table to an RFC-4180 CSV string.
+ */
+async function exportTableToCsv(client, tableName, options = {}) {
+    const delimiter = options.delimiter ?? ',';
+    const includeHeader = options.includeHeader ?? true;
+    const rows = await client.findMany(tableName);
+    if (rows.length === 0) {
+        if (options.columns && includeHeader) {
+            return options.columns.map(c => escapeCsvValue(c, delimiter)).join(delimiter);
+        }
+        return '';
+    }
+    // Determine columns
+    const columns = options.columns && options.columns.length > 0
+        ? options.columns
+        : Object.keys(rows[0]);
+    const lines = [];
+    if (includeHeader) {
+        lines.push(columns.map(c => escapeCsvValue(c, delimiter)).join(delimiter));
+    }
+    for (const row of rows) {
+        const values = columns.map(col => escapeCsvValue(row[col], delimiter));
+        lines.push(values.join(delimiter));
+    }
+    return lines.join('\n');
+}
+/**
+ * Imports an RFC-4180 CSV string into a SQLite table.
+ */
+async function importTableFromCsv(client, tableName, csvString, options = {}) {
+    if (!csvString || !csvString.trim()) {
+        return { rowCount: 0 };
+    }
+    const delimiter = options.delimiter ?? ',';
+    const hasHeader = options.hasHeader ?? true;
+    const mode = options.mode ?? 'merge';
+    const skipOutbox = options.skipOutbox ?? false;
+    const pk = client.getPrimaryKey();
+    const parsedRows = parseCsv(csvString.trim(), delimiter);
+    if (parsedRows.length === 0) {
+        return { rowCount: 0 };
+    }
+    let columns;
+    let dataRows;
+    if (hasHeader) {
+        columns = parsedRows[0].map(c => c.trim());
+        dataRows = parsedRows.slice(1);
+    }
+    else {
+        if (!options.columns || options.columns.length === 0) {
+            throw new Error('Explicit columns must be specified when CSV has no header.');
+        }
+        columns = options.columns;
+        dataRows = parsedRows;
+    }
+    let importedCount = 0;
+    await client.transaction(async (tx) => {
+        if (mode === 'replace') {
+            const safeTable = (0, sql_js_1.escapeIdentifier)(tableName);
+            await tx.query(`DELETE FROM ${safeTable}`);
+        }
+        for (const rowVals of dataRows) {
+            if (rowVals.length === 0 || (rowVals.length === 1 && !rowVals[0].trim())) {
+                continue;
+            }
+            const payload = {};
+            for (let i = 0; i < columns.length; i++) {
+                const col = columns[i];
+                const raw = rowVals[i];
+                if (raw === undefined || raw === '') {
+                    payload[col] = null;
+                    continue;
+                }
+                // Auto-detect JSON, boolean, and numeric types
+                const trimmed = raw.trim();
+                if ((trimmed.startsWith('{') && trimmed.endsWith('}')) ||
+                    (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
+                    try {
+                        payload[col] = JSON.parse(trimmed);
+                        continue;
+                    }
+                    catch {
+                        // Keep as string
+                    }
+                }
+                if (trimmed.toLowerCase() === 'true') {
+                    payload[col] = 1;
+                }
+                else if (trimmed.toLowerCase() === 'false') {
+                    payload[col] = 0;
+                }
+                else if (!isNaN(Number(trimmed)) && trimmed !== '') {
+                    payload[col] = Number(trimmed);
+                }
+                else {
+                    payload[col] = raw;
+                }
+            }
+            const id = String(payload[pk] ?? payload.id);
+            if (!id)
+                continue;
+            await tx.mutate(tableName, id, 'INSERT', payload, { primaryKey: pk, skipOutbox });
+            importedCount++;
+        }
+    });
+    return { rowCount: importedCount };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "local-lite",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "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",