@peers-app/peers-sdk 0.1.4

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

@@ -0,0 +1,553 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const data_query_1 = require("./data-query");
+const data_query_sqlite_1 = require("./data-query.sqlite");
+const factory_1 = require("./factory");
+describe('dataFilterToSqlWhere (SQLite)', () => {
+    it('should return "1=1" when filter is empty', () => {
+        const filter = {};
+        const result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe('(1=1)');
+    });
+    it('should return correct SQL WHERE clause for single field filter', () => {
+        const filter = { name: 'John' };
+        const result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe(`("name" = 'John')`);
+    });
+    it('should return correct SQL WHERE clause for multiple field filter', () => {
+        const filter = { name: 'John', age: 30 };
+        const result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe(`("name" = 'John' AND "age" = 30)`);
+    });
+    it('should return correct SQL WHERE clause for $in filter', () => {
+        const filter = { name: { $in: ['John', 'Jane'] } };
+        const result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe(`("name" IN ('John', 'Jane'))`);
+    });
+    it('should handle null and undefined values correctly', () => {
+        const filter = { name: null, age: undefined };
+        const result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe(`("name" IS NULL AND "age" IS NULL)`);
+    });
+    it('should escape single quotes in strings', () => {
+        const filter = { name: "John's" };
+        const result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe(`("name" = 'John''s')`);
+    });
+    it('should escape multiple single quotes in strings', () => {
+        const filter = { name: "It's John''s" };
+        const result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe(`("name" = 'It''s John''''s')`);
+    });
+    it('should escape single quotes in strings when doing $matchText', () => {
+        const result = (0, data_query_sqlite_1.dataFilterToSqlWhere)({ name: { $matchWords: "It's John's" } });
+        expect(result).toBe(`("name" LIKE '%It''s%' AND "name" LIKE '%John''s%')`);
+    });
+    it('should escape and preserver sequences of single quotes when doing $matchText', () => {
+        const result = (0, data_query_sqlite_1.dataFilterToSqlWhere)({ name: { $matchWords: "It''s John''s" } });
+        expect(result).toBe(`("name" LIKE '%It''''s%' AND "name" LIKE '%John''''s%')`);
+    });
+    it('should convert top level arrays into OR statements', () => {
+        const filter = [
+            { name: 'John' },
+            { age: 32 },
+        ];
+        const result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe(`(("name" = 'John') OR ("age" = 32))`);
+    });
+    it('should convert top level arrays into OR statements', () => {
+        const filter = [
+            { name: 'John' },
+            { age: 32, airport: { $in: ['LAX', 'PSP'] } },
+        ];
+        const result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe(`(("name" = 'John') OR ("age" = 32 AND "airport" IN ('LAX', 'PSP')))`);
+    });
+    it('should convert $nin to NOT IN', () => {
+        const filter = { age: { $nin: [29, 'lol'] } };
+        const result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe(`("age" NOT IN (29, 'lol'))`);
+    });
+    it('should convert $gte to ">="', () => {
+        const filter = { age: { $gte: 12 } };
+        const result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe(`("age" >= 12)`);
+    });
+    it('should convert $gt to >', () => {
+        const filter = [{ age: { $gt: 12 } }];
+        const result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe(`(("age" > 12))`);
+    });
+    it('should convert $ne to "<> OR IS NULL"', () => {
+        const filter = [{ age: { $ne: 12 } }];
+        const result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe(`((("age" <> 12 OR "age" IS NULL)))`);
+    });
+    it('should escape single quotes for $ne', () => {
+        const filter = [{ name: { $ne: "O'Hara" } }];
+        const result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe(`((("name" <> 'O''Hara' OR "name" IS NULL)))`);
+    });
+    it('should escape sequences single quotes for $ne', () => {
+        const filter = [{ name: { $ne: "O''Hara" } }];
+        const result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe(`((("name" <> 'O''''Hara' OR "name" IS NULL)))`);
+    });
+    it('should convert $exists to IS or IS NOT NULL', () => {
+        const filter = [
+            { age: { $exists: true } },
+            { age: { $exists: false } },
+        ];
+        const result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe(`(("age" IS NOT NULL) OR ("age" IS NULL))`);
+    });
+    it('should convert $lt, $lte, $ne correctly', () => {
+        const filter = [
+            { age: { $lt: 10 } },
+            { age: { $lte: 10 } },
+            { age: { $ne: 10 } },
+        ];
+        const result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe(`(("age" < 10) OR ("age" <= 10) OR (("age" <> 10 OR "age" IS NULL)))`);
+    });
+    it('should convert $matchWords to a LIKE for each word', () => {
+        const filter = { name: { $matchWords: 'John Doe' } };
+        const result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe(`("name" LIKE '%John%' AND "name" LIKE '%Doe%')`);
+    });
+    it('should generate AND clause for $and directive', () => {
+        let filter = { $and: [{ age: 32 }, { name: 'John' }] };
+        let result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe(`((("age" = 32) AND ("name" = 'John')))`);
+        filter = {
+            name: { $ne: 'John M. Doe' },
+            $and: [
+                { age: { $gte: 30 } },
+                { age: { $lte: 32 } },
+                { name: { $matchWords: 'John Doe' } }
+            ]
+        };
+        result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe(`(("name" <> 'John M. Doe' OR "name" IS NULL) AND (("age" >= 30) AND ("age" <= 32) AND ("name" LIKE '%John%' AND "name" LIKE '%Doe%')))`);
+    });
+    it('should allow indicating columns with $ prefix', () => {
+        let filter = { id: { $gte: '$col1' } };
+        let result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe(`("id" >= "col1")`);
+    });
+    it('should allow escaping $prefix with backslash', () => {
+        let filter = { id: { $gte: '\\$col1' } };
+        let result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe(`("id" >= '$col1')`);
+    });
+    it('should leave backslash prefix if not followed by $', () => {
+        let filter = { id: { $gte: '\\col1' } };
+        let result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe(`("id" >= '\\col1')`);
+    });
+    it('should generate substr clause for $substr directive on right hand side', () => {
+        let filter = { id: { $gte: { $substr: ['$col1', 2, 4] } } };
+        let result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe(`("id" >= (substr("col1", 2, 4)))`);
+    });
+    it('should generate substr clauses for $substr directive on left hand side', () => {
+        let filter = { $expr: [{ $substr: ['$id1', -1, 1] }, { $eq: 'a' }] };
+        let result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe(`((substr("id1", -1, 1)) = 'a')`);
+    });
+    it('should generate substr clauses for $substr directive on left and right hand side', () => {
+        let filter = { $expr: [{ $substr: ['$id1', -1, 1] }, { $gte: { $substr: ['$col1', 2, 4] } }] };
+        let result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe(`((substr("id1", -1, 1)) >= (substr("col1", 2, 4)))`);
+    });
+    it('should generate substr clause for $substr directive and correctly escape single quotes in string', () => {
+        let filter = { id: { $gte: { $substr: [`$id`, -1, 1] } } };
+        let result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe(`("id" >= (substr("id", -1, 1)))`);
+    });
+    it('should generate substr clause for $expr directive and correctly escape single quotes in string', () => {
+        let filter = { $expr: [{ $substr: [`I'm a string`, -1, 1] }, { $gte: 'a' }] };
+        let result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe(`((substr('I''m a string', -1, 1)) >= 'a')`);
+    });
+    it('should generate substr clause for $expr directive and correctly escape double quotes in identifiers', () => {
+        let filter = { $expr: [{ $substr: ['$weird"col"name', -1, 1] }, { $gte: 'a' }] };
+        let result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe(`((substr("weird""col""name", -1, 1)) >= 'a')`);
+    });
+    it('should handle empty $or arrays without generating empty parentheses', () => {
+        let filter = { $or: [] };
+        let result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe('((1=1))');
+    });
+    it('should handle $or arrays with filters that resolve to (1=1)', () => {
+        let filter = { $or: [{}] };
+        let result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe('(((1=1)))');
+    });
+    it('should handle empty $and arrays without generating empty parentheses', () => {
+        let filter = { $and: [] };
+        let result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe('((1=1))');
+    });
+    it('should handle $and arrays with filters that resolve to (1=1)', () => {
+        let filter = { $and: [{}] };
+        let result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe('(((1=1)))');
+    });
+    it('should handle mixed $or and $and with empty conditions', () => {
+        let filter = {
+            $and: [
+                { name: 'John' },
+                { $or: [] }
+            ]
+        };
+        let result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe(`((("name" = 'John') AND ((1=1))))`);
+    });
+    it('should throw error for direct array usage', () => {
+        let filter = { name: ['John', 'Jane'] };
+        expect(() => (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toThrow('Invalid filter: Arrays are not allowed as direct field values. Use $in instead: { name: { $in: [\'John\', \'Jane\'] } }');
+    });
+    it('should handle $in operator correctly', () => {
+        let filter = { name: { $in: ['John', 'Jane', 'Bob'] } };
+        let result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe(`("name" IN ('John', 'Jane', 'Bob'))`);
+    });
+    it('should throw error for $in with non-array value', () => {
+        let filter = { name: { $in: 'John' } };
+        expect(() => (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toThrow('$in value must be an array');
+    });
+});
+describe('filterToSkipPastValue', () => {
+    it('should a filter limited to results after the next item', () => {
+        const sortBy = ['id'];
+        let filter = { id: { $gte: '$col1' } };
+        filter = (0, data_query_1.filterToSkipPastValue)(filter, sortBy, { id: 10 });
+        expect(filter).toEqual({
+            $and: [
+                { id: { $gte: '$col1' } },
+                {
+                    $or: [
+                        { id: { $gt: 10 } },
+                    ]
+                }
+            ]
+        });
+        let result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe(`((("id" >= "col1") AND ((("id" > 10)))))`);
+    });
+    it('should a work with descending sorts', () => {
+        const sortBy = ['-id'];
+        let filter = { id: { $gte: '$col1' } };
+        filter = (0, data_query_1.filterToSkipPastValue)(filter, sortBy, { id: 10 });
+        expect(filter).toEqual({
+            $and: [
+                { id: { $gte: '$col1' } },
+                {
+                    $or: [
+                        { id: { $lt: 10 } },
+                    ]
+                }
+            ]
+        });
+        let result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe(`((("id" >= "col1") AND ((("id" < 10)))))`);
+    });
+    it('should work with multiple sorts', () => {
+        const sortBy = ['name', '-id', 'age'];
+        let filter = { id: { $gte: '$col1' } };
+        filter = (0, data_query_1.filterToSkipPastValue)(filter, sortBy, { id: 10, name: 'test', age: 30 });
+        expect(filter).toEqual({
+            $and: [
+                { id: { $gte: '$col1' } },
+                {
+                    $or: [
+                        { name: { $gt: 'test' } },
+                        { name: { $eq: 'test' }, id: { $lt: 10 } },
+                        { name: { $eq: 'test' }, id: { $eq: 10 }, age: { $gt: 30 } },
+                    ]
+                }
+            ]
+        });
+        let result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe(`((("id" >= "col1") AND ((("name" > 'test') OR ("id" < 10 AND "name" = 'test') OR ("age" > 30 AND "id" = 10 AND "name" = 'test')))))`);
+    });
+    it('should correctly handle null values', () => {
+        const sortBy = ['name', '-id', 'age'];
+        let filter = { id: { $gte: '$col1' } };
+        filter = (0, data_query_1.filterToSkipPastValue)(filter, sortBy, { id: 10 });
+        expect(filter).toEqual({
+            $and: [
+                { id: { $gte: '$col1' } },
+                {
+                    $or: [
+                        { name: { $exists: true } },
+                        { name: { $exists: false }, id: { $lt: 10 } },
+                        { name: { $exists: false }, id: { $eq: 10 }, age: { $exists: true } },
+                    ]
+                }
+            ]
+        });
+        let result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe(`((("id" >= "col1") AND ((("name" IS NOT NULL) OR ("id" < 10 AND "name" IS NULL) OR ("age" IS NOT NULL AND "id" = 10 AND "name" IS NULL)))))`);
+    });
+    it('should handle empty filter', () => {
+        const sortBy = ['name', '-id', 'age'];
+        let filter = {};
+        filter = (0, data_query_1.filterToSkipPastValue)(filter, sortBy, { id: 10 });
+        expect(filter).toEqual({
+            $and: [
+                {},
+                {
+                    $or: [
+                        { name: { $exists: true } },
+                        { name: { $exists: false }, id: { $lt: 10 } },
+                        { name: { $exists: false }, id: { $eq: 10 }, age: { $exists: true } },
+                    ]
+                }
+            ]
+        });
+        let result = (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter);
+        expect(result).toBe(`(((1=1) AND (((\"name\" IS NOT NULL) OR (\"id\" < 10 AND \"name\" IS NULL) OR (\"age\" IS NOT NULL AND \"id\" = 10 AND \"name\" IS NULL)))))`);
+    });
+});
+const aryTable = (0, factory_1.arrayAsTable)([
+    { id: 1, name: 'John', age: 30 },
+    { id: 2, name: 'Jane', age: 32 },
+    { id: 3, name: 'Joe', age: 29 },
+    { id: 4, name: 'Jeb', age: 50 },
+    { id: 5, name: 'Joey', age: 31 },
+], {
+    name: 'People',
+});
+describe('DataQuery', () => {
+    describe('cursor', () => {
+        const query = new data_query_1.DataQuery(aryTable);
+        query.pageSize = 2;
+        it('should allow async iteration via `for await`', async () => {
+            let results = [];
+            for await (const item of query.cursor()) {
+                results.push(item.id);
+            }
+            expect(results).toEqual([1, 2, 3, 4, 5]);
+        });
+        it('should allow async iteration via `while await next`', async () => {
+            let results = [];
+            const cursor = query.cursor();
+            while (await cursor.next()) {
+                results.push(cursor.value?.id);
+            }
+            expect(results).toEqual([1, 2, 3, 4, 5]);
+        });
+    });
+});
+describe('dataQueryToSqliteQuery', () => {
+    const aryTable = (0, factory_1.arrayAsTable)([
+        { id: 1, name: 'John', age: 30 },
+        { id: 2, name: 'Jane', age: 32 },
+        { id: 3, name: 'Joe', age: 29 },
+    ], {
+        name: 'People',
+    });
+    function fmtSql(sql) {
+        return sql.replace(/      /g, '').trim();
+    }
+    let query = new data_query_1.DataQuery(aryTable);
+    beforeEach(() => {
+        query = new data_query_1.DataQuery(aryTable);
+    });
+    it('should return correct SQL query for empty query', () => {
+        let sql = (0, data_query_sqlite_1.dataQueryToSqliteQuery)(query);
+        expect(sql).toBe(fmtSql(`
+      SELECT
+        *
+      FROM "People"
+      WHERE (1=1)
+      ORDER BY 1
+    `));
+    });
+    it('should generate single clause for single field filter', () => {
+        query.filter = { age: 30 };
+        let sql = (0, data_query_sqlite_1.dataQueryToSqliteQuery)(query);
+        expect(sql).toBe(fmtSql(`
+      SELECT
+        *
+      FROM "People"
+      WHERE ("age" = 30)
+      ORDER BY 1
+    `));
+    });
+    it('should generate AND clause for multi-field filter', () => {
+        query.filter = { age: 30, name: 'John' };
+        let sql = (0, data_query_sqlite_1.dataQueryToSqliteQuery)(query);
+        expect(sql).toBe(fmtSql(`
+      SELECT
+        *
+      FROM "People"
+      WHERE ("age" = 30 AND "name" = 'John')
+      ORDER BY 1
+    `));
+    });
+    it('should generate OR LIKE clauses for all fields for text search', () => {
+        query.filter = {};
+        query.textSearch = 'John';
+        let sql = (0, data_query_sqlite_1.dataQueryToSqliteQuery)(query);
+        expect(sql).toBe(fmtSql(`
+      SELECT
+        *
+      FROM "People"
+      WHERE (("id" LIKE '%John%' OR "name" LIKE '%John%' OR "age" LIKE '%John%'))
+      ORDER BY 1
+    `));
+    });
+    it('should handle empty filter and text search with only spaces', () => {
+        query.filter = {};
+        query.textSearch = '   ';
+        let sql = (0, data_query_sqlite_1.dataQueryToSqliteQuery)(query);
+        expect(sql).toBe(fmtSql(`
+      SELECT
+        *
+      FROM "People"
+      WHERE (1=1)
+      ORDER BY 1
+    `));
+    });
+    it('should handle filter and text search with only spaces', () => {
+        query.filter = { age: 30 };
+        query.textSearch = '   ';
+        let sql = (0, data_query_sqlite_1.dataQueryToSqliteQuery)(query);
+        expect(sql).toBe(fmtSql(`
+      SELECT
+        *
+      FROM "People"
+      WHERE ("age" = 30)
+      ORDER BY 1
+    `));
+    });
+    it('should generate OR LIKE clauses for all fields for text search for each word given', () => {
+        query.filter = {};
+        query.textSearch = 'John Smith';
+        let sql = (0, data_query_sqlite_1.dataQueryToSqliteQuery)(query);
+        expect(sql).toBe(fmtSql(`
+      SELECT
+        *
+      FROM "People"
+      WHERE (("id" LIKE '%John%' OR "name" LIKE '%John%' OR "age" LIKE '%John%') AND ("id" LIKE '%Smith%' OR "name" LIKE '%Smith%' OR "age" LIKE '%Smith%'))
+      ORDER BY 1
+    `));
+    });
+    it('should generate OR LIKE clauses for all fields for exact text when specified', () => {
+        query.filter = {};
+        query.textSearch = 'John Smith';
+        query.textSearchExact = true;
+        let sql = (0, data_query_sqlite_1.dataQueryToSqliteQuery)(query);
+        expect(sql).toBe(fmtSql(`
+      SELECT
+        *
+      FROM "People"
+      WHERE ("id" LIKE '%John Smith%' OR "name" LIKE '%John Smith%' OR "age" LIKE '%John Smith%')
+      ORDER BY 1
+    `));
+    });
+    it('should generate OR clause for $or directive', () => {
+        query.filter = { $or: [{ age: 32 }, { name: 'John' }] };
+        let sql = (0, data_query_sqlite_1.dataQueryToSqliteQuery)(query);
+        expect(sql).toBe(fmtSql(`
+      SELECT
+        *
+      FROM "People"
+      WHERE ((("age" = 32) OR ("name" = 'John')))
+      ORDER BY 1
+    `));
+        query.filter = { $or: [{ age: 30, name: 'John' }, { age: 32, name: 'Jane' }], id: { $in: [1, 2, 3] }, name: { $ne: 'Joe' } };
+        sql = (0, data_query_sqlite_1.dataQueryToSqliteQuery)(query);
+        expect(sql).toBe(fmtSql(`
+      SELECT
+        *
+      FROM "People"
+      WHERE ((("age" = 30 AND "name" = 'John') OR ("age" = 32 AND "name" = 'Jane')) AND "id" IN (1, 2, 3) AND ("name" <> 'Joe' OR "name" IS NULL))
+      ORDER BY 1
+    `));
+    });
+    it('should generate AND clause for $and directive', () => {
+        query.filter = { $and: [{ age: 32 }, { name: 'John' }] };
+        let sql = (0, data_query_sqlite_1.dataQueryToSqliteQuery)(query);
+        expect(sql).toBe(fmtSql(`
+      SELECT
+        *
+      FROM "People"
+      WHERE ((("age" = 32) AND ("name" = 'John')))
+      ORDER BY 1
+    `));
+        query.filter = { $and: [{ age: 30, name: 'John' }, { age: 32, name: 'Jane' }], id: { $in: [1, 2, 3] }, name: { $ne: 'Joe' } };
+        sql = (0, data_query_sqlite_1.dataQueryToSqliteQuery)(query);
+        expect(sql).toBe(fmtSql(`
+      SELECT
+        *
+      FROM "People"
+      WHERE ((("age" = 30 AND "name" = 'John') AND ("age" = 32 AND "name" = 'Jane')) AND "id" IN (1, 2, 3) AND ("name" <> 'Joe' OR "name" IS NULL))
+      ORDER BY 1
+    `));
+    });
+    it('should combine filter and textSearch with AND', () => {
+        query.filter = ({ age: 30 });
+        query.textSearch = ('John');
+        let sql = (0, data_query_sqlite_1.dataQueryToSqliteQuery)(query);
+        expect(sql).toBe(fmtSql(`
+      SELECT
+        *
+      FROM "People"
+      WHERE (("age" = 30)) AND ((("id" LIKE '%John%' OR "name" LIKE '%John%' OR "age" LIKE '%John%')))
+      ORDER BY 1
+    `));
+    });
+    it('should respond correctly to pageSize changing', () => {
+        query.filter = ({});
+        query.textSearch = ('');
+        query.pageSize = (10);
+        let sql = (0, data_query_sqlite_1.dataQueryToSqliteQuery)(query);
+        expect(sql).toBe(fmtSql(`
+      SELECT
+        *
+      FROM "People"
+      WHERE (1=1)
+      ORDER BY 1
+      LIMIT 10
+      OFFSET 0
+    `));
+    });
+    it('should calculate LIMIT and OFFSET from page and pageSize', () => {
+        query.filter = ({});
+        query.textSearch = ('');
+        query.pageSize = (10);
+        query.page = (10);
+        let sql = (0, data_query_sqlite_1.dataQueryToSqliteQuery)(query);
+        expect(sql).toBe(fmtSql(`
+      SELECT
+        *
+      FROM "People"
+      WHERE (1=1)
+      ORDER BY 1
+      LIMIT 10
+      OFFSET 90
+    `));
+    });
+    it('should calculate LIMIT and OFFSET from page and pageSize', () => {
+        query.filter = ({});
+        query.textSearch = ('');
+        query.pageSize = (10);
+        query.page = (10);
+        query.sortBy = (['name', '-age']);
+        let sql = (0, data_query_sqlite_1.dataQueryToSqliteQuery)(query);
+        expect(sql).toBe(fmtSql(`
+      SELECT
+        *
+      FROM "People"
+      WHERE (1=1)
+      ORDER BY "name" ASC, "age" DESC
+      LIMIT 10
+      OFFSET 90
+    `));
+    });
+});

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

@@ -0,0 +1,6 @@
+/**
+ * Decorator that marks a table method as server-side only.
+ * When used on the client side, these methods will be automatically proxied
+ * to the server via rpcServerCalls.tableMethodCall.
+ */
+export declare function ProxyClientCalls(): (target: any, context: any) => any;

package/dist/data/orm/decorators.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProxyClientCalls = ProxyClientCalls;
+/**
+ * Decorator that marks a table method as server-side only.
+ * When used on the client side, these methods will be automatically proxied
+ * to the server via rpcServerCalls.tableMethodCall.
+ */
+function ProxyClientCalls() {
+    return function (target, context) {
+        if (context.kind === 'method' && typeof window !== 'undefined') {
+            const methodName = context.name;
+            return function (...args) {
+                // Lazy import to avoid circular dependencies
+                const { rpcServerCalls } = require("../..");
+                return rpcServerCalls.tableMethodCall(this.dataContextId, this.tableName, methodName, ...args);
+            };
+        }
+        return target;
+    };
+}

package/dist/data/orm/dependency-injection.test.d.ts

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