@lifeready/core 0.6.0-beta.1

package/esm2015/lib/auth/two-factor.service.js

@@ -0,0 +1,74 @@
+import { __awaiter } from "tslib";
+import { Injectable } from '@angular/core';
+import { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';
+import { LrBadArgumentException } from '../_common/exceptions';
+import * as i0 from "@angular/core";
+import * as i1 from "@aws-amplify/auth/lib-esm/Auth";
+export class TwoFactorService {
+    constructor(auth) {
+        this.auth = auth;
+    }
+    getPreferredMFA() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cognitoUser = yield this.auth.currentAuthenticatedUser();
+            return yield this.auth.getPreferredMFA(cognitoUser);
+        });
+    }
+    setPreferredMFA(method) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cognitoUser = yield this.auth.currentAuthenticatedUser();
+            yield this.auth.setPreferredMFA(cognitoUser, method);
+        });
+    }
+    setPhoneNumber(phone) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cognitoUser = yield this.auth.currentAuthenticatedUser();
+            yield this.auth.updateUserAttributes(cognitoUser, {
+                phone_number: phone,
+            });
+        });
+    }
+    getSMSCode() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.auth.verifyCurrentUserAttribute('phone_number');
+        });
+    }
+    verifySMSCode(verificationCode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.auth.verifyCurrentUserAttributeSubmit('phone_number', verificationCode);
+        });
+    }
+    getSoftwareToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [cognitoUser, userInfo] = yield Promise.all([
+                this.auth.currentAuthenticatedUser(),
+                this.auth.currentUserInfo(),
+            ]);
+            const code = yield this.auth.setupTOTP(cognitoUser);
+            const email = userInfo.attributes.email;
+            if (!email) {
+                throw new LrBadArgumentException('No email associated with user.');
+            }
+            return {
+                code,
+                codeUri: `otpauth://totp/${email}?secret=${code}&issuer=LifeReady`,
+            };
+        });
+    }
+    verifySoftwareToken(totpCode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cognitoUser = yield this.auth.currentAuthenticatedUser();
+            yield this.auth.verifyTotpToken(cognitoUser, totpCode);
+        });
+    }
+}
+TwoFactorService.ɵprov = i0.ɵɵdefineInjectable({ factory: function TwoFactorService_Factory() { return new TwoFactorService(i0.ɵɵinject(i1.AuthClass)); }, token: TwoFactorService, providedIn: "root" });
+TwoFactorService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+TwoFactorService.ctorParameters = () => [
+    { type: AuthClass }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/category/category-meta.service.js

@@ -0,0 +1,99 @@
+import { __awaiter } from "tslib";
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { CategoryService } from './category.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "./category.service";
+export class LoadedCategoryTree {
+}
+export class CategoryMetaService {
+    constructor(http, categoryService) {
+        this.http = http;
+        this.categoryService = categoryService;
+    }
+    getCoreCategories() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.categories) {
+                this.categories = yield this.http
+                    .get('/assets/meta/categories.json')
+                    .toPromise();
+            }
+            return Promise.resolve(this.categories);
+        });
+    }
+    loadCategories(categoryTrees, selectedCategoryId, trustedPartyId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rootCategories = trustedPartyId
+                ? (yield this.categoryService.getTrustedPartyCategories(trustedPartyId))
+                    .categories
+                : yield this.categoryService.getCategories();
+            const selectedCategory = selectedCategoryId
+                ? yield this.categoryService.getCategory(selectedCategoryId)
+                : null;
+            const categoryPromises = categoryTrees.map((x) => __awaiter(this, void 0, void 0, function* () {
+                return ({
+                    categoryTree: x,
+                    category: yield this.loadCategory([...x], rootCategories, selectedCategory),
+                });
+            }));
+            const loadedCategories = yield Promise.all(categoryPromises);
+            const loadedCategoryTree = {
+                categories: [],
+                missingCategories: [],
+            };
+            loadedCategories.forEach((x) => x.category
+                ? loadedCategoryTree.categories.push(x.category)
+                : loadedCategoryTree.missingCategories.push(x.categoryTree));
+            return loadedCategoryTree;
+        });
+    }
+    loadCategoriesForRole(categories) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rootCategories = yield this.categoryService.getCategories();
+            return yield Promise.all(categories.map((x) => __awaiter(this, void 0, void 0, function* () {
+                return ({
+                    category: yield this.loadCategory([...x.category], rootCategories),
+                    accessLevel: x.accessLevel,
+                });
+            })));
+        });
+    }
+    loadCategory(categoryTree, categories, selectedCategory) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const name = categoryTree.shift();
+            const currentCategory = categories.find((x) => x.code === name && !x.isCustom);
+            if (currentCategory) {
+                if (categoryTree.length) {
+                    const { subCategories } = yield this.categoryService.getCategory(currentCategory.id);
+                    return this.loadCategory(categoryTree, subCategories, selectedCategory);
+                }
+                else {
+                    const { category } = yield this.categoryService.getCategory(currentCategory.id);
+                    if (selectedCategory &&
+                        selectedCategory.category.parents.some((x) => x.id === category.id)) {
+                        return selectedCategory.category;
+                    }
+                    return category;
+                }
+            }
+            else if (categoryTree.length) {
+                return this.loadCategory(categoryTree, categories, selectedCategory);
+            }
+            else {
+                return null;
+            }
+        });
+    }
+}
+CategoryMetaService.ɵprov = i0.ɵɵdefineInjectable({ factory: function CategoryMetaService_Factory() { return new CategoryMetaService(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.CategoryService)); }, token: CategoryMetaService, providedIn: "root" });
+CategoryMetaService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+CategoryMetaService.ctorParameters = () => [
+    { type: HttpClient },
+    { type: CategoryService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"category-meta.service.js","sourceRoot":"C:/Projects/test/projects/core/src/","sources":["lib/category/category-meta.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\r\nimport { Injectable } from '@angular/core';\r\nimport { CategoryService } from './category.service';\r\nimport {\r\n  AccessLevel,\r\n  Category,\r\n  CurrentCategory,\r\n  DefaultCategory,\r\n  VaultCategory,\r\n} from './category.types';\r\n\r\nexport class LoadedCategoryTree {\r\n  categories: CurrentCategory[];\r\n  missingCategories: string[][];\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class CategoryMetaService {\r\n  private categories: DefaultCategory[];\r\n\r\n  constructor(\r\n    private http: HttpClient,\r\n    private categoryService: CategoryService\r\n  ) {}\r\n\r\n  public async getCoreCategories(): Promise<DefaultCategory[]> {\r\n    if (!this.categories) {\r\n      this.categories = await this.http\r\n        .get<DefaultCategory[]>('/assets/meta/categories.json')\r\n        .toPromise();\r\n    }\r\n    return Promise.resolve(this.categories);\r\n  }\r\n\r\n  async loadCategories(\r\n    categoryTrees: string[][],\r\n    selectedCategoryId?: string,\r\n    trustedPartyId?: string\r\n  ): Promise<LoadedCategoryTree> {\r\n    const rootCategories = trustedPartyId\r\n      ? (await this.categoryService.getTrustedPartyCategories(trustedPartyId))\r\n          .categories\r\n      : await this.categoryService.getCategories();\r\n\r\n    const selectedCategory = selectedCategoryId\r\n      ? await this.categoryService.getCategory(selectedCategoryId)\r\n      : null;\r\n\r\n    const categoryPromises = categoryTrees.map(async (x) => ({\r\n      categoryTree: x,\r\n      category: await this.loadCategory(\r\n        [...x],\r\n        rootCategories,\r\n        selectedCategory\r\n      ),\r\n    }));\r\n\r\n    const loadedCategories = await Promise.all(categoryPromises);\r\n\r\n    const loadedCategoryTree: LoadedCategoryTree = {\r\n      categories: [],\r\n      missingCategories: [],\r\n    };\r\n\r\n    loadedCategories.forEach((x) =>\r\n      x.category\r\n        ? loadedCategoryTree.categories.push(x.category)\r\n        : loadedCategoryTree.missingCategories.push(x.categoryTree)\r\n    );\r\n\r\n    return loadedCategoryTree;\r\n  }\r\n\r\n  async loadCategoriesForRole(\r\n    categories: { category: string[]; accessLevel: AccessLevel }[]\r\n  ): Promise<{ category: CurrentCategory; accessLevel: AccessLevel }[]> {\r\n    const rootCategories = await this.categoryService.getCategories();\r\n\r\n    return await Promise.all(\r\n      categories.map(async (x) => ({\r\n        category: await this.loadCategory([...x.category], rootCategories),\r\n        accessLevel: x.accessLevel,\r\n      }))\r\n    );\r\n  }\r\n\r\n  private async loadCategory(\r\n    categoryTree: string[],\r\n    categories: Category[],\r\n    selectedCategory?: VaultCategory\r\n  ): Promise<CurrentCategory> {\r\n    const name = categoryTree.shift();\r\n\r\n    const currentCategory = categories.find(\r\n      (x) => x.code === name && !x.isCustom\r\n    );\r\n\r\n    if (currentCategory) {\r\n      if (categoryTree.length) {\r\n        const { subCategories } = await this.categoryService.getCategory(\r\n          currentCategory.id\r\n        );\r\n        return this.loadCategory(categoryTree, subCategories, selectedCategory);\r\n      } else {\r\n        const { category } = await this.categoryService.getCategory(\r\n          currentCategory.id\r\n        );\r\n\r\n        if (\r\n          selectedCategory &&\r\n          selectedCategory.category.parents.some((x) => x.id === category.id)\r\n        ) {\r\n          return selectedCategory.category;\r\n        }\r\n        return category;\r\n      }\r\n    } else if (categoryTree.length) {\r\n      return this.loadCategory(categoryTree, categories, selectedCategory);\r\n    } else {\r\n      return null;\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2015/lib/category/category.gql.js

@@ -0,0 +1,406 @@
+import { KeyGraphFragment } from '../_common/queries.gql';
+import gql from 'graphql-tag';
+export const DEFAULT_BREADCRUMB_DEPTH = 5;
+export const DEFAULT_DESCENDANTS_DEPTH = 5;
+export var DirectoryType;
+(function (DirectoryType) {
+    DirectoryType["Vault"] = "vault";
+    DirectoryType["Category"] = "category";
+    DirectoryType["Record"] = "record";
+})(DirectoryType || (DirectoryType = {}));
+export const DefaultVaultFilter = JSON.stringify({
+    filter: [
+        {
+            contains: {
+                directoryType: DirectoryType.Vault,
+                default: true,
+            },
+        },
+    ],
+});
+export const CategoryFilter = JSON.stringify({
+    filter: [
+        {
+            contains: {
+                directoryType: DirectoryType.Category,
+            },
+        },
+    ],
+});
+export const RecordFilter = JSON.stringify({
+    filter: [
+        {
+            contains: {
+                directoryType: DirectoryType.Record,
+            },
+        },
+    ],
+});
+export const AccessFields = `
+accessRoles {
+  role
+  method
+  inheritedFrom {
+    id
+  }
+  trustedParty {
+    id
+  }
+  isIssuer
+}`;
+const descendantDirectories = `
+descendantDirectories(depth: ${DEFAULT_DESCENDANTS_DEPTH}, plainMeta: $categoryFilter, archived: false) {
+  recordsCount: directoriesCount(plainMeta: $recordFilter, archived: false)
+}
+`;
+export const CategoryFields = `
+  id
+  keyId
+  archived
+  plainMeta
+  cipherMeta
+  ${AccessFields}
+  ${descendantDirectories}
+`;
+export const VaultFields = `
+  id
+  keyId
+  plainMeta
+  cipherMeta
+`;
+export const GetRootDirectoryIdsQuery = gql `
+  query GetRootDirectoryIdsQuery($archived: Boolean) {
+    rootDirectories(archived: $archived) {
+      edges {
+        node {
+          id
+        }
+      }
+    }
+  }
+`;
+export const GetCategoriesQuery = gql `
+query GetCategories($vaultFilter: LrJSONFilter!, $categoryFilter: LrJSONFilter!, $recordFilter: LrJSONFilter!, $archived: Boolean, $cachedKeyIds: [LrRelayIdInput!])
+{
+  vaults: rootDirectories(plainMeta: $vaultFilter) {
+    edges {
+      node {
+        childDirectoryLinks(plainMeta: $categoryFilter, orderBy: "created", archived: $archived) {
+          edges {
+            node {
+              childDirectory {
+                ${CategoryFields}
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  keyGraph(cachedKeyIds: $cachedKeyIds) {
+    ...KeyGraphFragment
+  }
+}
+${KeyGraphFragment}
+`;
+export const GetVaultsQuery = gql `
+query GetVaults($plainMetaFilter: LrJSONFilter!, $cachedKeyIds: [LrRelayIdInput!])
+{
+  list: rootDirectories(plainMeta: $plainMetaFilter, orderBy: "created") {
+    edges {
+      node {
+        ${VaultFields}
+      }
+    }
+  }
+  keyGraph(cachedKeyIds: $cachedKeyIds) {
+    ...KeyGraphFragment
+  }
+}
+${KeyGraphFragment}
+`;
+export const GetTrustedPartyCategoriesQuery = gql `
+query GetTrustedPartyCategoriesQuery($trustedPartyId: LrRelayIdInput!, $categoryFilter: LrJSONFilter!, $recordFilter: LrJSONFilter!, $contentFilter: LrJSONFilter, $cachedKeyIds: [LrRelayIdInput!])
+{
+  tp(id: $trustedPartyId) {
+    sharedItems {
+      list: directories(plainMeta: $categoryFilter, orderBy: "created") {
+        edges {
+          node {
+            ${CategoryFields}
+          }
+        }
+      }
+      records: directories(plainMeta: $recordFilter, orderBy: "created") {
+        edges {
+          node {
+            id
+            keyId
+            archived
+            plainMeta
+            cipherMeta
+            created
+            modified
+            ${AccessFields}
+            content: childFileLinks(plainMeta: $contentFilter) {
+              edges {
+                node {
+                  childFile {
+                    id
+                    archived
+                    currentVersion {
+                      state {
+                        keyId
+                        plainMeta
+                        cipherMeta
+                        created
+                        modified
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  keyGraph(cachedKeyIds: $cachedKeyIds) {
+    ...KeyGraphFragment
+  }
+}
+${KeyGraphFragment}
+`;
+export const GetMySharedCategoriesQuery = gql `
+query GetMySharedCategoriesQuery($trustedPartyId: LrRelayIdInput!, $categoryFilter: LrJSONFilter!, $recordFilter: LrJSONFilter!, $contentFilter: LrJSONFilter, $cachedKeyIds: [LrRelayIdInput!])
+{
+  tp(id: $trustedPartyId) {
+    myItems {
+      list: directories(plainMeta: $categoryFilter, orderBy: "created") {
+        edges {
+          node {
+            ${CategoryFields}
+          }
+        }
+      }
+      records: directories(plainMeta: $recordFilter, orderBy: "created") {
+        edges {
+          node {
+            id
+            keyId
+            archived
+            plainMeta
+            cipherMeta
+            created
+            modified
+            ${AccessFields}
+            content: childFileLinks(plainMeta: $contentFilter) {
+              edges {
+                node {
+                  childFile {
+                    id
+                    archived
+                    currentVersion {
+                      state {
+                        keyId
+                        plainMeta
+                        cipherMeta
+                        created
+                        modified
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  keyGraph(cachedKeyIds: $cachedKeyIds) {
+    ...KeyGraphFragment
+  }
+}
+${KeyGraphFragment}
+`;
+export const parentCategoriesField = (depth = DEFAULT_BREADCRUMB_DEPTH) => {
+    if (!depth) {
+        return '';
+    }
+    return `
+parentCategories: parentDirectoryLinks(plainMeta: $categoryFilter) {
+  edges {
+    node {
+      parentDirectory {
+        id
+        keyId
+        archived
+        plainMeta
+        cipherMeta
+        ${parentCategoriesField(depth - 1)}
+        ${AccessFields}
+      }
+    }
+  }
+}
+`;
+};
+export const GetCategoryQuery = (depth = DEFAULT_BREADCRUMB_DEPTH) => gql `
+query GetCategory(
+  $id: LrRelayIdInput!,
+  $categoryFilter: LrJSONFilter!,
+  $recordFilter: LrJSONFilter!,
+  $contentFilter: LrJSONFilter,
+  $cachedKeyIds: [LrRelayIdInput!]) {
+  category: directory(id: $id) {
+    id
+    keyId
+    archived
+    plainMeta
+    cipherMeta
+    ${AccessFields}
+    ${descendantDirectories}
+    ${parentCategoriesField(depth)}
+    subCategories: childDirectoryLinks(plainMeta: $categoryFilter, orderBy: "created") {
+      edges {
+        node {
+          childDirectory {
+            ${CategoryFields}
+          }
+        }
+      }
+    }
+    records: childDirectoryLinks(plainMeta: $recordFilter, orderBy: "created") {
+      edges {
+        node {
+          childDirectory {
+            id
+            keyId
+            archived
+            plainMeta
+            cipherMeta
+            created
+            modified
+            ${AccessFields}
+            content: childFileLinks(plainMeta: $contentFilter) {
+              edges {
+                node {
+                  childFile {
+                    id
+                    archived
+                    currentVersion {
+                      state {
+                        keyId
+                        plainMeta
+                        cipherMeta
+                        created
+                        modified
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  keyGraph(cachedKeyIds: $cachedKeyIds) {
+    ...KeyGraphFragment
+  }
+}
+${KeyGraphFragment} `;
+export const GetCategoryKeyIdQuery = gql `
+  query GetCategoryKeyIdQuery(
+    $id: LrRelayIdInput!
+    $cachedKeyIds: [LrRelayIdInput!]
+  ) {
+    category: directory(id: $id) {
+      keyId
+    }
+    keyGraph(cachedKeyIds: $cachedKeyIds) {
+      ...KeyGraphFragment
+    }
+  }
+  ${KeyGraphFragment}
+`;
+export const CreateCategoryMutation = gql `
+  mutation CreateCategory(
+    $plainMeta: LrJSONString
+    $cipherMeta: String
+    $parentDirectories: [ParentDirectoryInput!]
+    $parentRootDirectory: ParentRootDirectoryInput
+  ) {
+    new: createDirectory(
+      input: {
+        plainMeta: $plainMeta
+        cipherMeta: $cipherMeta
+        parentDirectories: $parentDirectories
+        parentRootDirectory: $parentRootDirectory
+      }
+    ) {
+      category: directory {
+        id
+        keyId
+      }
+    }
+  }
+`;
+export const CreateVaultMutation = gql `
+  mutation CreateCategory(
+    $plainMeta: LrJSONString
+    $cipherMeta: String
+    $parentRootDirectory: ParentRootDirectoryInput
+  ) {
+    new: createDirectory(
+      input: {
+        plainMeta: $plainMeta
+        cipherMeta: $cipherMeta
+        parentRootDirectory: $parentRootDirectory
+      }
+    ) {
+      vault: directory {
+        id
+        keyId
+      }
+    }
+  }
+`;
+export const UpdateCategoryMutation = gql `
+  mutation UpdateCategory($input: UpdateDirectoryInput!) {
+    updateDirectory(input: $input) {
+      directory {
+        id
+      }
+    }
+  }
+`;
+export const DeleteCategoryMutation = gql `
+  mutation DeleteCategory($categoryId: LrRelayIdInput!) {
+    deleteDirectory(input: { directoryId: $categoryId }) {
+      id
+    }
+  }
+`;
+export const ArchiveDirectoryMutation = gql `
+  mutation ArchiveDirectory($input: ArchiveDirectoryInput!) {
+    archiveDirectory(input: $input) {
+      directory {
+        id
+      }
+    }
+  }
+`;
+export const UnarchiveDirectoryMutation = gql `
+  mutation UnarchiveDirectory($input: UnarchiveDirectoryInput!) {
+    unarchiveDirectory(input: $input) {
+      directory {
+        id
+      }
+    }
+  }
+`;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"category.gql.js","sourceRoot":"C:/Projects/test/projects/core/src/","sources":["lib/category/category.gql.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,GAAG,MAAM,aAAa,CAAC;AAG9B,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,CAAC;AAC1C,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,CAAC;AAE3C,MAAM,CAAN,IAAY,aAIX;AAJD,WAAY,aAAa;IACvB,gCAAe,CAAA;IACf,sCAAqB,CAAA;IACrB,kCAAiB,CAAA;AACnB,CAAC,EAJW,aAAa,KAAb,aAAa,QAIxB;AAED,MAAM,CAAC,MAAM,kBAAkB,GAAG,IAAI,CAAC,SAAS,CAAC;IAC/C,MAAM,EAAE;QACN;YACE,QAAQ,EAAE;gBACR,aAAa,EAAE,aAAa,CAAC,KAAK;gBAClC,OAAO,EAAE,IAAI;aACd;SACF;KACF;CACF,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,cAAc,GAAG,IAAI,CAAC,SAAS,CAAC;IAC3C,MAAM,EAAE;QACN;YACE,QAAQ,EAAE;gBACR,aAAa,EAAE,aAAa,CAAC,QAAQ;aACtC;SACF;KACF;CACF,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,YAAY,GAAG,IAAI,CAAC,SAAS,CAAC;IACzC,MAAM,EAAE;QACN;YACE,QAAQ,EAAE;gBACR,aAAa,EAAE,aAAa,CAAC,MAAM;aACpC;SACF;KACF;CACF,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,YAAY,GAAG;;;;;;;;;;;EAW1B,CAAC;AAEH,MAAM,qBAAqB,GAAG;+BACC,yBAAyB;;;CAGvD,CAAC;AAEF,MAAM,CAAC,MAAM,cAAc,GAAG;;;;;;IAM1B,YAAY;IACZ,qBAAqB;CACxB,CAAC;AAEF,MAAM,CAAC,MAAM,WAAW,GAAG;;;;;CAK1B,CAAC;AAEF,MAAM,CAAC,MAAM,wBAAwB,GAAG,GAAG,CAAA;;;;;;;;;;CAU1C,CAAC;AAEF,MAAM,CAAC,MAAM,kBAAkB,GAAG,GAAG,CAAA;;;;;;;;;;kBAUnB,cAAc;;;;;;;;;;;;EAY9B,gBAAgB;CACjB,CAAC;AAEF,MAAM,CAAC,MAAM,cAAc,GAAG,GAAG,CAAA;;;;;;UAMvB,WAAW;;;;;;;;EAQnB,gBAAgB;CACjB,CAAC;AAWF,MAAM,CAAC,MAAM,8BAA8B,GAAG,GAAG,CAAA;;;;;;;;cAQnC,cAAc;;;;;;;;;;;;;;cAcd,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6BxB,gBAAgB;CACjB,CAAC;AAWF,MAAM,CAAC,MAAM,0BAA0B,GAAG,GAAG,CAAA;;;;;;;;cAQ/B,cAAc;;;;;;;;;;;;;;cAcd,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6BxB,gBAAgB;CACjB,CAAC;AAEF,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,KAAK,GAAG,wBAAwB,EAAE,EAAE;IACxE,IAAI,CAAC,KAAK,EAAE;QACV,OAAO,EAAE,CAAC;KACX;IACD,OAAO;;;;;;;;;;UAUC,qBAAqB,CAAC,KAAK,GAAG,CAAC,CAAC;UAChC,YAAY;;;;;CAKrB,CAAC;AACF,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAC9B,QAAgB,wBAAwB,EACxC,EAAE,CAAC,GAAG,CAAA;;;;;;;;;;;;;MAaF,YAAY;MACZ,qBAAqB;MACrB,qBAAqB,CAAC,KAAK,CAAC;;;;;cAKpB,cAAc;;;;;;;;;;;;;;;;cAgBd,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6BxB,gBAAgB,GAAG,CAAC;AAEtB,MAAM,CAAC,MAAM,qBAAqB,GAAG,GAAG,CAAA;;;;;;;;;;;;IAYpC,gBAAgB;CACnB,CAAC;AAEF,MAAM,CAAC,MAAM,sBAAsB,GAAG,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;CAqBxC,CAAC;AAEF,MAAM,CAAC,MAAM,mBAAmB,GAAG,GAAG,CAAA;;;;;;;;;;;;;;;;;;;CAmBrC,CAAC;AAEF,MAAM,CAAC,MAAM,sBAAsB,GAAG,GAAG,CAAA;;;;;;;;CAQxC,CAAC;AAEF,MAAM,CAAC,MAAM,sBAAsB,GAAG,GAAG,CAAA;;;;;;CAMxC,CAAC;AAEF,MAAM,CAAC,MAAM,wBAAwB,GAAG,GAAG,CAAA;;;;;;;;CAQ1C,CAAC;AAEF,MAAM,CAAC,MAAM,0BAA0B,GAAG,GAAG,CAAA;;;;;;;;CAQ5C,CAAC","sourcesContent":["import { HasKeyGraph } from './../cryptography/cryptography.types';\r\nimport { KeyGraphFragment } from '../_common/queries.gql';\r\nimport gql from 'graphql-tag';\r\nimport { HasKeyGraphEdges, HasEdges } from '../_common/types';\r\n\r\nexport const DEFAULT_BREADCRUMB_DEPTH = 5;\r\nexport const DEFAULT_DESCENDANTS_DEPTH = 5;\r\n\r\nexport enum DirectoryType {\r\n  Vault = 'vault',\r\n  Category = 'category',\r\n  Record = 'record',\r\n}\r\n\r\nexport const DefaultVaultFilter = JSON.stringify({\r\n  filter: [\r\n    {\r\n      contains: {\r\n        directoryType: DirectoryType.Vault,\r\n        default: true,\r\n      },\r\n    },\r\n  ],\r\n});\r\n\r\nexport const CategoryFilter = JSON.stringify({\r\n  filter: [\r\n    {\r\n      contains: {\r\n        directoryType: DirectoryType.Category,\r\n      },\r\n    },\r\n  ],\r\n});\r\n\r\nexport const RecordFilter = JSON.stringify({\r\n  filter: [\r\n    {\r\n      contains: {\r\n        directoryType: DirectoryType.Record,\r\n      },\r\n    },\r\n  ],\r\n});\r\n\r\nexport const AccessFields = `\r\naccessRoles {\r\n  role\r\n  method\r\n  inheritedFrom {\r\n    id\r\n  }\r\n  trustedParty {\r\n    id\r\n  }\r\n  isIssuer\r\n}`;\r\n\r\nconst descendantDirectories = `\r\ndescendantDirectories(depth: ${DEFAULT_DESCENDANTS_DEPTH}, plainMeta: $categoryFilter, archived: false) {\r\n  recordsCount: directoriesCount(plainMeta: $recordFilter, archived: false)\r\n}\r\n`;\r\n\r\nexport const CategoryFields = `\r\n  id\r\n  keyId\r\n  archived\r\n  plainMeta\r\n  cipherMeta\r\n  ${AccessFields}\r\n  ${descendantDirectories}\r\n`;\r\n\r\nexport const VaultFields = `\r\n  id\r\n  keyId\r\n  plainMeta\r\n  cipherMeta\r\n`;\r\n\r\nexport const GetRootDirectoryIdsQuery = gql`\r\n  query GetRootDirectoryIdsQuery($archived: Boolean) {\r\n    rootDirectories(archived: $archived) {\r\n      edges {\r\n        node {\r\n          id\r\n        }\r\n      }\r\n    }\r\n  }\r\n`;\r\n\r\nexport const GetCategoriesQuery = gql`\r\nquery GetCategories($vaultFilter: LrJSONFilter!, $categoryFilter: LrJSONFilter!, $recordFilter: LrJSONFilter!, $archived: Boolean, $cachedKeyIds: [LrRelayIdInput!])\r\n{\r\n  vaults: rootDirectories(plainMeta: $vaultFilter) {\r\n    edges {\r\n      node {\r\n        childDirectoryLinks(plainMeta: $categoryFilter, orderBy: \"created\", archived: $archived) {\r\n          edges {\r\n            node {\r\n              childDirectory {\r\n                ${CategoryFields}\r\n              }\r\n            }\r\n          }\r\n        }\r\n      }\r\n    }\r\n  }\r\n  keyGraph(cachedKeyIds: $cachedKeyIds) {\r\n    ...KeyGraphFragment\r\n  }\r\n}\r\n${KeyGraphFragment}\r\n`;\r\n\r\nexport const GetVaultsQuery = gql`\r\nquery GetVaults($plainMetaFilter: LrJSONFilter!, $cachedKeyIds: [LrRelayIdInput!])\r\n{\r\n  list: rootDirectories(plainMeta: $plainMetaFilter, orderBy: \"created\") {\r\n    edges {\r\n      node {\r\n        ${VaultFields}\r\n      }\r\n    }\r\n  }\r\n  keyGraph(cachedKeyIds: $cachedKeyIds) {\r\n    ...KeyGraphFragment\r\n  }\r\n}\r\n${KeyGraphFragment}\r\n`;\r\n\r\nexport interface GetTrustedPartyCategoriesQueryType extends HasKeyGraph {\r\n  tp: {\r\n    sharedItems: {\r\n      list: HasEdges<any>;\r\n      records: HasEdges<any>;\r\n    };\r\n  };\r\n}\r\n\r\nexport const GetTrustedPartyCategoriesQuery = gql`\r\nquery GetTrustedPartyCategoriesQuery($trustedPartyId: LrRelayIdInput!, $categoryFilter: LrJSONFilter!, $recordFilter: LrJSONFilter!, $contentFilter: LrJSONFilter, $cachedKeyIds: [LrRelayIdInput!])\r\n{\r\n  tp(id: $trustedPartyId) {\r\n    sharedItems {\r\n      list: directories(plainMeta: $categoryFilter, orderBy: \"created\") {\r\n        edges {\r\n          node {\r\n            ${CategoryFields}\r\n          }\r\n        }\r\n      }\r\n      records: directories(plainMeta: $recordFilter, orderBy: \"created\") {\r\n        edges {\r\n          node {\r\n            id\r\n            keyId\r\n            archived\r\n            plainMeta\r\n            cipherMeta\r\n            created\r\n            modified\r\n            ${AccessFields}\r\n            content: childFileLinks(plainMeta: $contentFilter) {\r\n              edges {\r\n                node {\r\n                  childFile {\r\n                    id\r\n                    archived\r\n                    currentVersion {\r\n                      state {\r\n                        keyId\r\n                        plainMeta\r\n                        cipherMeta\r\n                        created\r\n                        modified\r\n                      }\r\n                    }\r\n                  }\r\n                }\r\n              }\r\n            }\r\n          }\r\n        }\r\n      }\r\n    }\r\n  }\r\n  keyGraph(cachedKeyIds: $cachedKeyIds) {\r\n    ...KeyGraphFragment\r\n  }\r\n}\r\n${KeyGraphFragment}\r\n`;\r\n\r\nexport interface GetMySharedCategoriesQueryType extends HasKeyGraph {\r\n  tp: {\r\n    myItems: {\r\n      list: HasEdges<any>;\r\n      records: HasEdges<any>;\r\n    };\r\n  };\r\n}\r\n\r\nexport const GetMySharedCategoriesQuery = gql`\r\nquery GetMySharedCategoriesQuery($trustedPartyId: LrRelayIdInput!, $categoryFilter: LrJSONFilter!, $recordFilter: LrJSONFilter!, $contentFilter: LrJSONFilter, $cachedKeyIds: [LrRelayIdInput!])\r\n{\r\n  tp(id: $trustedPartyId) {\r\n    myItems {\r\n      list: directories(plainMeta: $categoryFilter, orderBy: \"created\") {\r\n        edges {\r\n          node {\r\n            ${CategoryFields}\r\n          }\r\n        }\r\n      }\r\n      records: directories(plainMeta: $recordFilter, orderBy: \"created\") {\r\n        edges {\r\n          node {\r\n            id\r\n            keyId\r\n            archived\r\n            plainMeta\r\n            cipherMeta\r\n            created\r\n            modified\r\n            ${AccessFields}\r\n            content: childFileLinks(plainMeta: $contentFilter) {\r\n              edges {\r\n                node {\r\n                  childFile {\r\n                    id\r\n                    archived\r\n                    currentVersion {\r\n                      state {\r\n                        keyId\r\n                        plainMeta\r\n                        cipherMeta\r\n                        created\r\n                        modified\r\n                      }\r\n                    }\r\n                  }\r\n                }\r\n              }\r\n            }\r\n          }\r\n        }\r\n      }\r\n    }\r\n  }\r\n  keyGraph(cachedKeyIds: $cachedKeyIds) {\r\n    ...KeyGraphFragment\r\n  }\r\n}\r\n${KeyGraphFragment}\r\n`;\r\n\r\nexport const parentCategoriesField = (depth = DEFAULT_BREADCRUMB_DEPTH) => {\r\n  if (!depth) {\r\n    return '';\r\n  }\r\n  return `\r\nparentCategories: parentDirectoryLinks(plainMeta: $categoryFilter) {\r\n  edges {\r\n    node {\r\n      parentDirectory {\r\n        id\r\n        keyId\r\n        archived\r\n        plainMeta\r\n        cipherMeta\r\n        ${parentCategoriesField(depth - 1)}\r\n        ${AccessFields}\r\n      }\r\n    }\r\n  }\r\n}\r\n`;\r\n};\r\n\r\nexport const GetCategoryQuery = (\r\n  depth: number = DEFAULT_BREADCRUMB_DEPTH\r\n) => gql`\r\nquery GetCategory(\r\n  $id: LrRelayIdInput!,\r\n  $categoryFilter: LrJSONFilter!,\r\n  $recordFilter: LrJSONFilter!,\r\n  $contentFilter: LrJSONFilter,\r\n  $cachedKeyIds: [LrRelayIdInput!]) {\r\n  category: directory(id: $id) {\r\n    id\r\n    keyId\r\n    archived\r\n    plainMeta\r\n    cipherMeta\r\n    ${AccessFields}\r\n    ${descendantDirectories}\r\n    ${parentCategoriesField(depth)}\r\n    subCategories: childDirectoryLinks(plainMeta: $categoryFilter, orderBy: \"created\") {\r\n      edges {\r\n        node {\r\n          childDirectory {\r\n            ${CategoryFields}\r\n          }\r\n        }\r\n      }\r\n    }\r\n    records: childDirectoryLinks(plainMeta: $recordFilter, orderBy: \"created\") {\r\n      edges {\r\n        node {\r\n          childDirectory {\r\n            id\r\n            keyId\r\n            archived\r\n            plainMeta\r\n            cipherMeta\r\n            created\r\n            modified\r\n            ${AccessFields}\r\n            content: childFileLinks(plainMeta: $contentFilter) {\r\n              edges {\r\n                node {\r\n                  childFile {\r\n                    id\r\n                    archived\r\n                    currentVersion {\r\n                      state {\r\n                        keyId\r\n                        plainMeta\r\n                        cipherMeta\r\n                        created\r\n                        modified\r\n                      }\r\n                    }\r\n                  }\r\n                }\r\n              }\r\n            }\r\n          }\r\n        }\r\n      }\r\n    }\r\n  }\r\n  keyGraph(cachedKeyIds: $cachedKeyIds) {\r\n    ...KeyGraphFragment\r\n  }\r\n}\r\n${KeyGraphFragment} `;\r\n\r\nexport const GetCategoryKeyIdQuery = gql`\r\n  query GetCategoryKeyIdQuery(\r\n    $id: LrRelayIdInput!\r\n    $cachedKeyIds: [LrRelayIdInput!]\r\n  ) {\r\n    category: directory(id: $id) {\r\n      keyId\r\n    }\r\n    keyGraph(cachedKeyIds: $cachedKeyIds) {\r\n      ...KeyGraphFragment\r\n    }\r\n  }\r\n  ${KeyGraphFragment}\r\n`;\r\n\r\nexport const CreateCategoryMutation = gql`\r\n  mutation CreateCategory(\r\n    $plainMeta: LrJSONString\r\n    $cipherMeta: String\r\n    $parentDirectories: [ParentDirectoryInput!]\r\n    $parentRootDirectory: ParentRootDirectoryInput\r\n  ) {\r\n    new: createDirectory(\r\n      input: {\r\n        plainMeta: $plainMeta\r\n        cipherMeta: $cipherMeta\r\n        parentDirectories: $parentDirectories\r\n        parentRootDirectory: $parentRootDirectory\r\n      }\r\n    ) {\r\n      category: directory {\r\n        id\r\n        keyId\r\n      }\r\n    }\r\n  }\r\n`;\r\n\r\nexport const CreateVaultMutation = gql`\r\n  mutation CreateCategory(\r\n    $plainMeta: LrJSONString\r\n    $cipherMeta: String\r\n    $parentRootDirectory: ParentRootDirectoryInput\r\n  ) {\r\n    new: createDirectory(\r\n      input: {\r\n        plainMeta: $plainMeta\r\n        cipherMeta: $cipherMeta\r\n        parentRootDirectory: $parentRootDirectory\r\n      }\r\n    ) {\r\n      vault: directory {\r\n        id\r\n        keyId\r\n      }\r\n    }\r\n  }\r\n`;\r\n\r\nexport const UpdateCategoryMutation = gql`\r\n  mutation UpdateCategory($input: UpdateDirectoryInput!) {\r\n    updateDirectory(input: $input) {\r\n      directory {\r\n        id\r\n      }\r\n    }\r\n  }\r\n`;\r\n\r\nexport const DeleteCategoryMutation = gql`\r\n  mutation DeleteCategory($categoryId: LrRelayIdInput!) {\r\n    deleteDirectory(input: { directoryId: $categoryId }) {\r\n      id\r\n    }\r\n  }\r\n`;\r\n\r\nexport const ArchiveDirectoryMutation = gql`\r\n  mutation ArchiveDirectory($input: ArchiveDirectoryInput!) {\r\n    archiveDirectory(input: $input) {\r\n      directory {\r\n        id\r\n      }\r\n    }\r\n  }\r\n`;\r\n\r\nexport const UnarchiveDirectoryMutation = gql`\r\n  mutation UnarchiveDirectory($input: UnarchiveDirectoryInput!) {\r\n    unarchiveDirectory(input: $input) {\r\n      directory {\r\n        id\r\n      }\r\n    }\r\n  }\r\n`;\r\n"]}