@peers-app/peers-sdk 0.1.4

package/dist/data/orm/multi-cursors.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cursorUnion = cursorUnion;
+exports.sortLikeSQL = sortLikeSQL;
+exports.queryMerge = queryMerge;
+exports.cursorMap = cursorMap;
+exports.cursorFilter = cursorFilter;
+const data_query_1 = require("./data-query");
+function cursorUnion(cursors) {
+    let currentCursorIndex = 0;
+    const cursor = {
+        value: null,
+        next: async (skipPast) => {
+            if (currentCursorIndex >= cursors.length) {
+                cursor.value = null;
+                return null;
+            }
+            const currentCursor = cursors[currentCursorIndex];
+            const nextValue = await currentCursor.next(skipPast);
+            if (nextValue === null) {
+                currentCursorIndex++;
+                return cursor.next(skipPast);
+            }
+            cursor.value = nextValue;
+            return nextValue;
+        },
+    };
+    return (0, data_query_1.iterableCursor)(cursor);
+}
+function sortLikeSQL(sortByFields, valueA, valueB) {
+    for (const field of sortByFields) {
+        const isDesc = field.startsWith('-');
+        const key = isDesc ? field.slice(1) : field;
+        let a = valueA[key];
+        let b = valueB[key];
+        if (typeof a === 'string' && (b == null || b === undefined)) {
+            return isDesc ? -1 : 1;
+        }
+        if (typeof b === 'string' && (a == null || a === undefined)) {
+            return isDesc ? 1 : -1;
+        }
+        // convert undefined to -Infinity to preserve SQL-like sorting behavior
+        a = valueA[key] ?? -Infinity;
+        b = valueB[key] ?? -Infinity;
+        if (a < b)
+            return isDesc ? 1 : -1;
+        if (a > b)
+            return isDesc ? -1 : 1;
+    }
+    return 0;
+}
+function queryMerge(dataSources, filter = {}, opts = {}) {
+    if (dataSources.length === 0) {
+        const cursor = {
+            value: null,
+            next: async () => {
+                cursor.value = null;
+                return null;
+            },
+        };
+        return (0, data_query_1.iterableCursor)(cursor);
+    }
+    const primaryKeyName = dataSources[0].primaryKeyName;
+    const sortBy = (opts.sortBy?.length ? opts.sortBy : [primaryKeyName]);
+    // Create cursors for each data source
+    const cursors = dataSources.map(dataSource => (0, data_query_1.dataSourceCursor)(dataSource, filter, opts));
+    // Keep track of the current "head" value from each cursor
+    const heads = new Array(cursors.length).fill(null);
+    let initialized = false;
+    const cursor = {
+        value: null,
+        next: async (skipPast) => {
+            // Initialize all cursors on first call
+            if (!initialized) {
+                await Promise.all(cursors.map(async (cursor, i) => {
+                    heads[i] = await cursor.next(skipPast);
+                }));
+                initialized = true;
+            }
+            // Find the next item according to sort order
+            let nextIndex = -1;
+            let nextValue = null;
+            for (let i = 0; i < heads.length; i++) {
+                const currentHead = heads[i];
+                if (currentHead !== null) {
+                    if (nextValue === null || sortLikeSQL(sortBy, currentHead, nextValue) < 0) {
+                        nextIndex = i;
+                        nextValue = currentHead;
+                    }
+                }
+            }
+            if (nextValue === null) {
+                cursor.value = null;
+                return null;
+            }
+            // Consume the selected value and get the next from that cursor
+            heads[nextIndex] = await cursors[nextIndex].next();
+            cursor.value = nextValue;
+            return nextValue;
+        },
+    };
+    return (0, data_query_1.iterableCursor)(cursor);
+}
+function cursorMap(sourceCursor, mapFn) {
+    const cursor = {
+        value: null,
+        next: async (skipPast) => {
+            if (skipPast !== undefined) {
+                throw new Error('skipPast is not supported for cursorMap since the mapped cursor has a different type than the source cursor');
+            }
+            const sourceValue = await sourceCursor.next();
+            if (sourceValue === null) {
+                cursor.value = null;
+                return null;
+            }
+            const mappedValue = await mapFn(sourceValue);
+            cursor.value = mappedValue;
+            return mappedValue;
+        },
+    };
+    return (0, data_query_1.iterableCursor)(cursor);
+}
+function cursorFilter(sourceCursor, filterFn) {
+    const cursor = {
+        value: null,
+        next: async (skipPast) => {
+            if (skipPast !== undefined) {
+                throw new Error('skipPast is not supported for cursorFilter since filtering changes the cursor iteration order');
+            }
+            while (true) {
+                const sourceValue = await sourceCursor.next();
+                if (sourceValue === null) {
+                    cursor.value = null;
+                    return null;
+                }
+                const shouldInclude = await filterFn(sourceValue);
+                if (shouldInclude) {
+                    cursor.value = sourceValue;
+                    return sourceValue;
+                }
+                // Continue to next item if this one doesn't match the filter
+            }
+        },
+    };
+    return (0, data_query_1.iterableCursor)(cursor);
+}

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

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

package/dist/data/orm/multi-cursors.test.js

@@ -0,0 +1,455 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const multi_cursors_1 = require("./multi-cursors");
+const data_query_1 = require("./data-query");
+const factory_1 = require("./factory");
+const field_type_1 = require("../../types/field-type");
+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('cursorUnion', () => {
+    it('should return items from first cursor, then second cursor in order', async () => {
+        const cursor1 = createMockCursor([1, 2, 3]);
+        const cursor2 = createMockCursor([4, 5, 6]);
+        const unionCursor = (0, multi_cursors_1.cursorUnion)([cursor1, cursor2]);
+        const results = [];
+        for await (const item of unionCursor) {
+            results.push(item);
+        }
+        expect(results).toEqual([1, 2, 3, 4, 5, 6]);
+    });
+    it('should handle empty cursors gracefully', async () => {
+        const cursor1 = createMockCursor([1, 2]);
+        const cursor2 = createMockCursor([]);
+        const cursor3 = createMockCursor([3, 4]);
+        const unionCursor = (0, multi_cursors_1.cursorUnion)([cursor1, cursor2, cursor3]);
+        const results = [];
+        for await (const item of unionCursor) {
+            results.push(item);
+        }
+        expect(results).toEqual([1, 2, 3, 4]);
+    });
+    it('should return empty result when all cursors are empty', async () => {
+        const cursor1 = createMockCursor([]);
+        const cursor2 = createMockCursor([]);
+        const unionCursor = (0, multi_cursors_1.cursorUnion)([cursor1, cursor2]);
+        const results = [];
+        for await (const item of unionCursor) {
+            results.push(item);
+        }
+        expect(results).toEqual([]);
+    });
+    it('should work with single cursor', async () => {
+        const cursor1 = createMockCursor(['a', 'b', 'c']);
+        const unionCursor = (0, multi_cursors_1.cursorUnion)([cursor1]);
+        const results = [];
+        for await (const item of unionCursor) {
+            results.push(item);
+        }
+        expect(results).toEqual(['a', 'b', 'c']);
+    });
+    it('should work with no cursors', async () => {
+        const unionCursor = (0, multi_cursors_1.cursorUnion)([]);
+        const results = [];
+        for await (const item of unionCursor) {
+            results.push(item);
+        }
+        expect(results).toEqual([]);
+    });
+    it('should work with manual next() calls', async () => {
+        const cursor1 = createMockCursor([10, 20]);
+        const cursor2 = createMockCursor([30, 40]);
+        const unionCursor = (0, multi_cursors_1.cursorUnion)([cursor1, cursor2]);
+        const results = [];
+        while (await unionCursor.next()) {
+            results.push(unionCursor.value);
+        }
+        expect(results).toEqual([10, 20, 30, 40]);
+    });
+    it('should handle different data types', async () => {
+        const cursor1 = createMockCursor([{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }]);
+        const cursor2 = createMockCursor([{ id: 3, name: 'Bob' }]);
+        const unionCursor = (0, multi_cursors_1.cursorUnion)([cursor1, cursor2]);
+        const results = [];
+        for await (const item of unionCursor) {
+            results.push(item);
+        }
+        expect(results).toEqual([
+            { id: 1, name: 'John' },
+            { id: 2, name: 'Jane' },
+            { id: 3, name: 'Bob' }
+        ]);
+    });
+    it('should maintain cursor.value correctly', async () => {
+        const cursor1 = createMockCursor(['first', 'second']);
+        const cursor2 = createMockCursor(['third']);
+        const unionCursor = (0, multi_cursors_1.cursorUnion)([cursor1, cursor2]);
+        // First item
+        await unionCursor.next();
+        expect(unionCursor.value).toBe('first');
+        // Second item
+        await unionCursor.next();
+        expect(unionCursor.value).toBe('second');
+        // Third item (from second cursor)
+        await unionCursor.next();
+        expect(unionCursor.value).toBe('third');
+        // End of data
+        const result = await unionCursor.next();
+        expect(result).toBeNull();
+        expect(unionCursor.value).toBeNull();
+    });
+});
+function createMockDataSource(items, tableName, primaryKeyName = 'id') {
+    return (0, factory_1.arrayAsTable)(items, {
+        name: tableName,
+        primaryKeyName
+    });
+}
+describe('sortLikeSQL', () => {
+    it('should sort by ascending field correctly', () => {
+        const a = { id: 1, name: 'Alice' };
+        const b = { id: 2, name: 'Bob' };
+        expect((0, multi_cursors_1.sortLikeSQL)(['id'], a, b)).toBe(-1); // a < b
+        expect((0, multi_cursors_1.sortLikeSQL)(['id'], b, a)).toBe(1); // b > a
+        expect((0, multi_cursors_1.sortLikeSQL)(['id'], a, a)).toBe(0); // a === a
+    });
+    it('should sort by descending field correctly', () => {
+        const a = { id: 1, name: 'Alice' };
+        const b = { id: 2, name: 'Bob' };
+        expect((0, multi_cursors_1.sortLikeSQL)(['-id'], a, b)).toBe(1); // a > b (desc)
+        expect((0, multi_cursors_1.sortLikeSQL)(['-id'], b, a)).toBe(-1); // b < a (desc)
+        expect((0, multi_cursors_1.sortLikeSQL)(['-id'], a, a)).toBe(0); // a === a
+    });
+    it('should handle multiple sort fields', () => {
+        const a = { name: 'Alice', age: 25 };
+        const b = { name: 'Alice', age: 30 };
+        const c = { name: 'Bob', age: 25 };
+        // First by name, then by age
+        expect((0, multi_cursors_1.sortLikeSQL)(['name', 'age'], a, b)).toBe(-1); // same name, a.age < b.age
+        expect((0, multi_cursors_1.sortLikeSQL)(['name', 'age'], a, c)).toBe(-1); // a.name < c.name
+        expect((0, multi_cursors_1.sortLikeSQL)(['name', 'age'], c, a)).toBe(1); // c.name > a.name
+    });
+    it('should handle null/undefined values like SQL', () => {
+        const a = { id: 1, name: null };
+        const b = { id: 2, name: 'Bob' };
+        const c = { id: 3 }; // name is undefined
+        expect((0, multi_cursors_1.sortLikeSQL)(['name'], a, b)).toBe(-1); // null < string (treated as -Infinity)
+        expect((0, multi_cursors_1.sortLikeSQL)(['name'], c, b)).toBe(-1); // undefined < string (treated as -Infinity)
+        expect((0, multi_cursors_1.sortLikeSQL)(['name'], a, c)).toBe(0); // null === undefined (both -Infinity)
+    });
+});
+describe('queryMerge', () => {
+    it('should merge data from multiple sources in sorted order', async () => {
+        const dataSource1 = createMockDataSource([
+            { id: 1, name: 'Alice' },
+            { id: 3, name: 'Charlie' },
+            { id: 5, name: 'Eve' },
+        ], 'table1');
+        const dataSource2 = createMockDataSource([
+            { id: 2, name: 'Bob' },
+            { id: 4, name: 'David' },
+            { id: 6, name: 'Frank' },
+        ], 'table2');
+        const cursor = (0, multi_cursors_1.queryMerge)([dataSource1, dataSource2]);
+        const results = [];
+        for await (const item of cursor) {
+            results.push(item);
+        }
+        expect(results.map(r => r.id)).toEqual([1, 2, 3, 4, 5, 6]);
+        expect(results.map(r => r.name)).toEqual(['Alice', 'Bob', 'Charlie', 'David', 'Eve', 'Frank']);
+    });
+    it('should handle empty data sources', async () => {
+        const dataSource1 = (0, factory_1.arrayAsTable)([], {
+            name: 'table1',
+            primaryKeyName: 'id',
+            fields: [
+                { name: 'id', type: field_type_1.FieldType.number },
+                { name: 'name', type: field_type_1.FieldType.string }
+            ]
+        });
+        const dataSource2 = createMockDataSource([
+            { id: 1, name: 'Alice' },
+        ], 'table2');
+        const cursor = (0, multi_cursors_1.queryMerge)([dataSource1, dataSource2]);
+        const results = [];
+        for await (const item of cursor) {
+            results.push(item);
+        }
+        expect(results).toEqual([{ id: 1, name: 'Alice' }]);
+    });
+    it('should handle no data sources', async () => {
+        const cursor = (0, multi_cursors_1.queryMerge)([]);
+        const results = [];
+        for await (const item of cursor) {
+            results.push(item);
+        }
+        expect(results).toEqual([]);
+    });
+    it('should respect custom sort order', async () => {
+        // Use pre-sorted data to avoid arrayAsTable sorting issues
+        const dataSource1 = createMockDataSource([
+            { id: 1, name: 'Alice', age: 30 },
+            { id: 3, name: 'Charlie', age: 25 },
+        ], 'table1');
+        const dataSource2 = createMockDataSource([
+            { id: 2, name: 'Bob', age: 28 },
+            { id: 4, name: 'David', age: 22 },
+        ], 'table2');
+        // Sort by name ascending - data sources already have data in correct order
+        const cursor = (0, multi_cursors_1.queryMerge)([dataSource1, dataSource2], {}, { sortBy: ['name'] });
+        const results = [];
+        for await (const item of cursor) {
+            results.push(item);
+        }
+        expect(results.map(r => r.name)).toEqual(['Alice', 'Bob', 'Charlie', 'David']);
+    });
+    it('should work with single data source', async () => {
+        const dataSource = createMockDataSource([
+            { id: 1, name: 'Alice' },
+            { id: 2, name: 'Bob' },
+            { id: 3, name: 'Charlie' },
+        ], 'table1');
+        const cursor = (0, multi_cursors_1.queryMerge)([dataSource]);
+        const results = [];
+        for await (const item of cursor) {
+            results.push(item);
+        }
+        // Should be sorted by id (default primary key sort)
+        expect(results.map(r => r.id)).toEqual([1, 2, 3]);
+    });
+    it('should work with manual next() calls', async () => {
+        const dataSource1 = createMockDataSource([{ id: 1, name: 'Alice' }], 'table1');
+        const dataSource2 = createMockDataSource([{ id: 2, name: 'Bob' }], 'table2');
+        const cursor = (0, multi_cursors_1.queryMerge)([dataSource1, dataSource2]);
+        const results = [];
+        while (await cursor.next()) {
+            results.push(cursor.value);
+        }
+        expect(results.map(r => r?.id)).toEqual([1, 2]);
+    });
+});
+describe('cursorMap', () => {
+    it('should map cursor values using synchronous function', async () => {
+        const sourceCursor = createMockCursor([1, 2, 3, 4, 5]);
+        const mappedCursor = (0, multi_cursors_1.cursorMap)(sourceCursor, (x) => x * 2);
+        const results = [];
+        for await (const item of mappedCursor) {
+            results.push(item);
+        }
+        expect(results).toEqual([2, 4, 6, 8, 10]);
+    });
+    it('should map cursor values using async function', async () => {
+        const sourceCursor = createMockCursor(['a', 'b', 'c']);
+        const mappedCursor = (0, multi_cursors_1.cursorMap)(sourceCursor, async (x) => {
+            // Simulate async operation
+            await new Promise(resolve => setTimeout(resolve, 1));
+            return x.toUpperCase();
+        });
+        const results = [];
+        for await (const item of mappedCursor) {
+            results.push(item);
+        }
+        expect(results).toEqual(['A', 'B', 'C']);
+    });
+    it('should transform data types correctly', async () => {
+        const sourceCursor = createMockCursor([
+            { id: 1, name: 'Alice', age: 25 },
+            { id: 2, name: 'Bob', age: 30 },
+            { id: 3, name: 'Charlie', age: 35 }
+        ]);
+        const mappedCursor = (0, multi_cursors_1.cursorMap)(sourceCursor, (person) => `${person.name} is ${person.age} years old`);
+        const results = [];
+        for await (const item of mappedCursor) {
+            results.push(item);
+        }
+        expect(results).toEqual([
+            'Alice is 25 years old',
+            'Bob is 30 years old',
+            'Charlie is 35 years old'
+        ]);
+    });
+    it('should handle empty cursors', async () => {
+        const sourceCursor = createMockCursor([]);
+        const mappedCursor = (0, multi_cursors_1.cursorMap)(sourceCursor, (x) => x * 2);
+        const results = [];
+        for await (const item of mappedCursor) {
+            results.push(item);
+        }
+        expect(results).toEqual([]);
+    });
+    it('should work with manual next() calls', async () => {
+        const sourceCursor = createMockCursor([10, 20, 30]);
+        const mappedCursor = (0, multi_cursors_1.cursorMap)(sourceCursor, (x) => x / 10);
+        const results = [];
+        while (await mappedCursor.next()) {
+            results.push(mappedCursor.value);
+        }
+        expect(results).toEqual([1, 2, 3]);
+    });
+    it('should maintain cursor.value correctly', async () => {
+        const sourceCursor = createMockCursor(['hello', 'world']);
+        const mappedCursor = (0, multi_cursors_1.cursorMap)(sourceCursor, (x) => x.length);
+        // First item
+        await mappedCursor.next();
+        expect(mappedCursor.value).toBe(5);
+        // Second item
+        await mappedCursor.next();
+        expect(mappedCursor.value).toBe(5);
+        // End of data
+        const result = await mappedCursor.next();
+        expect(result).toBeNull();
+        expect(mappedCursor.value).toBeNull();
+    });
+    it('should handle async errors in map function', async () => {
+        const sourceCursor = createMockCursor([1, 2, 3]);
+        const mappedCursor = (0, multi_cursors_1.cursorMap)(sourceCursor, 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
+    });
+    it('should throw error when skipPast is used', async () => {
+        const sourceCursor = createMockCursor([1, 2, 3]);
+        const mappedCursor = (0, multi_cursors_1.cursorMap)(sourceCursor, (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');
+    });
+});
+describe('cursorFilter', () => {
+    it('should filter cursor values using synchronous predicate', async () => {
+        const sourceCursor = createMockCursor([1, 2, 3, 4, 5, 6]);
+        const filteredCursor = (0, multi_cursors_1.cursorFilter)(sourceCursor, (x) => x % 2 === 0);
+        const results = [];
+        for await (const item of filteredCursor) {
+            results.push(item);
+        }
+        expect(results).toEqual([2, 4, 6]);
+    });
+    it('should filter cursor values using async predicate', async () => {
+        const sourceCursor = createMockCursor(['apple', 'banana', 'cherry', 'date']);
+        const filteredCursor = (0, multi_cursors_1.cursorFilter)(sourceCursor, async (x) => {
+            // Simulate async operation
+            await new Promise(resolve => setTimeout(resolve, 1));
+            return x.length > 5;
+        });
+        const results = [];
+        for await (const item of filteredCursor) {
+            results.push(item);
+        }
+        expect(results).toEqual(['banana', 'cherry']);
+    });
+    it('should filter objects based on properties', async () => {
+        const sourceCursor = 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 filteredCursor = (0, multi_cursors_1.cursorFilter)(sourceCursor, (person) => person.age >= 30);
+        const results = [];
+        for await (const item of filteredCursor) {
+            results.push(item);
+        }
+        expect(results).toEqual([
+            { id: 2, name: 'Bob', age: 30 },
+            { id: 3, name: 'Charlie', age: 35 }
+        ]);
+    });
+    it('should handle empty cursors', async () => {
+        const sourceCursor = createMockCursor([]);
+        const filteredCursor = (0, multi_cursors_1.cursorFilter)(sourceCursor, (x) => x > 0);
+        const results = [];
+        for await (const item of filteredCursor) {
+            results.push(item);
+        }
+        expect(results).toEqual([]);
+    });
+    it('should handle cursors where no items match filter', async () => {
+        const sourceCursor = createMockCursor([1, 2, 3, 4, 5]);
+        const filteredCursor = (0, multi_cursors_1.cursorFilter)(sourceCursor, (x) => x > 10);
+        const results = [];
+        for await (const item of filteredCursor) {
+            results.push(item);
+        }
+        expect(results).toEqual([]);
+    });
+    it('should work with manual next() calls', async () => {
+        const sourceCursor = createMockCursor([10, 15, 20, 25, 30]);
+        const filteredCursor = (0, multi_cursors_1.cursorFilter)(sourceCursor, (x) => x >= 20);
+        const results = [];
+        while (await filteredCursor.next()) {
+            results.push(filteredCursor.value);
+        }
+        expect(results).toEqual([20, 25, 30]);
+    });
+    it('should maintain cursor.value correctly', async () => {
+        const sourceCursor = createMockCursor(['hello', 'hi', 'world', 'test']);
+        const filteredCursor = (0, multi_cursors_1.cursorFilter)(sourceCursor, (x) => x.length > 3);
+        // First item
+        await filteredCursor.next();
+        expect(filteredCursor.value).toBe('hello');
+        // Second item  
+        await filteredCursor.next();
+        expect(filteredCursor.value).toBe('world');
+        // Third item
+        await filteredCursor.next();
+        expect(filteredCursor.value).toBe('test');
+        // End of data
+        const result = await filteredCursor.next();
+        expect(result).toBeNull();
+        expect(filteredCursor.value).toBeNull();
+    });
+    it('should throw error when skipPast is used', async () => {
+        const sourceCursor = createMockCursor([1, 2, 3]);
+        const filteredCursor = (0, multi_cursors_1.cursorFilter)(sourceCursor, (x) => x > 1);
+        await expect(filteredCursor.next(2)).rejects.toThrow('skipPast is not supported for cursorFilter since filtering changes the cursor iteration order');
+    });
+    it('should handle async errors in filter function', async () => {
+        const sourceCursor = createMockCursor([1, 2, 3]);
+        const filteredCursor = (0, multi_cursors_1.cursorFilter)(sourceCursor, async (x) => {
+            if (x === 2) {
+                throw new Error('Filter error');
+            }
+            return x > 0;
+        });
+        const results = [];
+        let errorCaught = false;
+        try {
+            for await (const item of filteredCursor) {
+                results.push(item);
+            }
+        }
+        catch (error) {
+            errorCaught = true;
+            expect(error.message).toBe('Filter error');
+        }
+        expect(errorCaught).toBe(true);
+        expect(results).toEqual([1]); // Only first item before error
+    });
+});

package/dist/data/orm/sql-db.d.ts

@@ -0,0 +1,6 @@
+export interface ISqlDb {
+    get: (sql: string, params?: any) => Promise<any>;
+    all: (sql: string, params?: any) => Promise<any[]>;
+    exec: (sql: string, params?: any) => Promise<void>;
+    close: () => Promise<void>;
+}

package/dist/data/orm/sql-db.js

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

package/dist/data/orm/sql.data-source.d.ts

@@ -0,0 +1,38 @@
+import { z } from "zod";
+import { FieldType, IField } from "../../types/field-type";
+import { DataFilter, ICursorIterable, IDataQueryParams, IDataSource } from "./data-query";
+import { ITableMetaData } from "./types";
+import { ISqlDb } from "./sql-db";
+export declare class SQLDataSource<T extends {
+    [key: string]: any;
+}> implements IDataSource<T> {
+    readonly db: ISqlDb;
+    readonly metaData: ITableMetaData;
+    readonly schema: z.AnyZodObject;
+    readonly tableName: string;
+    readonly primaryKeyName: string;
+    constructor(db: ISqlDb, metaData: ITableMetaData, schema?: z.AnyZodObject);
+    private buildTableSql;
+    private ensureTableAndIndexesExist;
+    private ensureTableIsNewest;
+    private tableBuild;
+    initTable(force?: boolean): Promise<boolean>;
+    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>;
+    findOne(filter?: DataFilter<T>, opts?: {
+        enforceUnique?: boolean;
+    }): Promise<T | undefined>;
+    save(record: T): Promise<T>;
+    sqlRecordToJsRecord(record: any): T;
+    insert(record: T): Promise<T>;
+    update(record: T): Promise<T>;
+    delete(idOrRecord: string | T): Promise<void>;
+    dropTableIfExists(): Promise<void>;
+    clearTable(): Promise<void>;
+    initRecord(data?: Partial<T>): T;
+}
+export declare function jsValueToSqlValue(value: any, escapeQuote?: boolean): any;
+export declare function sqlValueToJsValue(value: any, fieldType: FieldType, isArray: boolean): any;
+export declare function globalDefaultValues(field: IField): {};