@peers-app/peers-sdk 0.1.4

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

@@ -0,0 +1,171 @@
+"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 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',
+        fields: [
+            { 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', () => {
+        // Create mock dependencies
+        const mockDeps = {
+            dataSource: {
+                tableName: 'TestTable',
+                primaryKeyName: 'id',
+                list: jest.fn().mockResolvedValue([]),
+                get: jest.fn().mockResolvedValue(null),
+                save: jest.fn().mockResolvedValue({}),
+                insert: jest.fn().mockResolvedValue({}),
+                update: jest.fn().mockResolvedValue({}),
+                delete: jest.fn().mockResolvedValue(undefined),
+            },
+            eventRegistry: {
+                getEmitter: jest.fn().mockReturnValue({
+                    event: { subscribe: 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');
+        // Verify schema works by parsing test data successfully
+        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', () => {
+        // 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 });
+            }
+        }
+        const mockDeps = {
+            dataSource: {
+                tableName: 'CustomTable',
+                primaryKeyName: 'id',
+                list: jest.fn().mockResolvedValue([{ id: '1', name: 'test' }]),
+                get: jest.fn(),
+                save: jest.fn(),
+                insert: jest.fn(),
+                update: jest.fn(),
+                delete: jest.fn(),
+            },
+            eventRegistry: {
+                getEmitter: jest.fn().mockReturnValue({
+                    event: { subscribe: 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');
+    });
+    it('should create table dependencies using DataContext factory method', () => {
+        // Create mock DataContext
+        const mockUserContext = {
+            userId: () => 'test-user',
+            dataSourceFactory: jest.fn().mockReturnValue({
+                tableName: 'TestTable',
+                primaryKeyName: 'id',
+                list: jest.fn(),
+            })
+        };
+        const dataContext = new data_context_1.DataContext(mockUserContext);
+        // Use factory method to create dependencies
+        const deps = dataContext.createTableDependencies(testMetaData, testSchema);
+        // Verify dependencies were created correctly
+        expect(deps.dataSource).toBeDefined();
+        expect(deps.eventRegistry).toBeDefined();
+        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', () => {
+        // Create mock dependencies without schema
+        const mockDeps = {
+            dataSource: {
+                tableName: 'TestTable',
+                primaryKeyName: 'id',
+                list: jest.fn().mockResolvedValue([]),
+                get: jest.fn().mockResolvedValue(null),
+                save: jest.fn().mockResolvedValue({}),
+                insert: jest.fn().mockResolvedValue({}),
+                update: jest.fn().mockResolvedValue({}),
+                delete: jest.fn().mockResolvedValue(undefined),
+            },
+            eventRegistry: {
+                getEmitter: jest.fn().mockReturnValue({
+                    event: { subscribe: 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' };
+        expect(() => table.schema.parse(testData)).not.toThrow();
+    });
+    it('should create tables using DataContext convenience method', () => {
+        // Create mock DataContext  
+        const mockUserContext = {
+            userId: () => 'test-user',
+            dataSourceFactory: jest.fn().mockReturnValue({
+                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.schema).toBe(testSchema);
+    });
+    it('should create tables through TableFactory using new DI pattern internally', () => {
+        // Create mock DataContext
+        const mockUserContext = {
+            userId: () => 'test-user',
+            dataSourceFactory: jest.fn().mockReturnValue({
+                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.schema).toBe(testSchema);
+        expect(table.metaData).toBe(testMetaData);
+    });
+});

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

@@ -0,0 +1,26 @@
+import { Table } from "./table";
+import { Observable } from "../../observable";
+export type IDoc<T extends {
+    [key: string]: any;
+}> = {
+    load: (objOrId?: any) => Promise<IDoc<T>>;
+    save: () => Promise<IDoc<T>>;
+    delete: () => Promise<IDoc<T>>;
+    toJS: () => T;
+    validate: () => T;
+    validationError: Observable<any>;
+    table: Table<T>;
+    qs: {
+        [K in keyof T]-?: Observable<T[K]>;
+    };
+    q: Observable<number>;
+    displayValue: (() => string);
+    primaryKey: (() => string | number);
+    isNew: boolean;
+    hasChanges: () => boolean;
+} & {
+    [key in keyof T]: T[key];
+};
+export declare function initDoc<T extends {
+    [key: string]: any;
+}>(data: T, table: Table<T>): IDoc<T>;

package/dist/data/orm/doc.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initDoc = initDoc;
+const lodash_1 = require("lodash");
+const observable_1 = require("../../observable");
+function initDoc(data, table) {
+    const columns = [...table.metaData.fields];
+    // @ts-ignore
+    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
+                const id = objOrId || doc[table.metaData.primaryKeyName];
+                if (!id) {
+                    return doc;
+                }
+                objOrId = await table.get(id);
+                if (!objOrId) {
+                    throw new Error(`Could not find doc for ${table.tableName}:${id}`);
+                }
+                loadedFromDb = true;
+            }
+            const fieldNames = Object.keys(objOrId);
+            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
+                    doc[fieldName] = objOrId[fieldName];
+                    // @ts-ignore
+                    data[fieldName] = objOrId[fieldName];
+                }
+            }
+            if (loadedFromDb) {
+                doc.isNew = false;
+                doc.q(0);
+            }
+            return doc;
+        },
+        toJS: () => {
+            const _data = (0, lodash_1.cloneDeep)(data);
+            for (const field of table.metaData.fields) {
+                // @ts-ignore
+                _data[field.name] = doc[field.name];
+            }
+            return _data;
+        },
+        validationError: (0, observable_1.observable)(null),
+        validate: () => {
+            try {
+                const _data = doc.toJS();
+                doc.validationError(null);
+                table.schema.parse(_data);
+                return _data;
+            }
+            catch (err) {
+                doc.validationError(err);
+                throw err;
+            }
+        },
+        save: async () => {
+            let _data = doc.validate();
+            const src = await table.save(_data);
+            return doc.load(src).then(() => {
+                doc.isNew = false;
+                doc.q(0);
+                return doc;
+            });
+        },
+        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;
+            }
+            return displayValue || 'display value not configured';
+            // if (typeof displayValue === 'function') {
+            // 	return displayValue(doc);
+            // } else if (displayValue) {
+            // 	return doc[displayValue]
+            // } else {
+            // 	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 fieldQ = (0, observable_1.observable)(data[fieldName]);
+        fieldQ.subscribe(() => {
+            // @ts-ignore
+            data[fieldName] = fieldQ();
+            doc.q(doc.q() + 1);
+        });
+        // @ts-ignore
+        doc.qs[fieldName] = fieldQ;
+        Object.defineProperty(doc, fieldName, {
+            get: () => {
+                return fieldQ();
+            },
+            set: value => {
+                // @ts-ignore
+                data[fieldName] = value;
+                fieldQ(value);
+            }
+        });
+    });
+    return doc;
+}
+//@ts-ignore
+if (typeof window !== 'undefined')
+    window.initDoc = initDoc;

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

@@ -0,0 +1,24 @@
+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,
+ * enabling cross-package event subscription.
+ */
+export declare class EventRegistry {
+    private dataContextId;
+    private emitters;
+    constructor(dataContextId: string);
+    /**
+     * Gets or creates an emitter for the given event name.
+     * Multiple calls with the same eventName will return the same emitter instance.
+     */
+    getEmitter<T>(eventName: string): Emitter<T>;
+    /**
+     * Clear all emitters. Primarily for testing.
+     */
+    clear(): void;
+    /**
+     * Get count of registered emitters. Primarily for testing.
+     */
+    getEmitterCount(): number;
+}

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventRegistry = void 0;
+const events_1 = require("../../events");
+/**
+ * Registry for managing shared event emitters across table instances.
+ * Ensures that tables with the same name share the same event emitter,
+ * enabling cross-package event subscription.
+ */
+class EventRegistry {
+    dataContextId;
+    emitters = new Map();
+    constructor(dataContextId) {
+        this.dataContextId = dataContextId;
+    }
+    /**
+     * Gets or creates an emitter for the given event name.
+     * Multiple calls with the same eventName will return the same emitter instance.
+     */
+    getEmitter(eventName) {
+        eventName += `_${this.dataContextId}`;
+        if (!this.emitters.has(eventName)) {
+            this.emitters.set(eventName, new events_1.Emitter(eventName));
+        }
+        return this.emitters.get(eventName);
+    }
+    /**
+     * Clear all emitters. Primarily for testing.
+     */
+    clear() {
+        this.emitters.clear();
+    }
+    /**
+     * Get count of registered emitters. Primarily for testing.
+     */
+    getEmitterCount() {
+        return this.emitters.size;
+    }
+}
+exports.EventRegistry = EventRegistry;

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

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

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const event_registry_1 = require("./event-registry");
+describe('EventRegistry', () => {
+    let registry;
+    beforeEach(() => {
+        const mockDataContext = {
+            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');
+        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');
+        expect(emitter1).not.toBe(emitter2);
+        expect(registry.getEmitterCount()).toBe(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');
+        // They should be the same instance
+        expect(emitter1).toBe(emitter2);
+        // Test event flow
+        let receivedData;
+        emitter1.event.subscribe((data) => {
+            receivedData = data;
+        });
+        await emitter2.emit('test-data');
+        expect(receivedData).toBe('test-data');
+    });
+});

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

@@ -0,0 +1,8 @@
+import { DataFilter } from "./data-query";
+import { Table } from "./table";
+import { 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
+ */
+export declare function applyFilterToItem(item: Record<string, any>, filter: DataFilter<any>): boolean;

package/dist/data/orm/factory.js

@@ -0,0 +1,147 @@
+"use strict";
+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");
+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 valueType = typeof firstValue;
+            let dataType = field_type_1.FieldType.any;
+            if (valueType !== 'object' && valueType !== 'function' && valueType !== 'symbol') {
+                dataType = valueType;
+            }
+            let optional = false;
+            return {
+                name,
+                description: '',
+                type: dataType,
+                optional
+            };
+        });
+    }
+    const metaData = {
+        name: `inMemoryTable_${inMemoryTableCount++}`,
+        description: 'In-memory table',
+        primaryKeyName: fields.find(f => f.type === 'id')?.name || 'id',
+        fields,
+        ...opts,
+    };
+    const dataSource = {
+        tableName: metaData.name,
+        primaryKeyName: metaData.primaryKeyName,
+        list: async (filter = {}, opts = {}) => {
+            const filteredArray = ary.filter(item => applyFilterToItem(item, filter));
+            if (opts.pageSize) {
+                const page = opts.page || 1;
+                const pageSize = opts.pageSize;
+                const subAry = filteredArray.slice((page - 1) * opts.pageSize, (page - 1) * pageSize + pageSize);
+                return [...subAry];
+            }
+            return [...filteredArray];
+        },
+        count: async (filter = {}) => {
+            return ary.filter(item => applyFilterToItem(item, filter)).length;
+        },
+        get: async (id) => ary.find(item => item[metaData.primaryKeyName] === id),
+        save: async (record) => {
+            const existing = ary.find(item => item[metaData.primaryKeyName] === record[metaData.primaryKeyName]);
+            if (existing) {
+                return dataSource.update(record);
+            }
+            else {
+                return dataSource.insert(record);
+            }
+        },
+        insert: async (record) => {
+            ary.push(record);
+            return record;
+        },
+        update: async (record) => {
+            const existing = ary.find(item => item[metaData.primaryKeyName] === record[metaData.primaryKeyName]);
+            if (existing) {
+                Object.assign(existing, record);
+            }
+            else {
+                throw new Error(`Record with id ${record[metaData.primaryKeyName]} not found`);
+            }
+            return record;
+        },
+        delete: async (id) => {
+            if (typeof id === 'object') {
+                id = id[metaData.primaryKeyName];
+            }
+            const index = ary.findIndex(item => item[metaData.primaryKeyName] === id);
+            if (index >= 0) {
+                ary.splice(index, 1);
+            }
+        },
+    };
+    const mockDataContextForRegistry = {
+        dataContextId: 'array-table-context'
+    };
+    const eventRegistry = new (require('./event-registry').EventRegistry)(mockDataContextForRegistry);
+    const deps = {
+        dataSource,
+        eventRegistry
+    };
+    return new table_1.Table(metaData, deps);
+}
+/**
+ * WARNING: this is an incomplete implementation of applyFilterToItem
+ */
+function applyFilterToItem(item, filter) {
+    const _filter = filter;
+    if (!Object.keys(_filter).length) {
+        return true;
+    }
+    for (const key in filter) {
+        if (key === '$and') {
+            return _filter.$and.every((subFilter) => applyFilterToItem(item, subFilter));
+        }
+        if (key === '$or') {
+            return _filter.$or.some((subFilter) => applyFilterToItem(item, subFilter));
+        }
+        if (key === '$lt') {
+            return item < _filter.$lt;
+        }
+        if (key === '$lte') {
+            return item <= _filter.$lte;
+        }
+        if (key === '$gt') {
+            return item > _filter.$gt;
+        }
+        if (key === '$gte') {
+            return item >= _filter.$gte;
+        }
+        if (key === '$ne') {
+            return item !== _filter.$ne;
+        }
+        if (key === '$in') {
+            return _filter.$in.includes(item);
+        }
+        if (key === '$nin') {
+            return !_filter.$nin.includes(item);
+        }
+        if (key.startsWith('$')) {
+            throw new Error(`Unsupported filter key: ${key}`);
+        }
+        const subFilter = _filter[key];
+        const value = item[key];
+        if ((0, lodash_1.isArray)(subFilter)) {
+            return subFilter.includes(value);
+        }
+        if (typeof subFilter === 'object') {
+            return applyFilterToItem(value, subFilter);
+        }
+        return value === subFilter;
+    }
+    return true;
+}

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

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

package/dist/data/orm/index.js

@@ -0,0 +1,32 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./data-query"), exports);
+__exportStar(require("./sql-db"), exports);
+__exportStar(require("./doc"), exports);
+__exportStar(require("./factory"), exports);
+__exportStar(require("./table"), exports);
+__exportStar(require("./table-dependencies"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./sql.data-source"), exports);
+__exportStar(require("./client-proxy.data-source"), exports);
+__exportStar(require("./table-container"), exports);
+__exportStar(require("./subscribable.data-source"), exports);
+__exportStar(require("./event-registry"), exports);
+__exportStar(require("./table-definitions.type"), exports);
+__exportStar(require("./multi-cursors"), exports);
+__exportStar(require("./cursor"), exports);
+__exportStar(require("./decorators"), exports);

package/dist/data/orm/multi-cursors.d.ts

@@ -0,0 +1,11 @@
+import { ICursorIterable, DataFilter, IDataQueryParams } from './data-query';
+export declare function cursorUnion<T>(cursors: ICursorIterable<T>[]): ICursorIterable<T>;
+export declare function sortLikeSQL(sortByFields: string[], valueA: any, valueB: any): 0 | 1 | -1;
+export declare function queryMerge<T extends {
+    [key: string]: any;
+}>(dataSources: {
+    list: (filter?: DataFilter<T>, opts?: IDataQueryParams<T>) => Promise<T[]>;
+    primaryKeyName: string;
+}[], filter?: DataFilter<T>, opts?: IDataQueryParams<T>): ICursorIterable<T>;
+export declare function cursorMap<T, U>(sourceCursor: ICursorIterable<T>, mapFn: (item: T) => U | Promise<U>): ICursorIterable<U>;
+export declare function cursorFilter<T>(sourceCursor: ICursorIterable<T>, filterFn: (item: T) => boolean | Promise<boolean>): ICursorIterable<T>;