@peers-app/peers-sdk 0.14.0 → 0.15.0

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

@@ -7,7 +7,7 @@ exports.dataSourceCount = dataSourceCount;
 exports.filterToSkipPastValue = filterToSkipPastValue;
 class DataQuery {
     table;
-    constructor(table, { page, pageSize, sortBy, filter, textSearch, textSearchExact, } = {}) {
+    constructor(table, { page, pageSize, sortBy, filter, textSearch, textSearchExact } = {}) {
         this.table = table;
         this.page = page;
         this.pageSize = pageSize;
@@ -32,8 +32,11 @@ class DataQuery {
                     return null;
                 }
                 if (!buffer.length) {
-                    const sortBy = (this.sortBy?.length && this.sortBy || [this.table.metaData.primaryKeyName]);
-                    if (!sortBy.includes(this.table.metaData.primaryKeyName) && !sortBy.includes(`-${this.table.metaData.primaryKeyName}`)) {
+                    const sortBy = ((this.sortBy?.length && this.sortBy) || [
+                        this.table.metaData.primaryKeyName,
+                    ]);
+                    if (!sortBy.includes(this.table.metaData.primaryKeyName) &&
+                        !sortBy.includes(`-${this.table.metaData.primaryKeyName}`)) {
                         sortBy.push(this.table.metaData.primaryKeyName);
                     }
                     let filter = { ...this.filter };
@@ -45,7 +48,7 @@ class DataQuery {
                         page: 1,
                         pageSize: this.pageSize,
                         sortBy: sortBy,
-                        textSearch: this.textSearch
+                        textSearch: this.textSearch,
                     });
                     buffer = data;
                 }
@@ -66,8 +69,11 @@ class DataQuery {
         if (!this.table.list) {
             throw new Error(`table does not support list`);
         }
-        const sortBy = (this.sortBy?.length && this.sortBy || [this.table.metaData.primaryKeyName]);
-        if (!sortBy.includes(this.table.metaData.primaryKeyName) && !sortBy.includes(`-${this.table.metaData.primaryKeyName}`)) {
+        const sortBy = ((this.sortBy?.length && this.sortBy) || [
+            this.table.metaData.primaryKeyName,
+        ]);
+        if (!sortBy.includes(this.table.metaData.primaryKeyName) &&
+            !sortBy.includes(`-${this.table.metaData.primaryKeyName}`)) {
             sortBy.push(this.table.metaData.primaryKeyName);
         }
         return this.table.list({ ...this.filter }, {
@@ -86,7 +92,7 @@ function iterableCursor(cursor) {
             next: async () => {
                 const value = await cursor.next();
                 return { value, done: !value };
-            }
+            },
         };
     };
     return cursor;
@@ -96,7 +102,7 @@ function dataSourceCursor(dataSource, filter = {}, opts = {}) {
     //   return dataSource.cursor(filter, opts);
     // }
     let buffer = [];
-    let bufferPromise = undefined;
+    let bufferPromise;
     let eof = false;
     const primaryKeyName = dataSource.primaryKeyName;
     const pageSize = opts.pageSize || 100;
@@ -111,7 +117,7 @@ function dataSourceCursor(dataSource, filter = {}, opts = {}) {
                 bufferPromise = undefined;
             }
             if (!buffer.length) {
-                const sortBy = (opts.sortBy?.length && opts.sortBy || [primaryKeyName]);
+                const sortBy = ((opts.sortBy?.length && opts.sortBy) || [primaryKeyName]);
                 if (!sortBy.includes(primaryKeyName) && !sortBy.includes(`-${primaryKeyName}`)) {
                     sortBy.push(primaryKeyName);
                 }
@@ -125,7 +131,7 @@ function dataSourceCursor(dataSource, filter = {}, opts = {}) {
                         page: 1,
                         pageSize,
                         sortBy: sortBy,
-                        textSearch: opts.textSearch
+                        textSearch: opts.textSearch,
                     }));
                 const nextSkipPast = buffer[buffer.length - 1];
                 if (nextSkipPast) {
@@ -134,7 +140,7 @@ function dataSourceCursor(dataSource, filter = {}, opts = {}) {
                         page: 1,
                         pageSize,
                         sortBy: sortBy,
-                        textSearch: opts.textSearch
+                        textSearch: opts.textSearch,
                     });
                 }
             }
@@ -169,28 +175,28 @@ function filterToSkipPastValue(filter, sortBy, skipPast) {
         const filterEq = {};
         for (let j = i; j >= 0; j--) {
             const key = sortBy[j];
-            const desc = key.startsWith('-');
+            const desc = key.startsWith("-");
             const fieldName = desc ? key.substring(1) : key;
             const value = skipPast[fieldName];
-            let op = '';
+            let op = "";
             if (desc) {
                 if (j === i) {
-                    op = '$lt';
+                    op = "$lt";
                 }
                 else {
-                    op = '$eq';
+                    op = "$eq";
                 }
             }
             else {
                 if (j === i) {
-                    op = '$gt';
+                    op = "$gt";
                 }
                 else {
-                    op = '$eq';
+                    op = "$eq";
                 }
             }
             if (value === undefined || value === null) {
-                if (op === '$eq') {
+                if (op === "$eq") {
                     filterEq[fieldName] = { $exists: false };
                 }
                 else {

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

@@ -1,4 +1,4 @@
-import { DataFilter } from './data-query';
+import type { DataFilter } from "./data-query";
 /**
  * Converts a DataFilter to a MongoDB query object
  */

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

@@ -26,7 +26,7 @@ function handleOrArray(filters) {
     if (filters.length === 1) {
         return dataFilterToMongoQuery(filters[0]);
     }
-    return { $or: filters.map(f => dataFilterToMongoQuery(f)) };
+    return { $or: filters.map((f) => dataFilterToMongoQuery(f)) };
 }
 /**
  * Handles filter objects - processes each field
@@ -36,7 +36,7 @@ function handleFilterObject(filter) {
     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)) {
+        if (typeof result === "object" && result !== null && !(0, lodash_1.isArray)(result)) {
             Object.assign(mongoFilter, result);
         }
         else {
@@ -49,22 +49,22 @@ function handleFilterObject(filter) {
  * Handles individual filter fields
  */
 function handleFilterField(fieldName, value) {
-    if (fieldName === '$or') {
+    if (fieldName === "$or") {
         return { $or: value.map((v) => dataFilterToMongoQuery(v)) };
     }
-    if (fieldName === '$and') {
+    if (fieldName === "$and") {
         if (value.length === 0) {
             return {}; // Empty $and matches everything
         }
         return { $and: value.map((v) => dataFilterToMongoQuery(v)) };
     }
-    if (fieldName === '$matchWords') {
+    if (fieldName === "$matchWords") {
         return handleMatchWordsOperator(value);
     }
-    if (fieldName === '$substr') {
+    if (fieldName === "$substr") {
         return handleSubstrOperator(value);
     }
-    if (fieldName === '$expr') {
+    if (fieldName === "$expr") {
         return handleExprOperator(value);
     }
     return handleFieldCondition(fieldName, value);
@@ -79,7 +79,7 @@ function handleFieldCondition(fieldName, value) {
     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)) {
+    if (typeof value === "object" && !(0, lodash_1.isDate)(value)) {
         return { [fieldName]: handleObjectValue(value) };
     }
     return { [fieldName]: value };
@@ -90,7 +90,7 @@ function handleFieldCondition(fieldName, value) {
 function handleObjectValue(value) {
     const mongoValue = {};
     for (const [operator, operatorValue] of Object.entries(value)) {
-        if (operator.startsWith('$')) {
+        if (operator.startsWith("$")) {
             mongoValue[operator] = handleOperatorValue(operator, operatorValue);
         }
         else {
@@ -104,23 +104,23 @@ function handleObjectValue(value) {
  */
 function handleOperatorValue(operator, value) {
     switch (operator) {
-        case '$eq':
-        case '$ne':
-        case '$gt':
-        case '$gte':
-        case '$lt':
-        case '$lte':
-        case '$in':
-        case '$nin':
-        case '$exists':
+        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');
+        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}`);
     }
@@ -129,10 +129,10 @@ function handleOperatorValue(operator, value) {
  * Converts $matchWords to MongoDB text search or regex
  */
 function handleMatchWordsOperator(searchText) {
-    if (typeof searchText !== 'string') {
-        throw new Error('$matchWords value must be a string');
+    if (typeof searchText !== "string") {
+        throw new Error("$matchWords value must be a string");
     }
-    const words = searchText.split(' ').filter(word => word.trim());
+    const words = searchText.split(" ").filter((word) => word.trim());
     if (words.length === 0) {
         return {}; // Empty search matches everything
     }
@@ -140,33 +140,33 @@ function handleMatchWordsOperator(searchText) {
     // 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' };
+        return { $regex: escapeRegex(words[0]), $options: "i" };
     }
     // For multiple words, create AND condition with regex for each word
-    const regexConditions = words.map(word => ({
+    const _regexConditions = words.map((word) => ({
         $regex: escapeRegex(word),
-        $options: 'i'
+        $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');
+    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]');
+        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('$')
+    const mongoStr = typeof str === "string" && str.startsWith("$")
         ? str // Keep MongoDB field reference format
         : str;
     return {
         $expr: {
-            $substr: [mongoStr, start, length]
-        }
+            $substr: [mongoStr, start, length],
+        },
     };
 }
 /**
@@ -174,7 +174,7 @@ function handleSubstrOperator(args) {
  */
 function handleExprOperator(exprArray) {
     if (!(0, lodash_1.isArray)(exprArray) || exprArray.length !== 2) {
-        throw new Error('$expr requires exactly 2 arguments: [leftSide, rightSide]');
+        throw new Error("$expr requires exactly 2 arguments: [leftSide, rightSide]");
     }
     const [leftSide, rightSide] = exprArray;
     // Convert left side (usually a function like $substr)
@@ -182,37 +182,37 @@ function handleExprOperator(exprArray) {
     // 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 (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]]
-                }
+                    [op]: [mongoLeft, rightSide[op]],
+                },
             };
         }
     }
     // Default to equality comparison
     return {
         $expr: {
-            $eq: [mongoLeft, mongoRight]
-        }
+            $eq: [mongoLeft, mongoRight],
+        },
     };
 }
 /**
  * Converts parts of expressions to MongoDB format
  */
 function convertExpressionPart(part) {
-    if (typeof part === 'object' && part !== null && !(0, lodash_1.isArray)(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('$')) {
+        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) {
+            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;
+                const mongoStr = typeof str === "string" && str.startsWith("$") ? str : str;
                 return { $substr: [mongoStr, start, length] };
             }
         }
@@ -223,15 +223,13 @@ function convertExpressionPart(part) {
  * Escapes special regex characters
  */
 function escapeRegex(text) {
-    return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    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);
+    return typeof value !== "object" || (0, lodash_1.isDate)(value) || value === null;
 }
 /**
  * Converts DataQuery sort format to MongoDB sort format
@@ -242,7 +240,7 @@ function sortByToMongoSort(sortBy) {
     }
     const mongoSort = {};
     for (const field of sortBy) {
-        if (field.startsWith('-')) {
+        if (field.startsWith("-")) {
             mongoSort[field.substring(1)] = -1; // Descending
         }
         else {