@peers-app/peers-sdk 0.14.0 → 0.15.0

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

@@ -2,11 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TableContainer = void 0;
 exports.checkVersionedUpdate = checkVersionedUpdate;
-const types_1 = require("./types");
+const rpc_types_1 = require("../../rpc-types");
+const utils_1 = require("../../utils");
 const table_1 = require("./table");
 const table_definitions_system_1 = require("./table-definitions.system");
-const utils_1 = require("../../utils");
-const rpc_types_1 = require("../../rpc-types");
+const types_1 = require("./types");
 /**
  * Normalize metaData for structural comparison by stripping fields that can differ
  * between in-memory and DB-serialized representations without representing a real schema change.
@@ -27,16 +27,17 @@ function normalizeMetaDataForComparison(metaData) {
  */
 function checkVersionedUpdate(existingVersion, incomingVersion, existingMetaData, incomingMetaData) {
     if (existingVersion < incomingVersion) {
-        return 'update';
+        return "update";
     }
     if (existingVersion === incomingVersion) {
-        const sameDefinition = (0, utils_1.simpleObjectHash)(normalizeMetaDataForComparison(existingMetaData)) === (0, utils_1.simpleObjectHash)(normalizeMetaDataForComparison(incomingMetaData));
+        const sameDefinition = (0, utils_1.simpleObjectHash)(normalizeMetaDataForComparison(existingMetaData)) ===
+            (0, utils_1.simpleObjectHash)(normalizeMetaDataForComparison(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.`);
         }
     }
-    return 'skip';
+    return "skip";
     // commenting this out for now, it's too likely to end up in an infinite loop
     // if (existingVersion > incomingVersion) {
     //   return 'skip';
@@ -81,7 +82,8 @@ class TableContainer {
         }
         if (existing && opts?.overwrite) {
             const existingDef = this.tableDefinitions[tableName];
-            if (existingDef && (0, utils_1.simpleObjectHash)(existingDef.metaData) === (0, utils_1.simpleObjectHash)(tableDefinition.metaData)) {
+            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}.`);
@@ -95,7 +97,7 @@ class TableContainer {
      */
     setTable(table, opts) {
         if (!(0, utils_1.isid)(table.metaData.tableId)) {
-            throw new Error('Table must have a valid tableId in its metadata. Only system tables are allowed to have an empty tableId.');
+            throw new Error("Table must have a valid tableId in its metadata. Only system tables are allowed to have an empty tableId.");
         }
         const tableName = (0, utils_1.getFullTableName)(table.metaData);
         if (this.tableInstances[tableName]) {
@@ -109,7 +111,7 @@ class TableContainer {
         this.tableInstances[tableName] = table;
     }
     getTable(metaDataOrTableName, schema, tableConstructor) {
-        if (typeof metaDataOrTableName === 'string') {
+        if (typeof metaDataOrTableName === "string") {
             return this.getTableByName(metaDataOrTableName);
         }
         const metaData = metaDataOrTableName;
@@ -135,7 +137,7 @@ class TableContainer {
             return;
         if (!metaData.tableId)
             return; // system tables don't need to be saved
-        if (metaData.name === 'TableDefinitions')
+        if (metaData.name === "TableDefinitions")
             return; // avoid recursion
         if (this.savingDefinitions)
             return; // guard against re-entrant calls
@@ -143,7 +145,7 @@ class TableContainer {
         const tableName = (0, utils_1.getFullTableName)(metaData);
         try {
             // Lazy import to avoid circular dependency at module load time
-            const { TableDefinitions } = require('../table-definitions-table');
+            const { TableDefinitions } = require("../table-definitions-table");
             const tableDefsTable = TableDefinitions();
             const record = {
                 tableId: metaData.tableId,
@@ -152,17 +154,21 @@ class TableContainer {
                 versionNumber: metaData.versionNumber ?? 0,
             };
             // Fire-and-forget: check if existing record has a newer versionNumber
-            tableDefsTable.get(metaData.tableId).then(existing => {
+            tableDefsTable
+                .get(metaData.tableId)
+                .then((existing) => {
                 if (existing) {
                     const result = checkVersionedUpdate(existing.versionNumber, record.versionNumber, existing.metaData, record.metaData);
-                    if (result === 'skip') {
+                    if (result === "skip") {
                         return;
                     }
                 }
                 return tableDefsTable.save(record, { restoreIfDeleted: true, saveAsSnapshot: true });
-            }).catch(err => {
+            })
+                .catch((err) => {
                 console.warn(`Failed to save table definition for ${tableName}:`, err);
-            }).finally(() => {
+            })
+                .finally(() => {
                 this.savingDefinitions = false;
             });
         }
@@ -212,14 +218,14 @@ class TableContainer {
             this.fallbackInstances[tableName] = table;
             return table;
         }
-        const tableDefsTable = this.tableInstances['TableDefinitions'];
+        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') {
+                if (event.op === "delete") {
                     const md = event.dataObject?.metaData;
                     if (md) {
                         const name = (0, utils_1.getFullTableName)(md);
@@ -264,7 +270,7 @@ class TableContainer {
             const existingVersion = existing.metaData.versionNumber ?? 0;
             const incomingVersion = record.versionNumber ?? 0;
             const result = checkVersionedUpdate(existingVersion, incomingVersion, existing.metaData, metaData);
-            if (result === 'skip') {
+            if (result === "skip") {
                 return;
             }
             // Remove old fallback instance so it gets re-created with the new schema
@@ -279,10 +285,13 @@ class TableContainer {
      *
      * This is primarily intended to be used by the peer-device sync operation which needs all
      * tables to be able to apply changes correctly.
-    */
+     */
     getAllTables() {
         // 1. Instantiate all full definitions (system + code-registered)
-        const fullDefinitions = [...Object.values(table_definitions_system_1.systemTableDefinitions), ...Object.values(this.tableDefinitions)];
+        const fullDefinitions = [
+            ...Object.values(table_definitions_system_1.systemTableDefinitions),
+            ...Object.values(this.tableDefinitions),
+        ];
         for (const tableDefinition of fullDefinitions) {
             const { metaData, schema, tableConstructor } = tableDefinition;
             this.getTable(metaData, schema, tableConstructor);
@@ -296,7 +305,10 @@ class TableContainer {
             }
         }
         // 3. Merge: full instances take precedence, then add fallbacks for tables not in full
-        const result = { ...this.fallbackInstances, ...this.tableInstances };
+        const result = {
+            ...this.fallbackInstances,
+            ...this.tableInstances,
+        };
         return Object.values(result);
     }
 }

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

@@ -1,62 +1,73 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const zod_1 = require("zod");
-const table_container_1 = require("./table-container");
-const event_registry_1 = require("./event-registry");
-const client_proxy_data_source_1 = require("./client-proxy.data-source");
-const table_1 = require("./table");
 const field_type_1 = require("../../types/field-type");
 const utils_1 = require("../../utils");
-describe('checkVersionedUpdate', () => {
-    const metaA = { name: 'TestTable', fields: [{ name: 'id', type: 'string' }] };
-    const metaAReordered = { fields: [{ name: 'id', type: 'string' }], name: 'TestTable' };
-    const metaB = { name: 'TestTable', fields: [{ name: 'id', type: 'number' }] };
-    it('should skip when existing version is strictly newer', () => {
-        expect((0, table_container_1.checkVersionedUpdate)(200, 100, metaA, metaB)).toBe('skip');
+const client_proxy_data_source_1 = require("./client-proxy.data-source");
+const event_registry_1 = require("./event-registry");
+const table_1 = require("./table");
+const table_container_1 = require("./table-container");
+describe("checkVersionedUpdate", () => {
+    const metaA = {
+        name: "TestTable",
+        fields: [{ name: "id", type: "string" }],
+    };
+    const metaAReordered = {
+        fields: [{ name: "id", type: "string" }],
+        name: "TestTable",
+    };
+    const metaB = {
+        name: "TestTable",
+        fields: [{ name: "id", type: "number" }],
+    };
+    it("should skip when existing version is strictly newer", () => {
+        expect((0, table_container_1.checkVersionedUpdate)(200, 100, metaA, metaB)).toBe("skip");
     });
-    it('should update when incoming version is strictly newer', () => {
-        expect((0, table_container_1.checkVersionedUpdate)(100, 200, metaA, metaB)).toBe('update');
+    it("should update when incoming version is strictly newer", () => {
+        expect((0, table_container_1.checkVersionedUpdate)(100, 200, metaA, metaB)).toBe("update");
     });
-    it('should skip when same non-zero version and same definition', () => {
-        expect((0, table_container_1.checkVersionedUpdate)(100, 100, metaA, metaA)).toBe('skip');
+    it("should skip when same non-zero version and same definition", () => {
+        expect((0, table_container_1.checkVersionedUpdate)(100, 100, metaA, metaA)).toBe("skip");
     });
-    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 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 skip when same non-zero version but different definitions', () => {
-        expect((0, table_container_1.checkVersionedUpdate)(100, 100, metaA, metaB)).toBe('skip');
+    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 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 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 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 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 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');
-        expect((0, table_container_1.checkVersionedUpdate)(50, 100, metaA, metaB)).toBe('update');
+    it("should update when incoming is newer regardless of definition content", () => {
+        expect((0, table_container_1.checkVersionedUpdate)(50, 100, metaA, metaA)).toBe("update");
+        expect((0, table_container_1.checkVersionedUpdate)(50, 100, metaA, metaB)).toBe("update");
     });
-    it('should skip when existing is newer regardless of definition content', () => {
-        expect((0, table_container_1.checkVersionedUpdate)(100, 50, metaA, metaA)).toBe('skip');
-        expect((0, table_container_1.checkVersionedUpdate)(100, 50, metaA, metaB)).toBe('skip');
+    it("should skip when existing is newer regardless of definition content", () => {
+        expect((0, table_container_1.checkVersionedUpdate)(100, 50, metaA, metaA)).toBe("skip");
+        expect((0, table_container_1.checkVersionedUpdate)(100, 50, metaA, metaB)).toBe("skip");
     });
 });
 // --- Tiered table instance tests ---
 // Custom Table subclass for testing
 class CustomTestTable extends table_1.Table {
     customMethod() {
-        return 'custom';
+        return "custom";
     }
 }
 function createTestHarness() {
-    const mockDataContext = { dataContextId: 'test-context' };
+    const mockDataContext = { dataContextId: "test-context" };
     const eventRegistry = new event_registry_1.EventRegistry(mockDataContext);
-    const tableFactory = jest.fn().mockImplementation((metaData, schema, TableClass) => {
+    const tableFactory = jest
+        .fn()
+        .mockImplementation((metaData, schema, TableClass) => {
         const deps = {
-            dataSource: new client_proxy_data_source_1.ClientProxyDataSource(metaData, schema, 'test-context'),
+            dataSource: new client_proxy_data_source_1.ClientProxyDataSource(metaData, schema, "test-context"),
             eventRegistry,
         };
         return new (TableClass || table_1.Table)(metaData, deps);
@@ -65,12 +76,12 @@ function createTestHarness() {
     const tableId = (0, utils_1.newid)();
     const testMetaData = {
         tableId,
-        name: 'TestPkgTable',
-        description: 'A package-defined table',
-        primaryKeyName: 'id',
+        name: "TestPkgTable",
+        description: "A package-defined table",
+        primaryKeyName: "id",
         fields: [
-            { name: 'id', type: field_type_1.FieldType.id },
-            { name: 'title', type: field_type_1.FieldType.string },
+            { name: "id", type: field_type_1.FieldType.id },
+            { name: "title", type: field_type_1.FieldType.string },
         ],
     };
     const testSchema = zod_1.z.object({
@@ -85,8 +96,8 @@ function createTestHarness() {
     };
     return { container, testMetaData, testSchema, defRecord, tableFactory };
 }
-describe('Tiered table instances', () => {
-    it('bare-bones fallback instance should NOT block full instance with custom constructor', () => {
+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)
@@ -99,9 +110,9 @@ describe('Tiered table instances', () => {
         const fullTable = container.getTable(testMetaData, testSchema, CustomTestTable);
         // The full instance should be a CustomTestTable, NOT the bare-bones Table
         expect(fullTable).toBeInstanceOf(CustomTestTable);
-        expect(fullTable.customMethod()).toBe('custom');
+        expect(fullTable.customMethod()).toBe("custom");
     });
-    it('getTableByName should return full instance when one exists', () => {
+    it("getTableByName should return full instance when one exists", () => {
         const { container, testMetaData, testSchema, defRecord } = createTestHarness();
         // Register fallback definition (private — normally auto-called)
         container.registerFromTableDefinitionRecord(defRecord);
@@ -113,7 +124,7 @@ describe('Tiered table instances', () => {
         expect(byName).toBe(fullTable);
         expect(byName).toBeInstanceOf(CustomTestTable);
     });
-    it('getTableByName should return fallback instance when no full instance exists', () => {
+    it("getTableByName should return fallback instance when no full instance exists", () => {
         const { container, defRecord } = createTestHarness();
         // Only register from definition record -- no full definition available (private — normally auto-called)
         container.registerFromTableDefinitionRecord(defRecord);
@@ -122,18 +133,18 @@ describe('Tiered table instances', () => {
         expect(table).toBeInstanceOf(table_1.Table);
         expect(table).not.toBeInstanceOf(CustomTestTable);
     });
-    it('getAllTables should prefer full instances over fallback instances', () => {
+    it("getAllTables should prefer full instances over fallback instances", () => {
         const { container, testMetaData, testSchema, defRecord, tableFactory } = createTestHarness();
         // Create a second table that will only have a fallback definition
         const tableId2 = (0, utils_1.newid)();
         const metaData2 = {
             tableId: tableId2,
-            name: 'OtherTable',
-            description: 'Another table',
-            primaryKeyName: 'id',
+            name: "OtherTable",
+            description: "Another table",
+            primaryKeyName: "id",
             fields: [
-                { name: 'id', type: field_type_1.FieldType.id },
-                { name: 'value', type: field_type_1.FieldType.string },
+                { name: "id", type: field_type_1.FieldType.id },
+                { name: "value", type: field_type_1.FieldType.string },
             ],
         };
         const defRecord2 = {
@@ -149,14 +160,14 @@ describe('Tiered table instances', () => {
         container.getTable(testMetaData, testSchema, CustomTestTable);
         // getAllTables should include both tables
         const allTables = container.getAllTables();
-        const tableNames = allTables.map(t => t.tableName);
+        const tableNames = allTables.map((t) => t.tableName);
         expect(tableNames).toContain(defRecord.name);
         expect(tableNames).toContain(defRecord2.name);
         // The first table should be the full CustomTestTable instance
-        const firstTable = allTables.find(t => t.tableName === defRecord.name);
+        const firstTable = allTables.find((t) => t.tableName === defRecord.name);
         expect(firstTable).toBeInstanceOf(CustomTestTable);
         // The second table should be a bare-bones Table (fallback)
-        const secondTable = allTables.find(t => t.tableName === defRecord2.name);
+        const secondTable = allTables.find((t) => t.tableName === defRecord2.name);
         expect(secondTable).toBeInstanceOf(table_1.Table);
         expect(secondTable).not.toBeInstanceOf(CustomTestTable);
     });

package/dist/data/orm/table-definitions.system.d.ts

@@ -1,6 +1,6 @@
-import { z } from 'zod';
-import { ITableDefinition, TableConstructor } from './table-definitions.type';
-import { ITableMetaData } from './types';
+import type { z } from "zod";
+import type { ITableDefinition, TableConstructor } from "./table-definitions.type";
+import { type ITableMetaData } from "./types";
 export declare const systemTableDefinitions: {
     [tableName: string]: ITableDefinition<any>;
 };

package/dist/data/orm/table-definitions.system.js

@@ -3,15 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.systemTableDefinitions = void 0;
 exports.registerSystemTableDefinition = registerSystemTableDefinition;
 const keys_1 = require("../../keys");
-const types_1 = require("./types");
 const utils_1 = require("../../utils");
+const types_1 = require("./types");
 exports.systemTableDefinitions = {};
 function registerSystemTableDefinition(metaData, schema, tableConstructor) {
     const tableName = (0, utils_1.getFullTableName)(metaData);
     const def = {
         metaData,
         schema,
-        tableConstructor
+        tableConstructor,
     };
     if (exports.systemTableDefinitions[tableName]) {
         const s1 = (0, keys_1.stableStringify)(exports.systemTableDefinitions[tableName].metaData);
@@ -19,7 +19,7 @@ function registerSystemTableDefinition(metaData, schema, tableConstructor) {
         if (s1 !== s2) {
             console.warn(`Attempt to register new metadata for system table ${tableName}, it will be ignored`, {
                 registered: exports.systemTableDefinitions[tableName].metaData,
-                incoming: metaData
+                incoming: metaData,
             });
         }
         return;

package/dist/data/orm/table-definitions.type.d.ts

@@ -1,8 +1,8 @@
-import type { IDataSource } from './data-query';
-import type { Table } from './table';
-import type { ITableMetaData } from './types';
-import type { ITableDependencies } from './table-dependencies';
-import { z } from 'zod';
+import type { z } from "zod";
+import type { IDataSource } from "./data-query";
+import type { Table } from "./table";
+import type { ITableDependencies } from "./table-dependencies";
+import type { ITableMetaData } from "./types";
 export type DataSourceFactory = (metaData: ITableMetaData, schema?: z.AnyZodObject, groupId?: string) => IDataSource<any>;
 export type TableConstructor<T extends {
     [key: string]: any;

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

@@ -1,7 +1,7 @@
-import { z } from "zod";
+import type { z } from "zod";
+import type { UserContext } from "../../context/user-context";
 import type { IDataSource } from "./data-query";
 import type { EventRegistry } from "./event-registry";
-import type { UserContext } from "../../context/user-context";
 import type { DataSourceFactory } from "./table-definitions.type";
 /**
  * Dependencies required by Table instances.

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

@@ -1,9 +1,9 @@
-import { z } from "zod";
-import { Emitter, Event } from "../../events";
-import { DataFilter, ICursorIterable, IDataQueryParams, IDataSource, ISaveOptions } from "./data-query";
-import { IDataChangedEvent } from "./subscribable.data-source";
-import { ITableMetaData } from "./types";
+import type { z } from "zod";
+import type { Emitter, Event } from "../../events";
+import { type DataFilter, type ICursorIterable, type IDataQueryParams, type IDataSource, type ISaveOptions } from "./data-query";
+import { type IDataChangedEvent } from "./subscribable.data-source";
 import type { ITableDependencies } from "./table-dependencies";
+import { type ITableMetaData } from "./types";
 export declare class Table<T extends {
     [key: string]: any;
 }> implements IDataSource<T> {