@peers-app/peers-sdk 0.1.4

package/dist/data/orm/cursor.test.js

@@ -0,0 +1,315 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cursor_1 = require("./cursor");
+const data_query_1 = require("./data-query");
+const factory_1 = require("./factory");
+function createMockCursor(items) {
+    let index = 0;
+    const cursor = {
+        value: null,
+        next: async (_skipPast) => {
+            if (index >= items.length) {
+                cursor.value = null;
+                return null;
+            }
+            cursor.value = items[index];
+            index++;
+            return cursor.value;
+        },
+    };
+    return (0, data_query_1.iterableCursor)(cursor);
+}
+describe('Cursor', () => {
+    describe('basic functionality', () => {
+        it('should wrap an ICursorIterable and implement the interface', async () => {
+            const mockCursor = createMockCursor([1, 2, 3]);
+            const cursor = new cursor_1.Cursor(mockCursor);
+            const results = [];
+            for await (const item of cursor) {
+                results.push(item);
+            }
+            expect(results).toEqual([1, 2, 3]);
+        });
+        it('should support manual next() calls', async () => {
+            const mockCursor = createMockCursor(['a', 'b', 'c']);
+            const cursor = new cursor_1.Cursor(mockCursor);
+            const results = [];
+            while (await cursor.next()) {
+                results.push(cursor.value);
+            }
+            expect(results).toEqual(['a', 'b', 'c']);
+        });
+        it('should maintain cursor.value correctly', async () => {
+            const mockCursor = createMockCursor([10, 20]);
+            const cursor = new cursor_1.Cursor(mockCursor);
+            expect(cursor.value).toBeNull();
+            await cursor.next();
+            expect(cursor.value).toBe(10);
+            await cursor.next();
+            expect(cursor.value).toBe(20);
+            const result = await cursor.next();
+            expect(result).toBeNull();
+            expect(cursor.value).toBeNull();
+        });
+    });
+    describe('static factory methods', () => {
+        it('should create cursor from ICursorIterable using from()', async () => {
+            const mockCursor = createMockCursor([1, 2, 3]);
+            const cursor = cursor_1.Cursor.from(mockCursor);
+            const results = [];
+            for await (const item of cursor) {
+                results.push(item);
+            }
+            expect(results).toEqual([1, 2, 3]);
+        });
+        it('should create union cursor using static union()', async () => {
+            const cursor1 = createMockCursor([1, 2]);
+            const cursor2 = createMockCursor([3, 4]);
+            const cursor3 = createMockCursor([5, 6]);
+            const unionCursor = cursor_1.Cursor.union(cursor1, cursor2, cursor3);
+            const results = [];
+            for await (const item of unionCursor) {
+                results.push(item);
+            }
+            expect(results).toEqual([1, 2, 3, 4, 5, 6]);
+        });
+        it('should handle mix of Cursor and ICursorIterable in static union()', async () => {
+            const cursor1 = new cursor_1.Cursor(createMockCursor([1, 2]));
+            const cursor2 = createMockCursor([3, 4]);
+            const unionCursor = cursor_1.Cursor.union(cursor1, cursor2);
+            const results = [];
+            for await (const item of unionCursor) {
+                results.push(item);
+            }
+            expect(results).toEqual([1, 2, 3, 4]);
+        });
+    });
+    describe('instance methods', () => {
+        it('should create union cursor using instance union()', async () => {
+            const cursor1 = new cursor_1.Cursor(createMockCursor([1, 2]));
+            const cursor2 = createMockCursor([3, 4]);
+            const cursor3 = new cursor_1.Cursor(createMockCursor([5, 6]));
+            const unionCursor = cursor1.union(cursor2, cursor3);
+            const results = [];
+            for await (const item of unionCursor) {
+                results.push(item);
+            }
+            expect(results).toEqual([1, 2, 3, 4, 5, 6]);
+        });
+        it('should map cursor values using instance map()', async () => {
+            const cursor = new cursor_1.Cursor(createMockCursor([1, 2, 3, 4, 5]));
+            const mappedCursor = cursor.map((x) => x * 2);
+            const results = [];
+            for await (const item of mappedCursor) {
+                results.push(item);
+            }
+            expect(results).toEqual([2, 4, 6, 8, 10]);
+        });
+        it('should support async mapping functions', async () => {
+            const cursor = new cursor_1.Cursor(createMockCursor(['hello', 'world']));
+            const mappedCursor = cursor.map(async (x) => {
+                await new Promise(resolve => setTimeout(resolve, 1));
+                return x.toUpperCase();
+            });
+            const results = [];
+            for await (const item of mappedCursor) {
+                results.push(item);
+            }
+            expect(results).toEqual(['HELLO', 'WORLD']);
+        });
+        it('should support method chaining', async () => {
+            const cursor1 = new cursor_1.Cursor(createMockCursor([1, 2]));
+            const cursor2 = createMockCursor([3, 4]);
+            const result = cursor1
+                .union(cursor2)
+                .map(x => x * 10)
+                .map(x => `num: ${x}`);
+            const results = [];
+            for await (const item of result) {
+                results.push(item);
+            }
+            expect(results).toEqual(['num: 10', 'num: 20', 'num: 30', 'num: 40']);
+        });
+        it('should handle empty cursors in operations', async () => {
+            const cursor1 = new cursor_1.Cursor(createMockCursor([]));
+            const cursor2 = createMockCursor([1, 2]);
+            const unionCursor = cursor1.union(cursor2);
+            const mappedCursor = unionCursor.map(x => x * 2);
+            const results = [];
+            for await (const item of mappedCursor) {
+                results.push(item);
+            }
+            expect(results).toEqual([2, 4]);
+        });
+    });
+    describe('error handling', () => {
+        it('should propagate skipPast errors from map()', async () => {
+            const cursor = new cursor_1.Cursor(createMockCursor([1, 2, 3]));
+            const mappedCursor = cursor.map(x => x * 2);
+            await expect(mappedCursor.next(4)).rejects.toThrow('skipPast is not supported for cursorMap since the mapped cursor has a different type than the source cursor');
+        });
+        it('should propagate async errors from mapping functions', async () => {
+            const cursor = new cursor_1.Cursor(createMockCursor([1, 2, 3]));
+            const mappedCursor = cursor.map(async (x) => {
+                if (x === 2) {
+                    throw new Error('Test error');
+                }
+                return x * 2;
+            });
+            const results = [];
+            let errorCaught = false;
+            try {
+                for await (const item of mappedCursor) {
+                    results.push(item);
+                }
+            }
+            catch (error) {
+                errorCaught = true;
+                expect(error.message).toBe('Test error');
+            }
+            expect(errorCaught).toBe(true);
+            expect(results).toEqual([2]); // Only first item before error
+        });
+    });
+    describe('static factory methods for data sources', () => {
+        it('should create cursor from single dataSource using fromDataSource', async () => {
+            const dataSource = (0, factory_1.arrayAsTable)([
+                { id: 1, name: 'Alice' },
+                { id: 2, name: 'Bob' },
+                { id: 3, name: 'Charlie' },
+            ], { name: 'users' });
+            const cursor = cursor_1.Cursor.fromDataSource(dataSource, {}, { sortBy: ['name'] });
+            const results = [];
+            for await (const item of cursor) {
+                results.push(item);
+            }
+            expect(results.map(r => r.name)).toEqual(['Alice', 'Bob', 'Charlie']);
+        });
+        it('should create cursor from multiple dataSources using fromDataSources', async () => {
+            const dataSource1 = (0, factory_1.arrayAsTable)([
+                { id: 1, name: 'Alice' },
+                { id: 3, name: 'Charlie' },
+            ], { name: 'users1' });
+            const dataSource2 = (0, factory_1.arrayAsTable)([
+                { id: 2, name: 'Bob' },
+                { id: 4, name: 'David' },
+            ], { name: 'users2' });
+            const cursor = cursor_1.Cursor.fromDataSources([dataSource1, dataSource2]);
+            const results = [];
+            for await (const item of cursor) {
+                results.push(item);
+            }
+            expect(results.map(r => r.id)).toEqual([1, 2, 3, 4]);
+        });
+        it('should support filters and options with fromDataSource', async () => {
+            const dataSource = (0, factory_1.arrayAsTable)([
+                { id: 1, name: 'Alice', age: 25 },
+                { id: 2, name: 'Bob', age: 30 },
+                { id: 3, name: 'Charlie', age: 35 },
+            ], { name: 'users' });
+            const cursor = cursor_1.Cursor.fromDataSource(dataSource, { age: { $gte: 30 } }, { sortBy: ['name'] });
+            const results = [];
+            for await (const item of cursor) {
+                results.push(item);
+            }
+            // Should only get Bob and Charlie (age >= 30), sorted by name
+            expect(results.map(r => r.name)).toEqual(['Bob', 'Charlie']);
+        });
+        it('should support filters and options with fromDataSources', async () => {
+            const dataSource1 = (0, factory_1.arrayAsTable)([
+                { id: 1, name: 'Alice', age: 25 },
+                { id: 2, name: 'Bob', age: 30 },
+            ], { name: 'users1' });
+            const dataSource2 = (0, factory_1.arrayAsTable)([
+                { id: 3, name: 'Charlie', age: 35 },
+                { id: 4, name: 'David', age: 20 },
+            ], { name: 'users2' });
+            const cursor = cursor_1.Cursor.fromDataSources([dataSource1, dataSource2], { age: { $gte: 25 } }, { sortBy: ['name'] });
+            const results = [];
+            for await (const item of cursor) {
+                results.push(item);
+            }
+            // Should get Alice, Bob, Charlie (age >= 25), sorted by name
+            expect(results.map(r => r.name)).toEqual(['Alice', 'Bob', 'Charlie']);
+        });
+        it('should work with method chaining after fromDataSource', async () => {
+            const dataSource = (0, factory_1.arrayAsTable)([
+                { id: 1, name: 'Alice' },
+                { id: 2, name: 'Bob' },
+            ], { name: 'users' });
+            const cursor = cursor_1.Cursor.fromDataSource(dataSource)
+                .map(item => item.name.toUpperCase());
+            const results = [];
+            for await (const item of cursor) {
+                results.push(item);
+            }
+            expect(results).toEqual(['ALICE', 'BOB']);
+        });
+        it('should filter cursor values using instance filter()', async () => {
+            const cursor = new cursor_1.Cursor(createMockCursor([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]));
+            const filteredCursor = cursor.filter((x) => x % 3 === 0);
+            const results = [];
+            for await (const item of filteredCursor) {
+                results.push(item);
+            }
+            expect(results).toEqual([3, 6, 9]);
+        });
+        it('should support async filter functions', async () => {
+            const cursor = new cursor_1.Cursor(createMockCursor(['apple', 'banana', 'cherry', 'date', 'elderberry']));
+            const filteredCursor = cursor.filter(async (x) => {
+                await new Promise(resolve => setTimeout(resolve, 1));
+                return x.startsWith('a') || x.startsWith('e');
+            });
+            const results = [];
+            for await (const item of filteredCursor) {
+                results.push(item);
+            }
+            expect(results).toEqual(['apple', 'elderberry']);
+        });
+        it('should support method chaining with filter', async () => {
+            const cursor = new cursor_1.Cursor(createMockCursor([
+                { id: 1, name: 'Alice', age: 25 },
+                { id: 2, name: 'Bob', age: 30 },
+                { id: 3, name: 'Charlie', age: 35 },
+                { id: 4, name: 'David', age: 20 }
+            ]));
+            const result = cursor
+                .filter(person => person.age >= 25)
+                .map(person => person.name.toUpperCase())
+                .filter(name => name.includes('A'));
+            const results = [];
+            for await (const item of result) {
+                results.push(item);
+            }
+            expect(results).toEqual(['ALICE', 'CHARLIE']);
+        });
+        it('should handle empty results after filtering', async () => {
+            const cursor = new cursor_1.Cursor(createMockCursor([1, 2, 3, 4, 5]));
+            const filteredCursor = cursor.filter(x => x > 10);
+            const results = [];
+            for await (const item of filteredCursor) {
+                results.push(item);
+            }
+            expect(results).toEqual([]);
+        });
+        it('should propagate skipPast errors from filter()', async () => {
+            const cursor = new cursor_1.Cursor(createMockCursor([1, 2, 3, 4, 5]));
+            const filteredCursor = cursor.filter(x => x > 2);
+            await expect(filteredCursor.next(3)).rejects.toThrow('skipPast is not supported for cursorFilter since filtering changes the cursor iteration order');
+        });
+        it('should support complex method chaining with union, filter, and map', async () => {
+            const cursor1 = new cursor_1.Cursor(createMockCursor([1, 2, 3]));
+            const cursor2 = createMockCursor([4, 5, 6]);
+            const cursor3 = createMockCursor([7, 8, 9]);
+            const result = cursor1
+                .union(cursor2, cursor3)
+                .filter(x => x % 2 === 1) // odd numbers
+                .map(x => x * 10);
+            const results = [];
+            for await (const item of result) {
+                results.push(item);
+            }
+            expect(results).toEqual([10, 30, 50, 70, 90]);
+        });
+    });
+});

package/dist/data/orm/data-query.d.ts

@@ -0,0 +1,96 @@
+export interface ISaveOptions {
+    restoreIfDeleted?: boolean;
+    saveAsSnapshot?: boolean;
+}
+export interface IDataSource<T extends {
+    [key: string]: any;
+}> {
+    readonly tableName: string;
+    readonly primaryKeyName: string;
+    get: (id: string) => 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>;
+    save: (record: T, opts?: ISaveOptions) => Promise<T>;
+    insert: (record: T) => Promise<T>;
+    update: (record: T) => Promise<T>;
+    delete: (data: string | T) => Promise<void>;
+}
+export interface ITable<T extends Record<string, any>> {
+    tableName: string;
+    metaData: {
+        primaryKeyName: string;
+        fields: {
+            name: string;
+            type: string;
+        }[];
+    };
+    list: (filter: DataFilter<T>, opts: {
+        page?: number;
+        pageSize?: number;
+        sortBy?: SortBy<T>;
+        textSearch?: string;
+    }) => Promise<T[]>;
+}
+export interface IDataQueryParams<T extends Record<string, any>> {
+    page?: number;
+    pageSize?: number;
+    sortBy?: SortBy<T>;
+    filter?: DataFilter<T>;
+    textSearch?: string;
+    textSearchExact?: boolean;
+    skipPast?: T;
+}
+export declare class DataQuery<T extends Record<string, any>> {
+    readonly table: ITable<T>;
+    constructor(table: ITable<T>, { page, pageSize, sortBy, filter, textSearch, textSearchExact, }?: IDataQueryParams<T>);
+    page?: number;
+    pageSize?: number;
+    sortBy?: SortBy<T>;
+    filter?: DataFilter<T>;
+    textSearch?: string;
+    textSearchExact?: boolean;
+    cursor(): ICursorIterable<T>;
+    list(): Promise<T[]>;
+}
+export interface ICursor<T> {
+    value: T | null;
+    next: (skipPast?: T) => Promise<T | null>;
+}
+export type ICursorIterable<T> = ICursor<T> & AsyncIterable<T>;
+export declare function iterableCursor<T>(cursor: ICursor<T>): ICursorIterable<T>;
+export declare function dataSourceCursor<T extends {
+    [key: string]: any;
+}>(dataSource: {
+    list: (filter?: DataFilter<T>, opts?: IDataQueryParams<T>) => Promise<T[]>;
+    primaryKeyName: string;
+}, filter?: DataFilter<T>, opts?: IDataQueryParams<T>): ICursorIterable<T>;
+export declare function dataSourceCount<T extends {
+    [key: string]: any;
+}>(dataSource: {
+    count?: (filter?: DataFilter<T>) => Promise<number>;
+    list: (filter?: DataFilter<T>, opts?: IDataQueryParams<T>) => Promise<T[]>;
+    primaryKeyName: string;
+}, filter?: DataFilter<T>): Promise<number>;
+export type SortBy<T extends {
+    [key: string]: any;
+}> = (keyof T extends string | number ? keyof T | `-${keyof T}` : never)[];
+export type DataFieldScalar = boolean | number | string | Date | null;
+export type DataFilterValueOperator = '$eq' | '$ne' | '$gt' | '$gte' | '$lt' | '$lte' | '$exists' | '$matchWords' | '$substr' | '$expr' | '$in';
+export type DataFilterValue = DataFieldScalar | DataFieldScalar[] | {
+    [key in Exclude<DataFilterValueOperator, '$in'>]?: DataFieldScalar;
+} | {
+    $nin: DataFieldScalar[];
+} | {
+    $in: DataFieldScalar[];
+};
+export type DataFilterAnd<T> = {
+    [key in keyof T]?: DataFilterValue;
+};
+export type DataFilterOr<T> = DataFilterAnd<T>[] | {
+    $or: DataFilterAnd<T>[];
+};
+export type DataFilter<T> = DataFilterAnd<T> | DataFilterOr<T> | {
+    $and: DataFilter<T>[];
+};
+export declare function filterToSkipPastValue(filter: DataFilter<unknown>, sortBy: string[], skipPast: any): DataFilter<unknown>;

package/dist/data/orm/data-query.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataQuery = void 0;
+exports.iterableCursor = iterableCursor;
+exports.dataSourceCursor = dataSourceCursor;
+exports.dataSourceCount = dataSourceCount;
+exports.filterToSkipPastValue = filterToSkipPastValue;
+class DataQuery {
+    table;
+    constructor(table, { page, pageSize, sortBy, filter, textSearch, textSearchExact, } = {}) {
+        this.table = table;
+        this.page = page;
+        this.pageSize = pageSize;
+        this.sortBy = sortBy;
+        this.filter = filter;
+        this.textSearch = textSearch;
+        this.textSearchExact = textSearchExact;
+    }
+    page;
+    pageSize;
+    sortBy;
+    filter;
+    textSearch;
+    textSearchExact;
+    cursor() {
+        let buffer = [];
+        let eof = false;
+        const cursor = {
+            value: null,
+            next: async (skipPast) => {
+                if (eof) {
+                    return null;
+                }
+                if (!buffer.length) {
+                    const sortBy = (this.sortBy?.length && this.sortBy || [this.table.metaData.primaryKeyName]);
+                    if (!sortBy.includes(this.table.metaData.primaryKeyName) && !sortBy.includes(`-${this.table.metaData.primaryKeyName}`)) {
+                        sortBy.push(this.table.metaData.primaryKeyName);
+                    }
+                    let filter = { ...this.filter };
+                    skipPast = (skipPast || cursor.value) ?? undefined;
+                    if (skipPast) {
+                        filter = filterToSkipPastValue(filter, sortBy, skipPast);
+                    }
+                    const data = await this.table.list(filter, {
+                        page: 1,
+                        pageSize: this.pageSize,
+                        sortBy: sortBy,
+                        textSearch: this.textSearch
+                    });
+                    buffer = data;
+                }
+                if (buffer.length) {
+                    cursor.value = buffer.shift() ?? null;
+                    return cursor.value;
+                }
+                else {
+                    eof = true;
+                    cursor.value = null;
+                    return null;
+                }
+            },
+        };
+        return iterableCursor(cursor);
+    }
+    async list() {
+        if (!this.table.list) {
+            throw new Error(`table does not support list`);
+        }
+        const sortBy = (this.sortBy?.length && this.sortBy || [this.table.metaData.primaryKeyName]);
+        if (!sortBy.includes(this.table.metaData.primaryKeyName) && !sortBy.includes(`-${this.table.metaData.primaryKeyName}`)) {
+            sortBy.push(this.table.metaData.primaryKeyName);
+        }
+        return this.table.list({ ...this.filter }, {
+            page: this.page,
+            pageSize: this.pageSize,
+            sortBy: sortBy,
+            textSearch: this.textSearch,
+        });
+    }
+}
+exports.DataQuery = DataQuery;
+function iterableCursor(cursor) {
+    // @ts-expect-error - we're explicitly extending the cursor object to have this symbol
+    cursor[Symbol.asyncIterator] = () => {
+        return {
+            next: async () => {
+                const value = await cursor.next();
+                return { value, done: !value };
+            }
+        };
+    };
+    return cursor;
+}
+function dataSourceCursor(dataSource, filter = {}, opts = {}) {
+    // if (dataSource.cursor) {
+    //   return dataSource.cursor(filter, opts);
+    // }
+    let buffer = [];
+    let bufferPromise = undefined;
+    let eof = false;
+    const primaryKeyName = dataSource.primaryKeyName;
+    const pageSize = opts.pageSize || 100;
+    const cursor = {
+        value: null,
+        next: async (skipPast) => {
+            if (eof) {
+                return null;
+            }
+            if (skipPast) {
+                buffer = [];
+                bufferPromise = undefined;
+            }
+            if (!buffer.length) {
+                const sortBy = (opts.sortBy?.length && opts.sortBy || [primaryKeyName]);
+                if (!sortBy.includes(primaryKeyName) && !sortBy.includes(`-${primaryKeyName}`)) {
+                    sortBy.push(primaryKeyName);
+                }
+                let pageFilter = { ...filter };
+                skipPast = (skipPast || cursor.value) ?? opts.skipPast;
+                if (skipPast) {
+                    pageFilter = filterToSkipPastValue(pageFilter, sortBy, skipPast);
+                }
+                buffer = await (bufferPromise ||
+                    dataSource.list(pageFilter, {
+                        page: 1,
+                        pageSize,
+                        sortBy: sortBy,
+                        textSearch: opts.textSearch
+                    }));
+                const nextSkipPast = buffer[buffer.length - 1];
+                if (nextSkipPast) {
+                    pageFilter = filterToSkipPastValue(pageFilter, sortBy, nextSkipPast);
+                    bufferPromise = dataSource.list(pageFilter, {
+                        page: 1,
+                        pageSize,
+                        sortBy: sortBy,
+                        textSearch: opts.textSearch
+                    });
+                }
+            }
+            if (buffer.length) {
+                cursor.value = buffer.shift() ?? null;
+                return cursor.value;
+            }
+            else {
+                eof = true;
+                cursor.value = null;
+                return null;
+            }
+        },
+    };
+    return iterableCursor(cursor);
+}
+async function dataSourceCount(dataSource, filter = {}) {
+    if (dataSource.count) {
+        return dataSource.count(filter);
+    }
+    console.warn(`count is not supported by upstream data-source, falling back to cursor`);
+    const cursor = dataSourceCursor(dataSource, filter);
+    let count = 0;
+    for await (const _ of cursor) {
+        count++;
+    }
+    return count;
+}
+function filterToSkipPastValue(filter, sortBy, skipPast) {
+    const sortByFilters = [];
+    for (let i = 0; i < sortBy.length; i++) {
+        const filterEq = {};
+        for (let j = i; j >= 0; j--) {
+            const key = sortBy[j];
+            const desc = key.startsWith('-');
+            const fieldName = desc ? key.substring(1) : key;
+            const value = skipPast[fieldName];
+            let op = '';
+            if (desc) {
+                if (j === i) {
+                    op = '$lt';
+                }
+                else {
+                    op = '$eq';
+                }
+            }
+            else {
+                if (j === i) {
+                    op = '$gt';
+                }
+                else {
+                    op = '$eq';
+                }
+            }
+            if (value === undefined || value === null) {
+                if (op === '$eq') {
+                    filterEq[fieldName] = { $exists: false };
+                }
+                else {
+                    filterEq[fieldName] = { $exists: true };
+                }
+            }
+            else {
+                filterEq[fieldName] = { [op]: value };
+            }
+        }
+        sortByFilters.push(filterEq);
+    }
+    filter = { $and: [filter, { $or: sortByFilters }] };
+    return filter;
+}

package/dist/data/orm/data-query.mongo.d.ts

@@ -0,0 +1,17 @@
+import { DataFilter } from './data-query';
+/**
+ * Converts a DataFilter to a MongoDB query object
+ */
+export declare function dataFilterToMongoQuery(filter: DataFilter<any>): any;
+/**
+ * Converts DataQuery sort format to MongoDB sort format
+ */
+export declare function sortByToMongoSort(sortBy?: string[]): any;
+/**
+ * Converts DataQuery pagination to MongoDB skip/limit
+ */
+export interface MongoPagination {
+    skip?: number;
+    limit?: number;
+}
+export declare function paginationToMongoSkipLimit(page?: number, pageSize?: number): MongoPagination;