@peers-app/peers-sdk 0.14.0 → 0.15.0

package/dist/data/orm/decorators.js

@@ -12,12 +12,12 @@ const rpc_types_1 = require("../../rpc-types");
  * an infinite proxy loop.
  */
 function ProxyClientTableMethodCalls() {
-    return function (target, context) {
-        if (context.kind === 'method' && rpc_types_1.isClient) {
+    return (target, context) => {
+        if (context.kind === "method" && rpc_types_1.isClient) {
             const methodName = context.name;
             // WARNING: Using typescript's magical `this` param
             const proxyFn = function (...args) {
-                const dataContextId = this.dataSource.dataContextId || this.groupId || '';
+                const dataContextId = this.dataSource.dataContextId || this.groupId || "";
                 return rpc_types_1.rpcServerCalls.tableMethodCall(dataContextId, this.tableName, methodName, ...args);
             };
             proxyFn.__original = target;

package/dist/data/orm/dependency-injection.test.js

@@ -1,29 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const _1 = require(".");
-const field_type_1 = require("../../types/field-type");
-const data_context_1 = require("../../context/data-context");
 const zod_1 = require("zod");
-describe('Dependency Injection Pattern', () => {
+const data_context_1 = require("../../context/data-context");
+const field_type_1 = require("../../types/field-type");
+const _1 = require(".");
+describe("Dependency Injection Pattern", () => {
     const testSchema = zod_1.z.object({
         id: zod_1.z.string(),
         name: zod_1.z.string(),
     });
     const testMetaData = {
-        name: 'TestTable',
-        description: 'Test table for DI pattern',
-        primaryKeyName: 'id',
+        name: "TestTable",
+        description: "Test table for DI pattern",
+        primaryKeyName: "id",
         fields: [
-            { name: 'id', type: field_type_1.FieldType.string, description: 'ID field' },
-            { name: 'name', type: field_type_1.FieldType.string, description: 'Name field' },
+            { name: "id", type: field_type_1.FieldType.string, description: "ID field" },
+            { name: "name", type: field_type_1.FieldType.string, description: "Name field" },
         ],
     };
-    it('should create table using new DI constructor', () => {
+    it("should create table using new DI constructor", () => {
         // Create mock dependencies
         const mockDeps = {
             dataSource: {
-                tableName: 'TestTable',
-                primaryKeyName: 'id',
+                tableName: "TestTable",
+                primaryKeyName: "id",
                 list: jest.fn().mockResolvedValue([]),
                 get: jest.fn().mockResolvedValue(null),
                 save: jest.fn().mockResolvedValue({}),
@@ -34,27 +34,24 @@ describe('Dependency Injection Pattern', () => {
             eventRegistry: {
                 getEmitter: jest.fn().mockReturnValue({
                     event: { subscribe: jest.fn() },
-                    emit: jest.fn()
-                })
-            }
+                    emit: jest.fn(),
+                }),
+            },
         };
         // Create table using new DI pattern
         const table = new _1.Table(testMetaData, mockDeps);
         // Verify table was created correctly
-        expect(table.tableName).toBe('TestTable');
-        expect(table.primaryKeyName).toBe('id');
+        expect(table.tableName).toBe("TestTable");
+        expect(table.primaryKeyName).toBe("id");
         // Verify schema works by parsing test data successfully
-        const testData = { id: 'test-id', name: 'test-name' };
+        const testData = { id: "test-id", name: "test-name" };
         expect(() => table.schema.parse(testData)).not.toThrow();
         expect(table.metaData).toBe(testMetaData);
         expect(table.dataSource).toBe(mockDeps.dataSource);
     });
-    it('should allow easy custom table extension with DI pattern', () => {
+    it("should allow easy custom table extension with DI pattern", () => {
         // Example custom table class
         class CustomTable extends _1.Table {
-            constructor(metaData, deps) {
-                super(metaData, deps);
-            }
             // Custom business method
             async findByName(name) {
                 return this.list({ name });
@@ -62,9 +59,9 @@ describe('Dependency Injection Pattern', () => {
         }
         const mockDeps = {
             dataSource: {
-                tableName: 'CustomTable',
-                primaryKeyName: 'id',
-                list: jest.fn().mockResolvedValue([{ id: '1', name: 'test' }]),
+                tableName: "CustomTable",
+                primaryKeyName: "id",
+                list: jest.fn().mockResolvedValue([{ id: "1", name: "test" }]),
                 get: jest.fn(),
                 save: jest.fn(),
                 insert: jest.fn(),
@@ -74,26 +71,26 @@ describe('Dependency Injection Pattern', () => {
             eventRegistry: {
                 getEmitter: jest.fn().mockReturnValue({
                     event: { subscribe: jest.fn() },
-                    emit: jest.fn()
-                })
-            }
+                    emit: jest.fn(),
+                }),
+            },
         };
         const customTable = new CustomTable(testMetaData, mockDeps);
         // Verify custom table works
         expect(customTable).toBeInstanceOf(_1.Table);
         expect(customTable).toBeInstanceOf(CustomTable);
         // Verify custom method exists
-        expect(typeof customTable.findByName).toBe('function');
+        expect(typeof customTable.findByName).toBe("function");
     });
-    it('should create table dependencies using DataContext factory method', () => {
+    it("should create table dependencies using DataContext factory method", () => {
         // Create mock DataContext
         const mockUserContext = {
-            userId: () => 'test-user',
+            userId: () => "test-user",
             dataSourceFactory: jest.fn().mockReturnValue({
-                tableName: 'TestTable',
-                primaryKeyName: 'id',
+                tableName: "TestTable",
+                primaryKeyName: "id",
                 list: jest.fn(),
-            })
+            }),
         };
         const dataContext = new data_context_1.DataContext(mockUserContext);
         // Use factory method to create dependencies
@@ -104,12 +101,12 @@ describe('Dependency Injection Pattern', () => {
         expect(deps.schema).toBe(testSchema); // Schema should be passed through when explicitly provided
         expect(deps.eventRegistry).toBe(dataContext.eventRegistry);
     });
-    it('should compute schema from metaData when not provided in dependencies', () => {
+    it("should compute schema from metaData when not provided in dependencies", () => {
         // Create mock dependencies without schema
         const mockDeps = {
             dataSource: {
-                tableName: 'TestTable',
-                primaryKeyName: 'id',
+                tableName: "TestTable",
+                primaryKeyName: "id",
                 list: jest.fn().mockResolvedValue([]),
                 get: jest.fn().mockResolvedValue(null),
                 save: jest.fn().mockResolvedValue({}),
@@ -120,55 +117,55 @@ describe('Dependency Injection Pattern', () => {
             eventRegistry: {
                 getEmitter: jest.fn().mockReturnValue({
                     event: { subscribe: jest.fn() },
-                    emit: jest.fn()
-                })
-            }
+                    emit: jest.fn(),
+                }),
+            },
             // Note: no schema provided
         };
         // Create table - schema should be computed from metaData.fields
         const table = new _1.Table(testMetaData, mockDeps);
         // Verify schema was computed correctly by testing it works
-        const testData = { id: 'test-id', name: 'test-name' };
+        const testData = { id: "test-id", name: "test-name" };
         expect(() => table.schema.parse(testData)).not.toThrow();
     });
-    it('should create tables using DataContext convenience method', () => {
-        // Create mock DataContext  
+    it("should create tables using DataContext convenience method", () => {
+        // Create mock DataContext
         const mockUserContext = {
-            userId: () => 'test-user',
+            userId: () => "test-user",
             dataSourceFactory: jest.fn().mockReturnValue({
-                tableName: 'TestTable',
-                primaryKeyName: 'id',
+                tableName: "TestTable",
+                primaryKeyName: "id",
                 list: jest.fn(),
-            })
+            }),
         };
         const dataContext = new data_context_1.DataContext(mockUserContext);
         // Use convenience method to create table
         const table = dataContext.createTable(testMetaData, testSchema);
         // Verify table was created correctly
         expect(table).toBeInstanceOf(_1.Table);
-        expect(table.tableName).toBe('TestTable');
+        expect(table.tableName).toBe("TestTable");
         // Table merges fields-derived schema with code schema, so it's not the same reference
-        const testData = { id: 'test-id', name: 'test-name' };
+        const testData = { id: "test-id", name: "test-name" };
         expect(() => table.schema.parse(testData)).not.toThrow();
     });
-    it('should create tables through TableFactory using new DI pattern internally', () => {
+    it("should create tables through TableFactory using new DI pattern internally", () => {
         // Create mock DataContext
         const mockUserContext = {
-            userId: () => 'test-user',
+            userId: () => "test-user",
             dataSourceFactory: jest.fn().mockReturnValue({
-                tableName: 'TestTable',
-                primaryKeyName: 'id',
+                tableName: "TestTable",
+                primaryKeyName: "id",
                 list: jest.fn(),
-            })
+            }),
         };
         const dataContext = new data_context_1.DataContext(mockUserContext);
         // Use TableFactory (which should internally use DI pattern now)
         const table = dataContext.tableContainer.getTable(testMetaData, testSchema);
         // Verify table was created correctly through TableFactory
         expect(table).toBeInstanceOf(_1.Table);
-        expect(table.tableName).toBe('TestTable');
+        expect(table.tableName).toBe("TestTable");
         // Table merges fields-derived schema with code schema, so it's not the same reference
-        expect(() => table.schema.parse({ id: 'test-id', name: 'test-name' })).not.toThrow();
+        expect(() => table.schema.parse({ id: "test-id", name: "test-name" })).not.toThrow();
         expect(table.metaData).toBe(testMetaData);
     });
 });

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

@@ -1,5 +1,5 @@
-import { Table } from "./table";
-import { Observable } from "../../observable";
+import { type Observable } from "../../observable";
+import type { Table } from "./table";
 export type IDoc<T extends {
     [key: string]: any;
 }> = {
@@ -14,8 +14,8 @@ export type IDoc<T extends {
         [K in keyof T]-?: Observable<T[K]>;
     };
     q: Observable<number>;
-    displayValue: (() => string);
-    primaryKey: (() => string | number);
+    displayValue: () => string;
+    primaryKey: () => string | number;
     isNew: boolean;
     hasChanges: () => boolean;
 } & {

package/dist/data/orm/doc.js

@@ -5,17 +5,15 @@ const lodash_1 = require("lodash");
 const observable_1 = require("../../observable");
 function initDoc(data, table) {
     const columns = [...table.metaData.fields];
-    // @ts-ignore
+    // @ts-expect-error
     const doc = {
         isNew: true,
         table,
         q: (0, observable_1.observable)(0),
-        // @ts-ignore
         qs: {},
         load: async (objOrId) => {
             let loadedFromDb = false;
-            if (typeof objOrId !== 'object') {
-                // @ts-ignore
+            if (typeof objOrId !== "object") {
                 const id = objOrId || doc[table.metaData.primaryKeyName];
                 if (!id) {
                     return doc;
@@ -30,9 +28,9 @@ function initDoc(data, table) {
             for (const fieldName of fieldNames) {
                 if (objOrId[fieldName] !== undefined) {
                     // note that this won't create new observables for fields that weren't in the original data
-                    // @ts-ignore
+                    // @ts-expect-error
                     doc[fieldName] = objOrId[fieldName];
-                    // @ts-ignore
+                    // @ts-expect-error
                     data[fieldName] = objOrId[fieldName];
                 }
             }
@@ -45,7 +43,7 @@ function initDoc(data, table) {
         toJS: () => {
             const _data = (0, lodash_1.cloneDeep)(data);
             for (const field of table.metaData.fields) {
-                // @ts-ignore
+                // @ts-expect-error
                 _data[field.name] = doc[field.name];
             }
             return _data;
@@ -64,7 +62,7 @@ function initDoc(data, table) {
             }
         },
         save: async () => {
-            let _data = doc.validate();
+            const _data = doc.validate();
             const src = await table.save(_data);
             return doc.load(src).then(() => {
                 doc.isNew = false;
@@ -74,16 +72,15 @@ function initDoc(data, table) {
         },
         delete: async () => {
             doc.q(0);
-            // @ts-ignore
             await table.delete(doc[table.metaData.primaryKeyName]);
             return doc;
         },
         displayValue: () => {
             let displayValue = null; //table.entity.displayValue;
             if (!displayValue) {
-                displayValue = table.metaData.fields.find(c => c.type === 'string')?.name;
+                displayValue = table.metaData.fields.find((c) => c.type === "string")?.name;
             }
-            return displayValue || 'display value not configured';
+            return displayValue || "display value not configured";
             // if (typeof displayValue === 'function') {
             // 	return displayValue(doc);
             // } else if (displayValue) {
@@ -92,33 +89,32 @@ function initDoc(data, table) {
             // 	return doc[collection.primaryKey.name];
             // }
         },
-        // @ts-ignore
         primaryKey: () => doc[table.metaData.primaryKeyName],
         hasChanges: () => doc.isNew || doc.q() !== 0,
     };
-    const fieldNames = (0, lodash_1.uniq)([...columns.map(c => c.name), ...Object.keys(data)]);
-    fieldNames.forEach(fieldName => {
+    const fieldNames = (0, lodash_1.uniq)([...columns.map((c) => c.name), ...Object.keys(data)]);
+    fieldNames.forEach((fieldName) => {
         const fieldQ = (0, observable_1.observable)(data[fieldName]);
         fieldQ.subscribe(() => {
-            // @ts-ignore
+            // @ts-expect-error
             data[fieldName] = fieldQ();
             doc.q(doc.q() + 1);
         });
-        // @ts-ignore
+        // @ts-expect-error
         doc.qs[fieldName] = fieldQ;
         Object.defineProperty(doc, fieldName, {
             get: () => {
                 return fieldQ();
             },
-            set: value => {
-                // @ts-ignore
+            set: (value) => {
+                // @ts-expect-error
                 data[fieldName] = value;
                 fieldQ(value);
-            }
+            },
         });
     });
     return doc;
 }
-//@ts-ignore
-if (typeof window !== 'undefined')
+//@ts-expect-error
+if (typeof window !== "undefined")
     window.initDoc = initDoc;

package/dist/data/orm/event-registry.d.ts

@@ -1,4 +1,4 @@
-import { Emitter } from '../../events';
+import { Emitter } from "../../events";
 /**
  * Registry for managing shared event emitters across table instances.
  * Ensures that tables with the same name share the same event emitter,

package/dist/data/orm/event-registry.test.js

@@ -1,36 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const event_registry_1 = require("./event-registry");
-describe('EventRegistry', () => {
+describe("EventRegistry", () => {
     let registry;
     beforeEach(() => {
         const mockDataContext = {
-            dataContextId: 'test-context'
+            dataContextId: "test-context",
         };
         registry = new event_registry_1.EventRegistry(mockDataContext);
     });
-    it('should return the same emitter for the same event name', () => {
-        const emitter1 = registry.getEmitter('test-event');
-        const emitter2 = registry.getEmitter('test-event');
+    it("should return the same emitter for the same event name", () => {
+        const emitter1 = registry.getEmitter("test-event");
+        const emitter2 = registry.getEmitter("test-event");
         expect(emitter1).toBe(emitter2);
         expect(registry.getEmitterCount()).toBe(1);
     });
-    it('should return different emitters for different event names', () => {
-        const emitter1 = registry.getEmitter('event-1');
-        const emitter2 = registry.getEmitter('event-2');
+    it("should return different emitters for different event names", () => {
+        const emitter1 = registry.getEmitter("event-1");
+        const emitter2 = registry.getEmitter("event-2");
         expect(emitter1).not.toBe(emitter2);
         expect(registry.getEmitterCount()).toBe(2);
     });
-    it('should clear all emitters', () => {
-        registry.getEmitter('event-1');
-        registry.getEmitter('event-2');
+    it("should clear all emitters", () => {
+        registry.getEmitter("event-1");
+        registry.getEmitter("event-2");
         expect(registry.getEmitterCount()).toBe(2);
         registry.clear();
         expect(registry.getEmitterCount()).toBe(0);
     });
-    it('should handle event emission and subscription across shared emitters', async () => {
-        const emitter1 = registry.getEmitter('shared-event');
-        const emitter2 = registry.getEmitter('shared-event');
+    it("should handle event emission and subscription across shared emitters", async () => {
+        const emitter1 = registry.getEmitter("shared-event");
+        const emitter2 = registry.getEmitter("shared-event");
         // They should be the same instance
         expect(emitter1).toBe(emitter2);
         // Test event flow
@@ -38,7 +38,7 @@ describe('EventRegistry', () => {
         emitter1.event.subscribe((data) => {
             receivedData = data;
         });
-        await emitter2.emit('test-data');
-        expect(receivedData).toBe('test-data');
+        await emitter2.emit("test-data");
+        expect(receivedData).toBe("test-data");
     });
 });

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

@@ -1,6 +1,6 @@
-import { DataFilter } from "./data-query";
+import type { DataFilter } from "./data-query";
 import { Table } from "./table";
-import { ITableMetaData } from "./types";
+import type { ITableMetaData } from "./types";
 export declare function arrayAsTable<T extends Record<string, any>>(ary: T[], opts?: Partial<ITableMetaData>): Table<T>;
 /**
  * WARNING: this is an incomplete implementation of applyFilterToItem

package/dist/data/orm/factory.js

@@ -3,34 +3,34 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.arrayAsTable = arrayAsTable;
 exports.applyFilterToItem = applyFilterToItem;
 const lodash_1 = require("lodash");
-const table_1 = require("./table");
 const field_type_1 = require("../../types/field-type");
+const table_1 = require("./table");
 let inMemoryTableCount = 0;
 function arrayAsTable(ary, opts = {}) {
     let fields = opts.fields;
     delete opts.fields;
     if (!fields) {
-        const fieldNames = (0, lodash_1.uniq)(ary.map(item => Object.keys(item)).flat());
-        fields = fieldNames.map(name => {
-            const firstValue = ary.find(item => item[name] !== undefined && item[name] !== null)?.[name];
+        const fieldNames = (0, lodash_1.uniq)(ary.flatMap((item) => Object.keys(item)));
+        fields = fieldNames.map((name) => {
+            const firstValue = ary.find((item) => item[name] !== undefined && item[name] !== null)?.[name];
             const valueType = typeof firstValue;
             let dataType = field_type_1.FieldType.any;
-            if (valueType !== 'object' && valueType !== 'function' && valueType !== 'symbol') {
+            if (valueType !== "object" && valueType !== "function" && valueType !== "symbol") {
                 dataType = valueType;
             }
-            let optional = false;
+            const optional = false;
             return {
                 name,
-                description: '',
+                description: "",
                 type: dataType,
-                optional
+                optional,
             };
         });
     }
     const metaData = {
         name: `inMemoryTable_${inMemoryTableCount++}`,
-        description: 'In-memory table',
-        primaryKeyName: fields.find(f => f.type === 'id')?.name || 'id',
+        description: "In-memory table",
+        primaryKeyName: fields.find((f) => f.type === "id")?.name || "id",
         fields,
         ...opts,
     };
@@ -38,7 +38,7 @@ function arrayAsTable(ary, opts = {}) {
         tableName: metaData.name,
         primaryKeyName: metaData.primaryKeyName,
         list: async (filter = {}, opts = {}) => {
-            const filteredArray = ary.filter(item => applyFilterToItem(item, filter));
+            const filteredArray = ary.filter((item) => applyFilterToItem(item, filter));
             if (opts.pageSize) {
                 const page = opts.page || 1;
                 const pageSize = opts.pageSize;
@@ -48,16 +48,16 @@ function arrayAsTable(ary, opts = {}) {
             return [...filteredArray];
         },
         count: async (filter = {}) => {
-            return ary.filter(item => applyFilterToItem(item, filter)).length;
+            return ary.filter((item) => applyFilterToItem(item, filter)).length;
         },
-        get: async (id) => ary.find(item => item[metaData.primaryKeyName] === id),
+        get: async (id) => ary.find((item) => item[metaData.primaryKeyName] === id),
         save: async (record) => {
-            const existing = ary.find(item => item[metaData.primaryKeyName] === record[metaData.primaryKeyName]);
+            const existing = ary.find((item) => item[metaData.primaryKeyName] === record[metaData.primaryKeyName]);
             if (existing) {
-                return dataSource.update(record);
+                return dataSource.update?.(record);
             }
             else {
-                return dataSource.insert(record);
+                return dataSource.insert?.(record);
             }
         },
         insert: async (record) => {
@@ -65,7 +65,7 @@ function arrayAsTable(ary, opts = {}) {
             return record;
         },
         update: async (record) => {
-            const existing = ary.find(item => item[metaData.primaryKeyName] === record[metaData.primaryKeyName]);
+            const existing = ary.find((item) => item[metaData.primaryKeyName] === record[metaData.primaryKeyName]);
             if (existing) {
                 Object.assign(existing, record);
             }
@@ -75,22 +75,22 @@ function arrayAsTable(ary, opts = {}) {
             return record;
         },
         delete: async (id) => {
-            if (typeof id === 'object') {
+            if (typeof id === "object") {
                 id = id[metaData.primaryKeyName];
             }
-            const index = ary.findIndex(item => item[metaData.primaryKeyName] === id);
+            const index = ary.findIndex((item) => item[metaData.primaryKeyName] === id);
             if (index >= 0) {
                 ary.splice(index, 1);
             }
         },
     };
     const mockDataContextForRegistry = {
-        dataContextId: 'array-table-context'
+        dataContextId: "array-table-context",
     };
-    const eventRegistry = new (require('./event-registry').EventRegistry)(mockDataContextForRegistry);
+    const eventRegistry = new (require("./event-registry").EventRegistry)(mockDataContextForRegistry);
     const deps = {
         dataSource,
-        eventRegistry
+        eventRegistry,
     };
     return new table_1.Table(metaData, deps);
 }
@@ -103,34 +103,34 @@ function applyFilterToItem(item, filter) {
         return true;
     }
     for (const key in filter) {
-        if (key === '$and') {
+        if (key === "$and") {
             return _filter.$and.every((subFilter) => applyFilterToItem(item, subFilter));
         }
-        if (key === '$or') {
+        if (key === "$or") {
             return _filter.$or.some((subFilter) => applyFilterToItem(item, subFilter));
         }
-        if (key === '$lt') {
+        if (key === "$lt") {
             return item < _filter.$lt;
         }
-        if (key === '$lte') {
+        if (key === "$lte") {
             return item <= _filter.$lte;
         }
-        if (key === '$gt') {
+        if (key === "$gt") {
             return item > _filter.$gt;
         }
-        if (key === '$gte') {
+        if (key === "$gte") {
             return item >= _filter.$gte;
         }
-        if (key === '$ne') {
+        if (key === "$ne") {
             return item !== _filter.$ne;
         }
-        if (key === '$in') {
+        if (key === "$in") {
             return _filter.$in.includes(item);
         }
-        if (key === '$nin') {
+        if (key === "$nin") {
             return !_filter.$nin.includes(item);
         }
-        if (key.startsWith('$')) {
+        if (key.startsWith("$")) {
             throw new Error(`Unsupported filter key: ${key}`);
         }
         const subFilter = _filter[key];
@@ -138,7 +138,7 @@ function applyFilterToItem(item, filter) {
         if ((0, lodash_1.isArray)(subFilter)) {
             return subFilter.includes(value);
         }
-        if (typeof subFilter === 'object') {
+        if (typeof subFilter === "object") {
             return applyFilterToItem(value, subFilter);
         }
         return value === subFilter;

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

@@ -1,16 +1,16 @@
+export * from "./client-proxy.data-source";
+export * from "./cursor";
 export * from "./data-query";
-export * from "./sql-db";
+export * from "./decorators";
 export * from "./doc";
+export * from "./event-registry";
 export * from "./factory";
-export * from "./table";
-export * from "./table-dependencies";
-export * from "./types";
+export * from "./multi-cursors";
 export * from "./sql.data-source";
-export * from "./client-proxy.data-source";
-export * from "./table-container";
+export * from "./sql-db";
 export * from "./subscribable.data-source";
-export * from "./event-registry";
+export * from "./table";
+export * from "./table-container";
 export * from "./table-definitions.type";
-export * from "./multi-cursors";
-export * from "./cursor";
-export * from "./decorators";
+export * from "./table-dependencies";
+export * from "./types";