@lifeready/core 1.0.0 → 1.0.1

package/README.md

@@ -1,62 +1,62 @@
-# Key Crypt API
-
-Note that the following only applies to the new API.
-
-## General design principles
-- Use typing as much as possible
-- Use auto inferred type where possible. This makes refactoring easier. Also less likely to cause errors because auto type inference usually resolves to the most strict type.
-- Provide utilities to remove boiler plates where possible. Should consider even small and simple boiler plates to improve the ability to refactor, reduce bugs, and maintain consistency.
-- Consistent naming convention
-- Prefer composition over inheritance. Generally allow for more flexibility in combining primitive functions. Coding style is more functional which makes it easier to reason and debug.
-- 
-
-## KC specific design
-- Provide data in a form that's close to the graphql input and results such that the user of the lib can experiment in the online graphql explorer to test out queries and mutations and expect the results to be the same.
-  - Original data from API is always retained
-  - Processed data (eg. decrypted, JSON parsed) are names with consistent suffix, eg.
-    - cipherMeta (encrypted string) -> cipherMetaClear (decrypted string) -> cipherMetaClearJson (decrypted string JSON parsed)
-    - plainMeta (plain string) -> plainMetaJson (plain string JSON parsed)
-- Allow optional efficiency improvements. eg, the encryption keys can be optionally provide for mutations. If not provided, the mutation will make additional queries to fetch the keys.
-- Allow future refactoring to make KC client independent of Angular.
-- Transparent encryption and decryption of data where possible
-- Most queries should be defined out side of KC-client because the business logic dictate which fields to select.
-  - Except for certain instances where decrypting the data requires keys not managed within the key graph, eg. the key exchange function use a raw key string from OOB, so it contains functions to fetch and decrypt the data.
-- `gqlTyped` only has generic type on the return of the query or mutation, not on the input variable. Usually the LrMutation are created in a function, which has explit input types. The function will also do other preparation for the mutation, so the input type is not just the input variables. Because the end user does not need to interact with the gql mutation, it doesn't need an input variable type.
-- Use string enum instead of string constant union types because sometime you need to drop to JS and string typos becomes easy.
-- Return LrMutation where possible so that the user can choose how to compose the mutations. Unfortunately that's not always possible if subsequent steps depend on previous mutations. But these instances are rare.
-
-## Good to know
-- `JSON.stringify(void 0)` returns `undefined` so no need for this: `input JSON.stringify(input)`
-- When using mergeMap,concatMap, switchMap you can just return a promise.
-
-## Future
-- Being able to cancel apollo requests would be nice. Let's wait for support from apollo on that.
-
-## Convention
-- Suffixes
-  - `Option` is user to group variables together.
-  - `Input` is graphql mutation variable
-  - `Mutation` is a graphql mutation
-  - `Query` is a graphql query
-- When a graphql mutation wants to clear a field, pass in undefined or null as the variable value. If you want to prove that the user cleared the field, you can use empty string, which will get encrypted. And all encryption has a timestamp it can be verified to be cleared by the user at a certain time.
-- The return type of mutations should not use xxxNode types because the mutation performs a specific selection of fields in the result. The return type should be customised to include only those fields.
-- Use `gqlTyped` instead of `gql` and co-locate the interface for the result just above the query definition. Example
-```
-export interface CancelKeyExchangeMutation {
-  cancelKeyExchange: {
-    keyExchange: {
-      id: ID;
-    };
-  };
-}
-export const CancelKeyExchangeMutation = gqlTyped<CancelKeyExchangeMutation>`
-mutation CancelKeyExchangeMutation($input: CancelKeyExchangeInput!) {
-  cancelKeyExchange(input: $input) {
-    keyExchange {
-      id
-    }
-  }
-}
-`;
-```
-Notice the name of the interface and the query is the same. The name `CancelKeyExchangeMutation` should always be repeated 4 times: as the interface name, the query variable name, the gqlTyped generic type, and the mutation name.
+# Key Crypt API
+
+Note that the following only applies to the new API.
+
+## General design principles
+- Use typing as much as possible
+- Use auto inferred type where possible. This makes refactoring easier. Also less likely to cause errors because auto type inference usually resolves to the most strict type.
+- Provide utilities to remove boiler plates where possible. Should consider even small and simple boiler plates to improve the ability to refactor, reduce bugs, and maintain consistency.
+- Consistent naming convention
+- Prefer composition over inheritance. Generally allow for more flexibility in combining primitive functions. Coding style is more functional which makes it easier to reason and debug.
+- 
+
+## KC specific design
+- Provide data in a form that's close to the graphql input and results such that the user of the lib can experiment in the online graphql explorer to test out queries and mutations and expect the results to be the same.
+  - Original data from API is always retained
+  - Processed data (eg. decrypted, JSON parsed) are names with consistent suffix, eg.
+    - cipherMeta (encrypted string) -> cipherMetaClear (decrypted string) -> cipherMetaClearJson (decrypted string JSON parsed)
+    - plainMeta (plain string) -> plainMetaJson (plain string JSON parsed)
+- Allow optional efficiency improvements. eg, the encryption keys can be optionally provide for mutations. If not provided, the mutation will make additional queries to fetch the keys.
+- Allow future refactoring to make KC client independent of Angular.
+- Transparent encryption and decryption of data where possible
+- Most queries should be defined out side of KC-client because the business logic dictate which fields to select.
+  - Except for certain instances where decrypting the data requires keys not managed within the key graph, eg. the key exchange function use a raw key string from OOB, so it contains functions to fetch and decrypt the data.
+- `gqlTyped` only has generic type on the return of the query or mutation, not on the input variable. Usually the LrMutation are created in a function, which has explit input types. The function will also do other preparation for the mutation, so the input type is not just the input variables. Because the end user does not need to interact with the gql mutation, it doesn't need an input variable type.
+- Use string enum instead of string constant union types because sometime you need to drop to JS and string typos becomes easy.
+- Return LrMutation where possible so that the user can choose how to compose the mutations. Unfortunately that's not always possible if subsequent steps depend on previous mutations. But these instances are rare.
+
+## Good to know
+- `JSON.stringify(void 0)` returns `undefined` so no need for this: `input JSON.stringify(input)`
+- When using mergeMap,concatMap, switchMap you can just return a promise.
+
+## Future
+- Being able to cancel apollo requests would be nice. Let's wait for support from apollo on that.
+
+## Convention
+- Suffixes
+  - `Option` is user to group variables together.
+  - `Input` is graphql mutation variable
+  - `Mutation` is a graphql mutation
+  - `Query` is a graphql query
+- When a graphql mutation wants to clear a field, pass in undefined or null as the variable value. If you want to prove that the user cleared the field, you can use empty string, which will get encrypted. And all encryption has a timestamp it can be verified to be cleared by the user at a certain time.
+- The return type of mutations should not use xxxNode types because the mutation performs a specific selection of fields in the result. The return type should be customised to include only those fields.
+- Use `gqlTyped` instead of `gql` and co-locate the interface for the result just above the query definition. Example
+```
+export interface CancelKeyExchangeMutation {
+  cancelKeyExchange: {
+    keyExchange: {
+      id: ID;
+    };
+  };
+}
+export const CancelKeyExchangeMutation = gqlTyped<CancelKeyExchangeMutation>`
+mutation CancelKeyExchangeMutation($input: CancelKeyExchangeInput!) {
+  cancelKeyExchange(input: $input) {
+    keyExchange {
+      id
+    }
+  }
+}
+`;
+```
+Notice the name of the interface and the query is the same. The name `CancelKeyExchangeMutation` should always be repeated 4 times: as the interface name, the query variable name, the gqlTyped generic type, and the mutation name.

package/karma.conf.js

@@ -0,0 +1,32 @@
+// Karma configuration file, see link for more information
+// https://karma-runner.github.io/1.0/config/configuration-file.html
+
+module.exports = function (config) {
+  config.set({
+    basePath: '',
+    frameworks: ['jasmine', '@angular-devkit/build-angular'],
+    plugins: [
+      require('karma-jasmine'),
+      require('karma-chrome-launcher'),
+      require('karma-jasmine-html-reporter'),
+      require('karma-coverage-istanbul-reporter'),
+      require('@angular-devkit/build-angular/plugins/karma')
+    ],
+    client: {
+      clearContext: false // leave Jasmine Spec Runner output visible in browser
+    },
+    coverageIstanbulReporter: {
+      dir: require('path').join(__dirname, '../../coverage/lr-auth'),
+      reports: ['html', 'lcovonly', 'text-summary'],
+      fixWebpackSourcePaths: true
+    },
+    reporters: ['progress', 'kjhtml'],
+    port: 9876,
+    colors: true,
+    logLevel: config.LOG_INFO,
+    autoWatch: true,
+    browsers: ['Chrome'],
+    singleRun: false,
+    restartOnFileChange: true
+  });
+};

package/ng-package.json

@@ -0,0 +1,26 @@
+{
+  "$schema": "../../node_modules/ng-packagr/ng-package.schema.json",
+  "dest": "../../dist/@lifeready/core",
+  "lib": {
+    "entryFile": "src/public-api.ts",
+    "umdModuleIds": {
+      "@aws-amplify/auth": "@aws-amplify/auth",
+      "@aws-amplify/auth/lib-esm/Auth": "@aws-amplify/auth/lib-esm/Auth",
+      "@aws-amplify/core": "@aws-amplify/core",
+      "@dagrejs/graphlib": "@dagrejs/graphlib",
+      "@ng-idle/core": "@ng-idle/core",
+      "@ng-idle/keepalive": "@ng-idle/keepalive",
+      "apollo-angular": "apollo-angular",
+      "@apollo/client/core": "@apollo/client/core",
+      "@apollo/client/link/context": "@apollo/client/link/context",
+      "@apollo/client/link/retry": "@apollo/client/link/retry",
+      "graphql-tag": "graphql-tag",
+      "lodash": "lodash",
+      "moment": "moment",
+      "ngx-cookie-service": "ngx-cookie-service",
+      "node-jose": "node-jose",
+      "slip39": "slip39",
+      "graphql/language/printer": "graphql/language/printer"
+    }
+  }
+}

package/package.json

@@ -1,29 +1,21 @@
-{
-  "name": "@lifeready/core",
-  "version": "1.0.0",
-  "peerDependencies": {
-    "@angular/common": "~10.0.5",
-    "@angular/core": "~10.0.5",
-    "@apollo/client": "^3.3.12",
-    "@aws-amplify/auth": "^3.3.3",
-    "@dagrejs/graphlib": "^2.1.4",
-    "@ng-idle/core": "^10.0.0-beta.1",
-    "@ng-idle/keepalive": "^10.0.0-beta.1",
-    "apollo-angular": "^2.4.0",
-    "graphql-tag": "^2.10.0",
-    "ngx-cookie-service": "^10.0.1",
-    "node-jose": "^1.1.3",
-    "slip39": "github:lifeready/slip39-js"
-  },
-  "dependencies": {
-    "tslib": "^2.0.0"
-  },
-  "main": "bundles/lifeready-core.umd.js",
-  "module": "fesm2015/lifeready-core.js",
-  "es2015": "fesm2015/lifeready-core.js",
-  "esm2015": "esm2015/lifeready-core.js",
-  "fesm2015": "fesm2015/lifeready-core.js",
-  "typings": "lifeready-core.d.ts",
-  "metadata": "lifeready-core.metadata.json",
-  "sideEffects": false
-}
+{
+  "name": "@lifeready/core",
+  "version": "1.0.1",
+  "peerDependencies": {
+    "@angular/common": "~10.0.5",
+    "@angular/core": "~10.0.5",
+    "@apollo/client": "^3.3.12",
+    "@aws-amplify/auth": "^3.3.3",
+    "@dagrejs/graphlib": "^2.1.4",
+    "@ng-idle/core": "^10.0.0-beta.1",
+    "@ng-idle/keepalive": "^10.0.0-beta.1",
+    "apollo-angular": "^2.4.0",
+    "graphql-tag": "^2.10.0",
+    "ngx-cookie-service": "^10.0.1",
+    "node-jose": "^1.1.3",
+    "slip39": "github:lifeready/slip39-js"
+  },
+  "dependencies": {
+    "tslib": "^2.0.0"
+  }
+}

package/src/lib/_common/ast.ts

@@ -0,0 +1,75 @@
+// Abstract Syntax Tree
+
+import {
+  DocumentNode,
+  FieldNode,
+  FragmentDefinitionNode,
+  NameNode,
+  OperationDefinitionNode,
+  OperationTypeNode,
+} from 'graphql';
+import gql from 'graphql-tag';
+import { LrBadArgumentException, LrBadLogicException } from './exceptions';
+
+export function getAstOperation(
+  astDocument,
+  operation: OperationTypeNode
+): OperationDefinitionNode {
+  const operations = astDocument.definitions.filter(
+    (def: OperationDefinitionNode) => def.kind === 'OperationDefinition'
+  );
+
+  if (operations.length > 1) {
+    throw new LrBadLogicException(
+      `There can be only one '${operation}' operation, instead there are ${operations.length}`
+    );
+  }
+
+  return operations[0];
+}
+
+export function getQuery(doc: DocumentNode): OperationDefinitionNode {
+  return getAstOperation(doc, 'query');
+}
+
+export function getMutation(doc: DocumentNode): OperationDefinitionNode {
+  return getAstOperation(doc, 'mutation');
+}
+
+export function getFragments(doc: DocumentNode): FragmentDefinitionNode[] {
+  return doc.definitions.filter(
+    (def) => def.kind === 'FragmentDefinition'
+  ) as FragmentDefinitionNode[];
+}
+
+export function getFragment(astDocument: DocumentNode): FragmentDefinitionNode {
+  const fragments = getFragments(astDocument);
+  if (fragments.length > 1) {
+    throw new LrBadArgumentException(
+      'GraphQL document can only contain one fragment.'
+    );
+  }
+  return fragments[0];
+}
+
+export function name(value: string): NameNode {
+  return {
+    kind: 'Name',
+    value,
+  };
+}
+
+export function getAliasOrName(field: FieldNode) {
+  return field.alias?.value || field.name.value;
+}
+
+// Collocates the type with the document.
+/* tslint:disable:no-empty-interface */
+export interface TypedDocumentNode<T> extends DocumentNode {}
+
+export function gqlTyped<T = any>(
+  literals: ReadonlyArray<string> | Readonly<string>,
+  ...placeholders: any[]
+): TypedDocumentNode<T> {
+  return gql(literals, ...placeholders) as TypedDocumentNode<T>;
+}

package/src/lib/_common/deferred-promise.ts

@@ -0,0 +1,35 @@
+export type ResolvePromise<T> = (value?: T | PromiseLike<T>) => void;
+export type RejectPromise = (reason?: any) => void;
+
+export class DeferredPromise<T> {
+  public readonly promise: Promise<T>;
+  /* tslint:disable: variable-name */
+  private _resolve: ResolvePromise<T>;
+  /* tslint:disable: variable-name */
+  private _reject: RejectPromise;
+  /* tslint:disable: variable-name */
+  private _fulfilled = false;
+
+  constructor() {
+    this.promise = new Promise<T>((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    }).finally(() => {
+      // finally() simply gets called on both then() and catch(). The promise
+      // chain continues on.
+      this._fulfilled = true;
+    });
+  }
+
+  get resolve() {
+    return this._resolve;
+  }
+
+  get reject() {
+    return this._reject;
+  }
+
+  get fulfilled() {
+    return this._fulfilled;
+  }
+}

package/src/lib/_common/exceptions.ts

@@ -0,0 +1,189 @@
+import { GraphQLError } from 'graphql';
+import { debuglog } from 'util';
+
+export function handleApolloError(errors: ReadonlyArray<GraphQLError>) {
+  if (!errors || !errors.length) return;
+
+  const lrErrors = errors.map((x) => ({
+    code: x.extensions && x.extensions.code,
+    source: x.extensions && x.extensions.source,
+    message: x.message,
+    debug: {
+      locations: x.locations as any,
+      path: x.path as string[],
+    },
+  }));
+
+  throw new LrException(...lrErrors);
+}
+
+export class LrError {
+  code?: string;
+  source?: string;
+  message: string;
+  debug?: {
+    locations: {
+      line: number;
+      column: number;
+    }[];
+    path: string[];
+  };
+}
+
+export class LrException {
+  public errors: LrError[];
+
+  constructor(...errors: LrError[]) {
+    this.errors = errors;
+  }
+
+  public toString() {
+    return this.errors.map((t) => JSON.stringify(t, null, 2));
+  }
+}
+
+export enum LrApiErrorCode {
+  ARCHIVED_RESOURCE = 'ARCHIVED_RESOURCE',
+  BAD_ARGUMENT = 'BAD_ARGUMENT',
+  BAD_SIGNATURE = 'BAD_SIGNATURE',
+  BAD_STATE = 'BAD_STATE',
+  CHANGED_PERMISSIONS = 'CHANGED_PERMISSIONS',
+  CONCURRENT_ACCESS = 'CONCURRENT_ACCESS',
+  CONFIG_ERROR = 'CONFIG_ERROR',
+  CYCLE_DETECTED = 'CYCLE_DETECTED',
+  EXPIRED = 'EXPIRED',
+  INVALID_TOKEN = 'INVALID_TOKEN',
+  INTERNAL_ERROR = 'INTERNAL_ERROR',
+  JSON_DECODE_ERROR = 'JSON_DECODE_ERROR',
+  KEY_MISMATCH = 'KEY_MISMATCH',
+  LIMIT_REACHED = 'LIMIT_REACHED',
+  LOCKED = 'LOCKED',
+  LOGIC_ERROR = 'LOGIC_ERROR',
+  LR_DEBUG_ONLY = 'LR_DEBUG_ONLY',
+  MIN_DELAY = 'MIN_DELAY',
+  MISSING_FIELD = 'MISSING_FIELD',
+  MISSING_FIELD_VALUE = 'MISSING_FIELD_VALUE',
+  MISSING_QUERY_PARAM = 'MISSING_QUERY_PARAM',
+  NOT_IMPLEMENTED = 'NOT_IMPLEMENTED',
+  OBJECT_DOES_NOT_EXIST = 'OBJECT_DOES_NOT_EXIST',
+  OBJECT_EXISTS = 'OBJECT_EXISTS',
+  RANGE_ERROR = 'RANGE_ERROR',
+  TRUSTED_PARTY_NOT_FOUND = 'TRUSTED_PARTY_NOT_FOUND',
+  UNAUTHENTICATED_USER = 'UNAUTHENTICATED_USER',
+  USER_NOT_FOUND = 'USER_NOT_FOUND',
+  VERSION_MISMATCH = 'VERSION_MISMATCH',
+  WRONG_PERMISSIONS = 'WRONG_PERMISSIONS',
+}
+
+export enum LrErrorCode {
+  BadTimeSync = 'LrBadTimeSync',
+  ReceiveClaimMismatch = 'LrReceiveClaimMismatch',
+  BadState = 'LrBadState',
+  BadSignature = 'LrBadSignature',
+  Auth = 'LrAuth',
+  BadArgument = 'LrBadArgument',
+  SuspiciousException = 'LrSuspiciousException',
+  NotFound = 'LrNotFound',
+  BadLogic = 'LrBadLogicException',
+  CodeMismatch = 'LrCodeMismatchException',
+  ConcurrentAccess = 'LrConcurrentAccessException',
+  BadRequest = 'LrBadRequestException',
+  Encryption = 'LrEncryptionGoBad',
+  Locked = 'LrLockedException',
+}
+
+export class LrBadArgumentException extends LrException {
+  constructor(message) {
+    super({ code: LrErrorCode.BadArgument, message });
+  }
+}
+
+export class LrSuspiciousException extends LrException {
+  constructor(message) {
+    super({ code: LrErrorCode.BadArgument, message });
+  }
+}
+
+export class LrNotFoundException extends LrException {
+  constructor(message) {
+    super({ code: LrErrorCode.NotFound, message });
+  }
+}
+
+export class LrBadLogicException extends LrException {
+  constructor(message) {
+    super({ code: LrErrorCode.BadLogic, message });
+  }
+}
+
+export class LrCodeMismatchException extends LrException {
+  constructor(message) {
+    super({ code: LrErrorCode.CodeMismatch, message });
+  }
+}
+
+export class LrConcurrentAccessException extends LrException {
+  constructor(message) {
+    super({ code: LrErrorCode.ConcurrentAccess, message });
+  }
+}
+
+export class LrLockedException extends LrException {
+  constructor(message) {
+    super({ code: LrErrorCode.Locked, message });
+  }
+}
+
+export class LrBadRequestException extends LrException {
+  constructor(message) {
+    super({ code: LrErrorCode.BadRequest, message });
+  }
+}
+
+export class LrAuthException extends LrException {
+  constructor(message) {
+    super({ code: LrErrorCode.Auth, message });
+  }
+}
+
+export class LrEncryptionException extends LrException {
+  constructor(message) {
+    super({ code: LrErrorCode.Encryption, message });
+  }
+}
+
+export class LrUnsupportedException extends LrException {
+  constructor(message) {
+    super({
+      code: 'LrUnsupportedException',
+      message,
+    });
+  }
+}
+
+export class LrExpiredCodeException extends LrException {
+  constructor(message) {
+    super({
+      code: 'LrExpiredCodeException',
+      message,
+    });
+  }
+}
+
+export class LrExpiredException extends LrException {
+  constructor(message) {
+    super({
+      code: 'LrExpiredException',
+      message,
+    });
+  }
+}
+
+export class LrBadStateException extends LrException {
+  constructor(message) {
+    super({
+      code: 'LrBadStateException',
+      message,
+    });
+  }
+}