@lifeready/core 1.0.1 → 1.0.3

package/esm2015/lib/api/lock.gql.js

@@ -0,0 +1,40 @@
+import { gqlTyped } from '../_common/ast';
+export const LockFragment = gqlTyped `
+fragment LockFragment on LockField {
+  created
+  modified
+  version
+  expiryTime
+  state
+}`;
+export const UpdateLockMutation = gqlTyped `
+mutation UpdateLockMutation($input: UpdateLockInput!) {
+  updateLock(input: $input) {
+    lock {
+      ...LockFragment
+    }
+  }
+}
+${LockFragment}
+`;
+export const AcquireLockMutation = gqlTyped `
+mutation AcquireLockMutation($input: AcquireLockInput!) {
+  acquireLock(input: $input) {
+    lock {
+      ...LockFragment
+    }
+  }
+}
+${LockFragment}
+`;
+export const ReleaseLockMutation = gqlTyped `
+mutation ReleaseLockMutation($input: ReleaseLockInput!) {
+  releaseLock(input: $input) {
+    lock {
+      ...LockFragment
+    }
+  }
+}
+${LockFragment}
+`;
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/api/lock.service.js

@@ -0,0 +1,64 @@
+import { __decorate } from "tslib";
+import { Injectable, Injector, NgZone } from '@angular/core';
+import { LrMutation, LrService } from './lr-graphql';
+import { AcquireLockMutation, ReleaseLockMutation, UpdateLockMutation, } from './lock.gql';
+import { RunOutsideAngular } from '../_common/run-outside-angular';
+import * as i0 from "@angular/core";
+let LockService = class LockService extends LrService {
+    constructor(ngZone, injector) {
+        super(injector);
+        this.ngZone = ngZone;
+        this.injector = injector;
+    }
+    // Updating the lock version is always to be down along with another mutation.
+    updateLockMutation(resourceId, version) {
+        return new LrMutation({
+            mutation: UpdateLockMutation,
+            variables: {
+                input: {
+                    resourceId,
+                    version,
+                },
+            },
+        });
+    }
+    acquireLockMutation(resourceId, timeoutMs) {
+        return new LrMutation({
+            mutation: AcquireLockMutation,
+            variables: {
+                input: {
+                    resourceId,
+                    timeoutMs,
+                },
+            },
+        });
+    }
+    releaseLockMutation(resourceId, version) {
+        return new LrMutation({
+            mutation: ReleaseLockMutation,
+            variables: {
+                input: {
+                    resourceId,
+                    version,
+                },
+            },
+        });
+    }
+};
+LockService.ɵprov = i0.ɵɵdefineInjectable({ factory: function LockService_Factory() { return new LockService(i0.ɵɵinject(i0.NgZone), i0.ɵɵinject(i0.INJECTOR)); }, token: LockService, providedIn: "root" });
+LockService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+LockService.ctorParameters = () => [
+    { type: NgZone },
+    { type: Injector }
+];
+LockService = __decorate([
+    RunOutsideAngular({
+        ngZoneName: 'ngZone',
+    })
+], LockService);
+export { LockService };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/api/lr-apollo.service.js

@@ -0,0 +1,46 @@
+import { __awaiter } from "tslib";
+import { Injectable } from '@angular/core';
+import { Apollo } from 'apollo-angular';
+import { KeyGraphService } from '../cryptography/key-graph.service';
+import { handleApolloError } from '../_common/exceptions';
+import * as i0 from "@angular/core";
+import * as i1 from "apollo-angular";
+import * as i2 from "../cryptography/key-graph.service";
+export class LrApolloService {
+    constructor(apollo, keyGraph) {
+        this.apollo = apollo;
+        this.keyGraph = keyGraph;
+    }
+    addKeys(response) {
+        if (response.data.keyGraph) {
+            this.keyGraph.addKeys(response.data.keyGraph);
+        }
+    }
+    query(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.apollo.query(options).toPromise();
+            handleApolloError(response.errors);
+            this.addKeys(response);
+            return response.data;
+        });
+    }
+    mutate(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.apollo.mutate(options).toPromise();
+            handleApolloError(response.errors);
+            this.addKeys(response);
+            return response.data;
+        });
+    }
+}
+LrApolloService.ɵprov = i0.ɵɵdefineInjectable({ factory: function LrApolloService_Factory() { return new LrApolloService(i0.ɵɵinject(i1.Apollo), i0.ɵɵinject(i2.KeyGraphService)); }, token: LrApolloService, providedIn: "root" });
+LrApolloService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+LrApolloService.ctorParameters = () => [
+    { type: Apollo },
+    { type: KeyGraphService }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/api/lr-graphql/index.js

@@ -0,0 +1,6 @@
+export * from './lr-graphql.service';
+export * from './lr-merged-mutation';
+export * from './lr-mutation';
+export * from './lr-mutation-base';
+export * from './lr.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiQzovUHJvamVjdHMvbmV3cmVwby9rYy1jbGllbnQvcHJvamVjdHMvY29yZS9zcmMvIiwic291cmNlcyI6WyJsaWIvYXBpL2xyLWdyYXBocWwvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xyLWdyYXBocWwuc2VydmljZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbHItbWVyZ2VkLW11dGF0aW9uJztcclxuZXhwb3J0ICogZnJvbSAnLi9sci1tdXRhdGlvbic7XHJcbmV4cG9ydCAqIGZyb20gJy4vbHItbXV0YXRpb24tYmFzZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbHIuc2VydmljZSc7XHJcbiJdfQ==

package/esm2015/lib/api/lr-graphql/lr-graphql.service.js

@@ -0,0 +1,155 @@
+import { __awaiter, __decorate } from "tslib";
+import * as lodash from 'lodash';
+import { Injectable, NgZone } from '@angular/core';
+import { Apollo } from 'apollo-angular';
+import { KeyGraphService } from '../../cryptography/key-graph.service';
+import { handleApolloError, LrBadStateException, LrUnsupportedException, } from '../../_common/exceptions';
+import { FetchKeyGraphField, KeyGraphField } from '../../_common/queries.gql';
+import { getQuery, getMutation } from '../../_common/ast';
+import gql from 'graphql-tag';
+import { QueryProcessorService } from '../query-processor';
+import { RunOutsideAngular } from '../../_common/run-outside-angular';
+import * as gqlPrinter from 'graphql/language/printer';
+import { LrMergedMutation } from './lr-merged-mutation';
+import * as i0 from "@angular/core";
+import * as i1 from "apollo-angular";
+import * as i2 from "../../cryptography/key-graph.service";
+import * as i3 from "../query-processor/query-processor.service";
+// Data structures
+// --------------------------------------------------------------------------
+const keyGraphFieldAstSelection = getQuery(gql `
+query {
+  ${KeyGraphField}
+}
+`).selectionSet.selections[0];
+const fetchKeyGraphFieldAstSelection = getQuery(gql `
+query {
+  ${FetchKeyGraphField}
+}
+`).selectionSet.selections[0];
+let LrGraphQLService = class LrGraphQLService {
+    constructor(ngZone, apollo, keyGraph, queryProcessor) {
+        this.ngZone = ngZone;
+        this.apollo = apollo;
+        this.keyGraph = keyGraph;
+        this.queryProcessor = queryProcessor;
+        this.stats = {
+            queryCount: 0,
+            mutationCount: 0,
+        };
+    }
+    query(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Make copies to avoid side effect.
+            options = lodash.cloneDeep(options);
+            // Append the key graph query
+            const includeKeyGraph = this.isIncludeKeyGraph(options.includeKeyGraph);
+            if (includeKeyGraph) {
+                const operation = getQuery(options.query);
+                operation.selectionSet.selections = [
+                    ...operation.selectionSet.selections,
+                    keyGraphFieldAstSelection,
+                ];
+            }
+            const response = yield this.apollo.query(options).toPromise();
+            this.stats.queryCount++;
+            handleApolloError(response.errors);
+            this.addKeys(response);
+            const data = yield this.queryProcessor.processQuery(response.data, options.processorOptions);
+            return data;
+        });
+    }
+    lrMutateImpl(lrMutation, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (options === null || options === void 0 ? void 0 : options.variables) {
+                throw new LrUnsupportedException('Unsupported field: "options.variables"');
+            }
+            if (lrMutation.executed) {
+                throw new LrBadStateException('LrMutation has already executed. LrMutation can only be used once in a lrMutate() call. Create new instances of LrMutation.');
+            }
+            lrMutation.setExecuted();
+            return this.apolloMutate(Object.assign(Object.assign({}, options), lrMutation.lrMutationData))
+                .then((res) => {
+                // Resolve promises set on the lrMutation rather than the lrMutate() call.
+                lrMutation.resolve(res);
+                // Still need to return value to the promise waiting for the results of lrMutate().
+                return res;
+            })
+                .catch((error) => {
+                lrMutation.reject(error);
+                throw error;
+            });
+        });
+    }
+    apolloMutate(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Make copies to avoid side effect.
+            options = Object.assign(Object.assign({}, options), { mutation: lodash.cloneDeep(options.mutation) });
+            // Append the key graph query
+            const includeKeyGraph = this.isIncludeKeyGraph(options.includeKeyGraph);
+            if (includeKeyGraph) {
+                const operation = getMutation(options.mutation);
+                operation.selectionSet.selections = [
+                    ...operation.selectionSet.selections,
+                    fetchKeyGraphFieldAstSelection,
+                ];
+            }
+            // Format to string and parse again. This allows the "loc": { "start": ... }
+            // part of the DocumentNode to be correctly setup. It's extra processing
+            // in serialising and parsing, but probably minimal overhead.
+            options.mutation = gql(gqlPrinter.print(options.mutation));
+            const response = yield this.apollo.mutate(options).toPromise();
+            this.stats.mutationCount++;
+            handleApolloError(response.errors);
+            this.addKeys(response);
+            const data = yield this.queryProcessor.processQuery(response.data, options.processorOptions);
+            return data;
+        });
+    }
+    statsSnapshot() {
+        return lodash.cloneDeep(this.stats);
+    }
+    addKeys(response) {
+        if (response.data.keyGraph) {
+            this.keyGraph.addKeys(response.data.keyGraph);
+            delete response.data.keyGraph;
+        }
+    }
+    isIncludeKeyGraph(includeKeyGraph) {
+        // Default to true when null or undefined.
+        return includeKeyGraph == null ? true : false;
+    }
+    lrMutate(lrMutations, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (lrMutations instanceof Array) {
+                const merged = LrMergedMutation.create(yield Promise.all(lrMutations));
+                yield this.lrMutateImpl(merged, options);
+                return merged.promise;
+            }
+            else {
+                const resolved = yield lrMutations;
+                yield this.lrMutateImpl(resolved, options);
+                return resolved.promise;
+            }
+        });
+    }
+};
+LrGraphQLService.ɵprov = i0.ɵɵdefineInjectable({ factory: function LrGraphQLService_Factory() { return new LrGraphQLService(i0.ɵɵinject(i0.NgZone), i0.ɵɵinject(i1.Apollo), i0.ɵɵinject(i2.KeyGraphService), i0.ɵɵinject(i3.QueryProcessorService)); }, token: LrGraphQLService, providedIn: "root" });
+LrGraphQLService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+LrGraphQLService.ctorParameters = () => [
+    { type: NgZone },
+    { type: Apollo },
+    { type: KeyGraphService },
+    { type: QueryProcessorService }
+];
+LrGraphQLService = __decorate([
+    RunOutsideAngular({
+        ngZoneName: 'ngZone',
+    })
+], LrGraphQLService);
+export { LrGraphQLService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lr-graphql.service.js","sourceRoot":"C:/Projects/newrepo/kc-client/projects/core/src/","sources":["lib/api/lr-graphql/lr-graphql.service.ts"],"names":[],"mappings":"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","sourcesContent":["import * as lodash from 'lodash';\r\nimport { Injectable, NgZone } from '@angular/core';\r\nimport { Apollo } from 'apollo-angular';\r\nimport {\r\n  QueryOptions,\r\n  MutationOptions,\r\n  OperationVariables,\r\n  FetchPolicy,\r\n} from '@apollo/client/core';\r\nimport { MutationBaseOptions } from '@apollo/client/core/watchQueryOptions';\r\nimport { KeyGraphService } from '../../cryptography/key-graph.service';\r\nimport { HasKeyGraph } from '../../cryptography/cryptography.types';\r\nimport {\r\n  handleApolloError,\r\n  LrBadStateException,\r\n  LrUnsupportedException,\r\n} from '../../_common/exceptions';\r\nimport { FetchKeyGraphField, KeyGraphField } from '../../_common/queries.gql';\r\nimport { TypedDocumentNode, getQuery, getMutation } from '../../_common/ast';\r\nimport gql from 'graphql-tag';\r\nimport { ProcessorOptions, QueryProcessorService } from '../query-processor';\r\nimport { RunOutsideAngular } from '../../_common/run-outside-angular';\r\nimport { FieldNode } from 'graphql';\r\nimport { LrMutationBase } from './lr-mutation-base';\r\nimport * as gqlPrinter from 'graphql/language/printer';\r\nimport { LrMergedMutation } from './lr-merged-mutation';\r\n\r\n// Data structures\r\n// --------------------------------------------------------------------------\r\nconst keyGraphFieldAstSelection = getQuery(gql`\r\nquery {\r\n  ${KeyGraphField}\r\n}\r\n`).selectionSet.selections[0] as FieldNode;\r\n\r\nconst fetchKeyGraphFieldAstSelection = getQuery(gql`\r\nquery {\r\n  ${FetchKeyGraphField}\r\n}\r\n`).selectionSet.selections[0] as FieldNode;\r\n\r\n// const keyGraphFieldAstSelection = () =>\r\n//   lodash.deepClone(_keyGraphFieldAstSelection) as FieldNode;\r\n// const fetchKeyGraphFieldAstSelection = () =>\r\n//   lodash.deepClone(_fetchKeyGraphFieldAstSelection) as FieldNode;\r\n\r\nexport interface LrQueryOptions<T, TVariables>\r\n  extends QueryOptions<TVariables> {\r\n  query: TypedDocumentNode<T>;\r\n  includeKeyGraph?: boolean;\r\n  processorOptions?: ProcessorOptions;\r\n}\r\n\r\n// Copied from MutationOptions\r\n// Removed required field \"mutation\". The \"variables\" field is still there\r\n// but it's dynamically checked.\r\nexport interface LrMutationOptions<\r\n  T = {\r\n    [key: string]: any;\r\n  },\r\n  TVariables = OperationVariables\r\n> extends MutationBaseOptions<T, TVariables> {\r\n  context?: any;\r\n  fetchPolicy?: FetchPolicy;\r\n  includeKeyGraph?: boolean;\r\n}\r\n\r\n// The \"mutation\" and \"variable\" fields are inherited but dynamically prohibited because\r\n// they are provided by LrMutation. It's a bit unclean but avoids a lot of typing work.\r\nexport interface LrApolloMutationOptions<T, TVariables = OperationVariables>\r\n  extends MutationOptions<T, TVariables> {\r\n  mutation: TypedDocumentNode<T>;\r\n  includeKeyGraph?: boolean;\r\n  processorOptions?: ProcessorOptions;\r\n}\r\n\r\ninterface LrGraphQLServiceStats {\r\n  queryCount: number;\r\n  mutationCount: number;\r\n}\r\n\r\n@RunOutsideAngular({\r\n  ngZoneName: 'ngZone',\r\n})\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class LrGraphQLService {\r\n  private stats: LrGraphQLServiceStats = {\r\n    queryCount: 0,\r\n    mutationCount: 0,\r\n  };\r\n\r\n  constructor(\r\n    private ngZone: NgZone,\r\n    private apollo: Apollo,\r\n    private keyGraph: KeyGraphService,\r\n    private queryProcessor: QueryProcessorService\r\n  ) {}\r\n\r\n  async query<T, V = { [key: string]: any }>(\r\n    options: LrQueryOptions<T, V>\r\n  ): Promise<T> {\r\n    // Make copies to avoid side effect.\r\n    options = lodash.cloneDeep(options);\r\n\r\n    // Append the key graph query\r\n    const includeKeyGraph = this.isIncludeKeyGraph(options.includeKeyGraph);\r\n    if (includeKeyGraph) {\r\n      const operation = getQuery(options.query);\r\n      operation.selectionSet.selections = [\r\n        ...operation.selectionSet.selections,\r\n        keyGraphFieldAstSelection,\r\n      ];\r\n    }\r\n\r\n    const response = await this.apollo.query<T, V>(options).toPromise();\r\n\r\n    this.stats.queryCount++;\r\n\r\n    handleApolloError(response.errors);\r\n\r\n    this.addKeys(response);\r\n\r\n    const data = await this.queryProcessor.processQuery(\r\n      response.data,\r\n      options.processorOptions\r\n    );\r\n\r\n    return data;\r\n  }\r\n\r\n  private async lrMutateImpl(lrMutation, options?) {\r\n    if (options?.variables) {\r\n      throw new LrUnsupportedException(\r\n        'Unsupported field: \"options.variables\"'\r\n      );\r\n    }\r\n\r\n    if (lrMutation.executed) {\r\n      throw new LrBadStateException(\r\n        'LrMutation has already executed. LrMutation can only be used once in a lrMutate() call. Create new instances of LrMutation.'\r\n      );\r\n    }\r\n\r\n    lrMutation.setExecuted();\r\n\r\n    return this.apolloMutate({\r\n      ...options,\r\n      ...lrMutation.lrMutationData,\r\n    })\r\n      .then((res) => {\r\n        // Resolve promises set on the lrMutation rather than the lrMutate() call.\r\n        lrMutation.resolve(res);\r\n        // Still need to return value to the promise waiting for the results of lrMutate().\r\n        return res;\r\n      })\r\n      .catch((error) => {\r\n        lrMutation.reject(error);\r\n        throw error;\r\n      });\r\n  }\r\n\r\n  async apolloMutate<T extends any, TVariables = { [key: string]: any }>(\r\n    options: LrApolloMutationOptions<T, TVariables>\r\n  ): Promise<T> {\r\n    // Make copies to avoid side effect.\r\n    options = {\r\n      ...options,\r\n      mutation: lodash.cloneDeep(options.mutation),\r\n    };\r\n\r\n    // Append the key graph query\r\n    const includeKeyGraph = this.isIncludeKeyGraph(options.includeKeyGraph);\r\n\r\n    if (includeKeyGraph) {\r\n      const operation = getMutation(options.mutation);\r\n      operation.selectionSet.selections = [\r\n        ...operation.selectionSet.selections,\r\n        fetchKeyGraphFieldAstSelection,\r\n      ];\r\n    }\r\n\r\n    // Format to string and parse again. This allows the \"loc\": { \"start\": ... }\r\n    // part of the DocumentNode to be correctly setup. It's extra processing\r\n    // in serialising and parsing, but probably minimal overhead.\r\n    options.mutation = gql(gqlPrinter.print(options.mutation));\r\n\r\n    const response = await this.apollo.mutate<T>(options).toPromise();\r\n\r\n    this.stats.mutationCount++;\r\n\r\n    handleApolloError(response.errors);\r\n\r\n    this.addKeys(response);\r\n\r\n    const data = await this.queryProcessor.processQuery(\r\n      response.data,\r\n      options.processorOptions\r\n    );\r\n\r\n    return data;\r\n  }\r\n\r\n  statsSnapshot(): LrGraphQLServiceStats {\r\n    return lodash.cloneDeep(this.stats);\r\n  }\r\n\r\n  private addKeys(response) {\r\n    if ((response.data as HasKeyGraph).keyGraph) {\r\n      this.keyGraph.addKeys((response.data as HasKeyGraph).keyGraph);\r\n      delete response.data.keyGraph;\r\n    }\r\n  }\r\n\r\n  private isIncludeKeyGraph(includeKeyGraph) {\r\n    // Default to true when null or undefined.\r\n    return includeKeyGraph == null ? true : false;\r\n  }\r\n\r\n  async lrMutate<T1, TVariables1, T2, TVariables2>(\r\n    lrMutations: [\r\n      LrMutationMayAsync<T1, TVariables1>,\r\n      LrMutationMayAsync<T2, TVariables2>\r\n    ],\r\n    options?: LrMutationOptions\r\n  ): Promise<[T1, T2]>;\r\n\r\n  async lrMutate<T1, TVariables1, T2, TVariables2, T3, TVariables3>(\r\n    lrMutations: [\r\n      LrMutationMayAsync<T1, TVariables1>,\r\n      LrMutationMayAsync<T2, TVariables2>,\r\n      LrMutationMayAsync<T3, TVariables3>\r\n    ],\r\n    options?: LrMutationOptions\r\n  ): Promise<[T1, T2, T3]>;\r\n\r\n  async lrMutate<\r\n    T1,\r\n    TVariables1,\r\n    T2,\r\n    TVariables2,\r\n    T3,\r\n    TVariables3,\r\n    T4,\r\n    TVariables4\r\n  >(\r\n    lrMutations: [\r\n      LrMutationMayAsync<T1, TVariables1>,\r\n      LrMutationMayAsync<T2, TVariables2>,\r\n      LrMutationMayAsync<T3, TVariables3>,\r\n      LrMutationMayAsync<T4, TVariables4>\r\n    ],\r\n    options?: LrMutationOptions\r\n  ): Promise<[T1, T2, T3, T4]>;\r\n\r\n  async lrMutate<\r\n    T1,\r\n    TVariables1,\r\n    T2,\r\n    TVariables2,\r\n    T3,\r\n    TVariables3,\r\n    T4,\r\n    TVariables4,\r\n    T5,\r\n    TVariables5\r\n  >(\r\n    lrMutations: [\r\n      LrMutationMayAsync<T1, TVariables1>,\r\n      LrMutationMayAsync<T2, TVariables2>,\r\n      LrMutationMayAsync<T3, TVariables3>,\r\n      LrMutationMayAsync<T4, TVariables4>,\r\n      LrMutationMayAsync<T5, TVariables5>\r\n    ],\r\n    options?: LrMutationOptions\r\n  ): Promise<[T1, T2, T3, T4, T5]>;\r\n\r\n  async lrMutate<T, TVariables = { [key: string]: any }>(\r\n    lrMutation: LrMutationMayAsync<T, TVariables>,\r\n    options?: LrMutationOptions<T, TVariables>\r\n  ): Promise<T>;\r\n\r\n  async lrMutate<T, TVariables = { [key: string]: any }>(\r\n    lrMutations:\r\n      | LrMutationMayAsync<T, TVariables>[]\r\n      | LrMutationMayAsync<T, TVariables>,\r\n    options?: LrMutationOptions\r\n  );\r\n\r\n  async lrMutate<T, TVariables = { [key: string]: any }>(\r\n    lrMutations:\r\n      | LrMutationMayAsync<T, TVariables>[]\r\n      | LrMutationMayAsync<T, TVariables>,\r\n    options?: LrMutationOptions\r\n  ) {\r\n    if (lrMutations instanceof Array) {\r\n      const merged = LrMergedMutation.create(await Promise.all(lrMutations));\r\n      await this.lrMutateImpl(merged, options);\r\n      return merged.promise;\r\n    } else {\r\n      const resolved = await lrMutations;\r\n      await this.lrMutateImpl(resolved, options);\r\n      return resolved.promise;\r\n    }\r\n  }\r\n}\r\n\r\ntype LrMutationMayAsync<T, TVariables> =\r\n  | LrMutationBase<T, TVariables>\r\n  | Promise<LrMutationBase<T, TVariables>>\r\n  | LrMergedMutation<T>\r\n  | Promise<LrMergedMutation<T>>;\r\n"]}

package/esm2015/lib/api/lr-graphql/lr-merged-mutation.js

@@ -0,0 +1,213 @@
+import { LrBadLogicException, LrUnsupportedException, } from '../../_common/exceptions';
+import { LrMutation } from './lr-mutation';
+import { LrMutationBase } from './lr-mutation-base';
+import { getAliasOrName, getFragments, getMutation } from '../../_common/ast';
+import * as ast from '../../_common/ast';
+import * as lodash from 'lodash';
+const lrMergedMutationDoc = {
+    kind: 'Document',
+    definitions: [
+        {
+            kind: 'OperationDefinition',
+            operation: 'mutation',
+            name: {
+                kind: 'Name',
+                value: 'lrMergedMutation',
+            },
+            variableDefinitions: [],
+            directives: [],
+            selectionSet: {
+                kind: 'SelectionSet',
+                selections: [],
+            },
+        },
+    ],
+};
+export class LrMergedMutation extends LrMutationBase {
+    constructor(lrMutations) {
+        super();
+        this.lrMutations = lrMutations;
+        const { mutation, variables, prefixes } = this.merge();
+        this.mutation = mutation;
+        this.variables = variables;
+        this.prefixes = prefixes;
+        this.descendants = this.getDescendants();
+    }
+    static create(lrMutations) {
+        return new LrMergedMutation(lrMutations);
+    }
+    getDescendants() {
+        const ret = new Set();
+        const addOrThrow = (item) => {
+            if (ret.has(item)) {
+                throw new LrBadLogicException('Classes that are derived from LrMutationBase can not be used more than once in a merged mutation.');
+            }
+            ret.add(item);
+        };
+        this.lrMutations.forEach((lrMutation) => {
+            if (lrMutation instanceof LrMutation) {
+                addOrThrow(lrMutation);
+            }
+            else if (lrMutation instanceof LrMergedMutation) {
+                lrMutation.descendants.forEach((t) => addOrThrow(t));
+            }
+            else {
+                throw new LrUnsupportedException(`LrMergeMutation can not handle class: ${lrMutation.constructor.name}`);
+            }
+        });
+        return ret;
+    }
+    resolve(value) {
+        // Resolves any promises waiting for the child mutations
+        for (let i = 0; i < this.lrMutations.length; ++i) {
+            const prefix = this.prefixes[i];
+            // Remove the prefix and resolve child mutation.
+            const res = {};
+            for (const key2 in value) {
+                if (key2.startsWith(prefix)) {
+                    const originalKey = key2.slice(prefix.length);
+                    res[originalKey] = value[key2];
+                }
+            }
+            this.lrMutations[i].resolve(res);
+        }
+        // Resolves to the result of children
+        Promise.all(this.lrMutations.map((m) => m.promise)).then((childValues) => {
+            // Resolves any promises waiting for the current merged mutation
+            super.resolve(childValues);
+        });
+    }
+    reject(reason) {
+        super.reject(reason);
+        this.lrMutations.forEach((lrMutation) => lrMutation.reject(reason));
+    }
+    setExecuted() {
+        super.setExecuted();
+        this.lrMutations.forEach((lrMutation) => lrMutation.setExecuted());
+    }
+    renameVariableDefinition(varDef, prefix) {
+        return Object.assign(Object.assign({}, varDef), { variable: Object.assign(Object.assign({}, varDef.variable), { name: ast.name(prefix + varDef.variable.name.value) }) });
+    }
+    renameVariableDefinitions(varDefs, prefix) {
+        return varDefs.map((varDef) => this.renameVariableDefinition(varDef, prefix));
+    }
+    renameArgument(arg, prefix) {
+        if (arg.value.kind !== 'Variable') {
+            return arg;
+        }
+        return Object.assign(Object.assign({}, arg), { value: Object.assign(Object.assign({}, arg.value), { name: ast.name(prefix + arg.value.name.value) }) });
+    }
+    renameField(selection, prefix) {
+        // Only handling type Field
+        if (selection.kind !== 'Field') {
+            return selection;
+        }
+        const alias = prefix + getAliasOrName(selection);
+        const args = selection.arguments.map((arg) => this.renameArgument(arg, prefix));
+        return Object.assign(Object.assign({}, selection), { alias: {
+                kind: 'Name',
+                value: alias,
+            }, arguments: args });
+    }
+    renameFragmentSpread(selection, prefix) {
+        return Object.assign(Object.assign({}, selection), { name: ast.name(prefix + selection.name.value) });
+    }
+    processSelection(selection, prefix) {
+        switch (selection.kind) {
+            case 'FragmentSpread':
+                return this.renameFragmentSpread(selection, prefix);
+            case 'Field':
+                // Continue to process children for nested selections.
+                if (selection.selectionSet) {
+                    return Object.assign(Object.assign({}, selection), { selectionSet: this.processSelectionSet(selection.selectionSet, prefix) });
+                }
+                else {
+                    return selection;
+                }
+            default:
+                return selection;
+        }
+    }
+    processSelectionSet(selectionSet, prefix) {
+        return Object.assign(Object.assign({}, selectionSet), { selections: selectionSet.selections.map((selection) => this.processSelection(selection, prefix)) });
+    }
+    renameSelections(selections, prefix) {
+        return selections.map((selection) => {
+            switch (selection.kind) {
+                case 'Field':
+                    const field = this.renameField(selection, prefix);
+                    return this.processSelection(field, prefix);
+                default:
+                    return selection;
+            }
+        });
+    }
+    renameFragmentDefinition(fragment, prefix) {
+        const ret = Object.assign(Object.assign({}, fragment), { name: ast.name(prefix + fragment.name.value) });
+        if (fragment.selectionSet) {
+            ret.selectionSet = this.processSelectionSet(fragment.selectionSet, prefix);
+        }
+        return ret;
+    }
+    renameFragmentDefinitions(fragments, prefix) {
+        return fragments.map((fragment) => this.renameFragmentDefinition(fragment, prefix));
+    }
+    merge() {
+        let variableDefinitions = [];
+        let selections = [];
+        const mergedVariables = {};
+        let mergedFragments = [];
+        const prefixes = [];
+        // Just wait for everything to resolve because we have to
+        // merge the doc synchronously.
+        this.lrMutations.forEach((lrMutation, idx) => {
+            const { mutation, variables } = lrMutation.lrMutationData;
+            const childMutationNode = getMutation(mutation);
+            // Prefixing all mutation fields so they don't conflict.
+            let prefix = `item${idx}_`;
+            if (childMutationNode.name) {
+                prefix += childMutationNode.name.value + '_';
+            }
+            prefixes.push(prefix);
+            // Rename and merge variables
+            variableDefinitions = [
+                ...variableDefinitions,
+                ...this.renameVariableDefinitions(childMutationNode.variableDefinitions, prefix),
+            ];
+            // Rename and merge selections
+            selections = [
+                ...selections,
+                ...this.renameSelections(childMutationNode.selectionSet.selections, prefix),
+            ];
+            // TODO Rename and merge fragments
+            // Rename and merge variables
+            for (const key2 of Object.keys(variables)) {
+                mergedVariables[prefix + key2] = variables[key2];
+            }
+            // Rename and merge fragments
+            const fragments = getFragments(mutation);
+            mergedFragments = [
+                ...mergedFragments,
+                ...this.renameFragmentDefinitions(fragments, prefix),
+            ];
+        });
+        const mergedMutation = lodash.cloneDeep(lrMergedMutationDoc);
+        const mutationNode = getMutation(mergedMutation);
+        // Add in the mutation selections
+        mutationNode.selectionSet.selections = selections;
+        // Add in the variables
+        // variableDefinitions is readonly property.
+        mutationNode.variableDefinitions = variableDefinitions;
+        // Add in the fragments
+        mergedMutation.definitions = [
+            ...mergedMutation.definitions,
+            ...mergedFragments,
+        ];
+        return {
+            mutation: mergedMutation,
+            variables: mergedVariables,
+            prefixes,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lr-merged-mutation.js","sourceRoot":"C:/Projects/newrepo/kc-client/projects/core/src/","sources":["lib/api/lr-graphql/lr-merged-mutation.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  ArgumentNode,\r\n  DocumentNode,\r\n  FieldNode,\r\n  FragmentDefinitionNode,\r\n  FragmentSpreadNode,\r\n  SelectionNode,\r\n  SelectionSetNode,\r\n  VariableDefinitionNode,\r\n} from 'graphql';\r\nimport {\r\n  LrBadArgumentException,\r\n  LrBadLogicException,\r\n  LrUnsupportedException,\r\n} from '../../_common/exceptions';\r\nimport { LrMutation } from './lr-mutation';\r\nimport { LrMutationBase } from './lr-mutation-base';\r\nimport { getAliasOrName, getFragments, getMutation } from '../../_common/ast';\r\nimport * as ast from '../../_common/ast';\r\nimport * as lodash from 'lodash';\r\n\r\nconst lrMergedMutationDoc: DocumentNode = {\r\n  kind: 'Document',\r\n  definitions: [\r\n    {\r\n      kind: 'OperationDefinition',\r\n      operation: 'mutation',\r\n      name: {\r\n        kind: 'Name',\r\n        value: 'lrMergedMutation',\r\n      },\r\n      variableDefinitions: [],\r\n      directives: [],\r\n      selectionSet: {\r\n        kind: 'SelectionSet',\r\n        selections: [],\r\n      },\r\n    },\r\n  ],\r\n  // TODO What to do about these? Serialise and reparse?\r\n  // \"loc\": {\r\n  //   \"start\": 0,\r\n  //   \"end\": 204\r\n  // }\r\n};\r\n\r\nexport class LrMergedMutation<T> extends LrMutationBase<T> {\r\n  public readonly descendants: Set<LrMutationBase<any>>;\r\n  protected prefixes: string[];\r\n\r\n  constructor(public readonly lrMutations: LrMutationBase<any>[]) {\r\n    super();\r\n\r\n    const { mutation, variables, prefixes } = this.merge();\r\n    this.mutation = mutation;\r\n    this.variables = variables;\r\n    this.prefixes = prefixes;\r\n    this.descendants = this.getDescendants();\r\n  }\r\n\r\n  static create<T1, T2>(\r\n    lrMutations: [\r\n      LrMutationBase<T1> | LrMergedMutation<T1>,\r\n      LrMutationBase<T2> | LrMergedMutation<T2>\r\n    ]\r\n  ): LrMergedMutation<[T1, T2]>;\r\n\r\n  static create<T1, T2, T3>(\r\n    lrMutations: [\r\n      LrMutationBase<T1> | LrMergedMutation<T1>,\r\n      LrMutationBase<T2> | LrMergedMutation<T2>,\r\n      LrMutationBase<T3> | LrMergedMutation<T3>\r\n    ]\r\n  ): LrMergedMutation<[T1, T2, T3]>;\r\n\r\n  static create<T1, T2, T3, T4>(\r\n    lrMutations: [\r\n      LrMutationBase<T1> | LrMergedMutation<T1>,\r\n      LrMutationBase<T2> | LrMergedMutation<T2>,\r\n      LrMutationBase<T3> | LrMergedMutation<T3>,\r\n      LrMutationBase<T4> | LrMergedMutation<T4>\r\n    ]\r\n  ): LrMergedMutation<[T1, T2, T3, T4]>;\r\n\r\n  static create<T1, T2, T3, T4, T5>(\r\n    lrMutations: [\r\n      LrMutationBase<T1> | LrMergedMutation<T1>,\r\n      LrMutationBase<T2> | LrMergedMutation<T2>,\r\n      LrMutationBase<T3> | LrMergedMutation<T3>,\r\n      LrMutationBase<T4> | LrMergedMutation<T4>,\r\n      LrMutationBase<T5> | LrMergedMutation<T5>\r\n    ]\r\n  ): LrMergedMutation<[T1, T2, T3, T4, T5]>;\r\n\r\n  static create(lrMutations: LrMutationBase<any>[]): LrMergedMutation<any[]>;\r\n\r\n  static create(lrMutations: LrMutationBase<any>[]) {\r\n    return new LrMergedMutation(lrMutations);\r\n  }\r\n\r\n  private getDescendants() {\r\n    const ret = new Set<LrMutationBase<any>>();\r\n\r\n    const addOrThrow = (item) => {\r\n      if (ret.has(item)) {\r\n        throw new LrBadLogicException(\r\n          'Classes that are derived from LrMutationBase can not be used more than once in a merged mutation.'\r\n        );\r\n      }\r\n\r\n      ret.add(item);\r\n    };\r\n\r\n    this.lrMutations.forEach((lrMutation) => {\r\n      if (lrMutation instanceof LrMutation) {\r\n        addOrThrow(lrMutation);\r\n      } else if (lrMutation instanceof LrMergedMutation) {\r\n        lrMutation.descendants.forEach((t) => addOrThrow(t));\r\n      } else {\r\n        throw new LrUnsupportedException(\r\n          `LrMergeMutation can not handle class: ${lrMutation.constructor.name}`\r\n        );\r\n      }\r\n    });\r\n\r\n    return ret;\r\n  }\r\n\r\n  resolve(value: any) {\r\n    // Resolves any promises waiting for the child mutations\r\n    for (let i = 0; i < this.lrMutations.length; ++i) {\r\n      const prefix = this.prefixes[i];\r\n\r\n      // Remove the prefix and resolve child mutation.\r\n      const res: any = {};\r\n      for (const key2 in value) {\r\n        if (key2.startsWith(prefix)) {\r\n          const originalKey = key2.slice(prefix.length);\r\n          res[originalKey] = value[key2];\r\n        }\r\n      }\r\n      this.lrMutations[i].resolve(res);\r\n    }\r\n\r\n    // Resolves to the result of children\r\n    Promise.all(this.lrMutations.map((m) => m.promise)).then(\r\n      (childValues: any) => {\r\n        // Resolves any promises waiting for the current merged mutation\r\n        super.resolve(childValues);\r\n      }\r\n    );\r\n  }\r\n\r\n  reject(reason?: any) {\r\n    super.reject(reason);\r\n    this.lrMutations.forEach((lrMutation) => lrMutation.reject(reason));\r\n  }\r\n\r\n  setExecuted() {\r\n    super.setExecuted();\r\n    this.lrMutations.forEach((lrMutation) => lrMutation.setExecuted());\r\n  }\r\n\r\n  private renameVariableDefinition(varDef: VariableDefinitionNode, prefix) {\r\n    return {\r\n      ...varDef,\r\n      variable: {\r\n        ...varDef.variable,\r\n        name: ast.name(prefix + varDef.variable.name.value),\r\n      },\r\n    };\r\n  }\r\n\r\n  private renameVariableDefinitions(\r\n    varDefs: ReadonlyArray<VariableDefinitionNode>,\r\n    prefix\r\n  ) {\r\n    return varDefs.map((varDef) =>\r\n      this.renameVariableDefinition(varDef, prefix)\r\n    );\r\n  }\r\n\r\n  private renameArgument(arg: ArgumentNode, prefix) {\r\n    if (arg.value.kind !== 'Variable') {\r\n      return arg;\r\n    }\r\n\r\n    return {\r\n      ...arg,\r\n      value: {\r\n        ...arg.value,\r\n        name: ast.name(prefix + arg.value.name.value),\r\n      },\r\n    };\r\n  }\r\n\r\n  private renameField(selection: FieldNode, prefix): FieldNode {\r\n    // Only handling type Field\r\n    if (selection.kind !== 'Field') {\r\n      return selection;\r\n    }\r\n\r\n    const alias = prefix + getAliasOrName(selection);\r\n    const args = selection.arguments.map((arg) =>\r\n      this.renameArgument(arg, prefix)\r\n    );\r\n\r\n    return {\r\n      ...selection,\r\n      alias: {\r\n        kind: 'Name',\r\n        value: alias,\r\n      },\r\n      arguments: args,\r\n    };\r\n  }\r\n\r\n  private renameFragmentSpread(\r\n    selection: FragmentSpreadNode,\r\n    prefix\r\n  ): FragmentSpreadNode {\r\n    return {\r\n      ...selection,\r\n      name: ast.name(prefix + selection.name.value),\r\n    };\r\n  }\r\n\r\n  private processSelection(selection: SelectionNode, prefix): SelectionNode {\r\n    switch (selection.kind) {\r\n      case 'FragmentSpread':\r\n        return this.renameFragmentSpread(selection, prefix);\r\n      case 'Field':\r\n        // Continue to process children for nested selections.\r\n        if (selection.selectionSet) {\r\n          return {\r\n            ...selection,\r\n            selectionSet: this.processSelectionSet(\r\n              selection.selectionSet,\r\n              prefix\r\n            ),\r\n          };\r\n        } else {\r\n          return selection;\r\n        }\r\n      default:\r\n        return selection;\r\n    }\r\n  }\r\n\r\n  private processSelectionSet(\r\n    selectionSet: SelectionSetNode,\r\n    prefix\r\n  ): SelectionSetNode {\r\n    return {\r\n      ...selectionSet,\r\n      selections: selectionSet.selections.map((selection) =>\r\n        this.processSelection(selection, prefix)\r\n      ),\r\n    };\r\n  }\r\n\r\n  private renameSelections(\r\n    selections: ReadonlyArray<SelectionNode>,\r\n    prefix\r\n  ): SelectionNode[] {\r\n    return selections.map((selection) => {\r\n      switch (selection.kind) {\r\n        case 'Field':\r\n          const field = this.renameField(selection, prefix);\r\n          return this.processSelection(field, prefix);\r\n        default:\r\n          return selection;\r\n      }\r\n    });\r\n  }\r\n\r\n  private renameFragmentDefinition(fragment: FragmentDefinitionNode, prefix) {\r\n    const ret = {\r\n      ...fragment,\r\n      name: ast.name(prefix + fragment.name.value),\r\n    };\r\n\r\n    if (fragment.selectionSet) {\r\n      ret.selectionSet = this.processSelectionSet(\r\n        fragment.selectionSet,\r\n        prefix\r\n      );\r\n    }\r\n\r\n    return ret;\r\n  }\r\n\r\n  private renameFragmentDefinitions(\r\n    fragments: FragmentDefinitionNode[],\r\n    prefix\r\n  ) {\r\n    return fragments.map((fragment) =>\r\n      this.renameFragmentDefinition(fragment, prefix)\r\n    );\r\n  }\r\n\r\n  private merge() {\r\n    let variableDefinitions: VariableDefinitionNode[] = [];\r\n    let selections: SelectionNode[] = [];\r\n    const mergedVariables = {};\r\n    let mergedFragments: FragmentDefinitionNode[] = [];\r\n\r\n    const prefixes: string[] = [];\r\n\r\n    // Just wait for everything to resolve because we have to\r\n    // merge the doc synchronously.\r\n    this.lrMutations.forEach((lrMutation, idx) => {\r\n      const { mutation, variables } = lrMutation.lrMutationData;\r\n\r\n      const childMutationNode = getMutation(mutation);\r\n\r\n      // Prefixing all mutation fields so they don't conflict.\r\n      let prefix = `item${idx}_`;\r\n      if (childMutationNode.name) {\r\n        prefix += childMutationNode.name.value + '_';\r\n      }\r\n\r\n      prefixes.push(prefix);\r\n\r\n      // Rename and merge variables\r\n      variableDefinitions = [\r\n        ...variableDefinitions,\r\n        ...this.renameVariableDefinitions(\r\n          childMutationNode.variableDefinitions,\r\n          prefix\r\n        ),\r\n      ];\r\n\r\n      // Rename and merge selections\r\n      selections = [\r\n        ...selections,\r\n        ...this.renameSelections(\r\n          childMutationNode.selectionSet.selections,\r\n          prefix\r\n        ),\r\n      ];\r\n\r\n      // TODO Rename and merge fragments\r\n\r\n      // Rename and merge variables\r\n      for (const key2 of Object.keys(variables)) {\r\n        mergedVariables[prefix + key2] = variables[key2];\r\n      }\r\n\r\n      // Rename and merge fragments\r\n      const fragments = getFragments(mutation);\r\n      mergedFragments = [\r\n        ...mergedFragments,\r\n        ...this.renameFragmentDefinitions(fragments, prefix),\r\n      ];\r\n    });\r\n\r\n    const mergedMutation: DocumentNode = lodash.cloneDeep(lrMergedMutationDoc);\r\n    const mutationNode = getMutation(mergedMutation);\r\n    // Add in the mutation selections\r\n    mutationNode.selectionSet.selections = selections;\r\n    // Add in the variables\r\n    // variableDefinitions is readonly property.\r\n    (mutationNode as any).variableDefinitions = variableDefinitions;\r\n    // Add in the fragments\r\n    (mergedMutation as any).definitions = [\r\n      ...mergedMutation.definitions,\r\n      ...mergedFragments,\r\n    ];\r\n\r\n    return {\r\n      mutation: mergedMutation,\r\n      variables: mergedVariables,\r\n      prefixes,\r\n    };\r\n  }\r\n}\r\n"]}