@squidcloud/local-backend 1.0.35 → 1.0.36

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

@@ -1,135 +1,135 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseQuerySubscriptionId = exports.getQuerySubscriptionId = exports.compareOperator = exports.findQueriesForDocumentSync = exports.SimpleQueryMappingManager = exports.QueryMappingManager = void 0;
-const nullish_1 = require("./utils/nullish");
-const object_1 = require("./utils/object");
-const serialization_1 = require("./utils/serialization");
-class QueryMappingManager {
-}
-exports.QueryMappingManager = QueryMappingManager;
-class SimpleQueryMappingManager extends QueryMappingManager {
-    async findQueriesForDocument(appId, doc, collectionName, integrationId) {
-        const mapping = await this.getMapping(appId, collectionName, integrationId);
-        if (!mapping)
-            return [];
-        return findQueriesForDocumentSync(mapping, doc);
-    }
-}
-exports.SimpleQueryMappingManager = SimpleQueryMappingManager;
-function findQueriesForDocumentSync(mapping, doc) {
-    var _a;
-    const result = [...(mapping.unconditional || [])];
-    const ignoredMappedId = new Set();
-    const mappedIdFoundMap = new Map();
-    for (const [encodedFieldName, fieldMapping] of Object.entries(mapping.conditional || {})) {
-        const fieldName = (0, serialization_1.decodeValueForMapping)(encodedFieldName);
-        for (const [operator, operatorMapping] of Object.entries(fieldMapping)) {
-            const matchedMappedId = [];
-            const valueInDocument = (_a = (0, object_1.getInPath)(doc, fieldName)) !== null && _a !== void 0 ? _a : null;
-            const encodedValueInDocument = (0, serialization_1.encodeValueForMapping)(valueInDocument);
-            switch (operator) {
-                case '==': {
-                    matchedMappedId.push(...(operatorMapping[encodedValueInDocument] || []));
-                    break;
-                }
-                case '!=': {
-                    const matchedSubscriptionIds = operatorMapping[encodedValueInDocument] || [];
-                    matchedSubscriptionIds.forEach((qsi) => ignoredMappedId.add(qsi));
-                    const restOfValues = Object.entries(operatorMapping).filter(([value]) => value !== encodedValueInDocument);
-                    for (const [ignored, mappedId] of restOfValues) {
-                        matchedMappedId.push(...mappedId);
-                    }
-                    break;
-                }
-                case '<':
-                case '<=':
-                case '>':
-                case '>=':
-                case 'like':
-                case 'not like':
-                case 'like_cs':
-                case 'not like_cs': {
-                    if ((0, nullish_1.isNotNullish)(valueInDocument)) {
-                        matchedMappedId.push(...Object.entries(operatorMapping)
-                            .filter(([conditionValue]) => compareOperator((0, serialization_1.decodeValueForMapping)(conditionValue), valueInDocument, operator))
-                            .reduce((current, [ignored, matchedMappedId]) => {
-                            current.push(...matchedMappedId);
-                            return current;
-                        }, []));
-                    }
-                    break;
-                }
-                default:
-                    throw new Error('Unsupported operator: ' + operator);
-            }
-            for (const mappedId of matchedMappedId) {
-                mappedIdFoundMap.set(mappedId, (mappedIdFoundMap.get(mappedId) || 0) + 1);
-            }
-        }
-    }
-    for (const [mappedId, matchCount] of mappedIdFoundMap.entries()) {
-        if (ignoredMappedId.has(mappedId))
-            continue;
-        if (matchCount >= mapping.queriesMetadata[mappedId].condCount) {
-            result.push(mappedId);
-        }
-    }
-    return result;
-}
-exports.findQueriesForDocumentSync = findQueriesForDocumentSync;
-function compareOperator(conditionValue, valueInDocument, operator) {
-    if (conditionValue === null || valueInDocument === null)
-        return false;
-    switch (operator) {
-        case '<':
-            return valueInDocument < conditionValue;
-        case '<=':
-            return valueInDocument <= conditionValue;
-        case '>':
-            return valueInDocument > conditionValue;
-        case '>=':
-            return valueInDocument >= conditionValue;
-        case 'like':
-            return (typeof valueInDocument === 'string' &&
-                typeof conditionValue === 'string' &&
-                isStringMatch(valueInDocument, conditionValue, false));
-        case 'not like':
-            return !(typeof valueInDocument === 'string' &&
-                typeof conditionValue === 'string' &&
-                isStringMatch(valueInDocument, conditionValue, false));
-        case 'like_cs':
-            return (typeof valueInDocument === 'string' &&
-                typeof conditionValue === 'string' &&
-                isStringMatch(valueInDocument, conditionValue, true));
-        case 'not like_cs':
-            return !(typeof valueInDocument === 'string' &&
-                typeof conditionValue === 'string' &&
-                isStringMatch(valueInDocument, conditionValue, true));
-        default:
-            throw new Error(`Unsupported operator comparison: ${operator}`);
-    }
-}
-exports.compareOperator = compareOperator;
-function isStringMatch(str, pattern, caseSensitive) {
-    if (!caseSensitive) {
-        str = str.toLowerCase();
-        pattern = pattern.toLowerCase();
-    }
-    const escapedPattern = pattern.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
-    const regexPattern = escapedPattern.replace(/%/g, '.*');
-    const regex = new RegExp(`^${regexPattern}$`);
-    return regex.test(str);
-}
-function getQuerySubscriptionId(clientId, clientRequestId) {
-    return `${clientId}_${clientRequestId}`;
-}
-exports.getQuerySubscriptionId = getQuerySubscriptionId;
-function parseQuerySubscriptionId(querySubscriptionId) {
-    const splitString = querySubscriptionId.split('_');
-    return {
-        clientId: splitString[0],
-        clientRequestId: splitString[1],
-    };
-}
-exports.parseQuerySubscriptionId = parseQuerySubscriptionId;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseQuerySubscriptionId = exports.getQuerySubscriptionId = exports.compareOperator = exports.findQueriesForDocumentSync = exports.SimpleQueryMappingManager = exports.QueryMappingManager = void 0;
+const nullish_1 = require("./utils/nullish");
+const object_1 = require("./utils/object");
+const serialization_1 = require("./utils/serialization");
+class QueryMappingManager {
+}
+exports.QueryMappingManager = QueryMappingManager;
+class SimpleQueryMappingManager extends QueryMappingManager {
+    async findQueriesForDocument(appId, doc, collectionName, integrationId) {
+        const mapping = await this.getMapping(appId, collectionName, integrationId);
+        if (!mapping)
+            return [];
+        return findQueriesForDocumentSync(mapping, doc);
+    }
+}
+exports.SimpleQueryMappingManager = SimpleQueryMappingManager;
+function findQueriesForDocumentSync(mapping, doc) {
+    var _a;
+    const result = [...(mapping.unconditional || [])];
+    const ignoredMappedId = new Set();
+    const mappedIdFoundMap = new Map();
+    for (const [encodedFieldName, fieldMapping] of Object.entries(mapping.conditional || {})) {
+        const fieldName = (0, serialization_1.decodeValueForMapping)(encodedFieldName);
+        for (const [operator, operatorMapping] of Object.entries(fieldMapping)) {
+            const matchedMappedId = [];
+            const valueInDocument = (_a = (0, object_1.getInPath)(doc, fieldName)) !== null && _a !== void 0 ? _a : null;
+            const encodedValueInDocument = (0, serialization_1.encodeValueForMapping)(valueInDocument);
+            switch (operator) {
+                case '==': {
+                    matchedMappedId.push(...(operatorMapping[encodedValueInDocument] || []));
+                    break;
+                }
+                case '!=': {
+                    const matchedSubscriptionIds = operatorMapping[encodedValueInDocument] || [];
+                    matchedSubscriptionIds.forEach((qsi) => ignoredMappedId.add(qsi));
+                    const restOfValues = Object.entries(operatorMapping).filter(([value]) => value !== encodedValueInDocument);
+                    for (const [ignored, mappedId] of restOfValues) {
+                        matchedMappedId.push(...mappedId);
+                    }
+                    break;
+                }
+                case '<':
+                case '<=':
+                case '>':
+                case '>=':
+                case 'like':
+                case 'not like':
+                case 'like_cs':
+                case 'not like_cs': {
+                    if ((0, nullish_1.isNotNullish)(valueInDocument)) {
+                        matchedMappedId.push(...Object.entries(operatorMapping)
+                            .filter(([conditionValue]) => compareOperator((0, serialization_1.decodeValueForMapping)(conditionValue), valueInDocument, operator))
+                            .reduce((current, [ignored, matchedMappedId]) => {
+                            current.push(...matchedMappedId);
+                            return current;
+                        }, []));
+                    }
+                    break;
+                }
+                default:
+                    throw new Error('Unsupported operator: ' + operator);
+            }
+            for (const mappedId of matchedMappedId) {
+                mappedIdFoundMap.set(mappedId, (mappedIdFoundMap.get(mappedId) || 0) + 1);
+            }
+        }
+    }
+    for (const [mappedId, matchCount] of mappedIdFoundMap.entries()) {
+        if (ignoredMappedId.has(mappedId))
+            continue;
+        if (matchCount >= mapping.queriesMetadata[mappedId].condCount) {
+            result.push(mappedId);
+        }
+    }
+    return result;
+}
+exports.findQueriesForDocumentSync = findQueriesForDocumentSync;
+function compareOperator(conditionValue, valueInDocument, operator) {
+    if (conditionValue === null || valueInDocument === null)
+        return false;
+    switch (operator) {
+        case '<':
+            return valueInDocument < conditionValue;
+        case '<=':
+            return valueInDocument <= conditionValue;
+        case '>':
+            return valueInDocument > conditionValue;
+        case '>=':
+            return valueInDocument >= conditionValue;
+        case 'like':
+            return (typeof valueInDocument === 'string' &&
+                typeof conditionValue === 'string' &&
+                isStringMatch(valueInDocument, conditionValue, false));
+        case 'not like':
+            return !(typeof valueInDocument === 'string' &&
+                typeof conditionValue === 'string' &&
+                isStringMatch(valueInDocument, conditionValue, false));
+        case 'like_cs':
+            return (typeof valueInDocument === 'string' &&
+                typeof conditionValue === 'string' &&
+                isStringMatch(valueInDocument, conditionValue, true));
+        case 'not like_cs':
+            return !(typeof valueInDocument === 'string' &&
+                typeof conditionValue === 'string' &&
+                isStringMatch(valueInDocument, conditionValue, true));
+        default:
+            throw new Error(`Unsupported operator comparison: ${operator}`);
+    }
+}
+exports.compareOperator = compareOperator;
+function isStringMatch(str, pattern, caseSensitive) {
+    if (!caseSensitive) {
+        str = str.toLowerCase();
+        pattern = pattern.toLowerCase();
+    }
+    const escapedPattern = pattern.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+    const regexPattern = escapedPattern.replace(/%/g, '.*');
+    const regex = new RegExp(`^${regexPattern}$`);
+    return regex.test(str);
+}
+function getQuerySubscriptionId(clientId, clientRequestId) {
+    return `${clientId}_${clientRequestId}`;
+}
+exports.getQuerySubscriptionId = getQuerySubscriptionId;
+function parseQuerySubscriptionId(querySubscriptionId) {
+    const splitString = querySubscriptionId.split('_');
+    return {
+        clientId: splitString[0],
+        clientRequestId: splitString[1],
+    };
+}
+exports.parseQuerySubscriptionId = parseQuerySubscriptionId;
 //# sourceMappingURL=query.types.js.map

package/dist/common/src/regions.d.ts

@@ -1,21 +1,21 @@
-export type SquidCloudId = 'aws' | 'gcp' | 'azure';
-export declare const SupportedSquidRegions: readonly ["us-east-1.aws"];
-export type SupportedSquidRegion = (typeof SupportedSquidRegions)[number];
-export interface SquidCloudRegion {
-    id: string;
-    name: string;
-}
-export interface SquidSupportedCloud {
-    id: SquidCloudId;
-    name: string;
-    icon: string;
-    regions: Array<SquidCloudRegion>;
-    tooltip?: string;
-}
-export declare const squidSupportedRegionMap: Record<SupportedSquidRegion, SquidCloudRegion>;
-export declare function getSquidSupportedCloudMap(): Record<SquidCloudId, SquidSupportedCloud>;
-export declare function convertToSquidRegion(cloudId: SquidCloudId, region: string): SupportedSquidRegion;
-export declare function convertFromSquidRegion(regionAndCloud: SupportedSquidRegion): {
-    cloudId: SquidCloudId;
-    region: string;
-};
+export type SquidCloudId = 'aws' | 'gcp' | 'azure';
+export declare const SupportedSquidRegions: readonly ["us-east-1.aws"];
+export type SupportedSquidRegion = (typeof SupportedSquidRegions)[number];
+export interface SquidCloudRegion {
+    id: string;
+    name: string;
+}
+export interface SquidSupportedCloud {
+    id: SquidCloudId;
+    name: string;
+    icon: string;
+    regions: Array<SquidCloudRegion>;
+    tooltip?: string;
+}
+export declare const squidSupportedRegionMap: Record<SupportedSquidRegion, SquidCloudRegion>;
+export declare function getSquidSupportedCloudMap(): Record<SquidCloudId, SquidSupportedCloud>;
+export declare function convertToSquidRegion(cloudId: SquidCloudId, region: string): SupportedSquidRegion;
+export declare function convertFromSquidRegion(regionAndCloud: SupportedSquidRegion): {
+    cloudId: SquidCloudId;
+    region: string;
+};

package/dist/common/src/regions.js

@@ -1,47 +1,47 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertFromSquidRegion = exports.convertToSquidRegion = exports.getSquidSupportedCloudMap = exports.squidSupportedRegionMap = exports.SupportedSquidRegions = void 0;
-const nullish_1 = require("./utils/nullish");
-exports.SupportedSquidRegions = ['us-east-1.aws'];
-exports.squidSupportedRegionMap = {
-    'us-east-1.aws': { id: 'us-east-1', name: 'US East (N. Virginia)' },
-    ['us-east-1.aws-dev']: { id: 'us-east-1', name: 'US East (N. Virginia - Dev)' },
-    ['local']: { id: 'local', name: 'Local' },
-};
-function getSquidSupportedCloudMap() {
-    return {
-        aws: {
-            id: 'aws',
-            name: 'Amazon Web Services',
-            icon: 'aws_icon',
-            regions: [exports.squidSupportedRegionMap['us-east-1.aws']].filter(nullish_1.isNotNullish),
-        },
-        gcp: {
-            id: 'gcp',
-            name: 'Google Cloud Platform',
-            icon: 'gcp_icon',
-            tooltip: 'Google Cloud (GCP) support is coming soon!',
-            regions: [],
-        },
-        azure: {
-            id: 'azure',
-            name: 'Microsoft Azure',
-            icon: 'azure_icon',
-            tooltip: 'Microsoft Azure support is coming soon!',
-            regions: [],
-        },
-    };
-}
-exports.getSquidSupportedCloudMap = getSquidSupportedCloudMap;
-function convertToSquidRegion(cloudId, region) {
-    if (region === 'local')
-        return 'local';
-    return `${region}.${cloudId}`;
-}
-exports.convertToSquidRegion = convertToSquidRegion;
-function convertFromSquidRegion(regionAndCloud) {
-    const splitRegion = regionAndCloud.split('.');
-    return { cloudId: splitRegion[1], region: splitRegion[0] };
-}
-exports.convertFromSquidRegion = convertFromSquidRegion;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertFromSquidRegion = exports.convertToSquidRegion = exports.getSquidSupportedCloudMap = exports.squidSupportedRegionMap = exports.SupportedSquidRegions = void 0;
+const nullish_1 = require("./utils/nullish");
+exports.SupportedSquidRegions = ['us-east-1.aws'];
+exports.squidSupportedRegionMap = {
+    'us-east-1.aws': { id: 'us-east-1', name: 'US East (N. Virginia)' },
+    ['us-east-1.aws-dev']: { id: 'us-east-1', name: 'US East (N. Virginia - Dev)' },
+    ['local']: { id: 'local', name: 'Local' },
+};
+function getSquidSupportedCloudMap() {
+    return {
+        aws: {
+            id: 'aws',
+            name: 'Amazon Web Services',
+            icon: 'aws_icon',
+            regions: [exports.squidSupportedRegionMap['us-east-1.aws']].filter(nullish_1.isNotNullish),
+        },
+        gcp: {
+            id: 'gcp',
+            name: 'Google Cloud Platform',
+            icon: 'gcp_icon',
+            tooltip: 'Google Cloud (GCP) support is coming soon!',
+            regions: [],
+        },
+        azure: {
+            id: 'azure',
+            name: 'Microsoft Azure',
+            icon: 'azure_icon',
+            tooltip: 'Microsoft Azure support is coming soon!',
+            regions: [],
+        },
+    };
+}
+exports.getSquidSupportedCloudMap = getSquidSupportedCloudMap;
+function convertToSquidRegion(cloudId, region) {
+    if (region === 'local')
+        return 'local';
+    return `${region}.${cloudId}`;
+}
+exports.convertToSquidRegion = convertToSquidRegion;
+function convertFromSquidRegion(regionAndCloud) {
+    const splitRegion = regionAndCloud.split('.');
+    return { cloudId: splitRegion[1], region: splitRegion[0] };
+}
+exports.convertFromSquidRegion = convertFromSquidRegion;
 //# sourceMappingURL=regions.js.map

package/dist/common/src/schema/schema.types.d.ts

@@ -1,30 +1,30 @@
-import { JSONSchema } from 'json-schema-typed';
-export type FieldPlaceholder = '__SQUID_SERVER_TIMESTAMP__' | '__SQUID_CLIENT_IP__' | '__SQUID_USER_ID__' | '__SQUID_API_KEY__';
-export type BasicFieldType = 'string' | 'integer' | 'number' | 'boolean' | 'map' | 'array' | 'any';
-export type CustomFieldType = 'date' | 'json' | 'objectId';
-export type SupportedFieldType = BasicFieldType | CustomFieldType;
-export declare const SUPPORTED_FIELD_TYPES_ARRAY: Array<SupportedFieldType>;
-type ConvertDeep<T extends JSONSchema> = Exclude<T, boolean> & {
-    properties?: Record<string, ConvertDeep<JSONSchema>>;
-    patternProperties?: Record<string, ConvertDeep<JSONSchema>>;
-    nullable?: boolean;
-    applyDefaultValueOn?: 'always' | 'empty' | 'updateOrEmpty';
-    isDate?: boolean;
-    isJSON?: boolean;
-    insertable?: boolean;
-    deletable?: boolean;
-};
-export type PropertySchema = ConvertDeep<JSONSchema>;
-export type TopLevelPropertySchema = PropertySchema & {
-    primaryKey?: boolean;
-    isComputed?: boolean;
-    isDefaultComputed?: boolean;
-    dataType?: string;
-};
-export type CollectionSchema = Omit<ConvertDeep<JSONSchema>, 'properties'> & {
-    properties?: Record<string, TopLevelPropertySchema>;
-};
-export declare function compileSchema<S extends CollectionSchema>(schema: S): any;
-export declare function validateSchema<S extends CollectionSchema>(schema: S, data: any, updatedPaths?: Array<string>, dataBefore?: any): void;
-export declare function findMatchingPropertiesForKey<S extends CollectionSchema | PropertySchema>(schema: S, key: string): Array<PropertySchema>;
-export {};
+import { JSONSchema } from 'json-schema-typed';
+export type FieldPlaceholder = '__SQUID_SERVER_TIMESTAMP__' | '__SQUID_CLIENT_IP__' | '__SQUID_USER_ID__' | '__SQUID_API_KEY__';
+export type BasicFieldType = 'string' | 'integer' | 'number' | 'boolean' | 'map' | 'array' | 'any';
+export type CustomFieldType = 'date' | 'json' | 'objectId';
+export type SupportedFieldType = BasicFieldType | CustomFieldType;
+export declare const SUPPORTED_FIELD_TYPES_ARRAY: Array<SupportedFieldType>;
+type ConvertDeep<T extends JSONSchema> = Exclude<T, boolean> & {
+    properties?: Record<string, ConvertDeep<JSONSchema>>;
+    patternProperties?: Record<string, ConvertDeep<JSONSchema>>;
+    nullable?: boolean;
+    applyDefaultValueOn?: 'always' | 'empty' | 'updateOrEmpty';
+    isDate?: boolean;
+    isJSON?: boolean;
+    insertable?: boolean;
+    deletable?: boolean;
+};
+export type PropertySchema = ConvertDeep<JSONSchema>;
+export type TopLevelPropertySchema = PropertySchema & {
+    primaryKey?: boolean;
+    isComputed?: boolean;
+    isDefaultComputed?: boolean;
+    dataType?: string;
+};
+export type CollectionSchema = Omit<ConvertDeep<JSONSchema>, 'properties'> & {
+    properties?: Record<string, TopLevelPropertySchema>;
+};
+export declare function compileSchema<S extends CollectionSchema>(schema: S): any;
+export declare function validateSchema<S extends CollectionSchema>(schema: S, data: any, updatedPaths?: Array<string>, dataBefore?: any): void;
+export declare function findMatchingPropertiesForKey<S extends CollectionSchema | PropertySchema>(schema: S, key: string): Array<PropertySchema>;
+export {};