@lifeready/core 0.6.0-beta.1

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

@@ -0,0 +1,390 @@
+import { __awaiter } from "tslib";
+import { Injectable } from '@angular/core';
+import { LrApolloService } from '../api/lr-apollo.service';
+import { KeyMetaService } from '../cryptography/key-meta.service';
+import { RecordContentFilter } from '../record/record.gql';
+import { GetRootDirectoryIdsQuery, DefaultVaultFilter, CategoryFilter, CreateVaultMutation, CreateCategoryMutation, DeleteCategoryMutation, DirectoryType, GetCategoriesQuery, GetCategoryQuery, GetMySharedCategoriesQuery, GetTrustedPartyCategoriesQuery, RecordFilter, UpdateCategoryMutation, UnarchiveDirectoryMutation, ArchiveDirectoryMutation, GetVaultsQuery, } from './category.gql';
+import { AccessLevel, } from './category.types';
+import { LrBadStateException } from '../_common/exceptions';
+import { KeyGraphService } from '../cryptography/key-graph.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../api/lr-apollo.service";
+import * as i2 from "../cryptography/key-meta.service";
+import * as i3 from "../cryptography/key-graph.service";
+export class CategoryService {
+    constructor(lrApollo, keyMetaService, keyGraph) {
+        this.lrApollo = lrApollo;
+        this.keyMetaService = keyMetaService;
+        this.keyGraph = keyGraph;
+    }
+    getRootDirectoryIds(input = null) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { rootDirectories } = yield this.lrApollo.query({
+                query: GetRootDirectoryIdsQuery,
+                variables: {
+                    archived: input && input.archived,
+                },
+            });
+            return rootDirectories.edges.map((edge) => edge.node.id);
+        });
+    }
+    getDefaultVault() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { list } = yield this.lrApollo.query({
+                query: GetVaultsQuery,
+                variables: {
+                    plainMetaFilter: DefaultVaultFilter,
+                },
+            });
+            const defaultVaults = yield this.mapVaults(list);
+            if (defaultVaults.length > 1) {
+                throw new LrBadStateException('There are more than one default vaults');
+            }
+            return defaultVaults[0] || null;
+        });
+    }
+    getCategories(input = null) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.lrApollo.query({
+                query: GetCategoriesQuery,
+                variables: {
+                    vaultFilter: DefaultVaultFilter,
+                    categoryFilter: CategoryFilter,
+                    recordFilter: RecordFilter,
+                    archived: input && input.archived,
+                },
+            });
+            if (res.vaults.edges.length > 1) {
+                throw new LrBadStateException('There is more than one default vault');
+            }
+            else if (res.vaults.edges.length < 1) {
+                console.error('There is no default vault.');
+                return [];
+            }
+            else {
+                return yield this.mapCategories(res.vaults.edges[0].node.childDirectoryLinks);
+            }
+        });
+    }
+    getTrustedPartyCategories(trustedPartyId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { tp, } = yield this.lrApollo.query({
+                query: GetTrustedPartyCategoriesQuery,
+                variables: {
+                    trustedPartyId,
+                    categoryFilter: CategoryFilter,
+                    recordFilter: RecordFilter,
+                    contentFilter: RecordContentFilter,
+                },
+            });
+            return {
+                categories: yield this.mapCategories(tp.sharedItems.list),
+                records: yield this.mapRecords(tp.sharedItems.records),
+            };
+        });
+    }
+    getMySharedCategories(trustedPartyId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { tp } = yield this.lrApollo.query({
+                query: GetMySharedCategoriesQuery,
+                variables: {
+                    trustedPartyId,
+                    categoryFilter: CategoryFilter,
+                    recordFilter: RecordFilter,
+                    contentFilter: RecordContentFilter,
+                },
+            });
+            return {
+                categories: yield this.mapCategories(tp.myItems.list),
+                records: yield this.mapRecords(tp.myItems.records),
+            };
+        });
+    }
+    getCategory(categoryId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { category } = yield this.lrApollo.query({
+                query: GetCategoryQuery(),
+                variables: {
+                    id: categoryId,
+                    categoryFilter: CategoryFilter,
+                    recordFilter: RecordFilter,
+                    contentFilter: RecordContentFilter,
+                },
+            });
+            return {
+                category: Object.assign(Object.assign({}, (yield this.mapCategory(category))), { parents: yield this.mapParentCategories(category) }),
+                subCategories: yield this.mapCategories(category.subCategories),
+                records: yield this.mapRecords(category.records),
+            };
+        });
+    }
+    mapVaults(list) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Promise.all(list.edges.map((edge) => this.mapVault(edge.node)));
+        });
+    }
+    mapCategories(list) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield Promise.all(list.edges
+                .map((x) => x.node)
+                .map((x) => x.childDirectory || x)
+                .map((node) => this.mapCategory(node))))
+                .filter((x) => x)
+                .sort((x, y) => (x.name === y.name ? 0 : x.name > y.name ? 1 : -1));
+        });
+    }
+    mapRecords(list) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield Promise.all(list.edges
+                .map((x) => x.node)
+                .map((x) => x.childDirectory || x)
+                .map((node) => this.mapRecord(node))))
+                .filter((x) => x)
+                .sort((x, y) => (x.name === y.name ? 0 : x.name > y.name ? 1 : -1));
+        });
+    }
+    createDefaultVault() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const secureContent = '';
+            const wrappedContent = yield this.keyMetaService.wrapContent(secureContent);
+            const response = yield this.lrApollo.mutate({
+                mutation: CreateVaultMutation,
+                variables: {
+                    plainMeta: JSON.stringify({
+                        directoryType: DirectoryType.Vault,
+                        default: true,
+                    }),
+                    cipherMeta: wrappedContent.cipherMeta,
+                    parentRootDirectory: wrappedContent.rootKey,
+                },
+            });
+            return response.new.vault.id;
+        });
+    }
+    createCategory(newCategory) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const secureContent = {
+                name: newCategory.name,
+                code: newCategory.code,
+                isCustom: newCategory.isCustom,
+                allowRecords: newCategory.allowRecords,
+                allowCustomCategories: newCategory.allowCustomCategories,
+            };
+            const wrappedContent = yield this.keyMetaService.wrapContent(secureContent, newCategory.categoryIds);
+            const response = yield this.lrApollo.mutate({
+                mutation: CreateCategoryMutation,
+                variables: {
+                    plainMeta: JSON.stringify({
+                        directoryType: DirectoryType.Category,
+                        isHidden: false,
+                    }),
+                    cipherMeta: wrappedContent.cipherMeta,
+                    parentDirectories: wrappedContent.wrappedKeys,
+                    parentRootDirectory: wrappedContent.rootKey,
+                },
+            });
+            return response.new.category.id;
+        });
+    }
+    updateCategory(categoryId, keyId, updatedCategory) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const secureContent = {
+                name: updatedCategory.name,
+                code: updatedCategory.code,
+                isCustom: updatedCategory.isCustom,
+                allowRecords: updatedCategory.allowRecords,
+                allowCustomCategories: updatedCategory.allowCustomCategories,
+            };
+            const cipherMeta = yield this.keyGraph.encryptToString(keyId, secureContent);
+            yield this.lrApollo.mutate({
+                mutation: UpdateCategoryMutation,
+                variables: {
+                    input: {
+                        directoryId: categoryId,
+                        cipherMeta,
+                    },
+                },
+            });
+        });
+    }
+    setCategoryVisibility(categoryId, hide) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.lrApollo.mutate({
+                mutation: UpdateCategoryMutation,
+                variables: {
+                    input: {
+                        directoryId: categoryId,
+                        plainMeta: JSON.stringify({
+                            directoryType: DirectoryType.Category,
+                            isHidden: hide,
+                        }),
+                    },
+                },
+            });
+        });
+    }
+    deleteCategory(categoryId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.lrApollo.mutate({
+                mutation: DeleteCategoryMutation,
+                variables: { categoryId },
+            });
+        });
+    }
+    archiveCategory(categoryId, recursive) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.archiveDirectory(categoryId, recursive);
+        });
+    }
+    unarchiveCategory(categoryId, recursive) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.unarchiveDirectory(categoryId, recursive);
+        });
+    }
+    archiveDirectory(directoryId, recursive) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.lrApollo.mutate({
+                mutation: ArchiveDirectoryMutation,
+                variables: {
+                    input: {
+                        directoryId,
+                        recursive,
+                    },
+                },
+            });
+        });
+    }
+    unarchiveDirectory(directoryId, recursive) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.lrApollo.mutate({
+                mutation: UnarchiveDirectoryMutation,
+                variables: {
+                    input: {
+                        directoryId,
+                        recursive,
+                    },
+                },
+            });
+        });
+    }
+    mapVault(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { name } = (yield this.keyMetaService.decryptMeta(node)) || {};
+                return {
+                    id: node.id,
+                    keyId: node.keyId,
+                    name,
+                };
+            }
+            catch (e) {
+                console.error('Failed to decrypt Vault.', e, node);
+                return null;
+            }
+        });
+    }
+    mapParentCategories(category) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!category.parentCategories ||
+                !category.parentCategories.edges ||
+                !category.parentCategories.edges.length) {
+                return [];
+            }
+            const node = category.parentCategories.edges[0].node.parentDirectory;
+            return [
+                ...(yield this.mapParentCategories(node)),
+                yield this.mapCategory(node),
+            ];
+        });
+    }
+    mapCategory(node) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { name, isCustom, allowRecords, allowCustomCategories, code } = (yield this.keyMetaService.decryptMeta(node)) || {};
+                const { isHidden } = (node.plainMeta && JSON.parse(node.plainMeta)) || {};
+                const isOwner = node.accessRoles &&
+                    node.accessRoles.some((x) => x.role === AccessLevel.Owner);
+                return {
+                    id: node.id,
+                    keyId: node.keyId,
+                    code,
+                    name,
+                    isHidden: !!isHidden,
+                    isCustom: !!isCustom,
+                    isArchived: !!node.archived,
+                    allowRecords: !!allowRecords,
+                    allowCustomCategories: !!allowCustomCategories,
+                    isEmpty: node.descendantDirectories
+                        ? node.descendantDirectories.recordsCount === 0
+                        : null,
+                    allRecordsCount: (_a = node.descendantDirectories) === null || _a === void 0 ? void 0 : _a.recordsCount,
+                    myAccessLevel: isOwner ? AccessLevel.Owner : node.accessRoles[0].role,
+                    sharedAccess: isOwner
+                        ? node.accessRoles
+                            .filter((x) => x.role !== AccessLevel.Owner)
+                            .map((x) => ({
+                            trustedPartyId: x.trustedParty && x.trustedParty.id,
+                            accessLevel: x.role,
+                            isInherited: x.method === 'inherited',
+                            inheritedFrom: x.inheritedFrom && x.inheritedFrom.id,
+                        }))
+                        : [],
+                };
+            }
+            catch (e) {
+                console.error('Failed to decrypt Category.', e, node);
+                return null;
+            }
+        });
+    }
+    mapRecord(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const contents = node.content.edges[0].node.childFile;
+                const { name, recordType } = (yield this.keyMetaService.decryptMeta(contents.currentVersion.state)) || {};
+                const isOwner = node.accessRoles &&
+                    node.accessRoles.some((x) => x.role === AccessLevel.Owner);
+                return {
+                    id: node.id,
+                    keyId: node.keyId,
+                    name,
+                    recordType,
+                    isArchived: !!node.archived,
+                    createdOn: node.created,
+                    lastModified: new Date(node.modified) >
+                        new Date(contents.currentVersion.state.modified)
+                        ? node.modified
+                        : contents.currentVersion.state.modified,
+                    myAccessLevel: isOwner ? AccessLevel.Owner : node.accessRoles[0].role,
+                    sharedAccess: isOwner
+                        ? node.accessRoles
+                            .filter((x) => x.role !== AccessLevel.Owner)
+                            .map((x) => ({
+                            trustedPartyId: x.trustedParty && x.trustedParty.id,
+                            accessLevel: x.role,
+                            isInherited: x.method === 'inherited',
+                            inheritedFrom: x.inheritedFrom && x.inheritedFrom.id,
+                        }))
+                        : [],
+                };
+            }
+            catch (e) {
+                console.error('Failed to decrypt Record.', e);
+                return null;
+            }
+        });
+    }
+}
+CategoryService.ɵprov = i0.ɵɵdefineInjectable({ factory: function CategoryService_Factory() { return new CategoryService(i0.ɵɵinject(i1.LrApolloService), i0.ɵɵinject(i2.KeyMetaService), i0.ɵɵinject(i3.KeyGraphService)); }, token: CategoryService, providedIn: "root" });
+CategoryService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+CategoryService.ctorParameters = () => [
+    { type: LrApolloService },
+    { type: KeyMetaService },
+    { type: KeyGraphService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"category.service.js","sourceRoot":"C:/Projects/test/projects/core/src/","sources":["lib/category/category.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { LrApolloService } from '../api/lr-apollo.service';\r\nimport { KeyMetaService } from '../cryptography/key-meta.service';\r\nimport { RecordContentFilter } from '../record/record.gql';\r\nimport { HasEdges, HasKeyGraphEdges } from '../_common/types';\r\nimport {\r\n  GetRootDirectoryIdsQuery,\r\n  DefaultVaultFilter,\r\n  CategoryFilter,\r\n  CreateVaultMutation,\r\n  CreateCategoryMutation,\r\n  DeleteCategoryMutation,\r\n  DirectoryType,\r\n  GetCategoriesQuery,\r\n  GetCategoryQuery,\r\n  GetMySharedCategoriesQuery,\r\n  GetMySharedCategoriesQueryType,\r\n  GetTrustedPartyCategoriesQuery,\r\n  GetTrustedPartyCategoriesQueryType,\r\n  RecordFilter,\r\n  UpdateCategoryMutation,\r\n  UnarchiveDirectoryMutation,\r\n  ArchiveDirectoryMutation,\r\n  GetVaultsQuery,\r\n} from './category.gql';\r\nimport {\r\n  AccessLevel,\r\n  Category,\r\n  NewCategory,\r\n  UpdatedCategory,\r\n  VaultCategory,\r\n  VaultRecord,\r\n  Vault,\r\n} from './category.types';\r\nimport { LrBadStateException } from '../_common/exceptions';\r\nimport { KeyGraphService } from '../cryptography/key-graph.service';\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class CategoryService {\r\n  constructor(\r\n    private lrApollo: LrApolloService,\r\n    private keyMetaService: KeyMetaService,\r\n    private keyGraph: KeyGraphService\r\n  ) {}\r\n\r\n  public async getRootDirectoryIds(\r\n    input: { archived: boolean } = null\r\n  ): Promise<string[]> {\r\n    const { rootDirectories } = await this.lrApollo.query<any>({\r\n      query: GetRootDirectoryIdsQuery,\r\n      variables: {\r\n        archived: input && input.archived,\r\n      },\r\n    });\r\n    return rootDirectories.edges.map((edge) => edge.node.id);\r\n  }\r\n\r\n  public async getDefaultVault(): Promise<Vault> {\r\n    const { list } = await this.lrApollo.query<HasKeyGraphEdges<any>>({\r\n      query: GetVaultsQuery,\r\n      variables: {\r\n        plainMetaFilter: DefaultVaultFilter,\r\n      },\r\n    });\r\n\r\n    const defaultVaults = await this.mapVaults(list);\r\n    if (defaultVaults.length > 1) {\r\n      throw new LrBadStateException('There are more than one default vaults');\r\n    }\r\n\r\n    return defaultVaults[0] || null;\r\n  }\r\n\r\n  public async getCategories(\r\n    input: { archived: boolean } = null\r\n  ): Promise<Category[]> {\r\n    const res: any = await this.lrApollo.query<HasKeyGraphEdges<any>>({\r\n      query: GetCategoriesQuery,\r\n      variables: {\r\n        vaultFilter: DefaultVaultFilter,\r\n        categoryFilter: CategoryFilter,\r\n        recordFilter: RecordFilter,\r\n        archived: input && input.archived,\r\n      },\r\n    });\r\n\r\n    if (res.vaults.edges.length > 1) {\r\n      throw new LrBadStateException('There is more than one default vault');\r\n    } else if (res.vaults.edges.length < 1) {\r\n      console.error('There is no default vault.');\r\n      return [];\r\n    } else {\r\n      return await this.mapCategories(\r\n        res.vaults.edges[0].node.childDirectoryLinks\r\n      );\r\n    }\r\n  }\r\n\r\n  public async getTrustedPartyCategories(\r\n    trustedPartyId: string\r\n  ): Promise<{ categories: Category[]; records?: VaultRecord[] }> {\r\n    const {\r\n      tp,\r\n    } = await this.lrApollo.query<GetTrustedPartyCategoriesQueryType>({\r\n      query: GetTrustedPartyCategoriesQuery,\r\n      variables: {\r\n        trustedPartyId,\r\n        categoryFilter: CategoryFilter,\r\n        recordFilter: RecordFilter,\r\n        contentFilter: RecordContentFilter,\r\n      },\r\n    });\r\n    return {\r\n      categories: await this.mapCategories(tp.sharedItems.list),\r\n      records: await this.mapRecords(tp.sharedItems.records),\r\n    };\r\n  }\r\n\r\n  public async getMySharedCategories(\r\n    trustedPartyId: string\r\n  ): Promise<{ categories: Category[]; records?: VaultRecord[] }> {\r\n    const { tp } = await this.lrApollo.query<GetMySharedCategoriesQueryType>({\r\n      query: GetMySharedCategoriesQuery,\r\n      variables: {\r\n        trustedPartyId,\r\n        categoryFilter: CategoryFilter,\r\n        recordFilter: RecordFilter,\r\n        contentFilter: RecordContentFilter,\r\n      },\r\n    });\r\n    return {\r\n      categories: await this.mapCategories(tp.myItems.list),\r\n      records: await this.mapRecords(tp.myItems.records),\r\n    };\r\n  }\r\n\r\n  public async getCategory(categoryId: string): Promise<VaultCategory> {\r\n    const { category } = await this.lrApollo.query<any>({\r\n      query: GetCategoryQuery(),\r\n      variables: {\r\n        id: categoryId,\r\n        categoryFilter: CategoryFilter,\r\n        recordFilter: RecordFilter,\r\n        contentFilter: RecordContentFilter,\r\n      },\r\n    });\r\n\r\n    return {\r\n      category: {\r\n        ...(await this.mapCategory(category)),\r\n        parents: await this.mapParentCategories(category),\r\n      },\r\n      subCategories: await this.mapCategories(category.subCategories),\r\n      records: await this.mapRecords(category.records),\r\n    };\r\n  }\r\n\r\n  private async mapVaults(list: HasEdges<any>): Promise<Vault[]> {\r\n    return Promise.all<Vault>(\r\n      list.edges.map((edge) => this.mapVault(edge.node))\r\n    );\r\n  }\r\n\r\n  private async mapCategories(list: HasEdges<any>) {\r\n    return (\r\n      await Promise.all<Category>(\r\n        list.edges\r\n          .map((x) => x.node)\r\n          .map((x) => x.childDirectory || x)\r\n          .map(\r\n            (node: {\r\n              id;\r\n              keyId;\r\n              plainMeta;\r\n              cipherMeta;\r\n              descendantDirectories;\r\n              accessRoles;\r\n              archived;\r\n            }) => this.mapCategory(node)\r\n          )\r\n      )\r\n    )\r\n      .filter((x) => x)\r\n      .sort((x, y) => (x.name === y.name ? 0 : x.name > y.name ? 1 : -1));\r\n  }\r\n\r\n  private async mapRecords(list: HasEdges<any>) {\r\n    return (\r\n      await Promise.all<VaultRecord>(\r\n        list.edges\r\n          .map((x) => x.node)\r\n          .map((x) => x.childDirectory || x)\r\n          .map(\r\n            (node: {\r\n              id;\r\n              keyId;\r\n              plainMeta;\r\n              cipherMeta;\r\n              created;\r\n              modified;\r\n              content;\r\n              accessRoles;\r\n              archived;\r\n            }) => this.mapRecord(node)\r\n          )\r\n      )\r\n    )\r\n      .filter((x) => x)\r\n      .sort((x, y) => (x.name === y.name ? 0 : x.name > y.name ? 1 : -1));\r\n  }\r\n\r\n  public async createDefaultVault(): Promise<string> {\r\n    const secureContent = '';\r\n    const wrappedContent = await this.keyMetaService.wrapContent(secureContent);\r\n\r\n    const response = await this.lrApollo.mutate<any>({\r\n      mutation: CreateVaultMutation,\r\n      variables: {\r\n        plainMeta: JSON.stringify({\r\n          directoryType: DirectoryType.Vault,\r\n          default: true,\r\n        }),\r\n        cipherMeta: wrappedContent.cipherMeta,\r\n        parentRootDirectory: wrappedContent.rootKey,\r\n      },\r\n    });\r\n\r\n    return response.new.vault.id;\r\n  }\r\n\r\n  public async createCategory(newCategory: NewCategory): Promise<string> {\r\n    const secureContent = {\r\n      name: newCategory.name,\r\n      code: newCategory.code,\r\n      isCustom: newCategory.isCustom,\r\n      allowRecords: newCategory.allowRecords,\r\n      allowCustomCategories: newCategory.allowCustomCategories,\r\n    };\r\n    const wrappedContent = await this.keyMetaService.wrapContent(\r\n      secureContent,\r\n      newCategory.categoryIds\r\n    );\r\n\r\n    const response = await this.lrApollo.mutate<any>({\r\n      mutation: CreateCategoryMutation,\r\n      variables: {\r\n        plainMeta: JSON.stringify({\r\n          directoryType: DirectoryType.Category,\r\n          isHidden: false,\r\n        }),\r\n        cipherMeta: wrappedContent.cipherMeta,\r\n        parentDirectories: wrappedContent.wrappedKeys,\r\n        parentRootDirectory: wrappedContent.rootKey,\r\n      },\r\n    });\r\n\r\n    return response.new.category.id;\r\n  }\r\n\r\n  public async updateCategory(\r\n    categoryId: string,\r\n    keyId: string,\r\n    updatedCategory: UpdatedCategory\r\n  ): Promise<void> {\r\n    const secureContent = {\r\n      name: updatedCategory.name,\r\n      code: updatedCategory.code,\r\n      isCustom: updatedCategory.isCustom,\r\n      allowRecords: updatedCategory.allowRecords,\r\n      allowCustomCategories: updatedCategory.allowCustomCategories,\r\n    };\r\n\r\n    const cipherMeta = await this.keyGraph.encryptToString(\r\n      keyId,\r\n      secureContent\r\n    );\r\n\r\n    await this.lrApollo.mutate({\r\n      mutation: UpdateCategoryMutation,\r\n      variables: {\r\n        input: {\r\n          directoryId: categoryId,\r\n          cipherMeta,\r\n        },\r\n      },\r\n    });\r\n  }\r\n\r\n  public async setCategoryVisibility(\r\n    categoryId: string,\r\n    hide: boolean\r\n  ): Promise<void> {\r\n    await this.lrApollo.mutate({\r\n      mutation: UpdateCategoryMutation,\r\n      variables: {\r\n        input: {\r\n          directoryId: categoryId,\r\n          plainMeta: JSON.stringify({\r\n            directoryType: DirectoryType.Category,\r\n            isHidden: hide,\r\n          }),\r\n        },\r\n      },\r\n    });\r\n  }\r\n\r\n  public async deleteCategory(categoryId: string): Promise<void> {\r\n    await this.lrApollo.mutate({\r\n      mutation: DeleteCategoryMutation,\r\n      variables: { categoryId },\r\n    });\r\n  }\r\n\r\n  public async archiveCategory(\r\n    categoryId: string,\r\n    recursive: boolean\r\n  ): Promise<void> {\r\n    return this.archiveDirectory(categoryId, recursive);\r\n  }\r\n\r\n  public async unarchiveCategory(\r\n    categoryId: string,\r\n    recursive: boolean\r\n  ): Promise<void> {\r\n    return this.unarchiveDirectory(categoryId, recursive);\r\n  }\r\n\r\n  public async archiveDirectory(\r\n    directoryId: string,\r\n    recursive: boolean\r\n  ): Promise<void> {\r\n    await this.lrApollo.mutate({\r\n      mutation: ArchiveDirectoryMutation,\r\n      variables: {\r\n        input: {\r\n          directoryId,\r\n          recursive,\r\n        },\r\n      },\r\n    });\r\n  }\r\n\r\n  public async unarchiveDirectory(\r\n    directoryId: string,\r\n    recursive: boolean\r\n  ): Promise<void> {\r\n    await this.lrApollo.mutate({\r\n      mutation: UnarchiveDirectoryMutation,\r\n      variables: {\r\n        input: {\r\n          directoryId,\r\n          recursive,\r\n        },\r\n      },\r\n    });\r\n  }\r\n\r\n  public async mapVault(node: {\r\n    id;\r\n    keyId;\r\n    plainMeta;\r\n    cipherMeta;\r\n  }): Promise<Vault> {\r\n    try {\r\n      const { name } = (await this.keyMetaService.decryptMeta(node)) || {};\r\n      return {\r\n        id: node.id,\r\n        keyId: node.keyId,\r\n        name,\r\n      };\r\n    } catch (e) {\r\n      console.error('Failed to decrypt Vault.', e, node);\r\n      return null;\r\n    }\r\n  }\r\n\r\n  public async mapParentCategories(category: {\r\n    parentCategories: any;\r\n  }): Promise<Category[]> {\r\n    if (\r\n      !category.parentCategories ||\r\n      !category.parentCategories.edges ||\r\n      !category.parentCategories.edges.length\r\n    ) {\r\n      return [];\r\n    }\r\n    const node = category.parentCategories.edges[0].node.parentDirectory;\r\n\r\n    return [\r\n      ...(await this.mapParentCategories(node)),\r\n      await this.mapCategory(node),\r\n    ];\r\n  }\r\n\r\n  public async mapCategory(node: {\r\n    id;\r\n    keyId;\r\n    plainMeta;\r\n    cipherMeta;\r\n    descendantDirectories;\r\n    accessRoles: any[];\r\n    archived;\r\n  }): Promise<Category> {\r\n    try {\r\n      const { name, isCustom, allowRecords, allowCustomCategories, code } =\r\n        (await this.keyMetaService.decryptMeta(node)) || {};\r\n      const { isHidden } = (node.plainMeta && JSON.parse(node.plainMeta)) || {};\r\n\r\n      const isOwner =\r\n        node.accessRoles &&\r\n        node.accessRoles.some((x) => x.role === AccessLevel.Owner);\r\n\r\n      return {\r\n        id: node.id,\r\n        keyId: node.keyId,\r\n        code,\r\n        name,\r\n        isHidden: !!isHidden,\r\n        isCustom: !!isCustom,\r\n        isArchived: !!node.archived,\r\n        allowRecords: !!allowRecords,\r\n        allowCustomCategories: !!allowCustomCategories,\r\n        isEmpty: node.descendantDirectories\r\n          ? node.descendantDirectories.recordsCount === 0\r\n          : null,\r\n        allRecordsCount: node.descendantDirectories?.recordsCount, // Need this for testing.\r\n        myAccessLevel: isOwner ? AccessLevel.Owner : node.accessRoles[0].role,\r\n        sharedAccess: isOwner\r\n          ? node.accessRoles\r\n              .filter((x) => x.role !== AccessLevel.Owner)\r\n              .map((x) => ({\r\n                trustedPartyId: x.trustedParty && x.trustedParty.id,\r\n                accessLevel: x.role,\r\n                isInherited: x.method === 'inherited',\r\n                inheritedFrom: x.inheritedFrom && x.inheritedFrom.id,\r\n              }))\r\n          : [],\r\n      };\r\n    } catch (e) {\r\n      console.error('Failed to decrypt Category.', e, node);\r\n      return null;\r\n    }\r\n  }\r\n\r\n  public async mapRecord(node: {\r\n    id;\r\n    keyId;\r\n    plainMeta;\r\n    cipherMeta;\r\n    created;\r\n    modified;\r\n    content;\r\n    accessRoles: any[];\r\n    archived;\r\n  }): Promise<VaultRecord> {\r\n    try {\r\n      const contents = node.content.edges[0].node.childFile;\r\n      const { name, recordType } =\r\n        (await this.keyMetaService.decryptMeta(\r\n          contents.currentVersion.state\r\n        )) || {};\r\n\r\n      const isOwner =\r\n        node.accessRoles &&\r\n        node.accessRoles.some((x) => x.role === AccessLevel.Owner);\r\n\r\n      return {\r\n        id: node.id,\r\n        keyId: node.keyId,\r\n        name,\r\n        recordType,\r\n        isArchived: !!node.archived,\r\n        createdOn: node.created,\r\n        lastModified:\r\n          new Date(node.modified) >\r\n          new Date(contents.currentVersion.state.modified)\r\n            ? node.modified\r\n            : contents.currentVersion.state.modified,\r\n        myAccessLevel: isOwner ? AccessLevel.Owner : node.accessRoles[0].role,\r\n        sharedAccess: isOwner\r\n          ? node.accessRoles\r\n              .filter((x) => x.role !== AccessLevel.Owner)\r\n              .map((x) => ({\r\n                trustedPartyId: x.trustedParty && x.trustedParty.id,\r\n                accessLevel: x.role,\r\n                isInherited: x.method === 'inherited',\r\n                inheritedFrom: x.inheritedFrom && x.inheritedFrom.id,\r\n              }))\r\n          : [],\r\n      };\r\n    } catch (e) {\r\n      console.error('Failed to decrypt Record.', e);\r\n      return null as VaultRecord;\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2015/lib/category/category.types.js

@@ -0,0 +1,29 @@
+export var AccessLevel;
+(function (AccessLevel) {
+    AccessLevel["Owner"] = "OWNER";
+    AccessLevel["Admin"] = "ADMIN";
+    AccessLevel["Writer"] = "WRITER";
+    AccessLevel["Reader"] = "READER";
+    AccessLevel["Deny"] = "DENY";
+})(AccessLevel || (AccessLevel = {}));
+export class SharedAccess {
+}
+export class DefaultCategory {
+}
+export class VaultRecordType {
+}
+export class VaultRecord {
+}
+export class Category {
+}
+export class CurrentCategory extends Category {
+}
+export class VaultCategory {
+}
+export class NewCategory {
+}
+export class UpdatedCategory {
+}
+export class Vault {
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/cryptography/cryptography.types.js

@@ -0,0 +1,11 @@
+export var NodeType;
+(function (NodeType) {
+    NodeType["Key"] = "key";
+    NodeType["PassKey"] = "passKey";
+})(NodeType || (NodeType = {}));
+export var EdgeType;
+(function (EdgeType) {
+    EdgeType["KeyLink"] = "keyLink";
+    EdgeType["PassKeyLink"] = "passKeyLink";
+})(EdgeType || (EdgeType = {}));
+//# sourceMappingURL=data:application/json;base64,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