@peers-app/peers-sdk 0.1.4

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

@@ -0,0 +1,267 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataFilterToMongoQuery = dataFilterToMongoQuery;
+exports.sortByToMongoSort = sortByToMongoSort;
+exports.paginationToMongoSkipLimit = paginationToMongoSkipLimit;
+const lodash_1 = require("lodash");
+/**
+ * Converts a DataFilter to a MongoDB query object
+ */
+function dataFilterToMongoQuery(filter) {
+    if (isScalarValue(filter)) {
+        return filter;
+    }
+    if ((0, lodash_1.isArray)(filter)) {
+        return handleOrArray(filter);
+    }
+    return handleFilterObject(filter);
+}
+/**
+ * Handles OR arrays - converts to MongoDB $or syntax
+ */
+function handleOrArray(filters) {
+    if (filters.length === 0) {
+        return {}; // Empty filter matches everything in MongoDB
+    }
+    if (filters.length === 1) {
+        return dataFilterToMongoQuery(filters[0]);
+    }
+    return { $or: filters.map(f => dataFilterToMongoQuery(f)) };
+}
+/**
+ * Handles filter objects - processes each field
+ */
+function handleFilterObject(filter) {
+    const mongoFilter = {};
+    for (const [fieldName, value] of Object.entries(filter)) {
+        const result = handleFilterField(fieldName, value);
+        // Merge the result into mongoFilter
+        if (typeof result === 'object' && result !== null && !(0, lodash_1.isArray)(result)) {
+            Object.assign(mongoFilter, result);
+        }
+        else {
+            mongoFilter[fieldName] = result;
+        }
+    }
+    return mongoFilter;
+}
+/**
+ * Handles individual filter fields
+ */
+function handleFilterField(fieldName, value) {
+    if (fieldName === '$or') {
+        return { $or: value.map((v) => dataFilterToMongoQuery(v)) };
+    }
+    if (fieldName === '$and') {
+        if (value.length === 0) {
+            return {}; // Empty $and matches everything
+        }
+        return { $and: value.map((v) => dataFilterToMongoQuery(v)) };
+    }
+    if (fieldName === '$matchWords') {
+        return handleMatchWordsOperator(value);
+    }
+    if (fieldName === '$substr') {
+        return handleSubstrOperator(value);
+    }
+    if (fieldName === '$expr') {
+        return handleExprOperator(value);
+    }
+    return handleFieldCondition(fieldName, value);
+}
+/**
+ * Handles regular field conditions
+ */
+function handleFieldCondition(fieldName, value) {
+    if (value === null || value === undefined) {
+        return { [fieldName]: null };
+    }
+    if ((0, lodash_1.isArray)(value)) {
+        throw new Error(`Invalid filter: Arrays are not allowed as direct field values. Use $in instead: { ${fieldName}: { $in: [...] } }`);
+    }
+    if (typeof value === 'object' && !(0, lodash_1.isDate)(value)) {
+        return { [fieldName]: handleObjectValue(value) };
+    }
+    return { [fieldName]: value };
+}
+/**
+ * Handles object values with operators
+ */
+function handleObjectValue(value) {
+    const mongoValue = {};
+    for (const [operator, operatorValue] of Object.entries(value)) {
+        if (operator.startsWith('$')) {
+            mongoValue[operator] = handleOperatorValue(operator, operatorValue);
+        }
+        else {
+            throw new Error(`Invalid operator: ${operator}. Operators must start with $`);
+        }
+    }
+    return mongoValue;
+}
+/**
+ * Handles specific operator values
+ */
+function handleOperatorValue(operator, value) {
+    switch (operator) {
+        case '$eq':
+        case '$ne':
+        case '$gt':
+        case '$gte':
+        case '$lt':
+        case '$lte':
+        case '$in':
+        case '$nin':
+        case '$exists':
+            // These operators work directly in MongoDB
+            return value;
+        case '$matchWords':
+            throw new Error('$matchWords should be handled at field level, not as nested operator');
+        case '$substr':
+            throw new Error('$substr should be handled at field level, not as nested operator');
+        case '$expr':
+            throw new Error('$expr should be handled at field level, not as nested operator');
+        default:
+            throw new Error(`Unknown operator: ${operator}`);
+    }
+}
+/**
+ * Converts $matchWords to MongoDB text search or regex
+ */
+function handleMatchWordsOperator(searchText) {
+    if (typeof searchText !== 'string') {
+        throw new Error('$matchWords value must be a string');
+    }
+    const words = searchText.split(' ').filter(word => word.trim());
+    if (words.length === 0) {
+        return {}; // Empty search matches everything
+    }
+    // Option 1: Use MongoDB text search (requires text index)
+    // return { $text: { $search: searchText } };
+    // Option 2: Use regex for each word (more compatible, works without indexes)
+    if (words.length === 1) {
+        return { $regex: escapeRegex(words[0]), $options: 'i' };
+    }
+    // For multiple words, create AND condition with regex for each word
+    const regexConditions = words.map(word => ({
+        $regex: escapeRegex(word),
+        $options: 'i'
+    }));
+    // This creates a field-level $and, which isn't standard MongoDB
+    // We need to return this to be handled at a higher level
+    throw new Error('$matchWords with multiple words requires field context - should be handled differently');
+}
+/**
+ * Converts $substr to MongoDB $expr with $substr
+ */
+function handleSubstrOperator(args) {
+    if (!(0, lodash_1.isArray)(args) || args.length !== 3) {
+        throw new Error('$substr requires exactly 3 arguments: [string, start, length]');
+    }
+    const [str, start, length] = args;
+    // Convert field references (strings starting with $)
+    const mongoStr = typeof str === 'string' && str.startsWith('$')
+        ? str // Keep MongoDB field reference format
+        : str;
+    return {
+        $expr: {
+            $substr: [mongoStr, start, length]
+        }
+    };
+}
+/**
+ * Converts SQL-style $expr to MongoDB $expr format
+ */
+function handleExprOperator(exprArray) {
+    if (!(0, lodash_1.isArray)(exprArray) || exprArray.length !== 2) {
+        throw new Error('$expr requires exactly 2 arguments: [leftSide, rightSide]');
+    }
+    const [leftSide, rightSide] = exprArray;
+    // Convert left side (usually a function like $substr)
+    const mongoLeft = convertExpressionPart(leftSide);
+    // Convert right side (usually a comparison)
+    const mongoRight = convertExpressionPart(rightSide);
+    // Determine the operation from rightSide
+    if (typeof rightSide === 'object' && rightSide !== null) {
+        const operators = Object.keys(rightSide).filter(k => k.startsWith('$'));
+        if (operators.length === 1) {
+            const op = operators[0];
+            return {
+                $expr: {
+                    [op]: [mongoLeft, rightSide[op]]
+                }
+            };
+        }
+    }
+    // Default to equality comparison
+    return {
+        $expr: {
+            $eq: [mongoLeft, mongoRight]
+        }
+    };
+}
+/**
+ * Converts parts of expressions to MongoDB format
+ */
+function convertExpressionPart(part) {
+    if (typeof part === 'object' && part !== null && !(0, lodash_1.isArray)(part)) {
+        // Handle function calls like { $substr: [...] }
+        const keys = Object.keys(part);
+        if (keys.length === 1 && keys[0].startsWith('$')) {
+            const func = keys[0];
+            const args = part[func];
+            if (func === '$substr' && (0, lodash_1.isArray)(args) && args.length === 3) {
+                const [str, start, length] = args;
+                const mongoStr = typeof str === 'string' && str.startsWith('$') ? str : str;
+                return { $substr: [mongoStr, start, length] };
+            }
+        }
+    }
+    return part;
+}
+/**
+ * Escapes special regex characters
+ */
+function escapeRegex(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Checks if a value is a scalar (primitive) value
+ */
+function isScalarValue(value) {
+    return (typeof value !== 'object' ||
+        (0, lodash_1.isDate)(value) ||
+        value === null);
+}
+/**
+ * Converts DataQuery sort format to MongoDB sort format
+ */
+function sortByToMongoSort(sortBy) {
+    if (!sortBy || sortBy.length === 0) {
+        return {};
+    }
+    const mongoSort = {};
+    for (const field of sortBy) {
+        if (field.startsWith('-')) {
+            mongoSort[field.substring(1)] = -1; // Descending
+        }
+        else {
+            mongoSort[field] = 1; // Ascending
+        }
+    }
+    return mongoSort;
+}
+function paginationToMongoSkipLimit(page, pageSize) {
+    const result = {};
+    if (pageSize) {
+        result.limit = Math.round(pageSize);
+    }
+    if (page && pageSize) {
+        const pageNum = Math.round(page);
+        const skip = Math.round(pageSize * (pageNum - 1));
+        if (skip > 0) {
+            result.skip = skip;
+        }
+    }
+    return result;
+}

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

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

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

@@ -0,0 +1,398 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const data_query_mongo_1 = require("./data-query.mongo");
+describe('dataFilterToMongoQuery', () => {
+    describe('Scalar values', () => {
+        it('should handle null values', () => {
+            expect((0, data_query_mongo_1.dataFilterToMongoQuery)(null)).toBe(null);
+        });
+        it('should handle undefined values', () => {
+            expect((0, data_query_mongo_1.dataFilterToMongoQuery)(undefined)).toBe(undefined);
+        });
+        it('should handle primitive values', () => {
+            expect((0, data_query_mongo_1.dataFilterToMongoQuery)(42)).toBe(42);
+            expect((0, data_query_mongo_1.dataFilterToMongoQuery)('test')).toBe('test');
+            expect((0, data_query_mongo_1.dataFilterToMongoQuery)(true)).toBe(true);
+        });
+        it('should handle Date objects', () => {
+            const date = new Date('2023-01-01');
+            expect((0, data_query_mongo_1.dataFilterToMongoQuery)(date)).toBe(date);
+        });
+    });
+    describe('Empty filters', () => {
+        it('should handle empty object filters', () => {
+            expect((0, data_query_mongo_1.dataFilterToMongoQuery)({})).toEqual({});
+        });
+        it('should handle empty array filters', () => {
+            expect((0, data_query_mongo_1.dataFilterToMongoQuery)([])).toEqual({});
+        });
+    });
+    describe('Simple field conditions', () => {
+        it('should handle basic field equality', () => {
+            const filter = { name: 'John' };
+            expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ name: 'John' });
+        });
+        it('should handle multiple fields', () => {
+            const filter = { name: 'John', age: 30 };
+            expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ name: 'John', age: 30 });
+        });
+        it('should handle null field values', () => {
+            const filter = { name: null };
+            expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ name: null });
+        });
+        it('should handle undefined field values', () => {
+            const filter = { name: undefined };
+            expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ name: null });
+        });
+        it('should throw error for direct array usage', () => {
+            const filter = { names: ['John', 'Jane'] };
+            expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow('Invalid filter: Arrays are not allowed as direct field values. Use $in instead');
+        });
+    });
+    describe('MongoDB operators (direct mapping)', () => {
+        describe('$eq operator', () => {
+            it('should handle $eq operator', () => {
+                const filter = { age: { $eq: 30 } };
+                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ age: { $eq: 30 } });
+            });
+        });
+        describe('$ne operator', () => {
+            it('should handle $ne operator', () => {
+                const filter = { age: { $ne: 30 } };
+                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ age: { $ne: 30 } });
+            });
+        });
+        describe('Comparison operators', () => {
+            it('should handle $gt operator', () => {
+                const filter = { age: { $gt: 18 } };
+                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ age: { $gt: 18 } });
+            });
+            it('should handle $gte operator', () => {
+                const filter = { age: { $gte: 18 } };
+                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ age: { $gte: 18 } });
+            });
+            it('should handle $lt operator', () => {
+                const filter = { age: { $lt: 65 } };
+                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ age: { $lt: 65 } });
+            });
+            it('should handle $lte operator', () => {
+                const filter = { age: { $lte: 65 } };
+                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ age: { $lte: 65 } });
+            });
+            it('should handle multiple comparison operators', () => {
+                const filter = { age: { $gte: 18, $lt: 65 } };
+                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ age: { $gte: 18, $lt: 65 } });
+            });
+        });
+        describe('$in and $nin operators', () => {
+            it('should handle $in operator', () => {
+                const filter = { status: { $in: ['active', 'pending'] } };
+                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ status: { $in: ['active', 'pending'] } });
+            });
+            it('should handle $nin operator', () => {
+                const filter = { status: { $nin: ['inactive', 'deleted'] } };
+                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ status: { $nin: ['inactive', 'deleted'] } });
+            });
+            it('should handle empty arrays', () => {
+                const filter = { status: { $in: [] } };
+                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ status: { $in: [] } });
+            });
+        });
+        describe('$exists operator', () => {
+            it('should handle $exists: true', () => {
+                const filter = { email: { $exists: true } };
+                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ email: { $exists: true } });
+            });
+            it('should handle $exists: false', () => {
+                const filter = { email: { $exists: false } };
+                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ email: { $exists: false } });
+            });
+        });
+    });
+    describe('Logical operators', () => {
+        describe('$or operator', () => {
+            it('should handle $or with multiple conditions', () => {
+                const filter = { $or: [{ name: 'John' }, { age: 30 }] };
+                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({
+                    $or: [{ name: 'John' }, { age: 30 }]
+                });
+            });
+            it('should handle empty $or array', () => {
+                const filter = { $or: [] };
+                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ $or: [] });
+            });
+            it('should handle $or with complex conditions', () => {
+                const filter = {
+                    $or: [
+                        { name: 'John', age: { $gte: 18 } },
+                        { status: { $in: ['active', 'pending'] } }
+                    ]
+                };
+                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({
+                    $or: [
+                        { name: 'John', age: { $gte: 18 } },
+                        { status: { $in: ['active', 'pending'] } }
+                    ]
+                });
+            });
+        });
+        describe('$and operator', () => {
+            it('should handle $and with multiple conditions', () => {
+                const filter = { $and: [{ name: 'John' }, { age: 30 }] };
+                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({
+                    $and: [{ name: 'John' }, { age: 30 }]
+                });
+            });
+            it('should handle empty $and array', () => {
+                const filter = { $and: [] };
+                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({});
+            });
+            it('should handle nested $and and $or', () => {
+                const filter = {
+                    $and: [
+                        { status: 'active' },
+                        {
+                            $or: [
+                                { age: { $gte: 18 } },
+                                { verified: true }
+                            ]
+                        }
+                    ]
+                };
+                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({
+                    $and: [
+                        { status: 'active' },
+                        {
+                            $or: [
+                                { age: { $gte: 18 } },
+                                { verified: true }
+                            ]
+                        }
+                    ]
+                });
+            });
+        });
+        describe('Array filters (OR logic)', () => {
+            it('should handle single condition arrays', () => {
+                const filter = [{ name: 'John' }];
+                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ name: 'John' });
+            });
+            it('should handle multiple condition arrays', () => {
+                const filter = [{ name: 'John' }, { age: 30 }, { city: 'NYC' }];
+                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({
+                    $or: [{ name: 'John' }, { age: 30 }, { city: 'NYC' }]
+                });
+            });
+            it('should handle complex array conditions', () => {
+                const filter = [
+                    { name: 'John', age: { $gte: 18 } },
+                    { status: { $in: ['active', 'pending'] } }
+                ];
+                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({
+                    $or: [
+                        { name: 'John', age: { $gte: 18 } },
+                        { status: { $in: ['active', 'pending'] } }
+                    ]
+                });
+            });
+        });
+    });
+    describe('Custom operators', () => {
+        describe('$matchWords operator', () => {
+            it('should throw error for $matchWords (needs field context)', () => {
+                const filter = { $matchWords: 'hello world' };
+                expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow('$matchWords with multiple words requires field context');
+            });
+            it('should throw error for non-string values', () => {
+                const filter = { $matchWords: 123 };
+                expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow('$matchWords value must be a string');
+            });
+        });
+        describe('$substr operator', () => {
+            it('should convert $substr to MongoDB $expr format', () => {
+                const filter = { $substr: ['$fieldName', 1, 3] };
+                const result = (0, data_query_mongo_1.dataFilterToMongoQuery)(filter);
+                expect(result).toEqual({
+                    $expr: {
+                        $substr: ['$fieldName', 1, 3]
+                    }
+                });
+            });
+            it('should handle string literals in $substr', () => {
+                const filter = { $substr: ['literal text', 0, 5] };
+                const result = (0, data_query_mongo_1.dataFilterToMongoQuery)(filter);
+                expect(result).toEqual({
+                    $expr: {
+                        $substr: ['literal text', 0, 5]
+                    }
+                });
+            });
+            it('should throw error for invalid $substr arguments', () => {
+                const filter = { $substr: ['$field'] }; // Missing arguments
+                expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow('$substr requires exactly 3 arguments');
+            });
+            it('should throw error for non-array $substr', () => {
+                const filter = { $substr: 'invalid' };
+                expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow('$substr requires exactly 3 arguments');
+            });
+        });
+        describe('$expr operator', () => {
+            it('should convert simple $expr to MongoDB format', () => {
+                const filter = { $expr: [{ $substr: ['$id', 0, 1] }, { $eq: 'A' }] };
+                const result = (0, data_query_mongo_1.dataFilterToMongoQuery)(filter);
+                expect(result).toEqual({
+                    $expr: {
+                        $eq: [
+                            { $substr: ['$id', 0, 1] },
+                            'A'
+                        ]
+                    }
+                });
+            });
+            it('should handle $expr with different operators', () => {
+                const filter = { $expr: [{ $substr: ['$name', 0, 1] }, { $ne: 'Z' }] };
+                const result = (0, data_query_mongo_1.dataFilterToMongoQuery)(filter);
+                expect(result).toEqual({
+                    $expr: {
+                        $ne: [
+                            { $substr: ['$name', 0, 1] },
+                            'Z'
+                        ]
+                    }
+                });
+            });
+            it('should default to $eq for simple expressions', () => {
+                const filter = { $expr: ['$field1', '$field2'] };
+                const result = (0, data_query_mongo_1.dataFilterToMongoQuery)(filter);
+                expect(result).toEqual({
+                    $expr: {
+                        $eq: ['$field1', '$field2']
+                    }
+                });
+            });
+            it('should throw error for invalid $expr format', () => {
+                const filter = { $expr: ['single_argument'] };
+                expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow('$expr requires exactly 2 arguments');
+            });
+        });
+    });
+    describe('Error cases', () => {
+        it('should throw error for unknown operators', () => {
+            const filter = { field: { $unknown: 'value' } };
+            expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow('Unknown operator: $unknown');
+        });
+        it('should throw error for operators without $ prefix', () => {
+            const filter = { field: { invalidOp: 'value' } };
+            expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow('Invalid operator: invalidOp. Operators must start with $');
+        });
+        it('should throw error for nested $matchWords', () => {
+            const filter = { field: { $matchWords: 'test' } };
+            expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow('$matchWords should be handled at field level');
+        });
+        it('should throw error for nested $substr', () => {
+            const filter = { field: { $substr: ['$other', 0, 1] } };
+            expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow('$substr should be handled at field level');
+        });
+        it('should throw error for nested $expr', () => {
+            const filter = { field: { $expr: ['$a', '$b'] } };
+            expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow('$expr should be handled at field level');
+        });
+    });
+    describe('Complex nested scenarios', () => {
+        it('should handle deeply nested conditions', () => {
+            const filter = {
+                $and: [
+                    { status: 'active' },
+                    {
+                        $or: [
+                            { age: { $gte: 18, $lt: 65 } },
+                            { verified: true }
+                        ]
+                    },
+                    { role: { $in: ['user', 'admin'] } }
+                ]
+            };
+            expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({
+                $and: [
+                    { status: 'active' },
+                    {
+                        $or: [
+                            { age: { $gte: 18, $lt: 65 } },
+                            { verified: true }
+                        ]
+                    },
+                    { role: { $in: ['user', 'admin'] } }
+                ]
+            });
+        });
+        it('should handle mixed array and object filters', () => {
+            const filter = [
+                { name: 'John', age: { $gte: 18 } },
+                {
+                    $and: [
+                        { status: 'active' },
+                        { verified: true }
+                    ]
+                }
+            ];
+            expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({
+                $or: [
+                    { name: 'John', age: { $gte: 18 } },
+                    {
+                        $and: [
+                            { status: 'active' },
+                            { verified: true }
+                        ]
+                    }
+                ]
+            });
+        });
+    });
+});
+describe('sortByToMongoSort', () => {
+    it('should handle empty sort', () => {
+        expect((0, data_query_mongo_1.sortByToMongoSort)()).toEqual({});
+        expect((0, data_query_mongo_1.sortByToMongoSort)([])).toEqual({});
+    });
+    it('should handle ascending sort', () => {
+        expect((0, data_query_mongo_1.sortByToMongoSort)(['name'])).toEqual({ name: 1 });
+    });
+    it('should handle descending sort', () => {
+        expect((0, data_query_mongo_1.sortByToMongoSort)(['-name'])).toEqual({ name: -1 });
+    });
+    it('should handle multiple sort fields', () => {
+        expect((0, data_query_mongo_1.sortByToMongoSort)(['name', '-age', 'created'])).toEqual({
+            name: 1,
+            age: -1,
+            created: 1
+        });
+    });
+    it('should handle complex field names', () => {
+        expect((0, data_query_mongo_1.sortByToMongoSort)(['-user.name', 'profile.age'])).toEqual({
+            'user.name': -1,
+            'profile.age': 1
+        });
+    });
+});
+describe('paginationToMongoSkipLimit', () => {
+    it('should handle no pagination', () => {
+        expect((0, data_query_mongo_1.paginationToMongoSkipLimit)()).toEqual({});
+    });
+    it('should handle only pageSize', () => {
+        expect((0, data_query_mongo_1.paginationToMongoSkipLimit)(undefined, 10)).toEqual({ limit: 10 });
+    });
+    it('should handle only page (no effect without pageSize)', () => {
+        expect((0, data_query_mongo_1.paginationToMongoSkipLimit)(2)).toEqual({});
+    });
+    it('should handle page and pageSize', () => {
+        expect((0, data_query_mongo_1.paginationToMongoSkipLimit)(1, 10)).toEqual({ limit: 10 });
+        expect((0, data_query_mongo_1.paginationToMongoSkipLimit)(2, 10)).toEqual({ limit: 10, skip: 10 });
+        expect((0, data_query_mongo_1.paginationToMongoSkipLimit)(3, 20)).toEqual({ limit: 20, skip: 40 });
+    });
+    it('should handle fractional numbers', () => {
+        expect((0, data_query_mongo_1.paginationToMongoSkipLimit)(2.7, 10.3)).toEqual({ limit: 10, skip: 21 });
+    });
+    it('should handle zero page', () => {
+        expect((0, data_query_mongo_1.paginationToMongoSkipLimit)(0, 10)).toEqual({ limit: 10 });
+    });
+});

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

@@ -0,0 +1,14 @@
+import { DataFilter, DataQuery } from './data-query';
+export declare function dataFilterToSqlWhere(filter: DataFilter<any>): string;
+/**
+ * Converts a DataQuery to a complete SQLite query string
+ */
+export declare function dataQueryToSqliteQuery(dataQuery: DataQuery<any>): string;
+/**
+ * Converts DataQuery text search to SQLite LIKE clauses
+ */
+export declare function dataFilterToSqliteTextSearch(query: DataQuery<any>): string;
+/**
+ * Converts $substr directive to SQLite substr function
+ */
+export declare function substrDirectiveToSqlite(substrArgs: any): string;