@peers-app/peers-sdk 0.14.0 → 0.15.0

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

@@ -15,29 +15,29 @@ function dataFilterToSqlWhere(filter) {
     return handleFilterObject(filter);
 }
 function handleOrArray(filters) {
-    const conditions = filters.map(f => dataFilterToSqlWhere(f));
-    const orStatement = conditions.join(' OR ').trim();
-    return `(${orStatement || '1=1'})`;
+    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)';
+        return "(1=1)";
     }
-    const conditions = fieldNames.map(name => handleFilterField(name, filter[name]));
-    return `(${conditions.join(' AND ')})`;
+    const conditions = fieldNames.map((name) => handleFilterField(name, filter[name]));
+    return `(${conditions.join(" AND ")})`;
 }
 function handleFilterField(name, value) {
-    if (name === '$or') {
+    if (name === "$or") {
         return handleOrOperator(value);
     }
-    if (name === '$and') {
+    if (name === "$and") {
         return handleAndOperator(value);
     }
-    if (name === '$substr') {
+    if (name === "$substr") {
         return substrDirectiveToSqlite(value);
     }
-    if (name === '$expr') {
+    if (name === "$expr") {
         return handleExprOperator(value);
     }
     return handleFieldCondition(name, value);
@@ -48,16 +48,19 @@ function handleFieldCondition(fieldName, value) {
         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 ? ', ...' : ''}] } }`);
+        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') {
+    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('$')) {
+    if (keys.length !== 1 || !keys[0].startsWith("$")) {
         throw new Error(`Invalid object value for field ${fieldName}`);
     }
     const operator = keys[0];
@@ -66,40 +69,40 @@ function handleObjectValue(fieldName, value) {
 }
 function handleFieldOperator(fieldName, operator, value) {
     switch (operator) {
-        case '$in':
+        case "$in":
             return handleInOperator(fieldName, value);
-        case '$nin':
+        case "$nin":
             return handleNinOperator(fieldName, value);
-        case '$matchWords':
+        case "$matchWords":
             return handleMatchWordsOperator(fieldName, value);
-        case '$exists':
+        case "$exists":
             return handleExistsOperator(fieldName, value);
-        case '$ne':
+        case "$ne":
             return handleNeOperator(fieldName, value);
-        case '$eq':
-        case '$gt':
-        case '$gte':
-        case '$lt':
-        case '$lte':
+        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'})`;
+    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)';
+        return "(1=1)";
     }
-    const conditions = value.map(f => dataFilterToSqlWhere(f));
-    return `(${conditions.join(' AND ')})`;
+    const conditions = value.map((f) => dataFilterToSqlWhere(f));
+    return `(${conditions.join(" AND ")})`;
 }
 function handleExprOperator(value) {
-    let expr = '';
+    let expr = "";
     let lhsSet = false;
     for (const exprPart of Object.values(value)) {
         if (!lhsSet) {
@@ -118,24 +121,27 @@ 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(', ');
+    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(', ');
+    const ninValues = value.map((v) => dataFilterToSqlWhere(v)).join(", ");
     return `"${fieldName}" NOT IN (${ninValues})`;
 }
 function handleMatchWordsOperator(fieldName, value) {
-    if (typeof value !== 'string') {
+    if (typeof value !== "string") {
         throw new Error(`$matchWords value must be a string`);
     }
-    return value.split(' ').map((word) => {
+    return value
+        .split(" ")
+        .map((word) => {
         const escapedWord = word.replace(/'/g, "''");
         return `"${fieldName}" LIKE '%${escapedWord}%'`;
-    }).join(' AND ');
+    })
+        .join(" AND ");
 }
 function handleExistsOperator(fieldName, value) {
     if (value) {
@@ -151,12 +157,12 @@ function handleNeOperator(fieldName, value) {
 }
 function handleComparisonOperator(fieldName, operator, value) {
     const sqlOperator = {
-        '$eq': '=',
-        '$ne': '<>',
-        '$gt': '>',
-        '$gte': '>=',
-        '$lt': '<',
-        '$lte': '<='
+        $eq: "=",
+        $ne: "<>",
+        $gt: ">",
+        $gte: ">=",
+        $lt: "<",
+        $lte: "<=",
     }[operator];
     if (!sqlOperator) {
         throw new Error(`Unknown operator: ${operator}`);
@@ -168,28 +174,26 @@ function escapeFieldName(name) {
     return name.replace(/"/g, `""`);
 }
 function isScalarValue(value) {
-    return (typeof value !== 'object' ||
-        (0, lodash_1.isDate)(value) ||
-        value === null);
+    return typeof value !== "object" || (0, lodash_1.isDate)(value) || value === null;
 }
 function dataFieldScalarToSqlValue(value) {
     if (value === undefined || value === null) {
-        return 'NULL';
+        return "NULL";
     }
-    else if (typeof value === 'boolean') {
-        return value ? '1' : '0';
+    else if (typeof value === "boolean") {
+        return value ? "1" : "0";
     }
-    else if (typeof value === 'number') {
+    else if (typeof value === "number") {
         return String(value);
     }
-    else if (typeof value === 'string') {
-        if (value.startsWith('$')) {
+    else if (typeof value === "string") {
+        if (value.startsWith("$")) {
             const escapedValue = value.substring(1).replace(/"/g, `""`);
             return `"${escapedValue}"`;
         }
         else {
             let processedValue = value;
-            if (value.startsWith('\\$')) {
+            if (value.startsWith("\\$")) {
                 processedValue = value.substring(1);
             }
             const escapedValue = processedValue.replace(/'/g, "''");
@@ -210,21 +214,23 @@ 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('-')) {
+        const sortBys = sortBy.map((s) => String(s));
+        orderBy = sortBys
+            .map((s) => {
+            if (s.startsWith("-")) {
                 return `"${s.substring(1)}" DESC`;
             }
             else {
                 return `"${s}" ASC`;
             }
-        }).join(', ');
+        })
+            .join(", ");
     }
-    let where = dataFilterToSqlWhere(dataQuery.filter || {}) || '(1=1)';
+    let where = dataFilterToSqlWhere(dataQuery.filter || {}) || "(1=1)";
     if (dataQuery.textSearch?.trim()) {
         const textSearch = dataFilterToSqliteTextSearch(dataQuery);
         if (textSearch) {
-            if (where === '(1=1)') {
+            if (where === "(1=1)") {
                 where = textSearch;
             }
             else {
@@ -232,9 +238,9 @@ function dataQueryToSqliteQuery(dataQuery) {
             }
         }
     }
-    if ((!where.trim()) || where === '()') {
+    if (!where.trim() || where === "()") {
         console.warn(`dataQueryToSqliteQuery: where clause is empty, using '1=1'`);
-        where = '(1=1)';
+        where = "(1=1)";
     }
     let sql = `
     SELECT
@@ -251,9 +257,7 @@ function dataQueryToSqliteQuery(dataQuery) {
     OFFSET ${pageSize * (page - 1)}
     `.substring(3);
     }
-    sql = sql
-        .trim()
-        .replace(/    /g, '');
+    sql = sql.trim().replace(/ {4}/g, "");
     return sql;
 }
 /**
@@ -262,27 +266,34 @@ function dataQueryToSqliteQuery(dataQuery) {
 function dataFilterToSqliteTextSearch(query) {
     const textSearch = query.textSearch;
     if (!textSearch?.trim()) {
-        return '';
+        return "";
     }
-    const fieldNames = query.table.metaData.fields.map(f => f.name);
+    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 => {
+        const strFilter = fieldNames
+            .map((name) => {
             return `"${name}" LIKE '%${escapedTextSearch}%'`;
-        }).join(' OR ');
+        })
+            .join(" OR ");
         return `(${strFilter})`;
     }
     else {
-        const words = escapedTextSearch.replace(/\s/mg, ' ').split(' ').filter(s => s);
+        const words = escapedTextSearch
+            .replace(/\s/gm, " ")
+            .split(" ")
+            .filter((s) => s);
         const strFilters = [];
         for (const word of words) {
-            const strFilter = fieldNames.map(name => {
+            const strFilter = fieldNames
+                .map((name) => {
                 return `"${name}" LIKE '%${word}%'`;
-            }).join(' OR ');
+            })
+                .join(" OR ");
             strFilters.push(`(${strFilter})`);
         }
-        return `(${strFilters.join(' AND ')})`;
+        return `(${strFilters.join(" AND ")})`;
     }
 }
 /**
@@ -290,8 +301,8 @@ function dataFilterToSqliteTextSearch(query) {
  */
 function substrDirectiveToSqlite(substrArgs) {
     const args = substrArgs;
-    let arg0 = dataFilterToSqlWhere(args[0]);
-    let arg1 = dataFilterToSqlWhere(args[1]);
-    let arg2 = dataFilterToSqlWhere(args[2]);
+    const arg0 = dataFilterToSqlWhere(args[0]);
+    const arg1 = dataFilterToSqlWhere(args[1]);
+    const arg2 = dataFilterToSqlWhere(args[2]);
     return `substr(${arg0}, ${arg1}, ${arg2})`;
 }