@squidcloud/local-backend 1.0.60 → 1.0.62

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

@@ -1,143 +1,143 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.reduceMutations = exports.convertInsertToUpdate = exports.applyUpdateMutation = exports.mergeMutations = exports.sortUpdateMutationProperties = void 0;
-const _ = require("lodash");
-const rxjs_1 = require("rxjs");
-const assert_1 = require("./utils/assert");
-const object_1 = require("./utils/object");
-function applyStringFn(initialValue, propertyMutation) {
-    switch (propertyMutation.fn) {
-        case 'trim':
-            if (typeof initialValue !== 'string')
-                return initialValue;
-            return initialValue.trim();
-        case 'extendString':
-            if (initialValue === null || initialValue === undefined)
-                return propertyMutation.value;
-            return initialValue + propertyMutation.value;
-        default:
-            throw new Error('Unknown string function: ' + JSON.stringify(propertyMutation));
-    }
-}
-function applyNumericFn(initialValue, propertyMutation) {
-    switch (propertyMutation.fn) {
-        case 'increment':
-            if (initialValue === null || initialValue === undefined)
-                return propertyMutation.value;
-            return initialValue + propertyMutation.value;
-        default:
-            throw new Error('Unknown numeric function: ' + JSON.stringify(propertyMutation));
-    }
-}
-function applyPropertyMutation(property, propertyMutation) {
-    switch (propertyMutation.type) {
-        case 'applyNumericFn':
-            return applyNumericFn(property, propertyMutation);
-        case 'applyStringFn':
-            return applyStringFn(property, propertyMutation);
-        case 'update':
-            return typeof propertyMutation.value === 'object' ? _.cloneDeep(propertyMutation.value) : propertyMutation.value;
-        case 'removeProperty':
-            return undefined;
-        default:
-            throw new Error('Unknown property mutation type: ' + JSON.stringify(propertyMutation));
-    }
-}
-function sortUpdateMutationProperties(updateMutation) {
-    return Object.entries(updateMutation.properties).sort(([propA], [propB]) => {
-        const propADots = propA.split('.').length;
-        const propBDots = propB.split('.').length;
-        return propADots - propBDots;
-    });
-}
-exports.sortUpdateMutationProperties = sortUpdateMutationProperties;
-function mergeMutations(mutationA, mutationB) {
-    if (mutationB.type === 'insert')
-        return mutationB;
-    if (mutationB.type === 'delete')
-        return mutationB;
-    if (mutationA.type === 'delete')
-        throw new Error('Cannot delete and then update');
-    (0, assert_1.assertTruthy)(mutationB.type === 'update', 'Invalid mutation type');
-    if (mutationA.type === 'update')
-        return mergeUpdateMutations(mutationA, mutationB);
-    const result = _.cloneDeep(mutationA);
-    for (const [fieldName, propertyMutationsAr] of sortUpdateMutationProperties(mutationB)) {
-        const propertyMutations = propertyMutationsAr;
-        for (const propertyMutation of propertyMutations) {
-            const value = applyPropertyMutation((0, object_1.getInPath)(result.properties, fieldName), propertyMutation);
-            if (value === undefined) {
-                (0, object_1.deleteInPath)(result.properties, fieldName);
-            }
-            else {
-                (0, object_1.setInPath)(result.properties, fieldName, value);
-            }
-        }
-    }
-    return result;
-}
-exports.mergeMutations = mergeMutations;
-function mergeUpdateMutations(mutationA, mutationB) {
-    const result = _.cloneDeep(mutationA);
-    mutationB = _.cloneDeep(mutationB);
-    for (const [aPropName] of sortUpdateMutationProperties(result)) {
-        const aPropNameDots = aPropName.split('.').length;
-        const isOverriddenByMutationB = Object.entries(mutationB.properties).some(([bPropName]) => {
-            return aPropName.startsWith(bPropName + '.') && aPropNameDots > bPropName.split('.').length;
-        });
-        if (isOverriddenByMutationB) {
-            delete result.properties[aPropName];
-        }
-    }
-    for (const [bPropName, bPropValues] of sortUpdateMutationProperties(mutationB)) {
-        result.properties[bPropName] = [...(result.properties[bPropName] || []), ...bPropValues];
-    }
-    return result;
-}
-function applyUpdateMutation(doc, updateMutation) {
-    if (!doc)
-        return undefined;
-    const result = Object.assign({}, doc);
-    const entries = sortUpdateMutationProperties(updateMutation);
-    for (const [fieldName, propertyMutationsAr] of entries) {
-        const propertyMutations = propertyMutationsAr;
-        for (const propertyMutation of propertyMutations) {
-            const value = applyPropertyMutation((0, object_1.getInPath)(result, fieldName), propertyMutation);
-            if (value === undefined) {
-                (0, object_1.deleteInPath)(result, fieldName);
-            }
-            else {
-                (0, object_1.setInPath)(result, fieldName, value);
-            }
-        }
-    }
-    return result;
-}
-exports.applyUpdateMutation = applyUpdateMutation;
-function convertInsertToUpdate(insertMutation) {
-    const result = {
-        type: 'update',
-        squidDocIdObj: insertMutation.squidDocIdObj,
-        properties: {},
-    };
-    for (const [key, value] of Object.entries(insertMutation.properties)) {
-        result.properties[key] = [{ type: 'update', value }];
-    }
-    return result;
-}
-exports.convertInsertToUpdate = convertInsertToUpdate;
-function reduceMutations(mutations) {
-    let result = [];
-    (0, rxjs_1.from)(mutations)
-        .pipe((0, rxjs_1.groupBy)((mutation) => {
-        return `${mutation.squidDocIdObj.integrationId}${mutation.squidDocIdObj.collectionName}/${mutation.squidDocIdObj.docId}`;
-    }), (0, rxjs_1.mergeMap)((mutationsGroup) => mutationsGroup.pipe((0, rxjs_1.reduce)((mutationA, mutationB) => {
-        return mergeMutations(mutationA, mutationB);
-    }))), (0, rxjs_1.toArray)())
-        .subscribe((value) => {
-        result = value;
-    });
-    return result;
-}
-exports.reduceMutations = reduceMutations;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reduceMutations = exports.convertInsertToUpdate = exports.applyUpdateMutation = exports.mergeMutations = exports.sortUpdateMutationProperties = void 0;
+const _ = require("lodash");
+const rxjs_1 = require("rxjs");
+const assert_1 = require("./utils/assert");
+const object_1 = require("./utils/object");
+function applyStringFn(initialValue, propertyMutation) {
+    switch (propertyMutation.fn) {
+        case 'trim':
+            if (typeof initialValue !== 'string')
+                return initialValue;
+            return initialValue.trim();
+        case 'extendString':
+            if (initialValue === null || initialValue === undefined)
+                return propertyMutation.value;
+            return initialValue + propertyMutation.value;
+        default:
+            throw new Error('Unknown string function: ' + JSON.stringify(propertyMutation));
+    }
+}
+function applyNumericFn(initialValue, propertyMutation) {
+    switch (propertyMutation.fn) {
+        case 'increment':
+            if (initialValue === null || initialValue === undefined)
+                return propertyMutation.value;
+            return initialValue + propertyMutation.value;
+        default:
+            throw new Error('Unknown numeric function: ' + JSON.stringify(propertyMutation));
+    }
+}
+function applyPropertyMutation(property, propertyMutation) {
+    switch (propertyMutation.type) {
+        case 'applyNumericFn':
+            return applyNumericFn(property, propertyMutation);
+        case 'applyStringFn':
+            return applyStringFn(property, propertyMutation);
+        case 'update':
+            return typeof propertyMutation.value === 'object' ? _.cloneDeep(propertyMutation.value) : propertyMutation.value;
+        case 'removeProperty':
+            return undefined;
+        default:
+            throw new Error('Unknown property mutation type: ' + JSON.stringify(propertyMutation));
+    }
+}
+function sortUpdateMutationProperties(updateMutation) {
+    return Object.entries(updateMutation.properties).sort(([propA], [propB]) => {
+        const propADots = propA.split('.').length;
+        const propBDots = propB.split('.').length;
+        return propADots - propBDots;
+    });
+}
+exports.sortUpdateMutationProperties = sortUpdateMutationProperties;
+function mergeMutations(mutationA, mutationB) {
+    if (mutationB.type === 'insert')
+        return mutationB;
+    if (mutationB.type === 'delete')
+        return mutationB;
+    if (mutationA.type === 'delete')
+        throw new Error('Cannot delete and then update');
+    (0, assert_1.assertTruthy)(mutationB.type === 'update', 'Invalid mutation type');
+    if (mutationA.type === 'update')
+        return mergeUpdateMutations(mutationA, mutationB);
+    const result = _.cloneDeep(mutationA);
+    for (const [fieldName, propertyMutationsAr] of sortUpdateMutationProperties(mutationB)) {
+        const propertyMutations = propertyMutationsAr;
+        for (const propertyMutation of propertyMutations) {
+            const value = applyPropertyMutation((0, object_1.getInPath)(result.properties, fieldName), propertyMutation);
+            if (value === undefined) {
+                (0, object_1.deleteInPath)(result.properties, fieldName);
+            }
+            else {
+                (0, object_1.setInPath)(result.properties, fieldName, value);
+            }
+        }
+    }
+    return result;
+}
+exports.mergeMutations = mergeMutations;
+function mergeUpdateMutations(mutationA, mutationB) {
+    const result = _.cloneDeep(mutationA);
+    mutationB = _.cloneDeep(mutationB);
+    for (const [aPropName] of sortUpdateMutationProperties(result)) {
+        const aPropNameDots = aPropName.split('.').length;
+        const isOverriddenByMutationB = Object.entries(mutationB.properties).some(([bPropName]) => {
+            return aPropName.startsWith(bPropName + '.') && aPropNameDots > bPropName.split('.').length;
+        });
+        if (isOverriddenByMutationB) {
+            delete result.properties[aPropName];
+        }
+    }
+    for (const [bPropName, bPropValues] of sortUpdateMutationProperties(mutationB)) {
+        result.properties[bPropName] = [...(result.properties[bPropName] || []), ...bPropValues];
+    }
+    return result;
+}
+function applyUpdateMutation(doc, updateMutation) {
+    if (!doc)
+        return undefined;
+    const result = Object.assign({}, doc);
+    const entries = sortUpdateMutationProperties(updateMutation);
+    for (const [fieldName, propertyMutationsAr] of entries) {
+        const propertyMutations = propertyMutationsAr;
+        for (const propertyMutation of propertyMutations) {
+            const value = applyPropertyMutation((0, object_1.getInPath)(result, fieldName), propertyMutation);
+            if (value === undefined) {
+                (0, object_1.deleteInPath)(result, fieldName);
+            }
+            else {
+                (0, object_1.setInPath)(result, fieldName, value);
+            }
+        }
+    }
+    return result;
+}
+exports.applyUpdateMutation = applyUpdateMutation;
+function convertInsertToUpdate(insertMutation) {
+    const result = {
+        type: 'update',
+        squidDocIdObj: insertMutation.squidDocIdObj,
+        properties: {},
+    };
+    for (const [key, value] of Object.entries(insertMutation.properties)) {
+        result.properties[key] = [{ type: 'update', value }];
+    }
+    return result;
+}
+exports.convertInsertToUpdate = convertInsertToUpdate;
+function reduceMutations(mutations) {
+    let result = [];
+    (0, rxjs_1.from)(mutations)
+        .pipe((0, rxjs_1.groupBy)((mutation) => {
+        return `${mutation.squidDocIdObj.integrationId}${mutation.squidDocIdObj.collectionName}/${mutation.squidDocIdObj.docId}`;
+    }), (0, rxjs_1.mergeMap)((mutationsGroup) => mutationsGroup.pipe((0, rxjs_1.reduce)((mutationA, mutationB) => {
+        return mergeMutations(mutationA, mutationB);
+    }))), (0, rxjs_1.toArray)())
+        .subscribe((value) => {
+        result = value;
+    });
+    return result;
+}
+exports.reduceMutations = reduceMutations;
 //# sourceMappingURL=mutation.types.js.map

package/dist/common/src/named-query.context.d.ts

@@ -1,4 +1,4 @@
-export declare class NamedQueryContext {
-    readonly params: Record<string, any>;
-    constructor(params: Record<string, any>);
-}
+export declare class NamedQueryContext {
+    readonly params: Record<string, any>;
+    constructor(params: Record<string, any>);
+}

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

@@ -1,10 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NamedQueryContext = void 0;
-class NamedQueryContext {
-    constructor(params) {
-        this.params = params;
-    }
-}
-exports.NamedQueryContext = NamedQueryContext;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NamedQueryContext = void 0;
+class NamedQueryContext {
+    constructor(params) {
+        this.params = params;
+    }
+}
+exports.NamedQueryContext = NamedQueryContext;
 //# sourceMappingURL=named-query.context.js.map

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

@@ -1,3 +1,3 @@
-import { JSONSchemaType } from 'ajv';
-import { ExecuteNamedQueryRequest } from './named-query.types';
-export declare const ExecuteNamedQueryRequestSchema: JSONSchemaType<ExecuteNamedQueryRequest>;
+import { JSONSchemaType } from 'ajv';
+import { ExecuteNamedQueryRequest } from './named-query.types';
+export declare const ExecuteNamedQueryRequestSchema: JSONSchemaType<ExecuteNamedQueryRequest>;

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

@@ -1,14 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExecuteNamedQueryRequestSchema = void 0;
-exports.ExecuteNamedQueryRequestSchema = {
-    type: 'object',
-    required: ['integrationId', 'queryName', 'paramsRecordStr', 'clientRequestId'],
-    properties: {
-        integrationId: { type: 'string', nullable: false },
-        queryName: { type: 'string', nullable: false },
-        paramsRecordStr: { type: 'string', nullable: false },
-        clientRequestId: { type: 'string', nullable: false },
-    },
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecuteNamedQueryRequestSchema = void 0;
+exports.ExecuteNamedQueryRequestSchema = {
+    type: 'object',
+    required: ['integrationId', 'queryName', 'paramsRecordStr', 'clientRequestId'],
+    properties: {
+        integrationId: { type: 'string', nullable: false },
+        queryName: { type: 'string', nullable: false },
+        paramsRecordStr: { type: 'string', nullable: false },
+        clientRequestId: { type: 'string', nullable: false },
+    },
+};
 //# sourceMappingURL=named-query.schemas.js.map

package/dist/common/src/named-query.types.d.ts

@@ -1,8 +1,8 @@
-import { ClientRequestId, IntegrationId } from './communication.types';
-import { QueryName } from './application.types';
-export interface ExecuteNamedQueryRequest {
-    integrationId: IntegrationId;
-    queryName: QueryName;
-    paramsRecordStr: string;
-    clientRequestId: ClientRequestId;
-}
+import { ClientRequestId, IntegrationId } from './communication.types';
+import { QueryName } from './application.types';
+export interface ExecuteNamedQueryRequest {
+    integrationId: IntegrationId;
+    queryName: QueryName;
+    paramsRecordStr: string;
+    clientRequestId: ClientRequestId;
+}

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

@@ -1,3 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=named-query.types.js.map

package/dist/common/src/query/base-query-builder.d.ts

@@ -1,66 +1,37 @@
-import { Observable } from 'rxjs';
-import { DocumentData, FieldName, PrimitiveFieldType } from '../document.types';
-import { FieldSort, Operator, SimpleCondition } from '../query.types';
-import { SerializedQuery } from './serialized-query.types';
-export interface SnapshotEmitter<ReturnType> {
-    snapshot(): Promise<Array<ReturnType>>;
-    snapshots(subscribe?: boolean): Observable<Array<ReturnType>>;
-    peek(): Array<ReturnType>;
-    clone(): SnapshotEmitter<ReturnType>;
-    getSortOrders(): Array<FieldSort<any>>;
-    addCompositeCondition(conditions: Array<SimpleCondition>): SnapshotEmitter<ReturnType>;
-    limit(limit: number): SnapshotEmitter<ReturnType>;
-    getLimit(): number;
-    flipSortOrder(): SnapshotEmitter<ReturnType>;
-    extractData(data: ReturnType): any;
-    paginate(options?: Partial<PaginationOptions>): Pagination<ReturnType>;
-    serialize(): SerializedQuery;
-}
-export declare abstract class BaseQueryBuilder<MyDocType extends DocumentData> {
-    abstract where(fieldName: (keyof MyDocType & FieldName) | string, operator: Operator | 'in' | 'not in', value: PrimitiveFieldType | Array<PrimitiveFieldType>): this;
-    eq(fieldName: (keyof MyDocType & FieldName) | string, value: PrimitiveFieldType): this;
-    neq(fieldName: (keyof MyDocType & FieldName) | string, value: PrimitiveFieldType): this;
-    in(fieldName: (keyof MyDocType & FieldName) | string, value: Array<PrimitiveFieldType>): this;
-    nin(fieldName: (keyof MyDocType & FieldName) | string, value: Array<PrimitiveFieldType>): this;
-    gt(fieldName: (keyof MyDocType & FieldName) | string, value: PrimitiveFieldType): this;
-    gte(fieldName: (keyof MyDocType & FieldName) | string, value: PrimitiveFieldType): this;
-    lt(fieldName: (keyof MyDocType & FieldName) | string, value: PrimitiveFieldType): this;
-    lte(fieldName: (keyof MyDocType & FieldName) | string, value: PrimitiveFieldType): this;
-    like(fieldName: (keyof MyDocType & FieldName) | string, pattern: string, caseSensitive?: boolean): this;
-    notLike(fieldName: (keyof MyDocType & FieldName) | string, pattern: string, caseSensitive?: boolean): this;
-    abstract limit(limit: number): this;
-    abstract sortBy(fieldName: keyof MyDocType & FieldName, asc?: boolean): this;
-}
-export interface HasDereference {
-    dereference(): any;
-}
-export interface PaginationState<ReturnType> {
-    data: Array<ReturnType>;
-    hasNext: boolean;
-    hasPrev: boolean;
-    isLoading: boolean;
-}
-export interface PaginationOptions {
-    subscribe: boolean;
-    pageSize: number;
-}
-export declare class Pagination<ReturnType> {
-    private readonly templateSnapshotEmitter;
-    private readonly firstPageSnapshotEmitterWrapper;
-    private readonly firstPageDataAvailable;
-    private lastPageSnapshotEmitterWrapper;
-    private lastPageDataAvailable;
-    private readonly isDestroyed;
-    private readonly destroyedObs;
-    private readonly _observeState;
-    private readonly currentPageSnapshotEmitterWrapperSubject;
-    private readonly options;
-    constructor(snapshotEmitter: SnapshotEmitter<ReturnType>, options?: Partial<PaginationOptions>);
-    next(): Promise<PaginationState<ReturnType>>;
-    prev(): Promise<PaginationState<ReturnType>>;
-    unsubscribe(): void;
-    observeState(): Observable<PaginationState<ReturnType>>;
-    waitForData(): Promise<PaginationState<ReturnType>>;
-    private createLastPageSnapshotEmitterWrapper;
-    private resetToFirstPageData;
-}
+import { Observable } from 'rxjs';
+import { DocumentData, FieldName, PrimitiveFieldType } from '../document.types';
+import { FieldSort, Operator, SimpleCondition } from '../query.types';
+import { SerializedQuery } from './serialized-query.types';
+import { PaginationOptions, Pagination } from './pagination';
+export interface SnapshotEmitter<ReturnType> {
+    snapshot(): Promise<Array<ReturnType>>;
+    snapshots(subscribe?: boolean): Observable<Array<ReturnType>>;
+    peek(): Array<ReturnType>;
+    clone(): SnapshotEmitter<ReturnType>;
+    getSortOrders(): Array<FieldSort<any>>;
+    addCompositeCondition(conditions: Array<SimpleCondition>): SnapshotEmitter<ReturnType>;
+    limit(limit: number): SnapshotEmitter<ReturnType>;
+    getLimit(): number;
+    flipSortOrder(): SnapshotEmitter<ReturnType>;
+    extractData(data: ReturnType): any;
+    paginate(options?: Partial<PaginationOptions>): Pagination<ReturnType>;
+    serialize(): SerializedQuery;
+}
+export declare abstract class BaseQueryBuilder<MyDocType extends DocumentData> {
+    abstract where(fieldName: (keyof MyDocType & FieldName) | string, operator: Operator | 'in' | 'not in', value: PrimitiveFieldType | Array<PrimitiveFieldType>): this;
+    eq(fieldName: (keyof MyDocType & FieldName) | string, value: PrimitiveFieldType): this;
+    neq(fieldName: (keyof MyDocType & FieldName) | string, value: PrimitiveFieldType): this;
+    in(fieldName: (keyof MyDocType & FieldName) | string, value: Array<PrimitiveFieldType>): this;
+    nin(fieldName: (keyof MyDocType & FieldName) | string, value: Array<PrimitiveFieldType>): this;
+    gt(fieldName: (keyof MyDocType & FieldName) | string, value: PrimitiveFieldType): this;
+    gte(fieldName: (keyof MyDocType & FieldName) | string, value: PrimitiveFieldType): this;
+    lt(fieldName: (keyof MyDocType & FieldName) | string, value: PrimitiveFieldType): this;
+    lte(fieldName: (keyof MyDocType & FieldName) | string, value: PrimitiveFieldType): this;
+    like(fieldName: (keyof MyDocType & FieldName) | string, pattern: string, caseSensitive?: boolean): this;
+    notLike(fieldName: (keyof MyDocType & FieldName) | string, pattern: string, caseSensitive?: boolean): this;
+    abstract limit(limit: number): this;
+    abstract sortBy(fieldName: keyof MyDocType & FieldName, asc?: boolean): this;
+}
+export interface HasDereference {
+    dereference(): any;
+}