@peers-app/peers-sdk 0.8.2 → 0.8.4

package/dist/data/change-tracking.d.ts

@@ -106,6 +106,40 @@ export declare class ChangeTrackingTable extends SQLDataSource<IChangeRecord> {
      * Override to serialize value field to JSON string
      */
     update(record: IChangeRecord): Promise<IChangeRecord>;
+    /**
+     * Synchronous insert for use within transactions.
+     * Table must be initialized before calling this method.
+     */
+    insertSync(record: IChangeRecord): IChangeRecord;
+    /**
+     * Synchronous update for use within transactions.
+     * Table must be initialized before calling this method.
+     */
+    updateSync(record: IChangeRecord): IChangeRecord;
+    /**
+     * Bulk insert multiple change records in a single transaction.
+     * Much faster than inserting records one at a time.
+     * All inserts succeed or all fail together.
+     */
+    bulkInsert(records: IChangeRecord[]): Promise<IChangeRecord[]>;
+    /**
+     * Synchronous batch mark superseded for use within transactions.
+     * Table must be initialized before calling this method.
+     */
+    batchMarkSupersededSync(updates: Array<{
+        changeId: string;
+        supersededAt: number;
+    }>): void;
+    /**
+     * Synchronous delete changes for use within transactions.
+     * Table must be initialized before calling this method.
+     */
+    deleteChangesSync(changeIds: string[]): void;
+    /**
+     * Synchronous delete superseded changes for use within transactions.
+     * Table must be initialized before calling this method.
+     */
+    deleteSupersededChangesOlderThanSync(tableName: string, beforeTimestamp: number): void;
     /**
      * Deserialize the value field if it's a JSON string
      * For path "/" (full object changes), use fromJSONString to handle special types

package/dist/data/change-tracking.js

@@ -206,6 +206,92 @@ class ChangeTrackingTable extends orm_1.SQLDataSource {
         }
         return super.update(record);
     }
+    //================================================================================================
+    // Synchronous methods for use within transactions
+    //================================================================================================
+    /**
+     * Synchronous insert for use within transactions.
+     * Table must be initialized before calling this method.
+     */
+    insertSync(record) {
+        if (record.value !== undefined) {
+            record = { ...record, value: (0, serial_json_1.toJSONString)(record.value) };
+        }
+        return super.insertSync(record);
+    }
+    /**
+     * Synchronous update for use within transactions.
+     * Table must be initialized before calling this method.
+     */
+    updateSync(record) {
+        if (record.value !== undefined) {
+            record = { ...record, value: (0, serial_json_1.toJSONString)(record.value) };
+        }
+        return super.updateSync(record);
+    }
+    /**
+     * Bulk insert multiple change records in a single transaction.
+     * Much faster than inserting records one at a time.
+     * All inserts succeed or all fail together.
+     */
+    async bulkInsert(records) {
+        if (records.length === 0)
+            return [];
+        await this.initTable();
+        if (!this.db.runInTransaction) {
+            // Fallback for databases that don't support transactions
+            const results = [];
+            for (const record of records) {
+                results.push(await this.insert(record));
+            }
+            return results;
+        }
+        return this.db.runInTransaction(() => {
+            return records.map(record => this.insertSync(record));
+        });
+    }
+    /**
+     * Synchronous batch mark superseded for use within transactions.
+     * Table must be initialized before calling this method.
+     */
+    batchMarkSupersededSync(updates) {
+        if (updates.length === 0)
+            return;
+        // Build a CASE statement for bulk update
+        const changeIds = updates.map(u => u.changeId);
+        const caseStatement = updates.map(u => `WHEN '${u.changeId}' THEN ${u.supersededAt}`).join('\n        ');
+        this.db.execSync(`
+      UPDATE "${this.tableName}"
+      SET supersededAt = CASE changeId
+        ${caseStatement}
+      END
+      WHERE changeId IN (${changeIds.map(() => '?').join(',')})
+    `, changeIds);
+    }
+    /**
+     * Synchronous delete changes for use within transactions.
+     * Table must be initialized before calling this method.
+     */
+    deleteChangesSync(changeIds) {
+        if (changeIds.length === 0)
+            return;
+        this.db.execSync(`
+      DELETE FROM "${this.tableName}"
+      WHERE changeId IN (${changeIds.map(c => "?").join()})
+    `, changeIds);
+    }
+    /**
+     * Synchronous delete superseded changes for use within transactions.
+     * Table must be initialized before calling this method.
+     */
+    deleteSupersededChangesOlderThanSync(tableName, beforeTimestamp) {
+        this.db.execSync(`
+      DELETE FROM "${this.tableName}"
+      WHERE tableName = ?
+        AND supersededAt IS NOT NULL
+        AND supersededAt < ?
+    `, [tableName, beforeTimestamp]);
+    }
     /**
      * Deserialize the value field if it's a JSON string
      * For path "/" (full object changes), use fromJSONString to handle special types

package/dist/data/files/files.js

@@ -129,3 +129,27 @@ rpc_types_1.rpcServerCalls.getFileContents = async (fileId, encoding = 'utf8') =
     }
     return Buffer.from(data).toString(encoding);
 };
+// Get file contents as base64 - useful for binary data like images
+rpc_types_1.rpcServerCalls.getFileContentsBase64 = async (fileId) => {
+    const data = await Files().getFileContents(fileId);
+    if (data === null) {
+        throw new Error(`File not found: ${fileId}`);
+    }
+    return Buffer.from(data).toString('base64');
+};
+// Save a file from the UI - data should be base64 encoded for binary files
+rpc_types_1.rpcServerCalls.saveFile = async (input) => {
+    const fileId = input.fileId || (0, utils_1.newid)();
+    const encoding = input.encoding || 'utf8';
+    // Convert data to Uint8Array based on encoding
+    const dataBuffer = encoding === 'base64'
+        ? Buffer.from(input.data, 'base64')
+        : Buffer.from(input.data, 'utf8');
+    const file = await Files().saveFile({
+        fileId,
+        name: input.name,
+        fileSize: dataBuffer.length,
+        mimeType: input.mimeType,
+    }, new Uint8Array(dataBuffer));
+    return file;
+};

package/dist/data/orm/sql-db.d.ts

@@ -3,4 +3,19 @@ export interface ISqlDb {
     all: (sql: string, params?: any) => Promise<any[]>;
     exec: (sql: string, params?: any) => Promise<void>;
     close: () => Promise<void>;
+    execSync?: (sql: string, params?: any) => void;
+    getSync?: (sql: string, params?: any) => any;
+    allSync?: (sql: string, params?: any) => any[];
+    /**
+     * Execute multiple operations in a single SQLite transaction.
+     * All operations within the callback are committed atomically.
+     * If any operation throws, the entire transaction is rolled back.
+     *
+     * Note: The callback must be synchronous since better-sqlite3 transactions are synchronous.
+     * Use execSync/getSync/allSync within the transaction callback.
+     *
+     * @param fn - Synchronous function containing database operations
+     * @returns The return value of the callback function
+     */
+    runInTransaction?: <R>(fn: () => R) => R;
 }

package/dist/data/orm/sql.data-source.d.ts

@@ -32,6 +32,44 @@ export declare class SQLDataSource<T extends {
     dropTableIfExists(): Promise<void>;
     clearTable(): Promise<void>;
     initRecord(data?: Partial<T>): T;
+    /**
+     * Synchronous insert for use within transactions.
+     * Table must be initialized before calling this method.
+     */
+    insertSync(record: T): T;
+    /**
+     * Synchronous update for use within transactions.
+     * Table must be initialized before calling this method.
+     */
+    updateSync(record: T): T;
+    /**
+     * Synchronous delete for use within transactions.
+     * Table must be initialized before calling this method.
+     */
+    deleteSync(idOrRecord: string | T): void;
+    /**
+     * Synchronous save (insert or update) for use within transactions.
+     * Table must be initialized before calling this method.
+     */
+    saveSync(record: T): T;
+    /**
+     * Insert multiple records in a single transaction.
+     * Much faster than inserting records one at a time.
+     * All inserts succeed or all fail together.
+     */
+    bulkInsert(records: T[]): Promise<T[]>;
+    /**
+     * Delete multiple records by ID in a single transaction.
+     * Much faster than deleting records one at a time.
+     * All deletes succeed or all fail together.
+     */
+    bulkDelete(ids: string[]): Promise<void>;
+    /**
+     * Save (insert or update) multiple records in a single transaction.
+     * Much faster than saving records one at a time.
+     * All saves succeed or all fail together.
+     */
+    bulkSave(records: T[]): Promise<T[]>;
 }
 export declare function jsValueToSqlValue(value: any, escapeQuote?: boolean): any;
 export declare function sqlValueToJsValue(value: any, fieldType: FieldType, isArray: boolean): any;

package/dist/data/orm/sql.data-source.js

@@ -312,6 +312,152 @@ class SQLDataSource {
         }
         return { ...defaults, ...data };
     }
+    //================================================================================================
+    // Synchronous methods for use within transactions
+    //================================================================================================
+    /**
+     * Synchronous insert for use within transactions.
+     * Table must be initialized before calling this method.
+     */
+    insertSync(record) {
+        if (!record[this.metaData.primaryKeyName]) {
+            // @ts-expect-error - need to figure out how to get typescript to understand what's going on here
+            record[this.metaData.primaryKeyName] = (0, utils_1.newid)();
+        }
+        // validate data
+        try {
+            this.schema.parse(record);
+        }
+        catch (e) {
+            throw new Error(`Validation on insert failed for ${this.tableName}: ${e}`);
+        }
+        const fields = this.metaData.fields.map(field => `"${field.name}"`).join(', ');
+        const values = this.metaData.fields.map(field => jsValueToSqlValue(record[field.name]));
+        const placeholders = values.map(v => '?').join(', ');
+        const sql = `INSERT INTO "${this.tableName}"(${fields}) VALUES(${placeholders})`;
+        this.db.execSync(sql, values);
+        return record;
+    }
+    /**
+     * Synchronous update for use within transactions.
+     * Table must be initialized before calling this method.
+     */
+    updateSync(record) {
+        if (!record[this.metaData.primaryKeyName]) {
+            // @ts-expect-error - need to figure out how to get typescript to understand what's going on here
+            record[this.metaData.primaryKeyName] = (0, utils_1.newid)();
+        }
+        // validate data
+        this.schema.parse(record);
+        const primaryKey = record[this.metaData.primaryKeyName];
+        const fields = this.metaData.fields.map(field => {
+            if (field.name === this.metaData.primaryKeyName)
+                return;
+            return `"${field.name}" = ?`;
+        }).filter(v => v !== undefined).join(',\n');
+        const values = this.metaData.fields.map(field => {
+            if (field.name === this.metaData.primaryKeyName)
+                return;
+            return jsValueToSqlValue(record[field.name]);
+        }).filter(v => v !== undefined);
+        const sql = [
+            `UPDATE "${this.tableName}"`,
+            `SET ${fields}`,
+            `WHERE "${this.metaData.primaryKeyName}" = ?`,
+        ].join('\n');
+        this.db.execSync(sql, [...values, primaryKey]);
+        return record;
+    }
+    /**
+     * Synchronous delete for use within transactions.
+     * Table must be initialized before calling this method.
+     */
+    deleteSync(idOrRecord) {
+        const primaryKey = typeof idOrRecord === 'string' ? idOrRecord : idOrRecord[this.metaData.primaryKeyName];
+        const sql = `DELETE FROM "${this.tableName}" WHERE "${this.metaData.primaryKeyName}" = ?`;
+        this.db.execSync(sql, [primaryKey]);
+    }
+    /**
+     * Synchronous save (insert or update) for use within transactions.
+     * Table must be initialized before calling this method.
+     */
+    saveSync(record) {
+        const primaryKey = record[this.metaData.primaryKeyName];
+        if (primaryKey) {
+            const existingRecord = this.db.getSync(`SELECT "${this.metaData.primaryKeyName}" FROM "${this.tableName}" WHERE ${this.metaData.primaryKeyName} = ?`, [primaryKey]);
+            if (existingRecord) {
+                return this.updateSync(record);
+            }
+        }
+        return this.insertSync(record);
+    }
+    //================================================================================================
+    // Bulk operations (use transactions for atomicity and performance)
+    //================================================================================================
+    /**
+     * Insert multiple records in a single transaction.
+     * Much faster than inserting records one at a time.
+     * All inserts succeed or all fail together.
+     */
+    async bulkInsert(records) {
+        if (records.length === 0)
+            return [];
+        await this.initTable();
+        if (!this.db.runInTransaction) {
+            // Fallback for databases that don't support transactions
+            const results = [];
+            for (const record of records) {
+                results.push(await this.insert(record));
+            }
+            return results;
+        }
+        return this.db.runInTransaction(() => {
+            return records.map(record => this.insertSync(record));
+        });
+    }
+    /**
+     * Delete multiple records by ID in a single transaction.
+     * Much faster than deleting records one at a time.
+     * All deletes succeed or all fail together.
+     */
+    async bulkDelete(ids) {
+        if (ids.length === 0)
+            return;
+        await this.initTable();
+        if (!this.db.runInTransaction) {
+            // Fallback for databases that don't support transactions
+            for (const id of ids) {
+                await this.delete(id);
+            }
+            return;
+        }
+        this.db.runInTransaction(() => {
+            for (const id of ids) {
+                this.deleteSync(id);
+            }
+        });
+    }
+    /**
+     * Save (insert or update) multiple records in a single transaction.
+     * Much faster than saving records one at a time.
+     * All saves succeed or all fail together.
+     */
+    async bulkSave(records) {
+        if (records.length === 0)
+            return [];
+        await this.initTable();
+        if (!this.db.runInTransaction) {
+            // Fallback for databases that don't support transactions
+            const results = [];
+            for (const record of records) {
+                results.push(await this.save(record));
+            }
+            return results;
+        }
+        return this.db.runInTransaction(() => {
+            return records.map(record => this.saveSync(record));
+        });
+    }
 }
 exports.SQLDataSource = SQLDataSource;
 function jsValueToSqlValue(value, escapeQuote = false) {

package/dist/device/binary-peer-connection.js

@@ -280,7 +280,7 @@ function handleRPCMessage(bytes, handlers, callbacks, sendRPCData) {
     if (message.type === 'call') {
         const handler = handlers[message.eventName];
         if (!handler) {
-            console.error(`No handler for event: ${message.eventName}`);
+            console.warn(`No handler for event: ${message.eventName}`);
             return;
         }
         try {

package/dist/rpc-types.d.ts

@@ -18,6 +18,20 @@ export declare const rpcServerCalls: {
     encryptData: ((value: string, groupId?: string) => Promise<string>);
     tableMethodCall: ((dataContextId: string, tableName: string, methodName: string, ...args: any[]) => Promise<any>);
     getFileContents: ((fileId: string, encoding?: BufferEncoding) => Promise<string>);
+    getFileContentsBase64: ((fileId: string) => Promise<string>);
+    saveFile: ((input: {
+        name: string;
+        mimeType?: string;
+        data: string;
+        encoding?: "utf8" | "base64";
+        fileId?: string;
+    }) => Promise<{
+        fileId: string;
+        name: string;
+        fileSize: number;
+        fileHash: string;
+        mimeType?: string;
+    }>);
     injectUIBundle: ((uiBundleFileId: string) => Promise<void>);
     resetAllDeviceSyncInfo: (() => Promise<void>);
     importGroupShare: ((groupShareJson: string) => Promise<string>);

package/dist/rpc-types.js

@@ -19,6 +19,10 @@ exports.rpcServerCalls = {
     tableMethodCall: rpcStub('tableMethodCall'),
     // TODO lock this down so not all code can get any file contents
     getFileContents: rpcStub('getFileContents'),
+    // Get file contents as base64 - useful for binary data like images
+    getFileContentsBase64: rpcStub('getFileContentsBase64'),
+    // Save a file from the UI - data should be base64 encoded for binary files
+    saveFile: rpcStub('saveFile'),
     // Inject UI bundle directly into WebView (bypasses slow postMessage for large strings)
     injectUIBundle: rpcStub('injectUIBundle'),
     resetAllDeviceSyncInfo: rpcStub('resetAllDeviceSyncInfo'),

package/dist/types/peer-device.js

@@ -6,6 +6,7 @@ exports.PeerDeviceConsts = Object.freeze({
     MAX_CONNECTIONS: 30,
     RESYNC_INTERVAL: 300_000, // play with this to find the right balance
     NOTIFY_CHANGE_DELAY: 100,
+    // CHANGES_PAGE_SIZE: 2_000,
     CHANGES_PAGE_SIZE: 100,
     RETRY_COUNT: 2,
     TIMEOUT_MIN: 3_000,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peers-app/peers-sdk",
-  "version": "0.8.2",
+  "version": "0.8.4",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/peers-app/peers-sdk.git"