@lifeready/core 1.0.1 → 1.0.2

package/src/lib/api/lr-apollo.service.ts

@@ -1,43 +0,0 @@
-import { Injectable } from '@angular/core';
-import { Apollo } from 'apollo-angular';
-import { QueryOptions, MutationOptions } from '@apollo/client/core';
-import { KeyGraphService } from '../cryptography/key-graph.service';
-import { HasKeyGraph } from '../cryptography/cryptography.types';
-import { handleApolloError } from '../_common/exceptions';
-
-@Injectable({
-  providedIn: 'root',
-})
-export class LrApolloService {
-  constructor(private apollo: Apollo, private keyGraph: KeyGraphService) {}
-
-  private addKeys(response) {
-    if ((response.data as HasKeyGraph).keyGraph) {
-      this.keyGraph.addKeys((response.data as HasKeyGraph).keyGraph);
-    }
-  }
-
-  async query<T, V = { [key: string]: any }>(
-    options: QueryOptions<V>
-  ): Promise<T> {
-    const response = await this.apollo.query<T, V>(options).toPromise();
-
-    handleApolloError(response.errors);
-
-    this.addKeys(response);
-
-    return response.data;
-  }
-
-  async mutate<T extends any, V = { [key: string]: any }>(
-    options: MutationOptions<T, V>
-  ): Promise<T> {
-    const response = await this.apollo.mutate<T>(options).toPromise();
-
-    handleApolloError(response.errors);
-
-    this.addKeys(response);
-
-    return response.data;
-  }
-}

package/src/lib/api/lr-graphql/lr-graphql.service.ts

@@ -1,313 +0,0 @@
-import * as lodash from 'lodash';
-import { Injectable, NgZone } from '@angular/core';
-import { Apollo } from 'apollo-angular';
-import {
-  QueryOptions,
-  MutationOptions,
-  OperationVariables,
-  FetchPolicy,
-} from '@apollo/client/core';
-import { MutationBaseOptions } from '@apollo/client/core/watchQueryOptions';
-import { KeyGraphService } from '../../cryptography/key-graph.service';
-import { HasKeyGraph } from '../../cryptography/cryptography.types';
-import {
-  handleApolloError,
-  LrBadStateException,
-  LrUnsupportedException,
-} from '../../_common/exceptions';
-import { FetchKeyGraphField, KeyGraphField } from '../../_common/queries.gql';
-import { TypedDocumentNode, getQuery, getMutation } from '../../_common/ast';
-import gql from 'graphql-tag';
-import { ProcessorOptions, QueryProcessorService } from '../query-processor';
-import { RunOutsideAngular } from '../../_common/run-outside-angular';
-import { FieldNode } from 'graphql';
-import { LrMutationBase } from './lr-mutation-base';
-import * as gqlPrinter from 'graphql/language/printer';
-import { LrMergedMutation } from './lr-merged-mutation';
-
-// Data structures
-// --------------------------------------------------------------------------
-const keyGraphFieldAstSelection = getQuery(gql`
-query {
-  ${KeyGraphField}
-}
-`).selectionSet.selections[0] as FieldNode;
-
-const fetchKeyGraphFieldAstSelection = getQuery(gql`
-query {
-  ${FetchKeyGraphField}
-}
-`).selectionSet.selections[0] as FieldNode;
-
-// const keyGraphFieldAstSelection = () =>
-//   lodash.deepClone(_keyGraphFieldAstSelection) as FieldNode;
-// const fetchKeyGraphFieldAstSelection = () =>
-//   lodash.deepClone(_fetchKeyGraphFieldAstSelection) as FieldNode;
-
-export interface LrQueryOptions<T, TVariables>
-  extends QueryOptions<TVariables> {
-  query: TypedDocumentNode<T>;
-  includeKeyGraph?: boolean;
-  processorOptions?: ProcessorOptions;
-}
-
-// Copied from MutationOptions
-// Removed required field "mutation". The "variables" field is still there
-// but it's dynamically checked.
-export interface LrMutationOptions<
-  T = {
-    [key: string]: any;
-  },
-  TVariables = OperationVariables
-> extends MutationBaseOptions<T, TVariables> {
-  context?: any;
-  fetchPolicy?: FetchPolicy;
-  includeKeyGraph?: boolean;
-}
-
-// The "mutation" and "variable" fields are inherited but dynamically prohibited because
-// they are provided by LrMutation. It's a bit unclean but avoids a lot of typing work.
-export interface LrApolloMutationOptions<T, TVariables = OperationVariables>
-  extends MutationOptions<T, TVariables> {
-  mutation: TypedDocumentNode<T>;
-  includeKeyGraph?: boolean;
-  processorOptions?: ProcessorOptions;
-}
-
-interface LrGraphQLServiceStats {
-  queryCount: number;
-  mutationCount: number;
-}
-
-@RunOutsideAngular({
-  ngZoneName: 'ngZone',
-})
-@Injectable({
-  providedIn: 'root',
-})
-export class LrGraphQLService {
-  private stats: LrGraphQLServiceStats = {
-    queryCount: 0,
-    mutationCount: 0,
-  };
-
-  constructor(
-    private ngZone: NgZone,
-    private apollo: Apollo,
-    private keyGraph: KeyGraphService,
-    private queryProcessor: QueryProcessorService
-  ) {}
-
-  async query<T, V = { [key: string]: any }>(
-    options: LrQueryOptions<T, V>
-  ): Promise<T> {
-    // 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 = await this.apollo.query<T, V>(options).toPromise();
-
-    this.stats.queryCount++;
-
-    handleApolloError(response.errors);
-
-    this.addKeys(response);
-
-    const data = await this.queryProcessor.processQuery(
-      response.data,
-      options.processorOptions
-    );
-
-    return data;
-  }
-
-  private async lrMutateImpl(lrMutation, options?) {
-    if (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({
-      ...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;
-      });
-  }
-
-  async apolloMutate<T extends any, TVariables = { [key: string]: any }>(
-    options: LrApolloMutationOptions<T, TVariables>
-  ): Promise<T> {
-    // Make copies to avoid side effect.
-    options = {
-      ...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 = await this.apollo.mutate<T>(options).toPromise();
-
-    this.stats.mutationCount++;
-
-    handleApolloError(response.errors);
-
-    this.addKeys(response);
-
-    const data = await this.queryProcessor.processQuery(
-      response.data,
-      options.processorOptions
-    );
-
-    return data;
-  }
-
-  statsSnapshot(): LrGraphQLServiceStats {
-    return lodash.cloneDeep(this.stats);
-  }
-
-  private addKeys(response) {
-    if ((response.data as HasKeyGraph).keyGraph) {
-      this.keyGraph.addKeys((response.data as HasKeyGraph).keyGraph);
-      delete response.data.keyGraph;
-    }
-  }
-
-  private isIncludeKeyGraph(includeKeyGraph) {
-    // Default to true when null or undefined.
-    return includeKeyGraph == null ? true : false;
-  }
-
-  async lrMutate<T1, TVariables1, T2, TVariables2>(
-    lrMutations: [
-      LrMutationMayAsync<T1, TVariables1>,
-      LrMutationMayAsync<T2, TVariables2>
-    ],
-    options?: LrMutationOptions
-  ): Promise<[T1, T2]>;
-
-  async lrMutate<T1, TVariables1, T2, TVariables2, T3, TVariables3>(
-    lrMutations: [
-      LrMutationMayAsync<T1, TVariables1>,
-      LrMutationMayAsync<T2, TVariables2>,
-      LrMutationMayAsync<T3, TVariables3>
-    ],
-    options?: LrMutationOptions
-  ): Promise<[T1, T2, T3]>;
-
-  async lrMutate<
-    T1,
-    TVariables1,
-    T2,
-    TVariables2,
-    T3,
-    TVariables3,
-    T4,
-    TVariables4
-  >(
-    lrMutations: [
-      LrMutationMayAsync<T1, TVariables1>,
-      LrMutationMayAsync<T2, TVariables2>,
-      LrMutationMayAsync<T3, TVariables3>,
-      LrMutationMayAsync<T4, TVariables4>
-    ],
-    options?: LrMutationOptions
-  ): Promise<[T1, T2, T3, T4]>;
-
-  async lrMutate<
-    T1,
-    TVariables1,
-    T2,
-    TVariables2,
-    T3,
-    TVariables3,
-    T4,
-    TVariables4,
-    T5,
-    TVariables5
-  >(
-    lrMutations: [
-      LrMutationMayAsync<T1, TVariables1>,
-      LrMutationMayAsync<T2, TVariables2>,
-      LrMutationMayAsync<T3, TVariables3>,
-      LrMutationMayAsync<T4, TVariables4>,
-      LrMutationMayAsync<T5, TVariables5>
-    ],
-    options?: LrMutationOptions
-  ): Promise<[T1, T2, T3, T4, T5]>;
-
-  async lrMutate<T, TVariables = { [key: string]: any }>(
-    lrMutation: LrMutationMayAsync<T, TVariables>,
-    options?: LrMutationOptions<T, TVariables>
-  ): Promise<T>;
-
-  async lrMutate<T, TVariables = { [key: string]: any }>(
-    lrMutations:
-      | LrMutationMayAsync<T, TVariables>[]
-      | LrMutationMayAsync<T, TVariables>,
-    options?: LrMutationOptions
-  );
-
-  async lrMutate<T, TVariables = { [key: string]: any }>(
-    lrMutations:
-      | LrMutationMayAsync<T, TVariables>[]
-      | LrMutationMayAsync<T, TVariables>,
-    options?: LrMutationOptions
-  ) {
-    if (lrMutations instanceof Array) {
-      const merged = LrMergedMutation.create(await Promise.all(lrMutations));
-      await this.lrMutateImpl(merged, options);
-      return merged.promise;
-    } else {
-      const resolved = await lrMutations;
-      await this.lrMutateImpl(resolved, options);
-      return resolved.promise;
-    }
-  }
-}
-
-type LrMutationMayAsync<T, TVariables> =
-  | LrMutationBase<T, TVariables>
-  | Promise<LrMutationBase<T, TVariables>>
-  | LrMergedMutation<T>
-  | Promise<LrMergedMutation<T>>;