@peers-app/peers-sdk 0.9.0 → 0.9.2

package/dist/data/orm/table-container.d.ts

@@ -2,13 +2,12 @@ import { z } from 'zod';
 import { ITableMetaData } from './types';
 import { Table } from './table';
 import { ITableDefinition, TableFactory, TableConstructor } from './table-definitions.type';
-import type { ITableDefinitionRecord } from '../table-definitions-table';
 /**
  * Compare two table definition versions and decide whether to update.
- * @returns 'update' to proceed, 'skip' to keep existing, 'update-warn-unversioned' to proceed with a warning,
- *          'skip-warn-conflict' to skip with a warning about mismatched definitions at the same version.
+ * @returns 'update' when incoming version is strictly newer, 'skip' otherwise.
+ * Logs an error if same version but different definitions (caller should bump versionNumber).
  */
-export declare function checkVersionedUpdate(existingVersion: number, incomingVersion: number, existingMetaData: any, incomingMetaData: any): 'update' | 'skip' | 'update-warn-unversioned' | 'skip-warn-conflict';
+export declare function checkVersionedUpdate(existingVersion: number, incomingVersion: number, existingMetaData: ITableMetaData, incomingMetaData: ITableMetaData): 'update' | 'skip';
 export declare class TableContainer {
     readonly tableFactory: TableFactory;
     readonly groupId?: string | undefined;
@@ -17,6 +16,7 @@ export declare class TableContainer {
     private savingDefinitions;
     private readonly fallbackDefinitions;
     private fallbackInstances;
+    private fallbackSubscribed;
     constructor(tableFactory: TableFactory, groupId?: string | undefined);
     registerTableDefinition<T extends {
         [key: string]: any;
@@ -45,12 +45,22 @@ export declare class TableContainer {
     getTableByName<T extends {
         [key: string]: any;
     }>(tableName: string): Table<T>;
+    /**
+     * Lazily look up a fallback table by name from the TableDefinitions system table.
+     * On first call, subscribes to TableDefinitions.dataChanged so future synced
+     * records are auto-registered (and removed on delete).
+     * Returns the table instance if found, or null if no definition exists.
+     */
+    getFallbackTable(tableName: string): Promise<Table<any> | null>;
     /**
      * Register a table definition from a synced TableDefinitions record.
      * These go into the fallback tier (no custom constructor) so they never
      * block full code-defined instances from being created later.
+     *
+     * Called automatically by the getFallbackTable dataChanged subscription.
+     * External code should not need to call this directly.
      */
-    registerFromTableDefinitionRecord(record: ITableDefinitionRecord): void;
+    private registerFromTableDefinitionRecord;
     /**
      * This ensures all tables have been new'ed up and then returns the entire list of them.
      * Full (code-defined) instances take precedence over fallback (synced-definition) instances.

package/dist/data/orm/table-container.js

@@ -9,23 +9,36 @@ const utils_1 = require("../../utils");
 const rpc_types_1 = require("../../rpc-types");
 /**
  * Compare two table definition versions and decide whether to update.
- * @returns 'update' to proceed, 'skip' to keep existing, 'update-warn-unversioned' to proceed with a warning,
- *          'skip-warn-conflict' to skip with a warning about mismatched definitions at the same version.
+ * @returns 'update' when incoming version is strictly newer, 'skip' otherwise.
+ * Logs an error if same version but different definitions (caller should bump versionNumber).
  */
 function checkVersionedUpdate(existingVersion, incomingVersion, existingMetaData, incomingMetaData) {
-    if (existingVersion > incomingVersion) {
-        return 'skip';
+    if (existingVersion < incomingVersion) {
+        return 'update';
     }
     if (existingVersion === incomingVersion) {
-        if (!incomingVersion) {
-            return 'update-warn-unversioned';
+        const sameDefinition = (0, utils_1.simpleObjectHash)(existingMetaData) === (0, utils_1.simpleObjectHash)(incomingMetaData);
+        if (!sameDefinition) {
+            const tableName = (0, utils_1.getFullTableName)(existingMetaData);
+            console.error(`Table "${tableName}" has two different definitions with the same versionNumber (${existingMetaData.versionNumber}). Skipping update. Increment versionNumber when changing table definitions.`);
         }
-        if ((0, utils_1.simpleObjectHash)(existingMetaData) !== (0, utils_1.simpleObjectHash)(incomingMetaData)) {
-            return 'skip-warn-conflict';
-        }
-        return 'skip'; // same version, same definition
     }
-    return 'update'; // incoming is strictly newer
+    return 'skip';
+    // commenting this out for now, it's too likely to end up in an infinite loop
+    // if (existingVersion > incomingVersion) {
+    //   return 'skip';
+    // }
+    // if (existingVersion === incomingVersion) {
+    //   const sameDefinition = simpleObjectHash(existingMetaData) === simpleObjectHash(incomingMetaData);
+    //   if (sameDefinition) {
+    //     return 'skip'; // same version, same definition — nothing to do
+    //   }
+    //   if (!incomingVersion) {
+    //     return 'update-warn-unversioned';
+    //   }
+    //   return 'skip-warn-conflict';
+    // }
+    // return 'update'; // incoming is strictly newer
 }
 class TableContainer {
     tableFactory;
@@ -37,6 +50,7 @@ class TableContainer {
     // These live in a separate map so they never block full instances from being created.
     fallbackDefinitions = {};
     fallbackInstances = {};
+    fallbackSubscribed = false;
     constructor(tableFactory, groupId) {
         this.tableFactory = tableFactory;
         this.groupId = groupId;
@@ -53,6 +67,10 @@ class TableContainer {
             return;
         }
         if (existing && opts?.overwrite) {
+            const existingDef = this.tableDefinitions[tableName];
+            if (existingDef && (0, utils_1.simpleObjectHash)(existingDef.metaData) === (0, utils_1.simpleObjectHash)(tableDefinition.metaData)) {
+                return; // definition hasn't changed, no need to overwrite
+            }
             console.warn(`Overwriting table definition for ${tableName}.`);
             delete this.tableInstances[tableName];
         }
@@ -124,14 +142,7 @@ class TableContainer {
             tableDefsTable.get(metaData.tableId).then(existing => {
                 if (existing) {
                     const result = checkVersionedUpdate(existing.versionNumber, record.versionNumber, existing.metaData, record.metaData);
-                    if (result === 'update-warn-unversioned') {
-                        console.error(`Table "${tableName}" has no versionNumber. Saving anyway but this could lose data. Set metaData.versionNumber to fix this.`);
-                    }
-                    else if (result === 'skip-warn-conflict') {
-                        console.error(`Table "${tableName}" has two different definitions with the same versionNumber (${record.versionNumber}). Skipping update. Increment versionNumber when changing table definitions.`);
-                        return;
-                    }
-                    else if (result === 'skip') {
+                    if (result === 'skip') {
                         return;
                     }
                 }
@@ -172,10 +183,56 @@ class TableContainer {
         }
         throw new Error(`There is no instantiated table or registered definition for ${tableName}`);
     }
+    /**
+     * Lazily look up a fallback table by name from the TableDefinitions system table.
+     * On first call, subscribes to TableDefinitions.dataChanged so future synced
+     * records are auto-registered (and removed on delete).
+     * Returns the table instance if found, or null if no definition exists.
+     */
+    async getFallbackTable(tableName) {
+        // Already have an instance or definition from a previous lookup
+        if (this.fallbackInstances[tableName])
+            return this.fallbackInstances[tableName];
+        if (this.fallbackDefinitions[tableName]) {
+            const { metaData, schema } = this.fallbackDefinitions[tableName];
+            const table = this.tableFactory(metaData, schema ?? (0, types_1.fieldsToSchema)(metaData.fields), table_1.Table, this.groupId);
+            this.fallbackInstances[tableName] = table;
+            return table;
+        }
+        const tableDefsTable = this.tableInstances['TableDefinitions'];
+        if (!tableDefsTable)
+            return null;
+        // Subscribe once so future changes are picked up automatically
+        if (!this.fallbackSubscribed) {
+            this.fallbackSubscribed = true;
+            tableDefsTable.dataChanged.subscribe((event) => {
+                if (event.op === 'delete') {
+                    const md = event.dataObject?.metaData;
+                    if (md) {
+                        const name = (0, utils_1.getFullTableName)(md);
+                        delete this.fallbackDefinitions[name];
+                        delete this.fallbackInstances[name];
+                    }
+                    return;
+                }
+                this.registerFromTableDefinitionRecord(event.dataObject);
+            });
+        }
+        // Query for this specific table definition
+        const record = await tableDefsTable.findOne({ name: tableName });
+        if (!record)
+            return null;
+        this.registerFromTableDefinitionRecord(record);
+        // Now instantiate via getTableByName which checks fallbackDefinitions
+        return this.getTableByName(tableName);
+    }
     /**
      * Register a table definition from a synced TableDefinitions record.
      * These go into the fallback tier (no custom constructor) so they never
      * block full code-defined instances from being created later.
+     *
+     * Called automatically by the getFallbackTable dataChanged subscription.
+     * External code should not need to call this directly.
      */
     registerFromTableDefinitionRecord(record) {
         const metaData = record.metaData;
@@ -194,14 +251,7 @@ class TableContainer {
             const existingVersion = existing.metaData.versionNumber ?? 0;
             const incomingVersion = record.versionNumber ?? 0;
             const result = checkVersionedUpdate(existingVersion, incomingVersion, existing.metaData, metaData);
-            if (result === 'update-warn-unversioned') {
-                console.error(`Table "${tableName}" has no versionNumber. Saving anyway but this could lose data. Set metaData.versionNumber to fix this.`);
-            }
-            else if (result === 'skip-warn-conflict') {
-                console.error(`Table "${tableName}" has two different definitions with the same versionNumber (${incomingVersion}). Skipping update. Increment versionNumber when changing table definitions.`);
-                return;
-            }
-            else if (result === 'skip') {
+            if (result === 'skip') {
                 return;
             }
             // Remove old fallback instance so it gets re-created with the new schema

package/dist/data/orm/table-container.test.js

@@ -23,14 +23,17 @@ describe('checkVersionedUpdate', () => {
     it('should skip when same non-zero version and same definition with different key order', () => {
         expect((0, table_container_1.checkVersionedUpdate)(100, 100, metaA, metaAReordered)).toBe('skip');
     });
-    it('should warn conflict when same non-zero version but different definitions', () => {
-        expect((0, table_container_1.checkVersionedUpdate)(100, 100, metaA, metaB)).toBe('skip-warn-conflict');
+    it('should skip when same non-zero version but different definitions', () => {
+        expect((0, table_container_1.checkVersionedUpdate)(100, 100, metaA, metaB)).toBe('skip');
     });
-    it('should warn unversioned when both versions are 0', () => {
-        expect((0, table_container_1.checkVersionedUpdate)(0, 0, metaA, metaA)).toBe('update-warn-unversioned');
+    it('should skip when both versions are 0 and definitions are the same', () => {
+        expect((0, table_container_1.checkVersionedUpdate)(0, 0, metaA, metaA)).toBe('skip');
     });
-    it('should warn unversioned when both versions are 0 even with different definitions', () => {
-        expect((0, table_container_1.checkVersionedUpdate)(0, 0, metaA, metaB)).toBe('update-warn-unversioned');
+    it('should skip when both versions are 0 and definitions are the same with different key order', () => {
+        expect((0, table_container_1.checkVersionedUpdate)(0, 0, metaA, metaAReordered)).toBe('skip');
+    });
+    it('should skip when both versions are 0 and definitions differ', () => {
+        expect((0, table_container_1.checkVersionedUpdate)(0, 0, metaA, metaB)).toBe('skip');
     });
     it('should update when incoming is newer regardless of definition content', () => {
         expect((0, table_container_1.checkVersionedUpdate)(50, 100, metaA, metaA)).toBe('update');
@@ -86,6 +89,7 @@ describe('Tiered table instances', () => {
     it('bare-bones fallback instance should NOT block full instance with custom constructor', () => {
         const { container, testMetaData, testSchema, defRecord } = createTestHarness();
         // Simulate sync: register from a TableDefinitionRecord (no custom constructor)
+        // (method is private — normally auto-called via dataChanged subscription)
         container.registerFromTableDefinitionRecord(defRecord);
         // Sync code calls getTableByName to get a working instance
         const fallbackTable = container.getTableByName(defRecord.name);
@@ -99,7 +103,7 @@ describe('Tiered table instances', () => {
     });
     it('getTableByName should return full instance when one exists', () => {
         const { container, testMetaData, testSchema, defRecord } = createTestHarness();
-        // Register fallback definition
+        // Register fallback definition (private — normally auto-called)
         container.registerFromTableDefinitionRecord(defRecord);
         // Package code creates the full instance first
         const fullTable = container.getTable(testMetaData, testSchema, CustomTestTable);
@@ -111,7 +115,7 @@ describe('Tiered table instances', () => {
     });
     it('getTableByName should return fallback instance when no full instance exists', () => {
         const { container, defRecord } = createTestHarness();
-        // Only register from definition record -- no full definition available
+        // Only register from definition record -- no full definition available (private — normally auto-called)
         container.registerFromTableDefinitionRecord(defRecord);
         // Should return a bare-bones Table instance
         const table = container.getTableByName(defRecord.name);
@@ -138,7 +142,7 @@ describe('Tiered table instances', () => {
             metaData: metaData2,
             versionNumber: 0,
         };
-        // Register both as fallback definitions
+        // Register both as fallback definitions (private — normally auto-called)
         container.registerFromTableDefinitionRecord(defRecord);
         container.registerFromTableDefinitionRecord(defRecord2);
         // Create full instance for only the first table

package/dist/data/orm/table.js

@@ -45,7 +45,7 @@ class Table {
         // Find any underlying SubscribableDataSource to intercept its events
         let subscribableDataSource = undefined;
         let _dataSource = this.dataSource;
-        while (!subscribableDataSource && _dataSource) {
+        while (_dataSource) {
             if (!subscribableDataSource && _dataSource instanceof subscribable_data_source_1.SubscribableDataSource) {
                 subscribableDataSource = _dataSource;
             }

package/dist/keys.js

@@ -63,6 +63,9 @@ function encodeBase64(data) {
     return str.replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
 }
 function decodeBase64(data) {
+    if (typeof data !== 'string') {
+        throw new TypeError(`decodeBase64 expected a string but received ${typeof data}`);
+    }
     data = data.replace(/-/g, '+').replace(/_/g, '/');
     while (data.length % 4 !== 0) {
         data += '=';
@@ -211,9 +214,12 @@ function addSignatureToObject(obj, secretKey) {
  * Will throw if the signature is invalid
  */
 function verifyObjectSignature(objectWithSignature) {
+    if (!objectWithSignature.signature) {
+        throw new Error('Object has no signature to verify');
+    }
     const objWithoutSignature = { ...objectWithSignature };
     delete objWithoutSignature.signature;
-    const [objPublicKey, objSignature] = objectWithSignature.signature?.split(':') || [];
+    const [objPublicKey, objSignature] = objectWithSignature.signature.split(':');
     const signedObject = {
         contents: objWithoutSignature,
         signature: objSignature,

package/package.json

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