@peers-app/peers-sdk 0.1.4

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

@@ -0,0 +1,297 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataFilterToSqlWhere = dataFilterToSqlWhere;
+exports.dataQueryToSqliteQuery = dataQueryToSqliteQuery;
+exports.dataFilterToSqliteTextSearch = dataFilterToSqliteTextSearch;
+exports.substrDirectiveToSqlite = substrDirectiveToSqlite;
+const lodash_1 = require("lodash");
+function dataFilterToSqlWhere(filter) {
+    if (isScalarValue(filter)) {
+        return dataFieldScalarToSqlValue(filter);
+    }
+    if ((0, lodash_1.isArray)(filter)) {
+        return handleOrArray(filter);
+    }
+    return handleFilterObject(filter);
+}
+function handleOrArray(filters) {
+    const conditions = filters.map(f => dataFilterToSqlWhere(f));
+    const orStatement = conditions.join(' OR ').trim();
+    return `(${orStatement || '1=1'})`;
+}
+function handleFilterObject(filter) {
+    const fieldNames = Object.keys(filter);
+    if (!fieldNames.length) {
+        return '(1=1)';
+    }
+    const conditions = fieldNames.map(name => handleFilterField(name, filter[name]));
+    return `(${conditions.join(' AND ')})`;
+}
+function handleFilterField(name, value) {
+    if (name === '$or') {
+        return handleOrOperator(value);
+    }
+    if (name === '$and') {
+        return handleAndOperator(value);
+    }
+    if (name === '$substr') {
+        return substrDirectiveToSqlite(value);
+    }
+    if (name === '$expr') {
+        return handleExprOperator(value);
+    }
+    return handleFieldCondition(name, value);
+}
+function handleFieldCondition(fieldName, value) {
+    const escapedName = escapeFieldName(fieldName);
+    if (value === undefined || value === null) {
+        return `"${escapedName}" IS 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: [${value.slice(0, 2).map(v => typeof v === 'string' ? `'${v}'` : v).join(', ')}${value.length > 2 ? ', ...' : ''}] } }`);
+    }
+    if (typeof value === 'object') {
+        return handleObjectValue(escapedName, value);
+    }
+    return `"${escapedName}" = ${dataFieldScalarToSqlValue(value)}`;
+}
+function handleObjectValue(fieldName, value) {
+    const keys = Object.keys(value);
+    if (keys.length !== 1 || !keys[0].startsWith('$')) {
+        throw new Error(`Invalid object value for field ${fieldName}`);
+    }
+    const operator = keys[0];
+    const operatorValue = value[operator];
+    return handleFieldOperator(fieldName, operator, operatorValue);
+}
+function handleFieldOperator(fieldName, operator, value) {
+    switch (operator) {
+        case '$in':
+            return handleInOperator(fieldName, value);
+        case '$nin':
+            return handleNinOperator(fieldName, value);
+        case '$matchWords':
+            return handleMatchWordsOperator(fieldName, value);
+        case '$exists':
+            return handleExistsOperator(fieldName, value);
+        case '$ne':
+            return handleNeOperator(fieldName, value);
+        case '$eq':
+        case '$gt':
+        case '$gte':
+        case '$lt':
+        case '$lte':
+            return handleComparisonOperator(fieldName, operator, value);
+        default:
+            throw new Error(`Unknown operator: ${operator}`);
+    }
+}
+function handleOrOperator(value) {
+    const conditions = value.map(f => dataFilterToSqlWhere(f));
+    const orStatement = conditions.join(' OR ').trim();
+    return `(${orStatement || '1=1'})`;
+}
+function handleAndOperator(value) {
+    if (value.length === 0) {
+        return '(1=1)';
+    }
+    const conditions = value.map(f => dataFilterToSqlWhere(f));
+    return `(${conditions.join(' AND ')})`;
+}
+function handleExprOperator(value) {
+    let expr = '';
+    let lhsSet = false;
+    for (const exprPart of Object.values(value)) {
+        if (!lhsSet) {
+            expr += dataFilterToSqlWhere(exprPart);
+            lhsSet = true;
+        }
+        else {
+            let tmp = dataFilterToSqlWhere({ $$$$: exprPart });
+            tmp = tmp.substring(7, tmp.length - 1);
+            expr += tmp;
+        }
+    }
+    return expr;
+}
+function handleInOperator(fieldName, value) {
+    if (!(0, lodash_1.isArray)(value)) {
+        throw new Error(`$in value must be an array`);
+    }
+    const inValues = value.map(v => dataFilterToSqlWhere(v)).join(', ');
+    return `"${fieldName}" IN (${inValues})`;
+}
+function handleNinOperator(fieldName, value) {
+    if (!(0, lodash_1.isArray)(value)) {
+        throw new Error(`$nin value must be an array`);
+    }
+    const ninValues = value.map(v => dataFilterToSqlWhere(v)).join(', ');
+    return `"${fieldName}" NOT IN (${ninValues})`;
+}
+function handleMatchWordsOperator(fieldName, value) {
+    if (typeof value !== 'string') {
+        throw new Error(`$matchWords value must be a string`);
+    }
+    return value.split(' ').map((word) => {
+        const escapedWord = word.replace(/'/g, "''");
+        return `"${fieldName}" LIKE '%${escapedWord}%'`;
+    }).join(' AND ');
+}
+function handleExistsOperator(fieldName, value) {
+    if (value) {
+        return `"${fieldName}" IS NOT NULL`;
+    }
+    else {
+        return `"${fieldName}" IS NULL`;
+    }
+}
+function handleNeOperator(fieldName, value) {
+    const strValue = dataFilterToSqlWhere(value);
+    return `("${fieldName}" <> ${strValue} OR "${fieldName}" IS NULL)`;
+}
+function handleComparisonOperator(fieldName, operator, value) {
+    const sqlOperator = {
+        '$eq': '=',
+        '$ne': '<>',
+        '$gt': '>',
+        '$gte': '>=',
+        '$lt': '<',
+        '$lte': '<='
+    }[operator];
+    if (!sqlOperator) {
+        throw new Error(`Unknown operator: ${operator}`);
+    }
+    const strValue = dataFilterToSqlWhere(value);
+    return `"${fieldName}" ${sqlOperator} ${strValue}`;
+}
+function escapeFieldName(name) {
+    return name.replace(/"/g, `""`);
+}
+function isScalarValue(value) {
+    return (typeof value !== 'object' ||
+        (0, lodash_1.isDate)(value) ||
+        value === null);
+}
+function dataFieldScalarToSqlValue(value) {
+    if (value === undefined || value === null) {
+        return 'NULL';
+    }
+    else if (typeof value === 'boolean') {
+        return value ? '1' : '0';
+    }
+    else if (typeof value === 'number') {
+        return String(value);
+    }
+    else if (typeof value === 'string') {
+        if (value.startsWith('$')) {
+            const escapedValue = value.substring(1).replace(/"/g, `""`);
+            return `"${escapedValue}"`;
+        }
+        else {
+            let processedValue = value;
+            if (value.startsWith('\\$')) {
+                processedValue = value.substring(1);
+            }
+            const escapedValue = processedValue.replace(/'/g, "''");
+            return `'${escapedValue}'`;
+        }
+    }
+    else if (value instanceof Date) {
+        return `'${value.toISOString()}'`;
+    }
+    else {
+        throw new Error(`Unknown data field type: ${value}`);
+    }
+}
+/**
+ * Converts a DataQuery to a complete SQLite query string
+ */
+function dataQueryToSqliteQuery(dataQuery) {
+    let orderBy = "1";
+    const sortBy = dataQuery.sortBy;
+    if (sortBy?.length) {
+        const sortBys = sortBy.map(s => String(s));
+        orderBy = sortBys.map(s => {
+            if (s.startsWith('-')) {
+                return `"${s.substring(1)}" DESC`;
+            }
+            else {
+                return `"${s}" ASC`;
+            }
+        }).join(', ');
+    }
+    let where = dataFilterToSqlWhere(dataQuery.filter || {}) || '(1=1)';
+    if (dataQuery.textSearch?.trim()) {
+        const textSearch = dataFilterToSqliteTextSearch(dataQuery);
+        if (textSearch) {
+            if (where === '(1=1)') {
+                where = textSearch;
+            }
+            else {
+                where = `(${where}) AND (${textSearch})`;
+            }
+        }
+    }
+    if ((!where.trim()) || where === '()') {
+        console.warn(`dataQueryToSqliteQuery: where clause is empty, using '1=1'`);
+        where = '(1=1)';
+    }
+    let sql = `
+    SELECT
+      *
+    FROM "${dataQuery.table.tableName}"
+    WHERE ${where}
+    ORDER BY ${orderBy}
+  `;
+    if (dataQuery.page || dataQuery.pageSize) {
+        const page = Math.round(dataQuery.page || 1);
+        const pageSize = Math.round(dataQuery.pageSize || 100);
+        sql += `
+    LIMIT ${pageSize}
+    OFFSET ${pageSize * (page - 1)}
+    `.substring(3);
+    }
+    sql = sql
+        .trim()
+        .replace(/    /g, '');
+    return sql;
+}
+/**
+ * Converts DataQuery text search to SQLite LIKE clauses
+ */
+function dataFilterToSqliteTextSearch(query) {
+    const textSearch = query.textSearch;
+    if (!textSearch?.trim()) {
+        return '';
+    }
+    const fieldNames = query.table.metaData.fields.map(f => f.name);
+    // escape single quotes
+    const escapedTextSearch = textSearch.replace(/'/g, "''");
+    if (query.textSearchExact) {
+        const strFilter = fieldNames.map(name => {
+            return `"${name}" LIKE '%${escapedTextSearch}%'`;
+        }).join(' OR ');
+        return `(${strFilter})`;
+    }
+    else {
+        const words = escapedTextSearch.replace(/\s/mg, ' ').split(' ').filter(s => s);
+        const strFilters = [];
+        for (const word of words) {
+            const strFilter = fieldNames.map(name => {
+                return `"${name}" LIKE '%${word}%'`;
+            }).join(' OR ');
+            strFilters.push(`(${strFilter})`);
+        }
+        return `(${strFilters.join(' AND ')})`;
+    }
+}
+/**
+ * Converts $substr directive to SQLite substr function
+ */
+function substrDirectiveToSqlite(substrArgs) {
+    const args = substrArgs;
+    let arg0 = dataFilterToSqlWhere(args[0]);
+    let arg1 = dataFilterToSqlWhere(args[1]);
+    let arg2 = dataFilterToSqlWhere(args[2]);
+    return `substr(${arg0}, ${arg1}, ${arg2})`;
+}

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

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

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

@@ -0,0 +1,377 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const data_query_sqlite_1 = require("./data-query.sqlite");
+describe('dataFilterToSqlWhere - Restructured Version', () => {
+    describe('Main orchestrator function', () => {
+        it('should handle scalar values', () => {
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(null)).toBe('NULL');
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(undefined)).toBe('NULL');
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(true)).toBe('1');
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(false)).toBe('0');
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(42)).toBe('42');
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)('test')).toBe("'test'");
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(new Date('2023-01-01T00:00:00.000Z'))).toBe("'2023-01-01T00:00:00.000Z'");
+        });
+        it('should handle empty filter object', () => {
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)({})).toBe('(1=1)');
+        });
+        it('should delegate to array handler for arrays', () => {
+            const filter = [{ name: 'John' }, { age: 30 }];
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`(("name" = 'John') OR ("age" = 30))`);
+        });
+        it('should delegate to object handler for filter objects', () => {
+            const filter = { name: 'John', age: 30 };
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" = 'John' AND "age" = 30)`);
+        });
+    });
+    describe('handleOrArray function', () => {
+        it('should handle empty arrays', () => {
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)([])).toBe('(1=1)');
+        });
+        it('should handle single condition arrays', () => {
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)([{ name: 'John' }])).toBe(`(("name" = 'John'))`);
+        });
+        it('should handle multiple conditions with OR', () => {
+            const filter = [{ name: 'John' }, { age: 30 }, { city: 'NYC' }];
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`(("name" = 'John') OR ("age" = 30) OR ("city" = 'NYC'))`);
+        });
+        it('should handle complex nested conditions', () => {
+            const filter = [
+                { name: 'John', age: 30 },
+                { city: { $in: ['NYC', 'LA'] } }
+            ];
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`(("name" = 'John' AND "age" = 30) OR ("city" IN ('NYC', 'LA')))`);
+        });
+    });
+    describe('handleFilterObject function', () => {
+        it('should handle multiple field conditions with AND', () => {
+            const filter = { name: 'John', age: 30, active: true };
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" = 'John' AND "age" = 30 AND "active" = 1)`);
+        });
+        it('should handle single field condition', () => {
+            const filter = { name: 'John' };
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" = 'John')`);
+        });
+    });
+    describe('Special operators', () => {
+        describe('$or operator', () => {
+            it('should handle $or with multiple conditions', () => {
+                const filter = { $or: [{ name: 'John' }, { age: 30 }] };
+                expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`((("name" = 'John') OR ("age" = 30)))`);
+            });
+            it('should handle empty $or array', () => {
+                const filter = { $or: [] };
+                expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`((1=1))`);
+            });
+            it('should handle $or with empty objects', () => {
+                const filter = { $or: [{}] };
+                expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`(((1=1)))`);
+            });
+        });
+        describe('$and operator', () => {
+            it('should handle $and with multiple conditions', () => {
+                const filter = { $and: [{ name: 'John' }, { age: 30 }] };
+                expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`((("name" = 'John') AND ("age" = 30)))`);
+            });
+            it('should handle empty $and array', () => {
+                const filter = { $and: [] };
+                expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`((1=1))`);
+            });
+            it('should handle $and with empty objects', () => {
+                const filter = { $and: [{}] };
+                expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`(((1=1)))`);
+            });
+        });
+        describe('$expr operator', () => {
+            it('should handle simple expressions', () => {
+                const filter = { $expr: [{ $substr: ['$id', 1, 1] }, { $eq: 'a' }] };
+                expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`((substr("id", 1, 1)) = 'a')`);
+            });
+            it('should handle expressions with column references', () => {
+                const filter = { $expr: [{ $substr: ['$col1', 2, 4] }, { $gte: '$col2' }] };
+                expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`((substr("col1", 2, 4)) >= "col2")`);
+            });
+        });
+        describe('$substr operator', () => {
+            it('should handle substr with column reference', () => {
+                const filter = { $substr: ['$col1', 2, 4] };
+                expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`(substr("col1", 2, 4))`);
+            });
+            it('should handle substr with string literal', () => {
+                const filter = { $substr: ['test string', 1, 4] };
+                expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`(substr('test string', 1, 4))`);
+            });
+            it('should handle substr with escaped quotes', () => {
+                const filter = { $substr: ["test's string", 1, 4] };
+                expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`(substr('test''s string', 1, 4))`);
+            });
+        });
+    });
+    describe('Field operators', () => {
+        describe('$in operator', () => {
+            it('should handle string arrays', () => {
+                const filter = { name: { $in: ['John', 'Jane', 'Bob'] } };
+                expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" IN ('John', 'Jane', 'Bob'))`);
+            });
+            it('should handle number arrays', () => {
+                const filter = { age: { $in: [20, 30, 40] } };
+                expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("age" IN (20, 30, 40))`);
+            });
+            it('should handle mixed type arrays', () => {
+                const filter = { value: { $in: ['test', 42, null, true] } };
+                expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("value" IN ('test', 42, NULL, 1))`);
+            });
+            it('should handle empty arrays', () => {
+                const filter = { name: { $in: [] } };
+                expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" IN ())`);
+            });
+            it('should throw error for non-array values', () => {
+                const filter = { name: { $in: 'John' } };
+                expect(() => (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toThrow('$in value must be an array');
+            });
+        });
+        describe('$nin operator', () => {
+            it('should handle string arrays', () => {
+                const filter = { name: { $nin: ['John', 'Jane'] } };
+                expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" NOT IN ('John', 'Jane'))`);
+            });
+            it('should handle number arrays', () => {
+                const filter = { age: { $nin: [20, 30] } };
+                expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("age" NOT IN (20, 30))`);
+            });
+            it('should throw error for non-array values', () => {
+                const filter = { name: { $nin: 'John' } };
+                expect(() => (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toThrow('$nin value must be an array');
+            });
+        });
+        describe('$matchWords operator', () => {
+            it('should handle single word', () => {
+                const filter = { description: { $matchWords: 'test' } };
+                expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("description" LIKE '%test%')`);
+            });
+            it('should handle multiple words', () => {
+                const filter = { description: { $matchWords: 'hello world' } };
+                expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("description" LIKE '%hello%' AND "description" LIKE '%world%')`);
+            });
+            it('should handle words with quotes', () => {
+                const filter = { description: { $matchWords: "John's world" } };
+                expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("description" LIKE '%John''s%' AND "description" LIKE '%world%')`);
+            });
+            it('should handle multiple quotes', () => {
+                const filter = { description: { $matchWords: "It's John's" } };
+                expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("description" LIKE '%It''s%' AND "description" LIKE '%John''s%')`);
+            });
+            it('should throw error for non-string values', () => {
+                const filter = { description: { $matchWords: 123 } };
+                expect(() => (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toThrow('$matchWords value must be a string');
+            });
+        });
+        describe('$exists operator', () => {
+            it('should handle $exists: true', () => {
+                const filter = { name: { $exists: true } };
+                expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" IS NOT NULL)`);
+            });
+            it('should handle $exists: false', () => {
+                const filter = { name: { $exists: false } };
+                expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" IS NULL)`);
+            });
+            it('should handle truthy values', () => {
+                const filter = { name: { $exists: 1 } };
+                expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" IS NOT NULL)`);
+            });
+            it('should handle falsy values', () => {
+                const filter = { name: { $exists: 0 } };
+                expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" IS NULL)`);
+            });
+        });
+        describe('$ne operator', () => {
+            it('should handle string values', () => {
+                const filter = { name: { $ne: 'John' } };
+                expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`(("name" <> 'John' OR "name" IS NULL))`);
+            });
+            it('should handle number values', () => {
+                const filter = { age: { $ne: 30 } };
+                expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`(("age" <> 30 OR "age" IS NULL))`);
+            });
+            it('should handle null values', () => {
+                const filter = { name: { $ne: null } };
+                expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`(("name" <> NULL OR "name" IS NULL))`);
+            });
+            it('should escape quotes in strings', () => {
+                const filter = { name: { $ne: "O'Hara" } };
+                expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`(("name" <> 'O''Hara' OR "name" IS NULL))`);
+            });
+        });
+        describe('Comparison operators', () => {
+            it('should handle $eq operator', () => {
+                const filter = { age: { $eq: 30 } };
+                expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("age" = 30)`);
+            });
+            it('should handle $gt operator', () => {
+                const filter = { age: { $gt: 30 } };
+                expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("age" > 30)`);
+            });
+            it('should handle $gte operator', () => {
+                const filter = { age: { $gte: 30 } };
+                expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("age" >= 30)`);
+            });
+            it('should handle $lt operator', () => {
+                const filter = { age: { $lt: 30 } };
+                expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("age" < 30)`);
+            });
+            it('should handle $lte operator', () => {
+                const filter = { age: { $lte: 30 } };
+                expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("age" <= 30)`);
+            });
+            it('should handle string values with comparison operators', () => {
+                const filter = { name: { $gt: 'John' } };
+                expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" > 'John')`);
+            });
+            it('should handle date values', () => {
+                const date = new Date('2023-01-01T00:00:00.000Z');
+                const filter = { created: { $gte: date } };
+                expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("created" >= '2023-01-01T00:00:00.000Z')`);
+            });
+        });
+    });
+    describe('Field conditions', () => {
+        it('should handle null field values', () => {
+            const filter = { name: null };
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" IS NULL)`);
+        });
+        it('should handle undefined field values', () => {
+            const filter = { name: undefined };
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" IS NULL)`);
+        });
+        it('should handle simple field values', () => {
+            const filter = { name: 'John', age: 30, active: true };
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" = 'John' AND "age" = 30 AND "active" = 1)`);
+        });
+        it('should throw error for direct array usage', () => {
+            const filter = { names: ['John', 'Jane'] };
+            expect(() => (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toThrow(`Invalid filter: Arrays are not allowed as direct field values. Use $in instead: { names: { $in: ['John', 'Jane'] } }`);
+        });
+        it('should throw error for direct array usage with more items', () => {
+            const filter = { names: ['John', 'Jane', 'Bob', 'Alice'] };
+            expect(() => (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toThrow(`Invalid filter: Arrays are not allowed as direct field values. Use $in instead: { names: { $in: ['John', 'Jane', ...] } }`);
+        });
+    });
+    describe('Field name escaping', () => {
+        it('should escape field names with double quotes', () => {
+            const filter = { 'field"name': 'test' };
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("field""name" = 'test')`);
+        });
+        it('should escape field names with multiple double quotes', () => {
+            const filter = { 'field"with"quotes': 'test' };
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("field""with""quotes" = 'test')`);
+        });
+        it('should handle normal field names', () => {
+            const filter = { fieldName: 'test' };
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("fieldName" = 'test')`);
+        });
+    });
+    describe('String value handling', () => {
+        it('should escape single quotes in string values', () => {
+            const filter = { name: "John's" };
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" = 'John''s')`);
+        });
+        it('should escape multiple single quotes', () => {
+            const filter = { name: "It's John's" };
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" = 'It''s John''s')`);
+        });
+        it('should handle column references with $ prefix', () => {
+            const filter = { name: '$other_column' };
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" = "other_column")`);
+        });
+        it('should handle escaped $ prefix', () => {
+            const filter = { name: '\\$literal' };
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" = '$literal')`);
+        });
+        it('should handle backslash not followed by $', () => {
+            const filter = { name: '\\literal' };
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" = '\\literal')`);
+        });
+        it('should escape double quotes in column references', () => {
+            const filter = { name: '$col"with"quotes' };
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" = "col""with""quotes")`);
+        });
+    });
+    describe('Error cases', () => {
+        it('should throw error for unknown operators', () => {
+            const filter = { name: { $unknown: 'test' } };
+            expect(() => (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toThrow('Unknown operator: $unknown');
+        });
+        it('should throw error for invalid object values', () => {
+            const filter = { name: { invalidKey: 'test' } };
+            expect(() => (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toThrow('Invalid object value for field name');
+        });
+        it('should throw error for multiple operators in object', () => {
+            const filter = { name: { $eq: 'test', $ne: 'other' } };
+            expect(() => (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toThrow('Invalid object value for field name');
+        });
+        it('should throw error for unknown scalar types', () => {
+            const filter = { name: Symbol('test') };
+            expect(() => (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toThrow('Cannot convert a Symbol value to a string');
+        });
+    });
+    describe('Complex nested scenarios', () => {
+        it('should handle deeply nested conditions', () => {
+            const filter = {
+                $and: [
+                    { name: 'John' },
+                    {
+                        $or: [
+                            { age: { $gte: 30 } },
+                            { city: { $in: ['NYC', 'LA'] } }
+                        ]
+                    }
+                ]
+            };
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`((("name" = 'John') AND (((\"age\" >= 30) OR (\"city\" IN ('NYC', 'LA'))))))`);
+        });
+        it('should handle mixed operators and conditions', () => {
+            const filter = {
+                name: { $ne: 'John' },
+                $and: [
+                    { age: { $gte: 25 } },
+                    { age: { $lte: 65 } }
+                ],
+                $or: [
+                    { city: 'NYC' },
+                    { state: 'CA' }
+                ]
+            };
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`(("name" <> 'John' OR "name" IS NULL) AND (("age" >= 25) AND ("age" <= 65)) AND (("city" = 'NYC') OR ("state" = 'CA')))`);
+        });
+        it('should handle arrays with complex conditions', () => {
+            const filter = [
+                { name: 'John', age: { $gte: 30 } },
+                { city: { $in: ['NYC', 'LA'] }, active: true }
+            ];
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`(("name" = 'John' AND "age" >= 30) OR ("city" IN ('NYC', 'LA') AND "active" = 1))`);
+        });
+    });
+    describe('Edge cases', () => {
+        it('should handle empty strings', () => {
+            const filter = { name: '' };
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" = '')`);
+        });
+        it('should handle zero values', () => {
+            const filter = { count: 0 };
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("count" = 0)`);
+        });
+        it('should handle boolean false', () => {
+            const filter = { active: false };
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("active" = 0)`);
+        });
+        it('should handle very long strings', () => {
+            const longString = 'a'.repeat(1000);
+            const filter = { description: longString };
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("description" = '${longString}')`);
+        });
+        it('should handle special characters in field names', () => {
+            const filter = { 'field-with-dashes': 'test', 'field_with_underscores': 'test2' };
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("field-with-dashes" = 'test' AND "field_with_underscores" = 'test2')`);
+        });
+    });
+});

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

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