@lifeready/core 1.0.1 → 1.0.2

package/esm2015/lib/_common/ast.js

@@ -0,0 +1,40 @@
+// Abstract Syntax Tree
+import gql from 'graphql-tag';
+import { LrBadArgumentException, LrBadLogicException } from './exceptions';
+export function getAstOperation(astDocument, operation) {
+    const operations = astDocument.definitions.filter((def) => 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) {
+    return getAstOperation(doc, 'query');
+}
+export function getMutation(doc) {
+    return getAstOperation(doc, 'mutation');
+}
+export function getFragments(doc) {
+    return doc.definitions.filter((def) => def.kind === 'FragmentDefinition');
+}
+export function getFragment(astDocument) {
+    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) {
+    return {
+        kind: 'Name',
+        value,
+    };
+}
+export function getAliasOrName(field) {
+    var _a;
+    return ((_a = field.alias) === null || _a === void 0 ? void 0 : _a.value) || field.name.value;
+}
+export function gqlTyped(literals, ...placeholders) {
+    return gql(literals, ...placeholders);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/_common/deferred-promise.js

@@ -0,0 +1,24 @@
+export class DeferredPromise {
+    constructor() {
+        /* tslint:disable: variable-name */
+        this._fulfilled = false;
+        this.promise = new Promise((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;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/_common/exceptions.js

@@ -0,0 +1,157 @@
+export function handleApolloError(errors) {
+    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,
+            path: x.path,
+        },
+    }));
+    throw new LrException(...lrErrors);
+}
+export class LrError {
+}
+export class LrException {
+    constructor(...errors) {
+        this.errors = errors;
+    }
+    toString() {
+        return this.errors.map((t) => JSON.stringify(t, null, 2));
+    }
+}
+export var LrApiErrorCode;
+(function (LrApiErrorCode) {
+    LrApiErrorCode["ARCHIVED_RESOURCE"] = "ARCHIVED_RESOURCE";
+    LrApiErrorCode["BAD_ARGUMENT"] = "BAD_ARGUMENT";
+    LrApiErrorCode["BAD_SIGNATURE"] = "BAD_SIGNATURE";
+    LrApiErrorCode["BAD_STATE"] = "BAD_STATE";
+    LrApiErrorCode["CHANGED_PERMISSIONS"] = "CHANGED_PERMISSIONS";
+    LrApiErrorCode["CONCURRENT_ACCESS"] = "CONCURRENT_ACCESS";
+    LrApiErrorCode["CONFIG_ERROR"] = "CONFIG_ERROR";
+    LrApiErrorCode["CYCLE_DETECTED"] = "CYCLE_DETECTED";
+    LrApiErrorCode["EXPIRED"] = "EXPIRED";
+    LrApiErrorCode["INVALID_TOKEN"] = "INVALID_TOKEN";
+    LrApiErrorCode["INTERNAL_ERROR"] = "INTERNAL_ERROR";
+    LrApiErrorCode["JSON_DECODE_ERROR"] = "JSON_DECODE_ERROR";
+    LrApiErrorCode["KEY_MISMATCH"] = "KEY_MISMATCH";
+    LrApiErrorCode["LIMIT_REACHED"] = "LIMIT_REACHED";
+    LrApiErrorCode["LOCKED"] = "LOCKED";
+    LrApiErrorCode["LOGIC_ERROR"] = "LOGIC_ERROR";
+    LrApiErrorCode["LR_DEBUG_ONLY"] = "LR_DEBUG_ONLY";
+    LrApiErrorCode["MIN_DELAY"] = "MIN_DELAY";
+    LrApiErrorCode["MISSING_FIELD"] = "MISSING_FIELD";
+    LrApiErrorCode["MISSING_FIELD_VALUE"] = "MISSING_FIELD_VALUE";
+    LrApiErrorCode["MISSING_QUERY_PARAM"] = "MISSING_QUERY_PARAM";
+    LrApiErrorCode["NOT_IMPLEMENTED"] = "NOT_IMPLEMENTED";
+    LrApiErrorCode["OBJECT_DOES_NOT_EXIST"] = "OBJECT_DOES_NOT_EXIST";
+    LrApiErrorCode["OBJECT_EXISTS"] = "OBJECT_EXISTS";
+    LrApiErrorCode["RANGE_ERROR"] = "RANGE_ERROR";
+    LrApiErrorCode["TRUSTED_PARTY_NOT_FOUND"] = "TRUSTED_PARTY_NOT_FOUND";
+    LrApiErrorCode["UNAUTHENTICATED_USER"] = "UNAUTHENTICATED_USER";
+    LrApiErrorCode["USER_NOT_FOUND"] = "USER_NOT_FOUND";
+    LrApiErrorCode["VERSION_MISMATCH"] = "VERSION_MISMATCH";
+    LrApiErrorCode["WRONG_PERMISSIONS"] = "WRONG_PERMISSIONS";
+})(LrApiErrorCode || (LrApiErrorCode = {}));
+export var LrErrorCode;
+(function (LrErrorCode) {
+    LrErrorCode["BadTimeSync"] = "LrBadTimeSync";
+    LrErrorCode["ReceiveClaimMismatch"] = "LrReceiveClaimMismatch";
+    LrErrorCode["BadState"] = "LrBadState";
+    LrErrorCode["BadSignature"] = "LrBadSignature";
+    LrErrorCode["Auth"] = "LrAuth";
+    LrErrorCode["BadArgument"] = "LrBadArgument";
+    LrErrorCode["SuspiciousException"] = "LrSuspiciousException";
+    LrErrorCode["NotFound"] = "LrNotFound";
+    LrErrorCode["BadLogic"] = "LrBadLogicException";
+    LrErrorCode["CodeMismatch"] = "LrCodeMismatchException";
+    LrErrorCode["ConcurrentAccess"] = "LrConcurrentAccessException";
+    LrErrorCode["BadRequest"] = "LrBadRequestException";
+    LrErrorCode["Encryption"] = "LrEncryptionGoBad";
+    LrErrorCode["Locked"] = "LrLockedException";
+})(LrErrorCode || (LrErrorCode = {}));
+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,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"exceptions.js","sourceRoot":"/opt/atlassian/pipelines/agent/build/projects/core/src/","sources":["lib/_common/exceptions.ts"],"names":[],"mappings":"AAGA,MAAM,UAAU,iBAAiB,CAAC,MAAmC;IACnE,IAAI,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM;QAAE,OAAO;IAEtC,MAAM,QAAQ,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QAClC,IAAI,EAAE,CAAC,CAAC,UAAU,IAAI,CAAC,CAAC,UAAU,CAAC,IAAI;QACvC,MAAM,EAAE,CAAC,CAAC,UAAU,IAAI,CAAC,CAAC,UAAU,CAAC,MAAM;QAC3C,OAAO,EAAE,CAAC,CAAC,OAAO;QAClB,KAAK,EAAE;YACL,SAAS,EAAE,CAAC,CAAC,SAAgB;YAC7B,IAAI,EAAE,CAAC,CAAC,IAAgB;SACzB;KACF,CAAC,CAAC,CAAC;IAEJ,MAAM,IAAI,WAAW,CAAC,GAAG,QAAQ,CAAC,CAAC;AACrC,CAAC;AAED,MAAM,OAAO,OAAO;CAWnB;AAED,MAAM,OAAO,WAAW;IAGtB,YAAY,GAAG,MAAiB;QAC9B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;IAEM,QAAQ;QACb,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;IAC5D,CAAC;CACF;AAED,MAAM,CAAN,IAAY,cA+BX;AA/BD,WAAY,cAAc;IACxB,yDAAuC,CAAA;IACvC,+CAA6B,CAAA;IAC7B,iDAA+B,CAAA;IAC/B,yCAAuB,CAAA;IACvB,6DAA2C,CAAA;IAC3C,yDAAuC,CAAA;IACvC,+CAA6B,CAAA;IAC7B,mDAAiC,CAAA;IACjC,qCAAmB,CAAA;IACnB,iDAA+B,CAAA;IAC/B,mDAAiC,CAAA;IACjC,yDAAuC,CAAA;IACvC,+CAA6B,CAAA;IAC7B,iDAA+B,CAAA;IAC/B,mCAAiB,CAAA;IACjB,6CAA2B,CAAA;IAC3B,iDAA+B,CAAA;IAC/B,yCAAuB,CAAA;IACvB,iDAA+B,CAAA;IAC/B,6DAA2C,CAAA;IAC3C,6DAA2C,CAAA;IAC3C,qDAAmC,CAAA;IACnC,iEAA+C,CAAA;IAC/C,iDAA+B,CAAA;IAC/B,6CAA2B,CAAA;IAC3B,qEAAmD,CAAA;IACnD,+DAA6C,CAAA;IAC7C,mDAAiC,CAAA;IACjC,uDAAqC,CAAA;IACrC,yDAAuC,CAAA;AACzC,CAAC,EA/BW,cAAc,KAAd,cAAc,QA+BzB;AAED,MAAM,CAAN,IAAY,WAeX;AAfD,WAAY,WAAW;IACrB,4CAA6B,CAAA;IAC7B,8DAA+C,CAAA;IAC/C,sCAAuB,CAAA;IACvB,8CAA+B,CAAA;IAC/B,8BAAe,CAAA;IACf,4CAA6B,CAAA;IAC7B,4DAA6C,CAAA;IAC7C,sCAAuB,CAAA;IACvB,+CAAgC,CAAA;IAChC,uDAAwC,CAAA;IACxC,+DAAgD,CAAA;IAChD,mDAAoC,CAAA;IACpC,+CAAgC,CAAA;IAChC,2CAA4B,CAAA;AAC9B,CAAC,EAfW,WAAW,KAAX,WAAW,QAetB;AAED,MAAM,OAAO,sBAAuB,SAAQ,WAAW;IACrD,YAAY,OAAO;QACjB,KAAK,CAAC,EAAE,IAAI,EAAE,WAAW,CAAC,WAAW,EAAE,OAAO,EAAE,CAAC,CAAC;IACpD,CAAC;CACF;AAED,MAAM,OAAO,qBAAsB,SAAQ,WAAW;IACpD,YAAY,OAAO;QACjB,KAAK,CAAC,EAAE,IAAI,EAAE,WAAW,CAAC,WAAW,EAAE,OAAO,EAAE,CAAC,CAAC;IACpD,CAAC;CACF;AAED,MAAM,OAAO,mBAAoB,SAAQ,WAAW;IAClD,YAAY,OAAO;QACjB,KAAK,CAAC,EAAE,IAAI,EAAE,WAAW,CAAC,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAC;IACjD,CAAC;CACF;AAED,MAAM,OAAO,mBAAoB,SAAQ,WAAW;IAClD,YAAY,OAAO;QACjB,KAAK,CAAC,EAAE,IAAI,EAAE,WAAW,CAAC,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAC;IACjD,CAAC;CACF;AAED,MAAM,OAAO,uBAAwB,SAAQ,WAAW;IACtD,YAAY,OAAO;QACjB,KAAK,CAAC,EAAE,IAAI,EAAE,WAAW,CAAC,YAAY,EAAE,OAAO,EAAE,CAAC,CAAC;IACrD,CAAC;CACF;AAED,MAAM,OAAO,2BAA4B,SAAQ,WAAW;IAC1D,YAAY,OAAO;QACjB,KAAK,CAAC,EAAE,IAAI,EAAE,WAAW,CAAC,gBAAgB,EAAE,OAAO,EAAE,CAAC,CAAC;IACzD,CAAC;CACF;AAED,MAAM,OAAO,iBAAkB,SAAQ,WAAW;IAChD,YAAY,OAAO;QACjB,KAAK,CAAC,EAAE,IAAI,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC;IAC/C,CAAC;CACF;AAED,MAAM,OAAO,qBAAsB,SAAQ,WAAW;IACpD,YAAY,OAAO;QACjB,KAAK,CAAC,EAAE,IAAI,EAAE,WAAW,CAAC,UAAU,EAAE,OAAO,EAAE,CAAC,CAAC;IACnD,CAAC;CACF;AAED,MAAM,OAAO,eAAgB,SAAQ,WAAW;IAC9C,YAAY,OAAO;QACjB,KAAK,CAAC,EAAE,IAAI,EAAE,WAAW,CAAC,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;IAC7C,CAAC;CACF;AAED,MAAM,OAAO,qBAAsB,SAAQ,WAAW;IACpD,YAAY,OAAO;QACjB,KAAK,CAAC,EAAE,IAAI,EAAE,WAAW,CAAC,UAAU,EAAE,OAAO,EAAE,CAAC,CAAC;IACnD,CAAC;CACF;AAED,MAAM,OAAO,sBAAuB,SAAQ,WAAW;IACrD,YAAY,OAAO;QACjB,KAAK,CAAC;YACJ,IAAI,EAAE,wBAAwB;YAC9B,OAAO;SACR,CAAC,CAAC;IACL,CAAC;CACF;AAED,MAAM,OAAO,sBAAuB,SAAQ,WAAW;IACrD,YAAY,OAAO;QACjB,KAAK,CAAC;YACJ,IAAI,EAAE,wBAAwB;YAC9B,OAAO;SACR,CAAC,CAAC;IACL,CAAC;CACF;AAED,MAAM,OAAO,kBAAmB,SAAQ,WAAW;IACjD,YAAY,OAAO;QACjB,KAAK,CAAC;YACJ,IAAI,EAAE,oBAAoB;YAC1B,OAAO;SACR,CAAC,CAAC;IACL,CAAC;CACF;AAED,MAAM,OAAO,mBAAoB,SAAQ,WAAW;IAClD,YAAY,OAAO;QACjB,KAAK,CAAC;YACJ,IAAI,EAAE,qBAAqB;YAC3B,OAAO;SACR,CAAC,CAAC;IACL,CAAC;CACF","sourcesContent":["import { GraphQLError } from 'graphql';\nimport { debuglog } from 'util';\n\nexport function handleApolloError(errors: ReadonlyArray<GraphQLError>) {\n  if (!errors || !errors.length) return;\n\n  const lrErrors = errors.map((x) => ({\n    code: x.extensions && x.extensions.code,\n    source: x.extensions && x.extensions.source,\n    message: x.message,\n    debug: {\n      locations: x.locations as any,\n      path: x.path as string[],\n    },\n  }));\n\n  throw new LrException(...lrErrors);\n}\n\nexport class LrError {\n  code?: string;\n  source?: string;\n  message: string;\n  debug?: {\n    locations: {\n      line: number;\n      column: number;\n    }[];\n    path: string[];\n  };\n}\n\nexport class LrException {\n  public errors: LrError[];\n\n  constructor(...errors: LrError[]) {\n    this.errors = errors;\n  }\n\n  public toString() {\n    return this.errors.map((t) => JSON.stringify(t, null, 2));\n  }\n}\n\nexport enum LrApiErrorCode {\n  ARCHIVED_RESOURCE = 'ARCHIVED_RESOURCE',\n  BAD_ARGUMENT = 'BAD_ARGUMENT',\n  BAD_SIGNATURE = 'BAD_SIGNATURE',\n  BAD_STATE = 'BAD_STATE',\n  CHANGED_PERMISSIONS = 'CHANGED_PERMISSIONS',\n  CONCURRENT_ACCESS = 'CONCURRENT_ACCESS',\n  CONFIG_ERROR = 'CONFIG_ERROR',\n  CYCLE_DETECTED = 'CYCLE_DETECTED',\n  EXPIRED = 'EXPIRED',\n  INVALID_TOKEN = 'INVALID_TOKEN',\n  INTERNAL_ERROR = 'INTERNAL_ERROR',\n  JSON_DECODE_ERROR = 'JSON_DECODE_ERROR',\n  KEY_MISMATCH = 'KEY_MISMATCH',\n  LIMIT_REACHED = 'LIMIT_REACHED',\n  LOCKED = 'LOCKED',\n  LOGIC_ERROR = 'LOGIC_ERROR',\n  LR_DEBUG_ONLY = 'LR_DEBUG_ONLY',\n  MIN_DELAY = 'MIN_DELAY',\n  MISSING_FIELD = 'MISSING_FIELD',\n  MISSING_FIELD_VALUE = 'MISSING_FIELD_VALUE',\n  MISSING_QUERY_PARAM = 'MISSING_QUERY_PARAM',\n  NOT_IMPLEMENTED = 'NOT_IMPLEMENTED',\n  OBJECT_DOES_NOT_EXIST = 'OBJECT_DOES_NOT_EXIST',\n  OBJECT_EXISTS = 'OBJECT_EXISTS',\n  RANGE_ERROR = 'RANGE_ERROR',\n  TRUSTED_PARTY_NOT_FOUND = 'TRUSTED_PARTY_NOT_FOUND',\n  UNAUTHENTICATED_USER = 'UNAUTHENTICATED_USER',\n  USER_NOT_FOUND = 'USER_NOT_FOUND',\n  VERSION_MISMATCH = 'VERSION_MISMATCH',\n  WRONG_PERMISSIONS = 'WRONG_PERMISSIONS',\n}\n\nexport enum LrErrorCode {\n  BadTimeSync = 'LrBadTimeSync',\n  ReceiveClaimMismatch = 'LrReceiveClaimMismatch',\n  BadState = 'LrBadState',\n  BadSignature = 'LrBadSignature',\n  Auth = 'LrAuth',\n  BadArgument = 'LrBadArgument',\n  SuspiciousException = 'LrSuspiciousException',\n  NotFound = 'LrNotFound',\n  BadLogic = 'LrBadLogicException',\n  CodeMismatch = 'LrCodeMismatchException',\n  ConcurrentAccess = 'LrConcurrentAccessException',\n  BadRequest = 'LrBadRequestException',\n  Encryption = 'LrEncryptionGoBad',\n  Locked = 'LrLockedException',\n}\n\nexport class LrBadArgumentException extends LrException {\n  constructor(message) {\n    super({ code: LrErrorCode.BadArgument, message });\n  }\n}\n\nexport class LrSuspiciousException extends LrException {\n  constructor(message) {\n    super({ code: LrErrorCode.BadArgument, message });\n  }\n}\n\nexport class LrNotFoundException extends LrException {\n  constructor(message) {\n    super({ code: LrErrorCode.NotFound, message });\n  }\n}\n\nexport class LrBadLogicException extends LrException {\n  constructor(message) {\n    super({ code: LrErrorCode.BadLogic, message });\n  }\n}\n\nexport class LrCodeMismatchException extends LrException {\n  constructor(message) {\n    super({ code: LrErrorCode.CodeMismatch, message });\n  }\n}\n\nexport class LrConcurrentAccessException extends LrException {\n  constructor(message) {\n    super({ code: LrErrorCode.ConcurrentAccess, message });\n  }\n}\n\nexport class LrLockedException extends LrException {\n  constructor(message) {\n    super({ code: LrErrorCode.Locked, message });\n  }\n}\n\nexport class LrBadRequestException extends LrException {\n  constructor(message) {\n    super({ code: LrErrorCode.BadRequest, message });\n  }\n}\n\nexport class LrAuthException extends LrException {\n  constructor(message) {\n    super({ code: LrErrorCode.Auth, message });\n  }\n}\n\nexport class LrEncryptionException extends LrException {\n  constructor(message) {\n    super({ code: LrErrorCode.Encryption, message });\n  }\n}\n\nexport class LrUnsupportedException extends LrException {\n  constructor(message) {\n    super({\n      code: 'LrUnsupportedException',\n      message,\n    });\n  }\n}\n\nexport class LrExpiredCodeException extends LrException {\n  constructor(message) {\n    super({\n      code: 'LrExpiredCodeException',\n      message,\n    });\n  }\n}\n\nexport class LrExpiredException extends LrException {\n  constructor(message) {\n    super({\n      code: 'LrExpiredException',\n      message,\n    });\n  }\n}\n\nexport class LrBadStateException extends LrException {\n  constructor(message) {\n    super({\n      code: 'LrBadStateException',\n      message,\n    });\n  }\n}\n"]}

package/esm2015/lib/_common/queries.gql.js

@@ -0,0 +1,190 @@
+import gql from 'graphql-tag';
+const KeyGraphFragmentBase = `
+{
+  keys {
+    id
+  }
+  keyLinks {
+    keyId
+    wrappingKeyId
+    wrappedKey
+  }
+  passKeys {
+    id
+  }
+  passKeyLinks {
+    keyId
+    passKeyId
+    wrappedKey
+  }
+  __typename
+}
+`;
+export const KeyGraphFragment = gql `
+fragment KeyGraphFragment on KeyGraphType ${KeyGraphFragmentBase}
+`;
+export const KeyGraphField = `keyGraph ${KeyGraphFragmentBase}`;
+export const FetchKeyGraphField = `keyGraph: fetchKeyGraph ${KeyGraphFragmentBase}`;
+export const FileQuery = gql `
+  query File($id: LrRelayIdInput!, $cachedKeyIds: [LrRelayIdInput!]) {
+    file(id: $id) {
+      id
+      keyId
+      currentVersion {
+        id
+        operation
+        state {
+          keyId
+          plainMeta
+          cipherMeta
+          contentResource
+        }
+      }
+      versions {
+        edges {
+          node {
+            id
+            state {
+              keyId
+              plainMeta
+              cipherMeta
+              contentResource
+            }
+          }
+        }
+      }
+      parentDirectoryLinks {
+        edges {
+          node {
+            parentDirectory {
+              id
+              plainMeta
+            }
+          }
+        }
+      }
+    }
+    keyGraph(cachedKeyIds: $cachedKeyIds) {
+      ...KeyGraphFragment
+    }
+  }
+  ${KeyGraphFragment}
+`;
+export const DirectoryQuery = gql `
+  query Directory($id: LrRelayIdInput!, $cachedKeyIds: [LrRelayIdInput!]) {
+    directory(id: $id) {
+      id
+      keyId
+      plainMeta
+      cipherMeta
+    }
+    keyGraph(cachedKeyIds: $cachedKeyIds) {
+      ...KeyGraphFragment
+    }
+  }
+  ${KeyGraphFragment}
+`;
+export const CreateFileQuery = gql `
+  mutation CreateFile($input: CreateFileInput!) {
+    createFile(input: $input) {
+      file {
+        id
+      }
+    }
+  }
+`;
+export const UpdateFileQuery = gql `
+  mutation UpdateFile($input: UpdateFileInput!) {
+    updateFile(input: $input) {
+      file {
+        id
+        currentVersion {
+          id
+          state {
+            id
+          }
+        }
+      }
+    }
+  }
+`;
+export const RevertFileQuery = gql `
+  mutation RevertFile($input: RevertFileInput!) {
+    revertFile(input: $input) {
+      file {
+        id
+        currentVersion {
+          id
+          state {
+            id
+          }
+        }
+      }
+    }
+  }
+`;
+export const MoveFileQuery = gql `
+  mutation MoveFile(
+    $fileId: LrRelayIdInput!
+    $fromParentDirectoryId: LrRelayIdInput!
+    $toParentDirectoryId: LrRelayIdInput!
+    $wrappingKeyId: LrRelayIdInput!
+    $wrappedKey: String!
+  ) {
+    moveFile(
+      input: {
+        fileId: $fileId
+        fromParentDirectoryId: $fromParentDirectoryId
+        toParentDirectoryId: $toParentDirectoryId
+        wrappingKeyId: $wrappingKeyId
+        wrappedKey: $wrappedKey
+      }
+    ) {
+      file {
+        id
+        parentDirectoryLinks {
+          edges {
+            node {
+              parentDirectory {
+                plainMeta
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+export const MoveDirectoryQuery = gql `
+  mutation MoveDirectory(
+    $directoryId: LrRelayIdInput!
+    $fromParentDirectoryId: LrRelayIdInput
+    $toParentDirectoryId: LrRelayIdInput!
+    $wrappedKey: String!
+    $wrappingKeyId: LrRelayIdInput!
+  ) {
+    moveDirectory(
+      input: {
+        directoryId: $directoryId
+        fromParentDirectoryId: $fromParentDirectoryId
+        toParentDirectoryId: $toParentDirectoryId
+        wrappedKey: $wrappedKey
+        wrappingKeyId: $wrappingKeyId
+      }
+    ) {
+      directory {
+        id
+        parentDirectoryLinks {
+          edges {
+            node {
+              parentDirectory {
+                plainMeta
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/_common/run-outside-angular.js

@@ -0,0 +1,79 @@
+import { LrBadLogicException } from '../_common/exceptions';
+/**
+ * If you wish to change the behaviour of those, you'll need to create a derived
+ * class and override the methods.
+ * However, can't figure out a way to call the super() in the derived class ctor, error says
+ * the super call can't be in tested function.
+ */
+export const EXCLUDE_METHODS = [
+    'constructor',
+    'ngOnChanges',
+    'ngOnInit',
+    'ngDoCheck',
+    'ngAfterContentInit',
+    'ngAfterContentChecked',
+    'ngAfterViewInit',
+    'ngAfterViewChecked',
+    'ngOnDestroy',
+];
+// Patch all methods of the class.
+//
+// Note, this will not patch functions in the base class, it only
+// patches the function defined in the current class because it's
+// using getOwnPropertyNames(). You should be using composition for
+// services anyway.
+//
+// Ref: https://stackoverflow.com/a/44409244
+// The above approach might be a bit old. Now that we have ngZone.runOutsideAngular(),
+// we should probably use that and not touch any angular zone internals. But the approach
+// above doesn't require injecting ngZone.
+//
+// Ref: https://github.com/2ng/run-outside-angular/blob/master/src/run-outside-angular.ts
+export function RunOutsideAngular({ ngZoneName, exceptLastPromise = true, excludeMethods = [], patchSetters = true, }) {
+    return (target) => {
+        function run(original, args) {
+            if (!this[ngZoneName]) {
+                throw new LrBadLogicException(`RunOutsideAngular decorator requires that ${target.name} inject NgZone as ${ngZoneName}`);
+            }
+            // runOutsideAngular() synchronously runs the callback and returns the result.
+            const result = this[ngZoneName].runOutsideAngular(() => original.apply(this, args));
+            if (exceptLastPromise && (result === null || result === void 0 ? void 0 : result.then)) {
+                // Bring back into zone which will trigger change detection properly.
+                // If this doesn't work, then we'll have to trigger change detection explicitly.
+                return Promise.resolve(result);
+            }
+            else {
+                return result;
+            }
+        }
+        // There should be no reason to run any of the ones in EXCLUDE_METHODS outside angular.
+        // So we always exclude them from patching. You can always explicit implement these ones differently.
+        excludeMethods = [...excludeMethods, ...EXCLUDE_METHODS];
+        const methods = Object.getOwnPropertyNames(target.prototype);
+        methods
+            .filter((method) => !excludeMethods.includes(method))
+            .forEach((method) => {
+            // Patch setters
+            // Note that setters do not return any thing. But they can still issue async calls.
+            // These async calls are not visible to the wrapper. So we can't issue change detection
+            // for setters when they are running outside angular.
+            if (patchSetters &&
+                Object.getOwnPropertyDescriptor(target.prototype, method).set) {
+                const original = Object.getOwnPropertyDescriptor(target.prototype, method).set;
+                Object.defineProperty(target.prototype, method, {
+                    set(...args) {
+                        return run.apply(this, [original, args]);
+                    },
+                });
+            }
+            if (typeof target.prototype[method] === 'function') {
+                const original = target.prototype[method];
+                target.prototype[method] = function (...args) {
+                    return run.apply(this, [original, args]);
+                };
+            }
+        });
+        return target;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"run-outside-angular.js","sourceRoot":"/opt/atlassian/pipelines/agent/build/projects/core/src/","sources":["lib/_common/run-outside-angular.ts"],"names":[],"mappings":"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","sourcesContent":["import { LrBadLogicException } from '../_common/exceptions';\n\nexport interface RunOutsideAngularConfig {\n  ngZoneName: string;\n  // If true, a single change detection is triggered on resolve of the Promise returned\n  // from the function.\n  // else, the entire function is run outside of zone.\n  // Note that if this is disabled, then change detection is not triggered even if you\n  // use async pipes to subscribe to observables on the resulting promise. This is because\n  // async pipes only _marks_ a component for change detection, it doesn't actually _trigger_\n  // the change detection cycle.\n  exceptLastPromise?: boolean;\n  // Any method or property you wish to exclude from patch. The methods in EXCLUDE_METHODS are\n  // never patched.\n  excludeMethods?: string[];\n  // If true, patch the setters as well. Settings are some\n  // Note that setters do not return any thing. But they can still issue async calls.\n  // These async calls are not visible to the wrapper. So we can't issue change detection\n  // for setters when they are running outside angular.\n  // Note that getters are not patched because getter and setter must use the same type. So if\n  // the getter returns a promise, then the setting must alway take a promise. It doesn't make\n  // much sense to use getters and setters this way. And if getter returns a value, then there's\n  // no need to patch it to run outside angular.\n  patchSetters?: boolean;\n}\n\n/**\n * If you wish to change the behaviour of those, you'll need to create a derived\n * class and override the methods.\n * However, can't figure out a way to call the super() in the derived class ctor, error says\n * the super call can't be in tested function.\n */\nexport const EXCLUDE_METHODS = [\n  'constructor',\n  'ngOnChanges',\n  'ngOnInit',\n  'ngDoCheck',\n  'ngAfterContentInit',\n  'ngAfterContentChecked',\n  'ngAfterViewInit',\n  'ngAfterViewChecked',\n  'ngOnDestroy',\n];\n\n// Patch all methods of the class.\n//\n// Note, this will not patch functions in the base class, it only\n// patches the function defined in the current class because it's\n// using getOwnPropertyNames(). You should be using composition for\n// services anyway.\n//\n// Ref: https://stackoverflow.com/a/44409244\n// The above approach might be a bit old. Now that we have ngZone.runOutsideAngular(),\n// we should probably use that and not touch any angular zone internals. But the approach\n// above doesn't require injecting ngZone.\n//\n// Ref: https://github.com/2ng/run-outside-angular/blob/master/src/run-outside-angular.ts\nexport function RunOutsideAngular({\n  ngZoneName,\n  exceptLastPromise = true,\n  excludeMethods = [],\n  patchSetters = true,\n}: RunOutsideAngularConfig) {\n  return (target: any) => {\n    function run(original, args) {\n      if (!this[ngZoneName]) {\n        throw new LrBadLogicException(\n          `RunOutsideAngular decorator requires that ${target.name} inject NgZone as ${ngZoneName}`\n        );\n      }\n      // runOutsideAngular() synchronously runs the callback and returns the result.\n      const result = this[ngZoneName].runOutsideAngular(() =>\n        original.apply(this, args)\n      );\n\n      if (exceptLastPromise && result?.then) {\n        // Bring back into zone which will trigger change detection properly.\n        // If this doesn't work, then we'll have to trigger change detection explicitly.\n        return Promise.resolve(result);\n      } else {\n        return result;\n      }\n    }\n\n    // There should be no reason to run any of the ones in EXCLUDE_METHODS outside angular.\n    // So we always exclude them from patching. You can always explicit implement these ones differently.\n    excludeMethods = [...excludeMethods, ...EXCLUDE_METHODS];\n\n    const methods = Object.getOwnPropertyNames(target.prototype);\n\n    methods\n      .filter((method) => !excludeMethods.includes(method))\n      .forEach((method) => {\n        // Patch setters\n        // Note that setters do not return any thing. But they can still issue async calls.\n        // These async calls are not visible to the wrapper. So we can't issue change detection\n        // for setters when they are running outside angular.\n        if (\n          patchSetters &&\n          Object.getOwnPropertyDescriptor(target.prototype, method).set\n        ) {\n          const original = Object.getOwnPropertyDescriptor(\n            target.prototype,\n            method\n          ).set;\n\n          Object.defineProperty(target.prototype, method, {\n            set(...args) {\n              return run.apply(this, [original, args]);\n            },\n          });\n        }\n\n        if (typeof target.prototype[method] === 'function') {\n          const original = target.prototype[method];\n\n          target.prototype[method] = function(...args) {\n            return run.apply(this, [original, args]);\n          };\n        }\n      });\n\n    return target;\n  };\n}\n"]}

package/esm2015/lib/_common/types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiL29wdC9hdGxhc3NpYW4vcGlwZWxpbmVzL2FnZW50L2J1aWxkL3Byb2plY3RzL2NvcmUvc3JjLyIsInNvdXJjZXMiOlsibGliL19jb21tb24vdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEhhc0tleUdyYXBoIH0gZnJvbSAnLi4vY3J5cHRvZ3JhcGh5L2NyeXB0b2dyYXBoeS50eXBlcyc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgRWRnZTxUPiB7XG4gIG5vZGU6IFQ7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgSGFzRWRnZXM8VD4ge1xuICBlZGdlczogRWRnZTxUPltdO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIEhhc0tleUdyYXBoRWRnZXM8VD4gZXh0ZW5kcyBIYXNLZXlHcmFwaCB7XG4gIGxpc3Q6IEhhc0VkZ2VzPFQ+O1xufVxuIl19

package/esm2015/lib/_common/utils.js

@@ -0,0 +1,44 @@
+// Promise.all always returns a promise, even if all the values are not async.
+// During processing of deep hierarchies of nested objects we don't always need to
+// promote everything to a promise.
+export function promiseAllMayAsync(values) {
+    if (!Array.isArray(values)) {
+        throw new Error('not array');
+    }
+    if (values.some((value) => value === null || value === void 0 ? void 0 : value.then)) {
+        const ret = Promise.all(values);
+        return ret;
+    }
+    else {
+        return values;
+    }
+}
+function remap(obj, values) {
+    const ret = {};
+    for (const [i, key] of Object.keys(obj).entries()) {
+        ret[key] = values[i];
+    }
+    return ret;
+}
+export function mapValuesMayAsync(obj, 
+// callback can either return a Promise, or a value.
+// The Promise<any> type is redundant but it shows that it can return a promise
+callback) {
+    const values = promiseAllMayAsync(Object.entries(obj).map(([key, value]) => callback(value, key, obj)));
+    if (values.then) {
+        return values.then((resolvedValues) => remap(obj, resolvedValues));
+    }
+    else {
+        return remap(obj, values);
+    }
+}
+export function mapValuesAsync(obj, 
+// callback can either return a Promise, or a value.
+// The Promise<any> type is redundant but it shows that it can return a promise
+// By default, it returns the value without any process, so you can use
+// this to simply wait for all promises in an object to resolve.
+callback) {
+    const values = Promise.all(Object.entries(obj).map(([key, value]) => callback ? callback(value, key, obj) : value));
+    return values.then((resolvedValues) => remap(obj, resolvedValues));
+}
+//# sourceMappingURL=data:application/json;base64,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