@squidcloud/local-backend 1.0.40 → 1.0.41

package/dist/common/src/query/query-context.js

@@ -1,159 +1,159 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueryContext = void 0;
-const _ = require("lodash");
-const lodash_1 = require("lodash");
-const query_types_1 = require("../query.types");
-const CompareTable = {
-    'in:in': (a, b) => a.every((c) => b.includes(c)),
-    'in:not in': (a, b) => a.every((c) => !b.includes(c)),
-    'not in:not in': (a, b) => b.every((c) => a.includes(c)),
-    '>:not in': (a, b) => b.every((c) => a >= c),
-    '>=:not in': (a, b) => b.every((c) => a > c),
-    '<:not in': (a, b) => b.every((c) => a <= c),
-    '<=:not in': (a, b) => b.every((c) => a < c),
-    '>:>': (a, b) => a >= b,
-    '>=:>': (a, b) => a > b,
-    'in:>': (a, b) => a.every((c) => c > b),
-    '>:>=': (a, b) => a >= b,
-    '>=:>=': (a, b) => a >= b,
-    'in:>=': (a, b) => a.every((c) => c >= b),
-    '<:<': (a, b) => a <= b,
-    '<=:<': (a, b) => a < b,
-    'in:<': (a, b) => a.every((c) => c < b),
-    '<:<=': (a, b) => a <= b,
-    '<=:<=': (a, b) => a <= b,
-    'in:<=': (a, b) => a.every((c) => c <= b),
-};
-class QueryContext {
-    constructor(query) {
-        this.query = query;
-        this.query = query;
-        this.parsedConditions = this.parseConditions(this.query.conditions);
-    }
-    get integrationId() {
-        return this.query.integrationId;
-    }
-    get collectionName() {
-        return this.query.collectionName;
-    }
-    get limit() {
-        return this.query.limit;
-    }
-    sortedBy(sorts) {
-        const mismatch = sorts.find((fieldSort, index) => {
-            var _a;
-            return !(0, lodash_1.isEqual)(this.query.sortOrder[index], Object.assign(Object.assign({}, fieldSort), { asc: (_a = fieldSort.asc) !== null && _a !== void 0 ? _a : true }));
-        });
-        return !mismatch;
-    }
-    sortedByExact(sorts) {
-        if (sorts.length !== this.query.sortOrder.length)
-            return false;
-        return this.sortedBy(sorts);
-    }
-    isSubqueryOf(fieldName, operator, value) {
-        return this.isSubqueryOfCondition({
-            fieldName,
-            operator,
-            value,
-        });
-    }
-    isSubqueryOfCondition(condition) {
-        const conditions = this.parsedConditions.filter((c) => c.fieldName === condition.fieldName);
-        return !!conditions.find((c) => this.evaluateSubset(c, condition));
-    }
-    isSubqueryOfConditions(conditions) {
-        const parsedConditions = this.parseConditions(conditions);
-        return parsedConditions.every((c) => this.isSubqueryOfCondition(c));
-    }
-    isSubqueryOfQuery(query) {
-        if (query.collectionName !== this.collectionName || query.integrationId !== this.integrationId)
-            return false;
-        const subsetOfConditions = this.isSubqueryOfConditions(query.conditions);
-        const subsetOfOrder = this.sortedBy(query.sortOrder);
-        const withinLimit = query.limit === -1 || (this.limit > -1 && this.limit < query.limit);
-        return subsetOfConditions && subsetOfOrder && withinLimit;
-    }
-    getConditionsFor(...fieldNames) {
-        return this.parsedConditions.filter((cond) => fieldNames.includes(cond.fieldName));
-    }
-    getConditionsForField(fieldName) {
-        return this.parsedConditions.filter((cond) => cond.fieldName === fieldName);
-    }
-    documentMatchesQuery(doc) {
-        for (const contextCondition of this.parsedConditions) {
-            const fieldNameOrPath = contextCondition.fieldName;
-            const operator = contextCondition.operator;
-            const valueInDoc = _.get(doc, fieldNameOrPath);
-            if (operator === 'in') {
-                if (contextCondition.value.includes(valueInDoc)) {
-                    continue;
-                }
-                return false;
-            }
-            else if (operator === 'not in') {
-                if (contextCondition.value.includes(valueInDoc)) {
-                    return false;
-                }
-                continue;
-            }
-            if (!(0, query_types_1.compareOperator)(contextCondition.value, valueInDoc, operator)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    evaluateSubset(queryCondition, testCondition) {
-        const { operator: queryOperator, value: queryValue } = queryCondition;
-        const { operator, value } = this.parseConditions([testCondition])[0];
-        const compareFunction = CompareTable[`${queryOperator}:${operator}`];
-        if (!compareFunction)
-            return false;
-        return compareFunction(queryValue, value);
-    }
-    evaluateIncludes(queryCondition, testCondition) {
-        const { operator: queryOperator, value: queryValue } = queryCondition;
-        const { operator, value } = this.parseConditions([testCondition])[0];
-        const sortedQueryValue = Array.isArray(queryValue) ? queryValue.sort() : queryValue;
-        const sortedValue = Array.isArray(value) ? value.sort() : value;
-        return operator === queryOperator && (0, lodash_1.isEqual)(sortedValue, sortedQueryValue);
-    }
-    parseConditions(conditions) {
-        const parsedConditions = [];
-        const inMap = new Map();
-        const notInMap = new Map();
-        conditions.forEach((c) => {
-            switch (c.operator) {
-                case '==':
-                case 'in':
-                    inMap.set(c.fieldName, (inMap.get(c.fieldName) || []).concat(c.value));
-                    break;
-                case '!=':
-                case 'not in':
-                    notInMap.set(c.fieldName, (notInMap.get(c.fieldName) || []).concat(c.value));
-                    break;
-                default:
-                    parsedConditions.push(c);
-                    break;
-            }
-        });
-        inMap.forEach((value, fieldName) => {
-            parsedConditions.push({
-                fieldName,
-                operator: 'in',
-                value: value,
-            });
-        });
-        notInMap.forEach((value, fieldName) => {
-            parsedConditions.push({
-                fieldName,
-                operator: 'not in',
-                value: value,
-            });
-        });
-        return parsedConditions;
-    }
-}
-exports.QueryContext = QueryContext;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryContext = void 0;
+const _ = require("lodash");
+const lodash_1 = require("lodash");
+const query_types_1 = require("../query.types");
+const CompareTable = {
+    'in:in': (a, b) => a.every((c) => b.includes(c)),
+    'in:not in': (a, b) => a.every((c) => !b.includes(c)),
+    'not in:not in': (a, b) => b.every((c) => a.includes(c)),
+    '>:not in': (a, b) => b.every((c) => a >= c),
+    '>=:not in': (a, b) => b.every((c) => a > c),
+    '<:not in': (a, b) => b.every((c) => a <= c),
+    '<=:not in': (a, b) => b.every((c) => a < c),
+    '>:>': (a, b) => a >= b,
+    '>=:>': (a, b) => a > b,
+    'in:>': (a, b) => a.every((c) => c > b),
+    '>:>=': (a, b) => a >= b,
+    '>=:>=': (a, b) => a >= b,
+    'in:>=': (a, b) => a.every((c) => c >= b),
+    '<:<': (a, b) => a <= b,
+    '<=:<': (a, b) => a < b,
+    'in:<': (a, b) => a.every((c) => c < b),
+    '<:<=': (a, b) => a <= b,
+    '<=:<=': (a, b) => a <= b,
+    'in:<=': (a, b) => a.every((c) => c <= b),
+};
+class QueryContext {
+    constructor(query) {
+        this.query = query;
+        this.query = query;
+        this.parsedConditions = this.parseConditions(this.query.conditions);
+    }
+    get integrationId() {
+        return this.query.integrationId;
+    }
+    get collectionName() {
+        return this.query.collectionName;
+    }
+    get limit() {
+        return this.query.limit;
+    }
+    sortedBy(sorts) {
+        const mismatch = sorts.find((fieldSort, index) => {
+            var _a;
+            return !(0, lodash_1.isEqual)(this.query.sortOrder[index], Object.assign(Object.assign({}, fieldSort), { asc: (_a = fieldSort.asc) !== null && _a !== void 0 ? _a : true }));
+        });
+        return !mismatch;
+    }
+    sortedByExact(sorts) {
+        if (sorts.length !== this.query.sortOrder.length)
+            return false;
+        return this.sortedBy(sorts);
+    }
+    isSubqueryOf(fieldName, operator, value) {
+        return this.isSubqueryOfCondition({
+            fieldName,
+            operator,
+            value,
+        });
+    }
+    isSubqueryOfCondition(condition) {
+        const conditions = this.parsedConditions.filter((c) => c.fieldName === condition.fieldName);
+        return !!conditions.find((c) => this.evaluateSubset(c, condition));
+    }
+    isSubqueryOfConditions(conditions) {
+        const parsedConditions = this.parseConditions(conditions);
+        return parsedConditions.every((c) => this.isSubqueryOfCondition(c));
+    }
+    isSubqueryOfQuery(query) {
+        if (query.collectionName !== this.collectionName || query.integrationId !== this.integrationId)
+            return false;
+        const subsetOfConditions = this.isSubqueryOfConditions(query.conditions);
+        const subsetOfOrder = this.sortedBy(query.sortOrder);
+        const withinLimit = query.limit === -1 || (this.limit > -1 && this.limit < query.limit);
+        return subsetOfConditions && subsetOfOrder && withinLimit;
+    }
+    getConditionsFor(...fieldNames) {
+        return this.parsedConditions.filter((cond) => fieldNames.includes(cond.fieldName));
+    }
+    getConditionsForField(fieldName) {
+        return this.parsedConditions.filter((cond) => cond.fieldName === fieldName);
+    }
+    documentMatchesQuery(doc) {
+        for (const contextCondition of this.parsedConditions) {
+            const fieldNameOrPath = contextCondition.fieldName;
+            const operator = contextCondition.operator;
+            const valueInDoc = _.get(doc, fieldNameOrPath);
+            if (operator === 'in') {
+                if (contextCondition.value.includes(valueInDoc)) {
+                    continue;
+                }
+                return false;
+            }
+            else if (operator === 'not in') {
+                if (contextCondition.value.includes(valueInDoc)) {
+                    return false;
+                }
+                continue;
+            }
+            if (!(0, query_types_1.compareOperator)(contextCondition.value, valueInDoc, operator)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    evaluateSubset(queryCondition, testCondition) {
+        const { operator: queryOperator, value: queryValue } = queryCondition;
+        const { operator, value } = this.parseConditions([testCondition])[0];
+        const compareFunction = CompareTable[`${queryOperator}:${operator}`];
+        if (!compareFunction)
+            return false;
+        return compareFunction(queryValue, value);
+    }
+    evaluateIncludes(queryCondition, testCondition) {
+        const { operator: queryOperator, value: queryValue } = queryCondition;
+        const { operator, value } = this.parseConditions([testCondition])[0];
+        const sortedQueryValue = Array.isArray(queryValue) ? queryValue.sort() : queryValue;
+        const sortedValue = Array.isArray(value) ? value.sort() : value;
+        return operator === queryOperator && (0, lodash_1.isEqual)(sortedValue, sortedQueryValue);
+    }
+    parseConditions(conditions) {
+        const parsedConditions = [];
+        const inMap = new Map();
+        const notInMap = new Map();
+        conditions.forEach((c) => {
+            switch (c.operator) {
+                case '==':
+                case 'in':
+                    inMap.set(c.fieldName, (inMap.get(c.fieldName) || []).concat(c.value));
+                    break;
+                case '!=':
+                case 'not in':
+                    notInMap.set(c.fieldName, (notInMap.get(c.fieldName) || []).concat(c.value));
+                    break;
+                default:
+                    parsedConditions.push(c);
+                    break;
+            }
+        });
+        inMap.forEach((value, fieldName) => {
+            parsedConditions.push({
+                fieldName,
+                operator: 'in',
+                value: value,
+            });
+        });
+        notInMap.forEach((value, fieldName) => {
+            parsedConditions.push({
+                fieldName,
+                operator: 'not in',
+                value: value,
+            });
+        });
+        return parsedConditions;
+    }
+}
+exports.QueryContext = QueryContext;
 //# sourceMappingURL=query-context.js.map

package/dist/common/src/query.schemas.d.ts

@@ -1,6 +1,6 @@
-import { JSONSchemaType } from 'ajv';
-import { Query, QueryRegisterRequest, QueryRequest, QueryUnsubscribeRequest } from './query.types';
-export declare const QuerySchema: JSONSchemaType<Query>;
-export declare const QueryRequestSchema: JSONSchemaType<QueryRequest>;
-export declare const QueryUnsubscribeRequestSchema: JSONSchemaType<QueryUnsubscribeRequest>;
-export declare const QueryRegisterRequestSchema: JSONSchemaType<QueryRegisterRequest>;
+import { JSONSchemaType } from 'ajv';
+import { Query, QueryRegisterRequest, QueryRequest, QueryUnsubscribeRequest } from './query.types';
+export declare const QuerySchema: JSONSchemaType<Query>;
+export declare const QueryRequestSchema: JSONSchemaType<QueryRequest>;
+export declare const QueryUnsubscribeRequestSchema: JSONSchemaType<QueryUnsubscribeRequest>;
+export declare const QueryRegisterRequestSchema: JSONSchemaType<QueryRegisterRequest>;

package/dist/common/src/query.schemas.js

@@ -1,97 +1,97 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueryRegisterRequestSchema = exports.QueryUnsubscribeRequestSchema = exports.QueryRequestSchema = exports.QuerySchema = void 0;
-exports.QuerySchema = {
-    $id: 'querySchema',
-    type: 'object',
-    required: ['collectionName', 'integrationId'],
-    properties: {
-        collectionName: { type: 'string', nullable: false },
-        integrationId: { type: 'string', nullable: false },
-        conditions: {
-            type: 'array',
-            nullable: false,
-            items: {
-                type: 'object',
-                nullable: false,
-                required: ['fieldName', 'operator', 'value'],
-                properties: {
-                    fieldName: { type: 'string', nullable: false },
-                    operator: {
-                        type: 'string',
-                        nullable: false,
-                        enum: ['==', '>=', '<=', '>', '<', '!=', 'like', 'not like', 'like_cs', 'not like_cs'],
-                    },
-                    value: {
-                        $ref: 'querySchema#/definitions/conditionValueSchema',
-                    },
-                },
-            },
-        },
-        sortOrder: {
-            type: 'array',
-            nullable: false,
-            items: {
-                type: 'object',
-                required: ['fieldName', 'asc'],
-                properties: {
-                    fieldName: { type: 'string' },
-                    asc: { type: 'boolean' },
-                },
-            },
-        },
-        limit: { type: 'number', nullable: false },
-    },
-    definitions: {
-        conditionValueSchema: {
-            oneOf: [
-                { type: 'null', nullable: true },
-                { type: 'string', nullable: false },
-                { type: 'number', nullable: false },
-                { type: 'boolean', nullable: false },
-                {
-                    type: 'array',
-                    nullable: false,
-                    items: {
-                        $ref: 'querySchema#/definitions/conditionValueSchema',
-                    },
-                },
-                {
-                    type: 'object',
-                    nullable: false,
-                    patternProperties: {
-                        '[0-9a-zA-Z\\$_\\-\\.]{1,64}': {
-                            $ref: 'querySchema#/definitions/conditionValueSchema',
-                        },
-                    },
-                },
-            ],
-        },
-    },
-};
-exports.QueryRequestSchema = {
-    type: 'object',
-    required: ['clientRequestId', 'query', 'subscribe'],
-    properties: {
-        clientRequestId: { type: 'string', nullable: false },
-        query: exports.QuerySchema,
-        subscribe: { type: 'boolean', nullable: false },
-    },
-};
-exports.QueryUnsubscribeRequestSchema = {
-    type: 'object',
-    required: ['clientRequestId'],
-    properties: {
-        clientRequestId: { type: 'string', nullable: false },
-    },
-};
-exports.QueryRegisterRequestSchema = {
-    type: 'object',
-    required: ['clientRequestId', 'query', 'parentClientRequestId'],
-    properties: {
-        clientRequestId: { type: 'string', nullable: false },
-        query: exports.QuerySchema,
-        parentClientRequestId: { type: 'string', nullable: false },
-    },
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryRegisterRequestSchema = exports.QueryUnsubscribeRequestSchema = exports.QueryRequestSchema = exports.QuerySchema = void 0;
+exports.QuerySchema = {
+    $id: 'querySchema',
+    type: 'object',
+    required: ['collectionName', 'integrationId'],
+    properties: {
+        collectionName: { type: 'string', nullable: false },
+        integrationId: { type: 'string', nullable: false },
+        conditions: {
+            type: 'array',
+            nullable: false,
+            items: {
+                type: 'object',
+                nullable: false,
+                required: ['fieldName', 'operator', 'value'],
+                properties: {
+                    fieldName: { type: 'string', nullable: false },
+                    operator: {
+                        type: 'string',
+                        nullable: false,
+                        enum: ['==', '>=', '<=', '>', '<', '!=', 'like', 'not like', 'like_cs', 'not like_cs'],
+                    },
+                    value: {
+                        $ref: 'querySchema#/definitions/conditionValueSchema',
+                    },
+                },
+            },
+        },
+        sortOrder: {
+            type: 'array',
+            nullable: false,
+            items: {
+                type: 'object',
+                required: ['fieldName', 'asc'],
+                properties: {
+                    fieldName: { type: 'string' },
+                    asc: { type: 'boolean' },
+                },
+            },
+        },
+        limit: { type: 'number', nullable: false },
+    },
+    definitions: {
+        conditionValueSchema: {
+            oneOf: [
+                { type: 'null', nullable: true },
+                { type: 'string', nullable: false },
+                { type: 'number', nullable: false },
+                { type: 'boolean', nullable: false },
+                {
+                    type: 'array',
+                    nullable: false,
+                    items: {
+                        $ref: 'querySchema#/definitions/conditionValueSchema',
+                    },
+                },
+                {
+                    type: 'object',
+                    nullable: false,
+                    patternProperties: {
+                        '[0-9a-zA-Z\\$_\\-\\.]{1,64}': {
+                            $ref: 'querySchema#/definitions/conditionValueSchema',
+                        },
+                    },
+                },
+            ],
+        },
+    },
+};
+exports.QueryRequestSchema = {
+    type: 'object',
+    required: ['clientRequestId', 'query', 'subscribe'],
+    properties: {
+        clientRequestId: { type: 'string', nullable: false },
+        query: exports.QuerySchema,
+        subscribe: { type: 'boolean', nullable: false },
+    },
+};
+exports.QueryUnsubscribeRequestSchema = {
+    type: 'object',
+    required: ['clientRequestId'],
+    properties: {
+        clientRequestId: { type: 'string', nullable: false },
+    },
+};
+exports.QueryRegisterRequestSchema = {
+    type: 'object',
+    required: ['clientRequestId', 'query', 'parentClientRequestId'],
+    properties: {
+        clientRequestId: { type: 'string', nullable: false },
+        query: exports.QuerySchema,
+        parentClientRequestId: { type: 'string', nullable: false },
+    },
+};
 //# sourceMappingURL=query.schemas.js.map