@peers-app/peers-sdk 0.1.4

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

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableContainer = void 0;
+const types_1 = require("./types");
+const table_1 = require("./table");
+const table_definitions_system_1 = require("./table-definitions.system");
+const utils_1 = require("../../utils");
+class TableContainer {
+    tableFactory;
+    groupId;
+    tableDefinitions = {};
+    tableInstances = {};
+    constructor(tableFactory, groupId) {
+        this.tableFactory = tableFactory;
+        this.groupId = groupId;
+    }
+    registerTableDefinition(tableDefinition, opts) {
+        const tableId = tableDefinition.metaData.tableId;
+        if (!(0, utils_1.isid)(tableId)) {
+            throw new Error(`Invalid tableId ${tableId} for table ${tableDefinition.metaData.name}. Table IDs must be valid IDs.`);
+        }
+        const tableName = (0, utils_1.getFullTableName)(tableDefinition.metaData);
+        const existing = this.tableInstances[tableName] || this.tableDefinitions[tableName];
+        if (existing && !opts?.overwrite) {
+            console.warn(`Table ${tableName} is already registered.`);
+            return;
+        }
+        if (existing && opts?.overwrite) {
+            console.warn(`Overwriting table definition for ${tableName}.`);
+            delete this.tableInstances[tableName];
+        }
+        this.tableDefinitions[tableName] = tableDefinition;
+    }
+    /**
+     * This shouldn't be used unless you have a good reason to bypass the normal table creation process.
+     * The normal process is to register the table definition and let the factory create the instance.
+     */
+    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.');
+        }
+        const tableName = (0, utils_1.getFullTableName)(table.metaData);
+        if (this.tableInstances[tableName]) {
+            if (opts?.overwrite) {
+                console.warn(`Overwriting existing table with ID ${tableName}.`);
+            }
+            else {
+                throw new Error(`Table with ID ${tableName} already exists.`);
+            }
+        }
+        this.tableInstances[tableName] = table;
+    }
+    getTable(metaDataOrTableName, schema, tableConstructor) {
+        if (typeof metaDataOrTableName === 'string') {
+            return this.getTableByName(metaDataOrTableName);
+        }
+        const metaData = metaDataOrTableName;
+        const tableName = (0, utils_1.getFullTableName)(metaData);
+        if (!this.tableInstances[tableName]) {
+            schema ??= (0, types_1.fieldsToSchema)(metaData.fields);
+            // Check if there's a registered custom constructor
+            const registeredDef = this.tableDefinitions[tableName] || table_definitions_system_1.systemTableDefinitions[tableName];
+            const TableClass = tableConstructor || registeredDef?.tableConstructor || (table_1.Table);
+            const table = this.tableFactory(metaData, schema, TableClass, this.groupId);
+            this.tableInstances[tableName] = table;
+        }
+        return this.tableInstances[tableName];
+    }
+    getTableByName(tableName) {
+        if (this.tableInstances[tableName]) {
+            // If the table is already instantiated, return it
+            return this.tableInstances[tableName];
+        }
+        const tableDefinition = this.tableDefinitions[tableName] || table_definitions_system_1.systemTableDefinitions[tableName];
+        if (!tableDefinition) {
+            throw new Error(`There is no instantiated table or registered definition for ${tableName}`);
+        }
+        const { metaData, schema, tableConstructor } = tableDefinition;
+        return this.getTable(metaData, schema, tableConstructor);
+    }
+    /**
+     * This ensures all tables have been new'ed up and then returns the entire list of them.
+     *
+     * 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() {
+        const allDefinitions = [...Object.values(table_definitions_system_1.systemTableDefinitions), ...Object.values(this.tableDefinitions)];
+        for (const tableDefinition of allDefinitions) {
+            const { metaData, schema, tableConstructor } = tableDefinition;
+            this.getTable(metaData, schema, tableConstructor);
+        }
+        return Object.values(this.tableInstances);
+    }
+}
+exports.TableContainer = TableContainer;

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

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { ITableDefinition, TableConstructor } from './table-definitions.type';
+import { ITableMetaData } from './types';
+export declare const systemTableDefinitions: {
+    [tableName: string]: ITableDefinition<any>;
+};
+export declare function registerSystemTableDefinition<T extends {
+    [key: string]: any;
+}>(metaData: ITableMetaData, schema?: z.AnyZodObject, tableConstructor?: TableConstructor<T>): void;

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

@@ -0,0 +1,29 @@
+"use strict";
+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");
+exports.systemTableDefinitions = {};
+function registerSystemTableDefinition(metaData, schema, tableConstructor) {
+    const tableName = (0, utils_1.getFullTableName)(metaData);
+    const def = {
+        metaData,
+        schema,
+        tableConstructor
+    };
+    if (exports.systemTableDefinitions[tableName]) {
+        const s1 = (0, keys_1.stableStringify)(exports.systemTableDefinitions[tableName].metaData);
+        const s2 = (0, keys_1.stableStringify)(metaData);
+        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
+            });
+        }
+        return;
+    }
+    schema ??= (0, types_1.fieldsToSchema)(metaData.fields);
+    exports.systemTableDefinitions[tableName] = def;
+}

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

@@ -0,0 +1,19 @@
+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';
+export type DataSourceFactory = (metaData: ITableMetaData, schema?: z.AnyZodObject, groupId?: string) => IDataSource<any>;
+export type TableConstructor<T extends {
+    [key: string]: any;
+}> = new (metaData: ITableMetaData, deps: ITableDependencies) => Table<T>;
+export type TableFactory = (metaData: ITableMetaData, schema?: z.AnyZodObject, TableClass?: TableConstructor<any>, groupId?: string) => Table<any>;
+export interface ITableDefinition<T extends {
+    [key: string]: any;
+} = {
+    [key: string]: any;
+}> {
+    metaData: ITableMetaData;
+    schema?: z.AnyZodObject;
+    tableConstructor?: TableConstructor<T>;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,32 @@
+import { z } from "zod";
+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.
+ * This interface defines the explicit dependencies that every table needs,
+ * making testing easier and eliminating circular dependencies.
+ */
+export interface ITableDependencies {
+    /** The data source for this table's CRUD operations */
+    dataSource: IDataSource<any>;
+    /** Registry for managing shared event emitters */
+    eventRegistry: EventRegistry;
+    /** Zod schema for data validation (optional - will be computed from metaData.fields if not provided) */
+    schema?: z.AnyZodObject;
+    /** Optional group ID for multi-tenancy */
+    groupId?: string;
+}
+/**
+ * Dependencies required by DataContext instances.
+ * Used to construct DataContext without circular references.
+ */
+export interface IDataContextDependencies {
+    /** The user context providing user/device information */
+    userContext: UserContext;
+    /** Optional group ID for multi-tenancy */
+    groupId?: string;
+    /** Factory function for creating data sources */
+    dataSourceFactory?: DataSourceFactory;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,42 @@
+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 { ITableDependencies } from "./table-dependencies";
+export declare class Table<T extends {
+    [key: string]: any;
+}> implements IDataSource<T> {
+    readonly tableName: string;
+    readonly primaryKeyName: string;
+    readonly schema: z.AnyZodObject;
+    protected readonly dataChangedEmitter: Emitter<IDataChangedEvent<T>>;
+    readonly dataChanged: Event<IDataChangedEvent<T>>;
+    private readonly localOperationCache;
+    readonly dataSource: IDataSource<T>;
+    readonly metaData: ITableMetaData;
+    readonly groupId?: string;
+    constructor(metaData: ITableMetaData, deps: ITableDependencies);
+    private getRecordId;
+    private setLocalOperation;
+    private clearLocalOperation;
+    private cachedRecords;
+    get(id: string, opts?: {
+        useCache?: boolean;
+        cacheTtlMs?: number;
+    }): Promise<T | undefined>;
+    list(filter?: DataFilter<T>, opts?: IDataQueryParams<T>): Promise<T[]>;
+    count(filter?: DataFilter<T>): Promise<number>;
+    cursor(filter?: DataFilter<T>, opts?: IDataQueryParams<T>): ICursorIterable<T>;
+    findOne(filter?: DataFilter<T>, opts?: {
+        enforceUnique?: boolean;
+    }): Promise<T | undefined>;
+    save(record: T, opts?: ISaveOptions): Promise<T>;
+    insert(record: T): Promise<T>;
+    update(record: T): Promise<T>;
+    delete(idOrRecord: string | T): Promise<void>;
+    initRecord(data?: Partial<T>): T;
+    initDoc(record: T): import("./doc").IDoc<T>;
+    getDoc(id: string): import("./doc").IDoc<T>;
+}
+export declare function getIconClassName(table: Table<any>): string;

package/dist/data/orm/table.event-source.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/data/orm/table.event-source.test.js

@@ -0,0 +1,341 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const table_1 = require("./table");
+const subscribable_data_source_1 = require("./subscribable.data-source");
+const types_1 = require("./types");
+const field_type_1 = require("../../types/field-type");
+const utils_1 = require("../../utils");
+const event_registry_1 = require("./event-registry");
+// Mock data source for testing
+class MockDataSource {
+    tableName;
+    primaryKeyName;
+    data = new Map();
+    constructor(tableName, primaryKeyName = 'id', initialData = []) {
+        this.tableName = tableName;
+        this.primaryKeyName = primaryKeyName;
+        initialData.forEach(item => {
+            this.data.set(item[primaryKeyName], item);
+        });
+    }
+    async get(id) {
+        return this.data.get(id);
+    }
+    async list() {
+        return Array.from(this.data.values());
+    }
+    async save(record) {
+        const id = record[this.primaryKeyName];
+        if (id && this.data.has(id)) {
+            return this.update(record);
+        }
+        else {
+            return this.insert(record);
+        }
+    }
+    async insert(record) {
+        if (!record[this.primaryKeyName]) {
+            // Create a new record with the generated ID
+            record = { ...record, [this.primaryKeyName]: (0, utils_1.newid)() };
+        }
+        this.data.set(record[this.primaryKeyName], record);
+        return record;
+    }
+    async update(record) {
+        const id = record[this.primaryKeyName];
+        if (!this.data.has(id)) {
+            throw new Error(`Record with id ${id} not found`);
+        }
+        this.data.set(id, record);
+        return record;
+    }
+    async delete(idOrRecord) {
+        const id = typeof idOrRecord === 'string' ? idOrRecord : idOrRecord[this.primaryKeyName];
+        this.data.delete(id);
+    }
+}
+describe('Table Event Source Functionality', () => {
+    let table;
+    let underlyingDataSource;
+    let subscribableDataSource;
+    let capturedEvents;
+    const testMetadata = {
+        name: 'TestTable',
+        description: 'Test table for event source functionality',
+        primaryKeyName: 'id',
+        fields: [
+            { name: 'id', type: field_type_1.FieldType.id, description: 'Primary key' },
+            { name: 'name', type: field_type_1.FieldType.string, description: 'Name field' },
+            { name: 'age', type: field_type_1.FieldType.number, description: 'Age field' }
+        ]
+    };
+    const testSchema = (0, types_1.fieldsToSchema)(testMetadata.fields);
+    const testRecord = {
+        id: 'test-1',
+        name: 'John Doe',
+        age: 30
+    };
+    beforeEach(() => {
+        capturedEvents = [];
+        // Create underlying data source with unique name to avoid conflicts
+        const uniqueTableName = `TestTable_${Date.now()}_${Math.random()}`;
+        underlyingDataSource = new MockDataSource(uniqueTableName, 'id');
+        // Wrap it in a SubscribableDataSource
+        subscribableDataSource = new subscribable_data_source_1.SubscribableDataSource(underlyingDataSource);
+        // Create real event registry for testing
+        const mockDataContextForRegistry = {
+            dataContextId: 'test-context'
+        };
+        const eventRegistry = new event_registry_1.EventRegistry(mockDataContextForRegistry);
+        const mockDataContext = {
+            dataSourceFactory: () => subscribableDataSource,
+            eventRegistry: eventRegistry
+        };
+        // Create table with the subscribable data source
+        const metaData = {
+            ...testMetadata,
+            name: uniqueTableName
+        };
+        const deps = {
+            dataSource: subscribableDataSource,
+            eventRegistry: eventRegistry,
+            schema: testSchema
+        };
+        table = new table_1.Table(metaData, deps);
+        // Subscribe to events to capture them
+        table.dataChanged.subscribe((event) => {
+            capturedEvents.push(event);
+        });
+    });
+    describe('Local Operations', () => {
+        it('should mark insert events as local when called from table', async () => {
+            await table.insert(testRecord);
+            expect(capturedEvents).toHaveLength(1);
+            expect(capturedEvents[0]).toEqual({
+                dataObject: testRecord,
+                op: 'insert',
+                source: 'local'
+            });
+        });
+        it('should mark update events as local when called from table', async () => {
+            // First insert the record
+            await table.insert(testRecord);
+            capturedEvents.length = 0; // Clear events
+            const updatedRecord = { ...testRecord, age: 31 };
+            await table.update(updatedRecord);
+            expect(capturedEvents).toHaveLength(1);
+            expect(capturedEvents[0]).toEqual({
+                dataObject: updatedRecord,
+                op: 'update',
+                source: 'local'
+            });
+        });
+        it('should mark delete events as local when called from table', async () => {
+            // First insert the record
+            await table.insert(testRecord);
+            capturedEvents.length = 0; // Clear events
+            await table.delete(testRecord.id);
+            expect(capturedEvents).toHaveLength(1);
+            expect(capturedEvents[0]).toEqual({
+                dataObject: testRecord,
+                op: 'delete',
+                source: 'local'
+            });
+        });
+        it('should mark save events as local (insert case)', async () => {
+            await table.save(testRecord);
+            expect(capturedEvents).toHaveLength(1);
+            expect(capturedEvents[0]).toEqual({
+                dataObject: testRecord,
+                op: 'insert',
+                source: 'local'
+            });
+        });
+        it('should mark save events as local (update case)', async () => {
+            // First insert the record directly to underlying source
+            await underlyingDataSource.insert(testRecord);
+            capturedEvents.length = 0; // Clear events
+            const updatedRecord = { ...testRecord, age: 31 };
+            await table.save(updatedRecord);
+            expect(capturedEvents).toHaveLength(1);
+            expect(capturedEvents[0]).toEqual({
+                dataObject: updatedRecord,
+                op: 'update',
+                source: 'local'
+            });
+        });
+    });
+    describe('Remote Operations', () => {
+        it('should mark insert events as remote when called from underlying source', async () => {
+            await subscribableDataSource.insert(testRecord);
+            expect(capturedEvents).toHaveLength(1);
+            expect(capturedEvents[0]).toEqual({
+                dataObject: testRecord,
+                op: 'insert',
+                source: 'remote'
+            });
+        });
+        it('should mark update events as remote when called from underlying source', async () => {
+            // First insert the record
+            await subscribableDataSource.insert(testRecord);
+            capturedEvents.length = 0; // Clear events
+            const updatedRecord = { ...testRecord, age: 31 };
+            await subscribableDataSource.update(updatedRecord);
+            expect(capturedEvents).toHaveLength(1);
+            expect(capturedEvents[0]).toEqual({
+                dataObject: updatedRecord,
+                op: 'update',
+                source: 'remote'
+            });
+        });
+        it('should mark delete events as remote when called from underlying source', async () => {
+            // First insert the record
+            await subscribableDataSource.insert(testRecord);
+            capturedEvents.length = 0; // Clear events
+            await subscribableDataSource.delete(testRecord.id);
+            expect(capturedEvents).toHaveLength(1);
+            expect(capturedEvents[0]).toEqual({
+                dataObject: testRecord,
+                op: 'delete',
+                source: 'remote'
+            });
+        });
+    });
+    describe('Concurrent Operations', () => {
+        it('should handle multiple concurrent insert operations correctly', async () => {
+            const record1 = { id: 'test-1', name: 'John', age: 30 };
+            const record2 = { id: 'test-2', name: 'Jane', age: 25 };
+            const record3 = { id: 'test-3', name: 'Bob', age: 35 };
+            // Execute multiple operations concurrently
+            await Promise.all([
+                table.insert(record1),
+                table.insert(record2),
+                table.insert(record3)
+            ]);
+            expect(capturedEvents).toHaveLength(3);
+            capturedEvents.forEach(event => {
+                expect(event.op).toBe('insert');
+                expect(event.source).toBe('local');
+            });
+            // Verify all records were inserted
+            const insertedIds = capturedEvents.map(e => e.dataObject.id).sort();
+            expect(insertedIds).toEqual(['test-1', 'test-2', 'test-3']);
+        });
+        it('should handle concurrent operations with different operations types', async () => {
+            const record1 = { id: 'test-1', name: 'John', age: 30 };
+            const record2 = { id: 'test-2', name: 'Jane', age: 25 };
+            // First insert records to set up for update/delete
+            await table.insert(record1);
+            await table.insert(record2);
+            capturedEvents.length = 0; // Clear events
+            const updatedRecord1 = { ...record1, age: 31 };
+            const record3 = { id: 'test-3', name: 'Alice', age: 28 };
+            // Execute mixed operations concurrently
+            await Promise.all([
+                table.update(updatedRecord1),
+                table.delete(record2.id),
+                table.insert(record3)
+            ]);
+            expect(capturedEvents).toHaveLength(3);
+            // All should be marked as local
+            capturedEvents.forEach(event => {
+                expect(event.source).toBe('local');
+            });
+            // Check specific operations
+            const operations = capturedEvents.map(e => e.op).sort();
+            expect(operations).toEqual(['delete', 'insert', 'update']);
+        });
+        it('should handle concurrent local and remote operations correctly', async () => {
+            const localRecord = { id: 'local-1', name: 'Local User', age: 30 };
+            const remoteRecord = { id: 'remote-1', name: 'Remote User', age: 25 };
+            // Execute local and remote operations concurrently
+            await Promise.all([
+                table.insert(localRecord),
+                subscribableDataSource.insert(remoteRecord)
+            ]);
+            expect(capturedEvents).toHaveLength(2);
+            // Find events by record ID
+            const localEvent = capturedEvents.find(e => e.dataObject.id === 'local-1');
+            const remoteEvent = capturedEvents.find(e => e.dataObject.id === 'remote-1');
+            expect(localEvent?.source).toBe('local');
+            expect(remoteEvent?.source).toBe('remote');
+        });
+        it('should handle concurrent operations on different records correctly', async () => {
+            const record1 = { id: 'test-1', name: 'John', age: 30 };
+            const record2 = { id: 'test-2', name: 'Jane', age: 25 };
+            // Insert records first
+            await table.insert(record1);
+            await subscribableDataSource.insert(record2);
+            capturedEvents.length = 0;
+            const localUpdate = { ...record1, name: 'John Local', age: 31 };
+            const remoteUpdate = { ...record2, name: 'Jane Remote', age: 26 };
+            // Execute concurrent updates on different records (one local, one remote)
+            await Promise.all([
+                table.update(localUpdate),
+                subscribableDataSource.update(remoteUpdate)
+            ]);
+            expect(capturedEvents).toHaveLength(2);
+            // Both operations should complete, but with different sources
+            const localEvent = capturedEvents.find(e => e.dataObject.name?.includes('Local'));
+            const remoteEvent = capturedEvents.find(e => e.dataObject.name?.includes('Remote'));
+            expect(localEvent?.source).toBe('local');
+            expect(remoteEvent?.source).toBe('remote');
+        });
+    });
+    describe('Cache Management', () => {
+        it('should clean up cache entries after operations complete', async () => {
+            const record = { id: 'test-1', name: 'John', age: 30 };
+            // Insert record
+            await table.insert(record);
+            // Verify the cache was cleaned up by checking that subsequent remote operations
+            // are marked as remote (not local)
+            const updatedRecord = { ...record, age: 31 };
+            await subscribableDataSource.update(updatedRecord);
+            expect(capturedEvents).toHaveLength(2);
+            expect(capturedEvents[0].source).toBe('local'); // Insert
+            expect(capturedEvents[1].source).toBe('remote'); // Update from subscribable source
+        });
+        it('should clean up cache entries even when operations throw errors', async () => {
+            const record = { id: 'nonexistent', name: 'John', age: 30 };
+            // Try to update a non-existent record (should throw)
+            try {
+                await table.update(record);
+            }
+            catch (error) {
+                // Expected to throw
+            }
+            // Now insert the same record through underlying source
+            await subscribableDataSource.insert(record);
+            // Should be marked as remote since cache was cleaned up
+            expect(capturedEvents).toHaveLength(1);
+            expect(capturedEvents[0].source).toBe('remote');
+        });
+    });
+    describe('Table Without Underlying SubscribableDataSource', () => {
+        it('should work correctly when no underlying SubscribableDataSource exists', async () => {
+            // Create table with plain data source (no SubscribableDataSource)
+            const plainDataSource = new MockDataSource('PlainTable', 'id');
+            const mockDataContextForRegistry2 = {
+                dataContextId: 'test-context-2'
+            };
+            const eventRegistry2 = new event_registry_1.EventRegistry(mockDataContextForRegistry2);
+            const mockDataContext = {
+                dataSourceFactory: () => plainDataSource,
+                eventRegistry: eventRegistry2
+            };
+            const plainTableDeps = {
+                dataSource: plainDataSource,
+                eventRegistry: eventRegistry2,
+                schema: testSchema
+            };
+            const plainTable = new table_1.Table(testMetadata, plainTableDeps);
+            const events = [];
+            plainTable.dataChanged.subscribe(event => {
+                events.push(event);
+            });
+            await plainTable.insert(testRecord);
+            expect(events).toHaveLength(1);
+            expect(events[0].source).toBe('local');
+        });
+    });
+});