@lifeready/core 1.0.1 → 1.0.2

package/src/lib/api/lr-graphql/lr-merged-mutation.ts

@@ -1,377 +0,0 @@
-import {
-  ArgumentNode,
-  DocumentNode,
-  FieldNode,
-  FragmentDefinitionNode,
-  FragmentSpreadNode,
-  SelectionNode,
-  SelectionSetNode,
-  VariableDefinitionNode,
-} from 'graphql';
-import {
-  LrBadArgumentException,
-  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: DocumentNode = {
-  kind: 'Document',
-  definitions: [
-    {
-      kind: 'OperationDefinition',
-      operation: 'mutation',
-      name: {
-        kind: 'Name',
-        value: 'lrMergedMutation',
-      },
-      variableDefinitions: [],
-      directives: [],
-      selectionSet: {
-        kind: 'SelectionSet',
-        selections: [],
-      },
-    },
-  ],
-  // TODO What to do about these? Serialise and reparse?
-  // "loc": {
-  //   "start": 0,
-  //   "end": 204
-  // }
-};
-
-export class LrMergedMutation<T> extends LrMutationBase<T> {
-  public readonly descendants: Set<LrMutationBase<any>>;
-  protected prefixes: string[];
-
-  constructor(public readonly lrMutations: LrMutationBase<any>[]) {
-    super();
-
-    const { mutation, variables, prefixes } = this.merge();
-    this.mutation = mutation;
-    this.variables = variables;
-    this.prefixes = prefixes;
-    this.descendants = this.getDescendants();
-  }
-
-  static create<T1, T2>(
-    lrMutations: [
-      LrMutationBase<T1> | LrMergedMutation<T1>,
-      LrMutationBase<T2> | LrMergedMutation<T2>
-    ]
-  ): LrMergedMutation<[T1, T2]>;
-
-  static create<T1, T2, T3>(
-    lrMutations: [
-      LrMutationBase<T1> | LrMergedMutation<T1>,
-      LrMutationBase<T2> | LrMergedMutation<T2>,
-      LrMutationBase<T3> | LrMergedMutation<T3>
-    ]
-  ): LrMergedMutation<[T1, T2, T3]>;
-
-  static create<T1, T2, T3, T4>(
-    lrMutations: [
-      LrMutationBase<T1> | LrMergedMutation<T1>,
-      LrMutationBase<T2> | LrMergedMutation<T2>,
-      LrMutationBase<T3> | LrMergedMutation<T3>,
-      LrMutationBase<T4> | LrMergedMutation<T4>
-    ]
-  ): LrMergedMutation<[T1, T2, T3, T4]>;
-
-  static create<T1, T2, T3, T4, T5>(
-    lrMutations: [
-      LrMutationBase<T1> | LrMergedMutation<T1>,
-      LrMutationBase<T2> | LrMergedMutation<T2>,
-      LrMutationBase<T3> | LrMergedMutation<T3>,
-      LrMutationBase<T4> | LrMergedMutation<T4>,
-      LrMutationBase<T5> | LrMergedMutation<T5>
-    ]
-  ): LrMergedMutation<[T1, T2, T3, T4, T5]>;
-
-  static create(lrMutations: LrMutationBase<any>[]): LrMergedMutation<any[]>;
-
-  static create(lrMutations: LrMutationBase<any>[]) {
-    return new LrMergedMutation(lrMutations);
-  }
-
-  private getDescendants() {
-    const ret = new Set<LrMutationBase<any>>();
-
-    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: any) {
-    // 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: any = {};
-      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: any) => {
-        // Resolves any promises waiting for the current merged mutation
-        super.resolve(childValues);
-      }
-    );
-  }
-
-  reject(reason?: any) {
-    super.reject(reason);
-    this.lrMutations.forEach((lrMutation) => lrMutation.reject(reason));
-  }
-
-  setExecuted() {
-    super.setExecuted();
-    this.lrMutations.forEach((lrMutation) => lrMutation.setExecuted());
-  }
-
-  private renameVariableDefinition(varDef: VariableDefinitionNode, prefix) {
-    return {
-      ...varDef,
-      variable: {
-        ...varDef.variable,
-        name: ast.name(prefix + varDef.variable.name.value),
-      },
-    };
-  }
-
-  private renameVariableDefinitions(
-    varDefs: ReadonlyArray<VariableDefinitionNode>,
-    prefix
-  ) {
-    return varDefs.map((varDef) =>
-      this.renameVariableDefinition(varDef, prefix)
-    );
-  }
-
-  private renameArgument(arg: ArgumentNode, prefix) {
-    if (arg.value.kind !== 'Variable') {
-      return arg;
-    }
-
-    return {
-      ...arg,
-      value: {
-        ...arg.value,
-        name: ast.name(prefix + arg.value.name.value),
-      },
-    };
-  }
-
-  private renameField(selection: FieldNode, prefix): FieldNode {
-    // 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 {
-      ...selection,
-      alias: {
-        kind: 'Name',
-        value: alias,
-      },
-      arguments: args,
-    };
-  }
-
-  private renameFragmentSpread(
-    selection: FragmentSpreadNode,
-    prefix
-  ): FragmentSpreadNode {
-    return {
-      ...selection,
-      name: ast.name(prefix + selection.name.value),
-    };
-  }
-
-  private processSelection(selection: SelectionNode, prefix): SelectionNode {
-    switch (selection.kind) {
-      case 'FragmentSpread':
-        return this.renameFragmentSpread(selection, prefix);
-      case 'Field':
-        // Continue to process children for nested selections.
-        if (selection.selectionSet) {
-          return {
-            ...selection,
-            selectionSet: this.processSelectionSet(
-              selection.selectionSet,
-              prefix
-            ),
-          };
-        } else {
-          return selection;
-        }
-      default:
-        return selection;
-    }
-  }
-
-  private processSelectionSet(
-    selectionSet: SelectionSetNode,
-    prefix
-  ): SelectionSetNode {
-    return {
-      ...selectionSet,
-      selections: selectionSet.selections.map((selection) =>
-        this.processSelection(selection, prefix)
-      ),
-    };
-  }
-
-  private renameSelections(
-    selections: ReadonlyArray<SelectionNode>,
-    prefix
-  ): SelectionNode[] {
-    return selections.map((selection) => {
-      switch (selection.kind) {
-        case 'Field':
-          const field = this.renameField(selection, prefix);
-          return this.processSelection(field, prefix);
-        default:
-          return selection;
-      }
-    });
-  }
-
-  private renameFragmentDefinition(fragment: FragmentDefinitionNode, prefix) {
-    const ret = {
-      ...fragment,
-      name: ast.name(prefix + fragment.name.value),
-    };
-
-    if (fragment.selectionSet) {
-      ret.selectionSet = this.processSelectionSet(
-        fragment.selectionSet,
-        prefix
-      );
-    }
-
-    return ret;
-  }
-
-  private renameFragmentDefinitions(
-    fragments: FragmentDefinitionNode[],
-    prefix
-  ) {
-    return fragments.map((fragment) =>
-      this.renameFragmentDefinition(fragment, prefix)
-    );
-  }
-
-  private merge() {
-    let variableDefinitions: VariableDefinitionNode[] = [];
-    let selections: SelectionNode[] = [];
-    const mergedVariables = {};
-    let mergedFragments: FragmentDefinitionNode[] = [];
-
-    const prefixes: string[] = [];
-
-    // 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: DocumentNode = 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 as any).variableDefinitions = variableDefinitions;
-    // Add in the fragments
-    (mergedMutation as any).definitions = [
-      ...mergedMutation.definitions,
-      ...mergedFragments,
-    ];
-
-    return {
-      mutation: mergedMutation,
-      variables: mergedVariables,
-      prefixes,
-    };
-  }
-}

package/src/lib/api/lr-graphql/lr-mutation-base.ts

@@ -1,67 +0,0 @@
-import { OperationVariables } from '@apollo/client/core';
-import { FragmentSpreadNode } from 'graphql';
-import gql from 'graphql-tag';
-import { getQuery, TypedDocumentNode } from '../../_common/ast';
-import { DeferredPromise } from '../../_common/deferred-promise';
-import { LrBadStateException } from '../../_common/exceptions';
-
-export interface LrMutationData<T, TVariables = OperationVariables> {
-  mutation: TypedDocumentNode<T>;
-  variables?: TVariables;
-}
-
-export const fragmentSpreadAstSelection = getQuery(gql`
-  query {
-    ...FragmentName
-  }
-`).selectionSet.selections[0] as FragmentSpreadNode;
-
-// const fragmentSpreadAstSelection = () =>
-//   lodash.deepClone(_fragmentSpreadAstSelection) as FragmentSpreadNode;
-
-/**
- * DECISION: LrMutationBase does not provide a convenience method to call lrGraphQL.lrMutate()
- * because this class could be made independent of what lib is used to call the API. If we
- * provided a configurable call back to make the API call, then the typing for that callback
- * needs to be known. But since the API lib (eg. Apollo) has it's own unique return type, so
- * it's not possible to do in general.
- */
-export abstract class LrMutationBase<T, TVariables = OperationVariables> {
-  protected mutation: TypedDocumentNode<T>;
-  protected variables?: TVariables;
-  /* tslint:disable:variable-name */
-  protected _executed = false;
-
-  // protected promises: DeferredPromise<T>[] = [];
-  public readonly deferredPromise = new DeferredPromise<T>();
-
-  get promise(): Promise<T> {
-    return this.deferredPromise.promise;
-  }
-
-  resolve(value: T) {
-    this.deferredPromise.resolve(value);
-  }
-
-  reject(reason?: any) {
-    this.deferredPromise.reject(reason);
-  }
-
-  get lrMutationData(): LrMutationData<T, TVariables> {
-    return {
-      mutation: this.mutation,
-      variables: this.variables,
-    };
-  }
-
-  get executed() {
-    return this._executed;
-  }
-
-  setExecuted() {
-    if (this._executed) {
-      throw new LrBadStateException('Already executed');
-    }
-    this._executed = true;
-  }
-}

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

@@ -1,74 +0,0 @@
-import * as lodash from 'lodash';
-import { OperationVariables } from '@apollo/client/core';
-import { DocumentNode, FieldNode, FragmentDefinitionNode } from 'graphql';
-import {
-  getAliasOrName,
-  getFragments,
-  getMutation,
-  TypedDocumentNode,
-} from '../../_common/ast';
-import * as ast from '../../_common/ast';
-import { LrMutationData } from './lr-mutation-base';
-import { fragmentSpreadAstSelection, LrMutationBase } from './lr-mutation-base';
-
-export class LrMutation<
-  T extends any,
-  TVariables = OperationVariables
-> extends LrMutationBase<T, TVariables> {
-  constructor(options: LrMutationData<T, TVariables>) {
-    super();
-    this.mutation = options.mutation;
-    this.variables = options.variables;
-  }
-
-  select<TResult>(fragments: TypedDocumentNode<TResult>) {
-    // Don't touch the original
-    const mutationDoc = lodash.cloneDeep(this.mutation) as DocumentNode;
-    const mutationNode = getMutation(mutationDoc);
-
-    const fragmentMap = {} as { [key: string]: FragmentDefinitionNode };
-    getFragments(fragments).forEach((fragment: FragmentDefinitionNode) => {
-      fragmentMap[fragment.name.value] = fragment;
-    });
-
-    const replaceFieldSelection = (selection: FieldNode) => {
-      const field = selection as FieldNode;
-      const fieldName = getAliasOrName(field);
-      const fragment = fragmentMap[fieldName];
-
-      if (!fragment) {
-        return;
-      }
-
-      // Make the entire selection of the mutation a spread of
-      // a fragment using the same name as the mutation field.
-      // We will also rename the fragment to the same name.
-      field.selectionSet.selections = [
-        {
-          ...fragmentSpreadAstSelection,
-          name: ast.name(fieldName),
-        },
-      ];
-    };
-
-    mutationNode.selectionSet.selections.forEach((selection) => {
-      if (selection.kind === 'Field') {
-        replaceFieldSelection(selection);
-      }
-    });
-
-    return new LrMutation({
-      mutation: {
-        ...mutationDoc,
-        definitions: [
-          // Remove all existing fragments
-          ...mutationDoc.definitions.filter(
-            (def) => def.kind !== 'FragmentDefinition'
-          ),
-          ...fragments.definitions,
-        ],
-      } as TypedDocumentNode<TResult>,
-      variables: this.variables,
-    });
-  }
-}

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

@@ -1,28 +0,0 @@
-import { Injector } from '@angular/core';
-import {
-  LrGraphQLService,
-  LrMutationOptions,
-  LrQueryOptions,
-} from './lr-graphql.service';
-import { LrMutationBase } from './lr-mutation-base';
-
-export class LrService {
-  protected lrGraphQL: LrGraphQLService;
-
-  constructor(injector: Injector) {
-    this.lrGraphQL = injector.get(LrGraphQLService);
-  }
-
-  protected async mutate<T, TVariables>(
-    lrMutation:
-      | LrMutationBase<T, TVariables>
-      | Promise<LrMutationBase<T, TVariables>>,
-    options?: LrMutationOptions<T, TVariables>
-  ) {
-    return this.lrGraphQL.lrMutate(lrMutation, options);
-  }
-
-  protected async query<T, V>(options: LrQueryOptions<T, V>) {
-    return this.lrGraphQL.query(options);
-  }
-}

package/src/lib/api/message.service.spec.ts

@@ -1,20 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { loginTestUser } from '../auth/life-ready-auth.service.spec';
-import { lrConfigureTestingModule, lrit } from '../_common/tests';
-
-const TIMEOUT = 1000 * 60 * 10;
-
-// describe('MessageService', () => {
-//   let service: MessageService;
-
-//   beforeEach(async () => {
-//     lrConfigureTestingModule();
-//     service = TestBed.inject(MessageService);
-//     await loginTestUser();
-//   }, TIMEOUT)
-
-//   it('should exchange keys', async () => {
-
-//   }, TIMEOUT);
-
-// });