@lifeready/core 1.0.1 → 1.0.2

package/src/lib/api/api-mutation.spec.ts

@@ -1,547 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import gql from 'graphql-tag';
-import { gqlTyped } from '../_common/ast';
-import {
-  lrConfigureTestingModule,
-  lrExpectAsyncThrow,
-  lrit,
-} from '../_common/tests';
-import { LrGraphQLService, LrMutation, LrMergedMutation } from './lr-graphql';
-
-const TIMEOUT = 1000 * 60 * 10;
-
-interface ServerTime {
-  timestamp: string;
-}
-
-interface DebugMutationPayload {
-  name?: string;
-  modified?: string;
-  serverTime?: ServerTime;
-}
-
-// As per graphql spec:
-// You can include multiple mutation of the same type, just give them unique aliases.
-// Convention: Variable name (TestMutation1) should be the same as the mutation name (mutation TestMutation1)
-// The mutation name is only used to make debugging easier on the server.
-// Testing:
-//   - Nested fragments
-//   - Field aliases
-const DebugMutationFragment1 = gql`
-  fragment DebugMutationFragment1 on DebugMutationPayload {
-    name
-    serverTime {
-      ...ServerTimeFragment
-    }
-  }
-`;
-
-const DebugMutationFragment2 = gql`
-  fragment DebugMutationFragment2 on DebugMutationPayload {
-    modified
-  }
-`;
-
-const ServerTimeFragment = gql`
-  fragment ServerTimeFragment on ServerTime {
-    timestamp
-  }
-`;
-
-interface Test1Result {
-  debugMutation: DebugMutationPayload;
-  myAlias: DebugMutationPayload;
-}
-
-const Test1Mutation = gqlTyped<Test1Result>`
-  mutation Test1Mutation(
-    $debugMutationInput: DebugMutationInput!
-    $myAliasInput: DebugMutationInput!
-  ) {
-    debugMutation(input: $debugMutationInput) {
-      ...DebugMutationFragment1
-      modified
-    }
-    myAlias: debugMutation(input: $myAliasInput) {
-      ...DebugMutationFragment2
-      name
-      serverTime {
-        ...ServerTimeFragment
-      }
-    }
-  }
-  ${DebugMutationFragment1}
-  ${DebugMutationFragment2}
-  ${ServerTimeFragment}
-`;
-
-// Alternative selections on the result of the mutation.
-interface SelectTest1Mutation {
-  debugMutation: DebugMutationPayload;
-  myAlias: DebugMutationPayload;
-}
-
-const SelectTest1Mutation = gqlTyped<SelectTest1Mutation>`
-  fragment debugMutation on DebugMutationPayload {
-    name
-  }
-  fragment myAlias on DebugMutationPayload {
-    modified
-  }
-`;
-
-const test1Input1 = {
-  debugMutationInput: {
-    name: 'input 1 debugMutation name',
-    forceFailure: false,
-  },
-  myAliasInput: {
-    name: 'input 1 myAlias name',
-    forceFailure: false,
-  },
-};
-
-const test1Input2 = {
-  debugMutationInput: {
-    name: 'input 2 debugMutation name',
-    forceFailure: false,
-  },
-  myAliasInput: {
-    name: 'input 2 myAlias name',
-    forceFailure: false,
-  },
-};
-
-interface Test2Result {
-  myAlias2: DebugMutationPayload;
-}
-
-const Test2Mutation = gqlTyped<Test2Result>`
-  mutation Test2Mutation(
-    $myAlias2Input: DebugMutationInput!
-  ) {
-    myAlias2: debugMutation(input: $myAlias2Input) {
-      ...DebugMutationFragment2
-      name
-      serverTime {
-        ...ServerTimeFragment
-      }
-    }
-  }
-  ${DebugMutationFragment2}
-  ${ServerTimeFragment}
-`;
-
-const test2Input1 = {
-  myAlias2Input: {
-    name: 'input 1 myAlias2 name',
-    forceFailure: false,
-  },
-};
-
-const test2Input2 = {
-  myAlias2Input: {
-    name: 'input 2 myAlias2 name',
-    forceFailure: false,
-  },
-};
-
-describe('API Mutation', () => {
-  let lrGraphQL: LrGraphQLService;
-
-  beforeEach(async () => {
-    lrConfigureTestingModule();
-    lrGraphQL = TestBed.inject(LrGraphQLService);
-  }, TIMEOUT);
-
-  function expectResultField(resField, inputField) {
-    expect(resField.name).toEqual(inputField.name);
-    expect(resField.modified).toBeDefined();
-    expect(resField.serverTime).toBeDefined();
-    expect(resField.serverTime.timestamp).toBeTruthy();
-  }
-
-  function expectResult(res, input) {
-    expectResultField(res.debugMutation, input.debugMutationInput);
-    expectResultField(res.myAlias, input.myAliasInput);
-  }
-
-  lrit(
-    'Should run a simple apollo mutation',
-    async () => {
-      // This is a thin wrapper around the apollo mutate() function that does some error
-      // handling and decryption of the results.
-      const res = await lrGraphQL.apolloMutate({
-        mutation: Test1Mutation,
-        variables: test1Input1,
-        includeKeyGraph: true, // pre-auth mutation
-      });
-
-      expectResult(res, test1Input1);
-      return;
-    },
-    TIMEOUT
-  );
-
-  lrit(
-    'Should run a simple lrMutation',
-    async () => {
-      // LrMutation groups the mutation specification and the variables together as a unit.
-      // So you can have mutation creation functions:
-      //
-      //   async createContactCard(name, email) {
-      //     cipher = await encrypt(name, email);
-      //     return LrMutation({
-      //       mutation: {...}
-      //       variables: {cipher}
-      //     })
-      //   }
-      const m1 = new LrMutation({
-        mutation: Test1Mutation,
-        variables: test1Input1,
-      });
-
-      const res = await lrGraphQL.lrMutate(m1, {
-        includeKeyGraph: false, // pre-auth mutation
-      });
-
-      expectResult(res, test1Input1);
-
-      return;
-    },
-    TIMEOUT
-  );
-
-  lrit(
-    'Should select new fields on the result',
-    async () => {
-      const m1 = new LrMutation({
-        mutation: Test1Mutation,
-        variables: test1Input1,
-      }).select(SelectTest1Mutation);
-
-      const res = await lrGraphQL.lrMutate(m1, {
-        includeKeyGraph: false,
-      });
-
-      expect(res.debugMutation.name).toBe(test1Input1.debugMutationInput.name);
-      expect(res.debugMutation.modified).toBeUndefined();
-      expect(res.myAlias.modified).toBeDefined();
-      expect(res.myAlias.name).toBeUndefined();
-    },
-    TIMEOUT
-  );
-
-  lrit(
-    'Should run a simplified syntax merged lrMutation with single level of nesting',
-    async () => {
-      const m1 = new LrMutation({
-        mutation: Test1Mutation,
-        variables: test1Input1,
-      });
-
-      const m2 = new LrMutation({
-        mutation: Test2Mutation,
-        variables: test2Input1,
-      });
-
-      const m3 = new LrMutation({
-        mutation: Test1Mutation,
-        variables: test1Input2,
-      });
-
-      const [r1, r2, r3] = await lrGraphQL.lrMutate([m1, m2, m3], {
-        includeKeyGraph: false,
-      });
-
-      expect(r1.myAlias.name).toEqual(test1Input1.myAliasInput.name);
-      expect(r2.myAlias2.name).toEqual(test2Input1.myAlias2Input.name);
-      expect(r3.myAlias.name).toEqual(test1Input2.myAliasInput.name);
-    },
-    TIMEOUT
-  );
-
-  lrit(
-    'Should run simplified syntax merged lrMutation',
-    async () => {
-      const m1 = new LrMutation({
-        mutation: Test1Mutation,
-        variables: test1Input1,
-      });
-
-      const m2 = new LrMutation({
-        mutation: Test2Mutation,
-        variables: test2Input1,
-      });
-
-      const m3 = new LrMutation({
-        mutation: Test1Mutation,
-        variables: test1Input2,
-      });
-
-      const m4 = new LrMutation({
-        mutation: Test2Mutation,
-        variables: test2Input2,
-      });
-
-      const merged1 = LrMergedMutation.create([m1, m2]);
-      const merged2 = LrMergedMutation.create([merged1, m3]);
-      const merged3 = LrMergedMutation.create([merged2, m4]);
-      const [[[r1, r2], r3], r4] = await lrGraphQL.lrMutate(merged3, {
-        includeKeyGraph: false,
-      });
-
-      expect(r1.myAlias.name).toEqual(test1Input1.myAliasInput.name);
-      expect(r2.myAlias2.name).toEqual(test2Input1.myAlias2Input.name);
-      expect(r3.myAlias.name).toEqual(test1Input2.myAliasInput.name);
-      expect(r4.myAlias2.name).toEqual(test2Input2.myAlias2Input.name);
-    },
-    TIMEOUT
-  );
-
-  lrit(
-    'Should run merged lrMutation',
-    async () => {
-      const m1 = new LrMutation({
-        mutation: Test1Mutation,
-        variables: test1Input1,
-      });
-
-      const m2 = new LrMutation({
-        mutation: Test1Mutation,
-        variables: test1Input2,
-      });
-
-      const m3 = new LrMutation({
-        mutation: Test2Mutation,
-        variables: test2Input1,
-      });
-
-      // Multiple LrMutation can be merged into the same mutation so that they are done in
-      // a single DB transaction. You should not assume that transactions are done in the
-      // same order as specified.
-      const mergedPromise = lrGraphQL.lrMutate([m1, m2], {
-        includeKeyGraph: false,
-      });
-
-      // You can wait for the result of each child mutation. If you use await, make sure to call
-      // lrGraphQL.lrMutate() first since that actually makes the request.
-      const res1 = await m1.promise;
-      const res1A = m1.promise; // Same reference returned.
-      const res2 = await m2.promise;
-
-      expectResult(res1, test1Input1);
-      expectResult(res2, test1Input2);
-
-      // You can also wait for the result of the lrGraphQL.lrMutate() call. Because lrGraphQL.lrMutate()
-      // runs in a single transaction, the m1.toPromise() and m2.toPromise() all resolve at the same time.
-      const [res1b, res2b] = await mergedPromise;
-
-      expect(res1b.myAlias.name).toEqual(res1.myAlias.name);
-      expect(res2b.myAlias.name).toEqual(res2.myAlias.name);
-
-      // res1_a should already be resolved and have the same value as res1
-      expect(await res1A).toEqual(res1);
-
-      return;
-    },
-    TIMEOUT
-  );
-
-  lrit(
-    'Should run multiple levels of merged lrMutation',
-    async () => {
-      function createMutation(name, forceFailure = false) {
-        return new LrMutation({
-          mutation: Test1Mutation,
-          variables: {
-            debugMutationInput: {
-              name: 'debugMutationInput ' + name,
-              forceFailure,
-            },
-            myAliasInput: {
-              name: 'myAliasInput ' + name,
-            },
-          },
-        });
-      }
-
-      const m1 = createMutation('m1');
-      const m2 = createMutation('m2');
-      const m3 = createMutation('m3');
-      const m4 = createMutation('m4');
-      // Create a mutation with a different type.
-      const m5 = new LrMutation({
-        mutation: Test2Mutation,
-        variables: test2Input1,
-      });
-
-      const merged1 = LrMergedMutation.create([m1, m2]);
-
-      const merged2 = LrMergedMutation.create([m3, m4]);
-
-      // Merged LrMutations can also be merged
-      const merged3 = LrMergedMutation.create([merged1, merged2]);
-
-      // LrMergedMutation can also be merged with LrMutation
-      const res = await lrGraphQL.lrMutate([merged3, m5], {
-        includeKeyGraph: false, // pre-auth mutation
-      });
-
-      // You can take a look at the result of the merged mutation. Lots of alias prefixes to keep names unique.
-      console.log('Merger mutation result', res);
-
-      await Promise.all(
-        [m1, m2, m3, m4].map(async (m) => {
-          // Only the first promise will actually wait for the mutation to complete since
-          // they all run at the same time.
-          const mRes = await m.promise;
-          expectResult(mRes, m.lrMutationData.variables);
-        })
-      );
-
-      expect((await m5.promise).myAlias2.name).toBeDefined(
-        test2Input1.myAlias2Input.name
-      );
-    },
-    TIMEOUT
-  );
-
-  lrit(
-    'Should cause errors',
-    async () => {
-      function createMutation(name, forceFailure = false) {
-        return new LrMutation({
-          mutation: Test1Mutation,
-          variables: {
-            debugMutationInput: {
-              name: 'debugMutationInput ' + name,
-              forceFailure,
-            },
-            myAliasInput: {
-              name: 'myAliasInput ' + name,
-            },
-          },
-        });
-      }
-
-      const m1 = createMutation('m1');
-      const m2 = createMutation('m2');
-      const m3 = createMutation('m3');
-      const m4 = createMutation('m4');
-      const m5 = createMutation('m5');
-
-      const merged1 = LrMergedMutation.create([m1, m2]);
-
-      const merged2 = LrMergedMutation.create([m3, m4]);
-
-      // Merged LrMutations can also be merged
-      const merged3 = LrMergedMutation.create([merged1, merged2]);
-
-      // duplicate LrMutation used.
-      expect(() => {
-        return LrMergedMutation.create([merged3, m4]);
-      }).toThrow();
-
-      // duplicate LrMutation used.
-      expect(() => {
-        return LrMergedMutation.create([merged3, merged1]);
-      }).toThrow();
-
-      // Run all mutations
-      const res = await lrGraphQL.lrMutate([merged3, m5], {
-        includeKeyGraph: false, // pre-auth mutation
-      });
-
-      expect(res).toBeTruthy();
-
-      // Can't run already executed mutation
-      (
-        await lrExpectAsyncThrow(
-          lrGraphQL.lrMutate(m1, {
-            includeKeyGraph: false, // pre-auth mutation
-          })
-        )
-      ).toBeTruthy();
-      (
-        await lrExpectAsyncThrow(
-          lrGraphQL.lrMutate(merged1, {
-            includeKeyGraph: false, // pre-auth mutation
-          })
-        )
-      ).toBeTruthy();
-      (
-        await lrExpectAsyncThrow(
-          lrGraphQL.lrMutate(m5, {
-            includeKeyGraph: false, // pre-auth mutation
-          })
-        )
-      ).toBeTruthy();
-    },
-    TIMEOUT
-  );
-
-  lrit('Should fail transaction', async () => {
-    const m1 = new LrMutation({
-      mutation: Test1Mutation,
-      variables: test1Input1,
-    });
-
-    const m2 = new LrMutation({
-      mutation: Test1Mutation,
-      variables: {
-        ...test1Input2,
-        debugMutationInput: {
-          ...test1Input2.debugMutationInput,
-          forceFailure: true,
-        },
-      },
-    });
-
-    const mergedPromise = lrGraphQL.lrMutate([m1, m2], {
-      includeKeyGraph: false,
-    });
-
-    // Forced failure
-    (await lrExpectAsyncThrow(mergedPromise)).toBeTruthy();
-  });
-
-  lrit(
-    'Should be able to use alternative selections in merged lrMutation',
-    async () => {
-      const m1 = new LrMutation({
-        mutation: Test1Mutation,
-        variables: test1Input1,
-      }).select(SelectTest1Mutation);
-
-      const m2 = new LrMutation({
-        mutation: Test1Mutation,
-        variables: test1Input2,
-      });
-
-      const m3 = new LrMutation({
-        mutation: Test1Mutation,
-        variables: test1Input2,
-      });
-
-      const merged1 = LrMergedMutation.create([m1, m2]);
-
-      const mergedPromise = lrGraphQL.lrMutate([merged1, m3], {
-        includeKeyGraph: false,
-      });
-
-      const m1Res = await m1.promise;
-      expect(m1Res.debugMutation.name).toBe(
-        test1Input1.debugMutationInput.name
-      );
-      expect(m1Res.debugMutation.modified).toBeUndefined();
-      expect(m1Res.myAlias.name).toBeUndefined();
-      expect(m1Res.myAlias.modified).toBeDefined();
-
-      expectResult(await m2.promise, test1Input2);
-
-      expectResult(await m3.promise, test1Input2);
-    },
-    TIMEOUT
-  );
-});

package/src/lib/api/api-query.spec.ts

@@ -1,40 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { gqlTyped } from '../_common/ast';
-import { lrConfigureTestingModule, lrit } from '../_common/tests';
-import { LrGraphQLService } from './lr-graphql';
-import { ServerTime } from './types';
-
-const TIMEOUT = 1000 * 60 * 10;
-
-interface Test1Query {
-  serverTime: ServerTime;
-}
-const Test1Query = gqlTyped<Test1Query>`
-  query TestQuery1 {
-    serverTime {
-      timestamp
-    }
-  }
-`;
-
-describe('API Query', () => {
-  let lrGraphQL: LrGraphQLService;
-
-  beforeEach(async () => {
-    lrConfigureTestingModule();
-    lrGraphQL = TestBed.inject(LrGraphQLService);
-  }, TIMEOUT);
-
-  lrit(
-    'Should run a simple query',
-    async () => {
-      const res = await lrGraphQL.query({
-        query: Test1Query,
-        // Not authenticated, so no access to key graph.
-        includeKeyGraph: false,
-      });
-      expect(res.serverTime.timestamp).toBeDefined();
-    },
-    TIMEOUT
-  );
-});

package/src/lib/api/contact-card.gql.ts

@@ -1,85 +0,0 @@
-import { KeyGraphField } from '../_common/queries.gql';
-import gql from 'graphql-tag';
-
-export const ContactCardFields = `
-id
-publicData
-publicSearchable
-cipherData
-key {
-  id
-}
-`;
-
-export const ContactCardQuery = gql`
-query ContactCardQuery(
-$id: LrRelayIdInput!
-) {
-contactCard (
-  id: $id
-) {
-  ${ContactCardFields}
-}
-${KeyGraphField}
-}`;
-
-export const SearchContactCardQuery = gql`
-query SearchContactCardQuery(
-  $publicSearchable: LrJSONFilter!
-) {
-  searchContactCards(
-    publicSearchable: $publicSearchable
-    orderBy: "created"
-  ) {
-    edges {
-      node {
-        ${ContactCardFields}
-      }
-    }
-  }
-  ${KeyGraphField}
-}`;
-
-export const ContactCardListQuery = gql`
-query ContactCardListQuery {
-  contactCards(
-    orderBy: "created"
-  ) {
-    edges {
-      node {
-        ${ContactCardFields}
-      }
-    }
-  }
-  ${KeyGraphField}
-}`;
-
-export const CreateContactCardMutation = gql`
-mutation CreateContactCardMutation(
-  $input: CreateContactCardInput!
-) {
-  createContactCard(input: $input) {
-    contactCard {
-      ${ContactCardFields}
-    }
-  }
-}`;
-
-export const UpdateContactCardMutation = gql`
-mutation UpdateContactCardMutation(
-  $input: UpdateContactCardInput!
-) {
-  updateContactCard(input: $input) {
-    contactCard {
-      ${ContactCardFields}
-    }
-  }
-}`;
-
-export const DeleteContactCardMutation = gql`
-  mutation DeleteContactCardMutation($input: DeleteContactCardInput!) {
-    deleteContactCard(input: $input) {
-      id
-    }
-  }
-`;