@lifeready/core 0.6.0-beta.1

package/esm2015/lib/api/item2.gql.js

@@ -0,0 +1,110 @@
+import { gqlTyped } from '../_common/ast';
+export const DirectoryKeyQuery = gqlTyped `
+query DirectoryKeyQuery($id: LrRelayIdInput!) {
+  directory(id: $id) {
+    keyId
+  }
+}
+`;
+export const FileKeyQuery = gqlTyped `
+query FileKeyQuery($id: LrRelayIdInput!) {
+  file(id: $id) {
+    keyId
+  }
+}
+`;
+export const FileStateKeyQuery = gqlTyped `
+query FileStateKeyQuery($id: LrRelayIdInput!) {
+  fileState(id: $id) {
+    keyId
+  }
+}
+`;
+export const CreateDirectoryMutation = gqlTyped `
+mutation CreateDirectoryMutation($input: CreateDirectoryInput!) {
+  createDirectory(input: $input) {
+    directory {
+      id
+    }
+  }
+}
+`;
+export const UpdateDirectoryMutation = gqlTyped `
+mutation UpdateDirectoryMutation($input: UpdateDirectoryInput!) {
+  updateDirectory(input: $input) {
+    directory {
+      id
+      modified
+    }
+  }
+}
+`;
+export const DeleteDirectoryMutation = gqlTyped `
+mutation DeleteDirectoryMutation($input: DeleteDirectoryInput!) {
+  deleteDirectory(input: $input) {
+    id
+  }
+}
+`;
+export const CreateFileMutation = gqlTyped `
+mutation CreateFileMutation($input: CreateFileInput!) {
+  createFile(input: $input) {
+    file {
+      id
+    }
+  }
+}
+`;
+export const UpdateFileMutation = gqlTyped `
+mutation UpdateFileMutation($input: UpdateFileInput!) {
+  updateFile(input: $input) {
+    file {
+      id
+    }
+  }
+}
+`;
+export const DeleteFileMutation = gqlTyped `
+mutation DeleteFileMutation($input: DeleteFileInput!) {
+  deleteFile(input: $input) {
+    id
+  }
+}
+`;
+export const ArchiveDirectoryMutation = gqlTyped `
+mutation ArchiveDirectoryMutation($input: ArchiveDirectoryInput!) {
+  archiveDirectory(input: $input) {
+    directory {
+      id
+    }
+  }
+}
+`;
+export const UnarchiveDirectoryMutation = gqlTyped `
+mutation UnarchiveDirectoryMutation($input: UnarchiveDirectoryInput!) {
+  unarchiveDirectory(input: $input) {
+    directory {
+      id
+    }
+  }
+}
+`;
+export const ChangeDirectoryParentsMutation = gqlTyped `
+mutation ChangeDirectoryParentsMutation($input: ChangeDirectoryParentsInput!) {
+  changeDirectoryParents(input: $input) {
+    directory {
+      id
+    }
+  }
+}
+`;
+export const ChangeFileParentsMutation = gqlTyped `
+mutation ChangeFileParentsMutation($input: ChangeFileParentsInput!) {
+  changeFileParents(input: $input) {
+    file {
+      id
+    }
+  }
+}
+`;
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/api/item2.service.js

@@ -0,0 +1,311 @@
+import { __awaiter, __decorate } from "tslib";
+import { Injectable, Injector, NgZone } from '@angular/core';
+import { KeyFactoryService } from '../cryptography/key-factory.service';
+import { KeyGraphService } from '../cryptography/key-graph.service';
+import { KeyMetaService } from '../cryptography/key-meta.service';
+import { KeyService } from '../cryptography/key.service';
+import { LrBadArgumentException } from '../_common/exceptions';
+import { RunOutsideAngular } from '../_common/run-outside-angular';
+import { FileService } from './file.service';
+import { LrMutation, LrService } from './lr-graphql';
+import { DirectoryKeyQuery, CreateDirectoryMutation, DeleteDirectoryMutation, CreateFileMutation, DeleteFileMutation, FileKeyQuery, FileStateKeyQuery, UpdateFileMutation, UpdateDirectoryMutation, ArchiveDirectoryMutation, UnarchiveDirectoryMutation, ChangeDirectoryParentsMutation, ChangeFileParentsMutation, } from './item2.gql';
+import * as i0 from "@angular/core";
+import * as i1 from "./file.service";
+import * as i2 from "../cryptography/key.service";
+import * as i3 from "../cryptography/key-meta.service";
+import * as i4 from "../cryptography/key-factory.service";
+import * as i5 from "../cryptography/key-graph.service";
+export var DirectoryLinkType;
+(function (DirectoryLinkType) {
+    DirectoryLinkType["HARD"] = "HARD";
+})(DirectoryLinkType || (DirectoryLinkType = {}));
+let Item2Service = class Item2Service extends LrService {
+    constructor(ngZone, injector, fileService, keyService, keyMeta, keyFactory, keyGraph) {
+        super(injector);
+        this.ngZone = ngZone;
+        this.injector = injector;
+        this.fileService = fileService;
+        this.keyService = keyService;
+        this.keyMeta = keyMeta;
+        this.keyFactory = keyFactory;
+        this.keyGraph = keyGraph;
+    }
+    downloadFileContent(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fileContent = yield this.fileService.downloadEncryptedFile2(options.fileStateNodeId);
+            const fileStateKey = yield this.keyGraph.getKey(options.fileStateKeyId, () => this.getFileStateKeyId(options.fileStateNodeId));
+            return this.keyGraph.decryptFromString(fileStateKey, fileContent, {
+                payloadType: 'ArrayBuffer',
+            });
+        });
+    }
+    createDirectory(options) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const directoryKey = yield this.keyFactory.createKey();
+            options.parentDirectories = options.parentDirectories || [];
+            if (!options.asRootDirectory && !((_a = options.parentDirectories) === null || _a === void 0 ? void 0 : _a.length)) {
+                throw new LrBadArgumentException('A new directory must be either a root directory or a sub-directory. So you must provide either parentDirectories and/or asRootDirectory parameter.');
+            }
+            const parentDirectories = yield Promise.all((_b = options.parentDirectories) === null || _b === void 0 ? void 0 : _b.map((t) => this.getParentDirectoryInput(t, directoryKey)));
+            // TODO this is rather an unfortunate name, change it to asRootDirectory.
+            let parentRootDirectory;
+            if (options.asRootDirectory) {
+                const rootKey = this.keyService.getCurrentRootKey();
+                parentRootDirectory = {
+                    wrappingKeyId: rootKey.id,
+                    wrappedKey: yield this.keyGraph.wrapKey(rootKey, directoryKey),
+                };
+            }
+            const input = Object.assign(Object.assign({}, (yield this.getInput(directoryKey, options))), { parentDirectories,
+                parentRootDirectory });
+            return new LrMutation({
+                mutation: CreateDirectoryMutation,
+                variables: {
+                    input,
+                },
+            });
+        });
+    }
+    updateDirectoryExec(options) {
+        return this.mutate(this.updateDirectoryMutation(options));
+    }
+    updateDirectory(options) {
+        return this.updateDirectoryMutation(options);
+    }
+    updateDirectoryMutation(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const directoryKey = yield this.getDirectoryKey(options.directoryId, options.directoryKeyId);
+            return new LrMutation({
+                mutation: UpdateDirectoryMutation,
+                variables: {
+                    input: Object.assign(Object.assign({}, (yield this.getInput(directoryKey.jwk, options))), { directoryId: options.directoryId }),
+                },
+            });
+        });
+    }
+    deleteDirectory(id) {
+        return new LrMutation({
+            mutation: DeleteDirectoryMutation,
+            variables: {
+                input: {
+                    directoryId: id,
+                },
+            },
+        });
+    }
+    createFile(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fileKey = yield this.keyFactory.createKey();
+            const parentDirectories = yield Promise.all(options.parentDirectories.map((t) => __awaiter(this, void 0, void 0, function* () {
+                const { directoryId, wrappingKeyId, wrappedKey, } = yield this.getParentDirectoryInput(t, fileKey);
+                // remap from ParentDirectoryInput to FileParentDirectoryInput
+                // TODO the server should really just use wrappedKey instead of wrappedFileKey
+                return {
+                    directoryId,
+                    wrappingKeyId,
+                    wrappedFileKey: wrappedKey,
+                };
+            })));
+            return new LrMutation({
+                mutation: CreateFileMutation,
+                variables: {
+                    input: Object.assign(Object.assign({}, (yield this.createFileState(fileKey, options))), { parentDirectories }),
+                },
+            });
+        });
+    }
+    updateFile(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fileKey = yield this.getFileKey(options.fileId, options.fileKeyId);
+            return new LrMutation({
+                mutation: UpdateFileMutation,
+                variables: {
+                    input: Object.assign(Object.assign({}, (yield this.createFileState(fileKey.jwk, options))), { fileId: options.fileId }),
+                },
+            });
+        });
+    }
+    deleteFile(id) {
+        return new LrMutation({
+            mutation: DeleteFileMutation,
+            variables: {
+                input: {
+                    fileId: id,
+                },
+            },
+        });
+    }
+    getParentDirectoryInput(options, newKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // If directory's key is not already in the key graph, then need to
+            // fetch the directory's key.
+            const wrappingKey = yield this.getDirectoryKey(options.directoryId, options.wrappingKeyId);
+            return {
+                directoryId: options.directoryId,
+                wrappingKeyId: wrappingKey.id,
+                wrappedKey: yield this.keyGraph.wrapKey(wrappingKey, newKey),
+            };
+        });
+    }
+    // async getKey(keyId: LrRelayIdInput, getKeyIdCallback: () => Promise<ID>) {
+    //   if (!this.keyGraph.hasKey(keyId)) {
+    //     keyId = await getKeyIdCallback();
+    //   }
+    //   return this.keyGraph.getKey(keyId);
+    // }
+    getFileStateKeyId(fileStateNodeId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.query({
+                query: FileStateKeyQuery,
+                variables: {
+                    id: fileStateNodeId,
+                },
+            })).fileState.keyId;
+        });
+    }
+    getDirectoryKeyId(directoryId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.query({
+                query: DirectoryKeyQuery,
+                variables: {
+                    id: directoryId,
+                },
+            })).directory.keyId;
+        });
+    }
+    getFileKeyId(fileId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.query({
+                query: FileKeyQuery,
+                variables: {
+                    id: fileId,
+                },
+            })).file.keyId;
+        });
+    }
+    getDirectoryKey(directoryId, directoryKeyId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.keyGraph.getKey(directoryKeyId, () => this.getDirectoryKeyId(directoryId));
+        });
+    }
+    getFileKey(fileId, fileKeyId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.keyGraph.getKey(fileKeyId, () => this.getFileKeyId(fileId));
+        });
+    }
+    getInput(key, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { plainMetaJson, cipherMetaClearJson } = options;
+            return {
+                plainMeta: plainMetaJson && JSON.stringify(plainMetaJson),
+                cipherMeta: cipherMetaClearJson &&
+                    (yield this.keyGraph.encryptToString(key, cipherMetaClearJson)),
+            };
+        });
+    }
+    createFileState(fileKey, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Each version of the file is encrypted using a new key.
+            const fileStateKey = yield this.keyFactory.createKey();
+            const fileContent = options.file && (yield this.fileService.loadFile(options.file));
+            let contentResource;
+            if (fileContent) {
+                const cipherFileContent = yield this.keyGraph.encryptToString(fileStateKey, fileContent);
+                if (options.upload) {
+                    contentResource = yield options.upload(cipherFileContent);
+                }
+                else {
+                    contentResource = yield this.fileService.uploadEncryptedFile({
+                        encryptedContent: cipherFileContent,
+                    });
+                }
+                console.log('contentResource', contentResource);
+            }
+            return Object.assign(Object.assign({}, (yield this.getInput(fileStateKey, options))), { wrappedStateKey: yield this.keyGraph.wrapKey(fileKey, fileStateKey), contentResource });
+        });
+    }
+    archiveDirectory(directoryId, recursive) {
+        return new LrMutation({
+            mutation: ArchiveDirectoryMutation,
+            variables: {
+                input: {
+                    directoryId,
+                    recursive,
+                },
+            },
+        });
+    }
+    unarchiveDirectory(directoryId, recursive) {
+        return new LrMutation({
+            mutation: UnarchiveDirectoryMutation,
+            variables: {
+                input: {
+                    directoryId,
+                    recursive,
+                },
+            },
+        });
+    }
+    getChangeItemParentsInput(options, itemKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const parentsToAdd = yield Promise.all(options.parentsToAdd.map((t) => this.getParentDirectoryInput(t, itemKey)));
+            return {
+                directoriesToRemove: options.parentsToRemove,
+                directoriesToAdd: parentsToAdd,
+            };
+        });
+    }
+    changeDirectoryParents(options) {
+        return this.mutate(this.changeDirectoryParentsMutation(options));
+    }
+    changeDirectoryParentsMutation(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const directoryKey = yield this.getDirectoryKey(options.directoryId, options.directoryKeyId);
+            return new LrMutation({
+                mutation: ChangeDirectoryParentsMutation,
+                variables: {
+                    input: Object.assign(Object.assign({}, (yield this.getChangeItemParentsInput(options, directoryKey.jwk))), { directoryId: options.directoryId }),
+                },
+            });
+        });
+    }
+    changeFileParents(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.mutate(this.changeFileParentsMutation(options));
+        });
+    }
+    changeFileParentsMutation(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fileKey = yield this.getFileKey(options.fileId, options.fileKeyId);
+            return new LrMutation({
+                mutation: ChangeFileParentsMutation,
+                variables: {
+                    input: Object.assign(Object.assign({}, (yield this.getChangeItemParentsInput(options, fileKey.jwk))), { fileId: options.fileId }),
+                },
+            });
+        });
+    }
+};
+Item2Service.ɵprov = i0.ɵɵdefineInjectable({ factory: function Item2Service_Factory() { return new Item2Service(i0.ɵɵinject(i0.NgZone), i0.ɵɵinject(i0.INJECTOR), i0.ɵɵinject(i1.FileService), i0.ɵɵinject(i2.KeyService), i0.ɵɵinject(i3.KeyMetaService), i0.ɵɵinject(i4.KeyFactoryService), i0.ɵɵinject(i5.KeyGraphService)); }, token: Item2Service, providedIn: "root" });
+Item2Service.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+Item2Service.ctorParameters = () => [
+    { type: NgZone },
+    { type: Injector },
+    { type: FileService },
+    { type: KeyService },
+    { type: KeyMetaService },
+    { type: KeyFactoryService },
+    { type: KeyGraphService }
+];
+Item2Service = __decorate([
+    RunOutsideAngular({
+        ngZoneName: 'ngZone',
+    })
+], Item2Service);
+export { Item2Service };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"item2.service.js","sourceRoot":"C:/Projects/test/projects/core/src/","sources":["lib/api/item2.service.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAE7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,qCAAqC,CAAC;AACxE,OAAO,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACpE,OAAO,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAClE,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AACzD,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAC/D,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AACnE,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAoB,UAAU,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACvE,OAAO,EACL,iBAAiB,EACjB,uBAAuB,EACvB,uBAAuB,EACvB,kBAAkB,EAClB,kBAAkB,EAClB,YAAY,EACZ,iBAAiB,EACjB,kBAAkB,EAClB,uBAAuB,EACvB,wBAAwB,EACxB,0BAA0B,EAC1B,8BAA8B,EAC9B,yBAAyB,GAC1B,MAAM,aAAa,CAAC;;;;;;;AAGrB,MAAM,CAAN,IAAY,iBAEX;AAFD,WAAY,iBAAiB;IAC3B,kCAAa,CAAA;AACf,CAAC,EAFW,iBAAiB,KAAjB,iBAAiB,QAE5B;IA+FY,YAAY,SAAZ,YAAa,SAAQ,SAAS;IACzC,YACU,MAAc,EACd,QAAkB,EAClB,WAAwB,EACxB,UAAsB,EACtB,OAAuB,EACvB,UAA6B,EAC7B,QAAyB;QAEjC,KAAK,CAAC,QAAQ,CAAC,CAAC;QARR,WAAM,GAAN,MAAM,CAAQ;QACd,aAAQ,GAAR,QAAQ,CAAU;QAClB,gBAAW,GAAX,WAAW,CAAa;QACxB,eAAU,GAAV,UAAU,CAAY;QACtB,YAAO,GAAP,OAAO,CAAgB;QACvB,eAAU,GAAV,UAAU,CAAmB;QAC7B,aAAQ,GAAR,QAAQ,CAAiB;IAGnC,CAAC;IAEY,mBAAmB,CAC9B,OAAmC;;YAEnC,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,sBAAsB,CAC/D,OAAO,CAAC,eAAe,CACxB,CAAC;YAEF,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAC7C,OAAO,CAAC,cAAc,EACtB,GAAG,EAAE,CAAC,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,eAAe,CAAC,CACtD,CAAC;YAEF,OAAO,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAC,YAAY,EAAE,WAAW,EAAE;gBAChE,WAAW,EAAE,aAAa;aAC3B,CAAC,CAAC;QACL,CAAC;KAAA;IAEY,eAAe,CAAC,OAA+B;;;YAC1D,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,CAAC;YACvD,OAAO,CAAC,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,IAAI,EAAE,CAAC;YAC5D,IAAI,CAAC,OAAO,CAAC,eAAe,IAAI,QAAC,OAAO,CAAC,iBAAiB,0CAAE,MAAM,CAAA,EAAE;gBAClE,MAAM,IAAI,sBAAsB,CAC9B,oJAAoJ,CACrJ,CAAC;aACH;YAED,MAAM,iBAAiB,GAAG,MAAM,OAAO,CAAC,GAAG,OACzC,OAAO,CAAC,iBAAiB,0CAAE,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CACnC,IAAI,CAAC,uBAAuB,CAAC,CAAC,EAAE,YAAY,CAAC,EAEhD,CAAC;YAEF,yEAAyE;YACzE,IAAI,mBAA6C,CAAC;YAClD,IAAI,OAAO,CAAC,eAAe,EAAE;gBAC3B,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,iBAAiB,EAAE,CAAC;gBACpD,mBAAmB,GAAG;oBACpB,aAAa,EAAE,OAAO,CAAC,EAAE;oBACzB,UAAU,EAAE,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,OAAO,EAAE,YAAY,CAAC;iBAC/D,CAAC;aACH;YAED,MAAM,KAAK,mCACN,CAAC,MAAM,IAAI,CAAC,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC,CAAC,KAC/C,iBAAiB;gBACjB,mBAAmB,GACpB,CAAC;YAEF,OAAO,IAAI,UAAU,CAAC;gBACpB,QAAQ,EAAE,uBAAuB;gBACjC,SAAS,EAAE;oBACT,KAAK;iBACN;aACF,CAAC,CAAC;;KACJ;IAED,mBAAmB,CAAC,OAA+B;QACjD,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,uBAAuB,CAAC,OAAO,CAAC,CAAC,CAAC;IAC5D,CAAC;IAED,eAAe,CAAC,OAA+B;QAC7C,OAAO,IAAI,CAAC,uBAAuB,CAAC,OAAO,CAAC,CAAC;IAC/C,CAAC;IAEK,uBAAuB,CAAC,OAA+B;;YAC3D,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,eAAe,CAC7C,OAAO,CAAC,WAAW,EACnB,OAAO,CAAC,cAAc,CACvB,CAAC;YAEF,OAAO,IAAI,UAAU,CAAC;gBACpB,QAAQ,EAAE,uBAAuB;gBACjC,SAAS,EAAE;oBACT,KAAK,kCACA,CAAC,MAAM,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC,KACnD,WAAW,EAAE,OAAO,CAAC,WAAW,GACjC;iBACF;aACF,CAAC,CAAC;QACL,CAAC;KAAA;IAEM,eAAe,CAAC,EAAM;QAC3B,OAAO,IAAI,UAAU,CAAC;YACpB,QAAQ,EAAE,uBAAuB;YACjC,SAAS,EAAE;gBACT,KAAK,EAAE;oBACL,WAAW,EAAE,EAAE;iBAChB;aACF;SACF,CAAC,CAAC;IACL,CAAC;IAEK,UAAU,CAAC,OAA0B;;YACzC,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,CAAC;YAElD,MAAM,iBAAiB,GAAG,MAAM,OAAO,CAAC,GAAG,CACzC,OAAO,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAO,CAAC,EAAE,EAAE;gBACxC,MAAM,EACJ,WAAW,EACX,aAAa,EACb,UAAU,GACX,GAAG,MAAM,IAAI,CAAC,uBAAuB,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;gBACnD,8DAA8D;gBAC9D,8EAA8E;gBAC9E,OAAO;oBACL,WAAW;oBACX,aAAa;oBACb,cAAc,EAAE,UAAU;iBACC,CAAC;YAChC,CAAC,CAAA,CAAC,CACH,CAAC;YAEF,OAAO,IAAI,UAAU,CAAC;gBACpB,QAAQ,EAAE,kBAAkB;gBAC5B,SAAS,EAAE;oBACT,KAAK,kCACA,CAAC,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,KACjD,iBAAiB,GAClB;iBACF;aACF,CAAC,CAAC;QACL,CAAC;KAAA;IAEK,UAAU,CAAC,OAA0B;;YACzC,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;YAEzE,OAAO,IAAI,UAAU,CAAC;gBACpB,QAAQ,EAAE,kBAAkB;gBAC5B,SAAS,EAAE;oBACT,KAAK,kCACA,CAAC,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC,KACrD,MAAM,EAAE,OAAO,CAAC,MAAM,GACvB;iBACF;aACF,CAAC,CAAC;QACL,CAAC;KAAA;IAEM,UAAU,CAAC,EAAM;QACtB,OAAO,IAAI,UAAU,CAAC;YACpB,QAAQ,EAAE,kBAAkB;YAC5B,SAAS,EAAE;gBACT,KAAK,EAAE;oBACL,MAAM,EAAE,EAAE;iBACX;aACF;SACF,CAAC,CAAC;IACL,CAAC;IAEa,uBAAuB,CACnC,OAA+B,EAC/B,MAAe;;YAEf,mEAAmE;YACnE,6BAA6B;YAC7B,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,eAAe,CAC5C,OAAO,CAAC,WAAW,EACnB,OAAO,CAAC,aAAa,CACtB,CAAC;YAEF,OAAO;gBACL,WAAW,EAAE,OAAO,CAAC,WAAW;gBAChC,aAAa,EAAE,WAAW,CAAC,EAAE;gBAC7B,UAAU,EAAE,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,WAAW,EAAE,MAAM,CAAC;aAC7D,CAAC;QACJ,CAAC;KAAA;IAED,6EAA6E;IAC7E,wCAAwC;IACxC,wCAAwC;IACxC,MAAM;IAEN,wCAAwC;IACxC,IAAI;IAEE,iBAAiB,CAAC,eAA+B;;YACrD,OAAO,CACL,MAAM,IAAI,CAAC,KAAK,CAAC;gBACf,KAAK,EAAE,iBAAiB;gBACxB,SAAS,EAAE;oBACT,EAAE,EAAE,eAAe;iBACpB;aACF,CAAC,CACH,CAAC,SAAS,CAAC,KAAK,CAAC;QACpB,CAAC;KAAA;IAEK,iBAAiB,CAAC,WAA2B;;YACjD,OAAO,CACL,MAAM,IAAI,CAAC,KAAK,CAAC;gBACf,KAAK,EAAE,iBAAiB;gBACxB,SAAS,EAAE;oBACT,EAAE,EAAE,WAAW;iBAChB;aACF,CAAC,CACH,CAAC,SAAS,CAAC,KAAK,CAAC;QACpB,CAAC;KAAA;IAEK,YAAY,CAAC,MAAsB;;YACvC,OAAO,CACL,MAAM,IAAI,CAAC,KAAK,CAAC;gBACf,KAAK,EAAE,YAAY;gBACnB,SAAS,EAAE;oBACT,EAAE,EAAE,MAAM;iBACX;aACF,CAAC,CACH,CAAC,IAAI,CAAC,KAAK,CAAC;QACf,CAAC;KAAA;IAEK,eAAe,CACnB,WAA2B,EAC3B,cAA+B;;YAE/B,OAAO,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,cAAc,EAAE,GAAG,EAAE,CAC/C,IAAI,CAAC,iBAAiB,CAAC,WAAW,CAAC,CACpC,CAAC;QACJ,CAAC;KAAA;IAEK,UAAU,CAAC,MAAsB,EAAE,SAA0B;;YACjE,OAAO,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC;QAC1E,CAAC;KAAA;IAEa,QAAQ,CACpB,GAAY,EACZ,OAA2D;;YAE3D,MAAM,EAAE,aAAa,EAAE,mBAAmB,EAAE,GAAG,OAAO,CAAC;YAEvD,OAAO;gBACL,SAAS,EAAE,aAAa,IAAI,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC;gBACzD,UAAU,EACR,mBAAmB;oBACnB,CAAC,MAAM,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,GAAG,EAAE,mBAAmB,CAAC,CAAC;aAClE,CAAC;QACJ,CAAC;KAAA;IAEa,eAAe,CAC3B,OAAgB,EAChB,OAA8C;;YAE9C,yDAAyD;YACzD,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,CAAC;YAEvD,MAAM,WAAW,GACf,OAAO,CAAC,IAAI,IAAI,CAAC,MAAM,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;YAElE,IAAI,eAAuB,CAAC;YAC5B,IAAI,WAAW,EAAE;gBACf,MAAM,iBAAiB,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,eAAe,CAC3D,YAAY,EACZ,WAAW,CACZ,CAAC;gBACF,IAAI,OAAO,CAAC,MAAM,EAAE;oBAClB,eAAe,GAAG,MAAM,OAAO,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC;iBAC3D;qBAAM;oBACL,eAAe,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,mBAAmB,CAAC;wBAC3D,gBAAgB,EAAE,iBAAiB;qBACpC,CAAC,CAAC;iBACJ;gBACD,OAAO,CAAC,GAAG,CAAC,iBAAiB,EAAE,eAAe,CAAC,CAAC;aACjD;YAED,uCACK,CAAC,MAAM,IAAI,CAAC,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC,CAAC,KAC/C,eAAe,EAAE,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,OAAO,EAAE,YAAY,CAAC,EACnE,eAAe,IACf;QACJ,CAAC;KAAA;IAED,gBAAgB,CAAC,WAAmB,EAAE,SAAkB;QACtD,OAAO,IAAI,UAAU,CAAC;YACpB,QAAQ,EAAE,wBAAwB;YAClC,SAAS,EAAE;gBACT,KAAK,EAAE;oBACL,WAAW;oBACX,SAAS;iBACV;aACF;SACF,CAAC,CAAC;IACL,CAAC;IAED,kBAAkB,CAAC,WAAmB,EAAE,SAAkB;QACxD,OAAO,IAAI,UAAU,CAAC;YACpB,QAAQ,EAAE,0BAA0B;YACpC,SAAS,EAAE;gBACT,KAAK,EAAE;oBACL,WAAW;oBACX,SAAS;iBACV;aACF;SACF,CAAC,CAAC;IACL,CAAC;IAEe,yBAAyB,CACvC,OAAiC,EACjC,OAAgB;;YAEhB,MAAM,YAAY,GAAG,MAAM,OAAO,CAAC,GAAG,CACpC,OAAO,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAC1E,CAAC;YAEF,OAAO;gBACL,mBAAmB,EAAE,OAAO,CAAC,eAAe;gBAC5C,gBAAgB,EAAE,YAAY;aAC/B,CAAC;QACJ,CAAC;KAAA;IAED,sBAAsB,CAAC,OAAsC;QAC3D,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,8BAA8B,CAAC,OAAO,CAAC,CAAC,CAAC;IACnE,CAAC;IAEK,8BAA8B,CAAC,OAAsC;;YACzE,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,eAAe,CAC7C,OAAO,CAAC,WAAW,EACnB,OAAO,CAAC,cAAc,CACvB,CAAC;YAEF,OAAO,IAAI,UAAU,CAAC;gBACpB,QAAQ,EAAE,8BAA8B;gBACxC,SAAS,EAAE;oBACT,KAAK,kCACA,CAAC,MAAM,IAAI,CAAC,yBAAyB,CAAC,OAAO,EAAE,YAAY,CAAC,GAAG,CAAC,CAAC,KACpE,WAAW,EAAE,OAAO,CAAC,WAAW,GACjC;iBACF;aACF,CAAC,CAAC;QACL,CAAC;KAAA;IAEK,iBAAiB,CAAC,OAAiC;;YACvD,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,yBAAyB,CAAC,OAAO,CAAC,CAAC,CAAC;QAC9D,CAAC;KAAA;IAEK,yBAAyB,CAAC,OAAiC;;YAC/D,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;YAEzE,OAAO,IAAI,UAAU,CAAC;gBACpB,QAAQ,EAAE,yBAAyB;gBACnC,SAAS,EAAE;oBACT,KAAK,kCACA,CAAC,MAAM,IAAI,CAAC,yBAAyB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,KAC/D,MAAM,EAAE,OAAO,CAAC,MAAM,GACvB;iBACF;aACF,CAAC,CAAC;QACL,CAAC;KAAA;CACF,CAAA;;;YAvWA,UAAU,SAAC;gBACV,UAAU,EAAE,MAAM;aACnB;;;YA3H8B,MAAM;YAAhB,QAAQ;YAQpB,WAAW;YAHX,UAAU;YADV,cAAc;YAFd,iBAAiB;YACjB,eAAe;;AAyHX,YAAY;IANxB,iBAAiB,CAAC;QACjB,UAAU,EAAE,QAAQ;KACrB,CAAC;GAIW,YAAY,CAoWxB;SApWY,YAAY","sourcesContent":["import { Injectable, Injector, NgZone } from '@angular/core';\r\nimport { JWK } from 'node-jose';\r\nimport { KeyFactoryService } from '../cryptography/key-factory.service';\r\nimport { KeyGraphService } from '../cryptography/key-graph.service';\r\nimport { KeyMetaService } from '../cryptography/key-meta.service';\r\nimport { KeyService } from '../cryptography/key.service';\r\nimport { LrBadArgumentException } from '../_common/exceptions';\r\nimport { RunOutsideAngular } from '../_common/run-outside-angular';\r\nimport { FileService } from './file.service';\r\nimport { LrGraphQLService, LrMutation, LrService } from './lr-graphql';\r\nimport {\r\n  DirectoryKeyQuery,\r\n  CreateDirectoryMutation,\r\n  DeleteDirectoryMutation,\r\n  CreateFileMutation,\r\n  DeleteFileMutation,\r\n  FileKeyQuery,\r\n  FileStateKeyQuery,\r\n  UpdateFileMutation,\r\n  UpdateDirectoryMutation,\r\n  ArchiveDirectoryMutation,\r\n  UnarchiveDirectoryMutation,\r\n  ChangeDirectoryParentsMutation,\r\n  ChangeFileParentsMutation,\r\n} from './item2.gql';\r\nimport { ID, LrRelayIdInput } from './types';\r\n\r\nexport enum DirectoryLinkType {\r\n  HARD = 'HARD',\r\n}\r\n\r\n// Suffix \"Options\" are what's need by the KC client.\r\nexport interface ParentDirectoryOptions {\r\n  directoryId: LrRelayIdInput;\r\n  // If wrapping key provided, then we can try fetching it from the\r\n  // key graph. If not found in key graph, then fetch the directory.\r\n  wrappingKeyId?: LrRelayIdInput;\r\n  // TODO: this can be other types, but server side implementation has not been\r\n  // thoroughly tested. So best not use anything else and just leave it out so\r\n  // server uses the default value of \"HARD\"\r\n  linkType?: DirectoryLinkType.HARD;\r\n}\r\n\r\nexport interface ParentRootDirectoryInput {\r\n  wrappedKey: string;\r\n  wrappingKeyId: LrRelayIdInput;\r\n}\r\n\r\n// Suffix \"Input\" matched with the graphql types\r\n// TODO these should be change to be exactly the same on the server since all that differs\r\n// is the wrappedKey/wrappedFileKey name\r\nexport interface ParentDirectoryInputBase {\r\n  directoryId: LrRelayIdInput;\r\n  wrappingKeyId: LrRelayIdInput;\r\n  linkType?: DirectoryLinkType.HARD;\r\n}\r\n\r\nexport interface ParentDirectoryInput extends ParentDirectoryInputBase {\r\n  wrappedKey: string;\r\n}\r\n\r\nexport interface FileParentDirectoryInput extends ParentDirectoryInputBase {\r\n  wrappedFileKey: string;\r\n}\r\n\r\nexport interface DownloadFileContentOptions {\r\n  fileStateNodeId: LrRelayIdInput;\r\n  fileStateKeyId?: LrRelayIdInput;\r\n}\r\n\r\nexport interface CommonDirectoryOptions {\r\n  plainMetaJson?: any;\r\n  cipherMetaClearJson?: any;\r\n}\r\n\r\nexport interface CreateDirectoryOptions extends CommonDirectoryOptions {\r\n  asRootDirectory?: boolean;\r\n  parentDirectories?: ParentDirectoryOptions[];\r\n}\r\n\r\nexport interface UpdateDirectoryOptions extends CommonDirectoryOptions {\r\n  directoryId: LrRelayIdInput;\r\n  directoryKeyId?: LrRelayIdInput;\r\n}\r\n\r\nexport interface CommonFileOptions {\r\n  plainMetaJson?: any;\r\n  cipherMetaClearJson?: any;\r\n  file?: File;\r\n  // custom uploader\r\n  upload?: (cipherFileContent: string) => Promise<string>;\r\n}\r\n\r\nexport interface CreateFileOptions extends CommonFileOptions {\r\n  parentDirectories: ParentDirectoryOptions[];\r\n}\r\n\r\nexport interface UpdateFileOptions extends CommonFileOptions {\r\n  fileId: LrRelayIdInput;\r\n  fileKeyId?: LrRelayIdInput;\r\n}\r\n\r\ninterface ChangeItemParentsOptions {\r\n  parentsToRemove: LrRelayIdInput[];\r\n  parentsToAdd: ParentDirectoryOptions[];\r\n}\r\n\r\nexport interface ChangeDirectoryParentsOptions\r\n  extends ChangeItemParentsOptions {\r\n  directoryId: LrRelayIdInput;\r\n  directoryKeyId?: LrRelayIdInput;\r\n}\r\n\r\nexport interface ChangeFileParentsOptions extends ChangeItemParentsOptions {\r\n  fileId: LrRelayIdInput;\r\n  fileKeyId?: LrRelayIdInput;\r\n}\r\n\r\n@RunOutsideAngular({\r\n  ngZoneName: 'ngZone',\r\n})\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class Item2Service extends LrService {\r\n  constructor(\r\n    private ngZone: NgZone,\r\n    private injector: Injector,\r\n    private fileService: FileService,\r\n    private keyService: KeyService,\r\n    private keyMeta: KeyMetaService,\r\n    private keyFactory: KeyFactoryService,\r\n    private keyGraph: KeyGraphService\r\n  ) {\r\n    super(injector);\r\n  }\r\n\r\n  public async downloadFileContent(\r\n    options: DownloadFileContentOptions\r\n  ): Promise<ArrayBuffer> {\r\n    const fileContent = await this.fileService.downloadEncryptedFile2(\r\n      options.fileStateNodeId\r\n    );\r\n\r\n    const fileStateKey = await this.keyGraph.getKey(\r\n      options.fileStateKeyId,\r\n      () => this.getFileStateKeyId(options.fileStateNodeId)\r\n    );\r\n\r\n    return this.keyGraph.decryptFromString(fileStateKey, fileContent, {\r\n      payloadType: 'ArrayBuffer',\r\n    });\r\n  }\r\n\r\n  public async createDirectory(options: CreateDirectoryOptions) {\r\n    const directoryKey = await this.keyFactory.createKey();\r\n    options.parentDirectories = options.parentDirectories || [];\r\n    if (!options.asRootDirectory && !options.parentDirectories?.length) {\r\n      throw new LrBadArgumentException(\r\n        'A new directory must be either a root directory or a sub-directory. So you must provide either parentDirectories and/or asRootDirectory parameter.'\r\n      );\r\n    }\r\n\r\n    const parentDirectories = await Promise.all(\r\n      options.parentDirectories?.map((t) =>\r\n        this.getParentDirectoryInput(t, directoryKey)\r\n      )\r\n    );\r\n\r\n    // TODO this is rather an unfortunate name, change it to asRootDirectory.\r\n    let parentRootDirectory: ParentRootDirectoryInput;\r\n    if (options.asRootDirectory) {\r\n      const rootKey = this.keyService.getCurrentRootKey();\r\n      parentRootDirectory = {\r\n        wrappingKeyId: rootKey.id,\r\n        wrappedKey: await this.keyGraph.wrapKey(rootKey, directoryKey),\r\n      };\r\n    }\r\n\r\n    const input = {\r\n      ...(await this.getInput(directoryKey, options)),\r\n      parentDirectories,\r\n      parentRootDirectory,\r\n    };\r\n\r\n    return new LrMutation({\r\n      mutation: CreateDirectoryMutation,\r\n      variables: {\r\n        input,\r\n      },\r\n    });\r\n  }\r\n\r\n  updateDirectoryExec(options: UpdateDirectoryOptions) {\r\n    return this.mutate(this.updateDirectoryMutation(options));\r\n  }\r\n\r\n  updateDirectory(options: UpdateDirectoryOptions) {\r\n    return this.updateDirectoryMutation(options);\r\n  }\r\n\r\n  async updateDirectoryMutation(options: UpdateDirectoryOptions) {\r\n    const directoryKey = await this.getDirectoryKey(\r\n      options.directoryId,\r\n      options.directoryKeyId\r\n    );\r\n\r\n    return new LrMutation({\r\n      mutation: UpdateDirectoryMutation,\r\n      variables: {\r\n        input: {\r\n          ...(await this.getInput(directoryKey.jwk, options)),\r\n          directoryId: options.directoryId,\r\n        },\r\n      },\r\n    });\r\n  }\r\n\r\n  public deleteDirectory(id: ID) {\r\n    return new LrMutation({\r\n      mutation: DeleteDirectoryMutation,\r\n      variables: {\r\n        input: {\r\n          directoryId: id,\r\n        },\r\n      },\r\n    });\r\n  }\r\n\r\n  async createFile(options: CreateFileOptions) {\r\n    const fileKey = await this.keyFactory.createKey();\r\n\r\n    const parentDirectories = await Promise.all(\r\n      options.parentDirectories.map(async (t) => {\r\n        const {\r\n          directoryId,\r\n          wrappingKeyId,\r\n          wrappedKey,\r\n        } = await this.getParentDirectoryInput(t, fileKey);\r\n        // remap from ParentDirectoryInput to FileParentDirectoryInput\r\n        // TODO the server should really just use wrappedKey instead of wrappedFileKey\r\n        return {\r\n          directoryId,\r\n          wrappingKeyId,\r\n          wrappedFileKey: wrappedKey,\r\n        } as FileParentDirectoryInput;\r\n      })\r\n    );\r\n\r\n    return new LrMutation({\r\n      mutation: CreateFileMutation,\r\n      variables: {\r\n        input: {\r\n          ...(await this.createFileState(fileKey, options)),\r\n          parentDirectories,\r\n        },\r\n      },\r\n    });\r\n  }\r\n\r\n  async updateFile(options: UpdateFileOptions) {\r\n    const fileKey = await this.getFileKey(options.fileId, options.fileKeyId);\r\n\r\n    return new LrMutation({\r\n      mutation: UpdateFileMutation,\r\n      variables: {\r\n        input: {\r\n          ...(await this.createFileState(fileKey.jwk, options)),\r\n          fileId: options.fileId,\r\n        },\r\n      },\r\n    });\r\n  }\r\n\r\n  public deleteFile(id: ID) {\r\n    return new LrMutation({\r\n      mutation: DeleteFileMutation,\r\n      variables: {\r\n        input: {\r\n          fileId: id,\r\n        },\r\n      },\r\n    });\r\n  }\r\n\r\n  private async getParentDirectoryInput(\r\n    options: ParentDirectoryOptions,\r\n    newKey: JWK.Key\r\n  ): Promise<ParentDirectoryInput> {\r\n    // If directory's key is not already in the key graph, then need to\r\n    // fetch the directory's key.\r\n    const wrappingKey = await this.getDirectoryKey(\r\n      options.directoryId,\r\n      options.wrappingKeyId\r\n    );\r\n\r\n    return {\r\n      directoryId: options.directoryId,\r\n      wrappingKeyId: wrappingKey.id,\r\n      wrappedKey: await this.keyGraph.wrapKey(wrappingKey, newKey),\r\n    };\r\n  }\r\n\r\n  // async getKey(keyId: LrRelayIdInput, getKeyIdCallback: () => Promise<ID>) {\r\n  //   if (!this.keyGraph.hasKey(keyId)) {\r\n  //     keyId = await getKeyIdCallback();\r\n  //   }\r\n\r\n  //   return this.keyGraph.getKey(keyId);\r\n  // }\r\n\r\n  async getFileStateKeyId(fileStateNodeId: LrRelayIdInput) {\r\n    return (\r\n      await this.query({\r\n        query: FileStateKeyQuery,\r\n        variables: {\r\n          id: fileStateNodeId,\r\n        },\r\n      })\r\n    ).fileState.keyId;\r\n  }\r\n\r\n  async getDirectoryKeyId(directoryId: LrRelayIdInput) {\r\n    return (\r\n      await this.query({\r\n        query: DirectoryKeyQuery,\r\n        variables: {\r\n          id: directoryId,\r\n        },\r\n      })\r\n    ).directory.keyId;\r\n  }\r\n\r\n  async getFileKeyId(fileId: LrRelayIdInput) {\r\n    return (\r\n      await this.query({\r\n        query: FileKeyQuery,\r\n        variables: {\r\n          id: fileId,\r\n        },\r\n      })\r\n    ).file.keyId;\r\n  }\r\n\r\n  async getDirectoryKey(\r\n    directoryId: LrRelayIdInput,\r\n    directoryKeyId?: LrRelayIdInput\r\n  ) {\r\n    return this.keyGraph.getKey(directoryKeyId, () =>\r\n      this.getDirectoryKeyId(directoryId)\r\n    );\r\n  }\r\n\r\n  async getFileKey(fileId: LrRelayIdInput, fileKeyId?: LrRelayIdInput) {\r\n    return this.keyGraph.getKey(fileKeyId, () => this.getFileKeyId(fileId));\r\n  }\r\n\r\n  private async getInput(\r\n    key: JWK.Key,\r\n    options: { plainMetaJson?: any; cipherMetaClearJson?: any }\r\n  ) {\r\n    const { plainMetaJson, cipherMetaClearJson } = options;\r\n\r\n    return {\r\n      plainMeta: plainMetaJson && JSON.stringify(plainMetaJson),\r\n      cipherMeta:\r\n        cipherMetaClearJson &&\r\n        (await this.keyGraph.encryptToString(key, cipherMetaClearJson)),\r\n    };\r\n  }\r\n\r\n  private async createFileState(\r\n    fileKey: JWK.Key,\r\n    options: CreateFileOptions | UpdateFileOptions\r\n  ) {\r\n    // Each version of the file is encrypted using a new key.\r\n    const fileStateKey = await this.keyFactory.createKey();\r\n\r\n    const fileContent =\r\n      options.file && (await this.fileService.loadFile(options.file));\r\n\r\n    let contentResource: string;\r\n    if (fileContent) {\r\n      const cipherFileContent = await this.keyGraph.encryptToString(\r\n        fileStateKey,\r\n        fileContent\r\n      );\r\n      if (options.upload) {\r\n        contentResource = await options.upload(cipherFileContent);\r\n      } else {\r\n        contentResource = await this.fileService.uploadEncryptedFile({\r\n          encryptedContent: cipherFileContent,\r\n        });\r\n      }\r\n      console.log('contentResource', contentResource);\r\n    }\r\n\r\n    return {\r\n      ...(await this.getInput(fileStateKey, options)),\r\n      wrappedStateKey: await this.keyGraph.wrapKey(fileKey, fileStateKey),\r\n      contentResource,\r\n    };\r\n  }\r\n\r\n  archiveDirectory(directoryId: string, recursive: boolean) {\r\n    return new LrMutation({\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  unarchiveDirectory(directoryId: string, recursive: boolean) {\r\n    return new LrMutation({\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  protected async getChangeItemParentsInput(\r\n    options: ChangeItemParentsOptions,\r\n    itemKey: JWK.Key\r\n  ) {\r\n    const parentsToAdd = await Promise.all(\r\n      options.parentsToAdd.map((t) => this.getParentDirectoryInput(t, itemKey))\r\n    );\r\n\r\n    return {\r\n      directoriesToRemove: options.parentsToRemove,\r\n      directoriesToAdd: parentsToAdd,\r\n    };\r\n  }\r\n\r\n  changeDirectoryParents(options: ChangeDirectoryParentsOptions) {\r\n    return this.mutate(this.changeDirectoryParentsMutation(options));\r\n  }\r\n\r\n  async changeDirectoryParentsMutation(options: ChangeDirectoryParentsOptions) {\r\n    const directoryKey = await this.getDirectoryKey(\r\n      options.directoryId,\r\n      options.directoryKeyId\r\n    );\r\n\r\n    return new LrMutation({\r\n      mutation: ChangeDirectoryParentsMutation,\r\n      variables: {\r\n        input: {\r\n          ...(await this.getChangeItemParentsInput(options, directoryKey.jwk)),\r\n          directoryId: options.directoryId,\r\n        },\r\n      },\r\n    });\r\n  }\r\n\r\n  async changeFileParents(options: ChangeFileParentsOptions) {\r\n    return this.mutate(this.changeFileParentsMutation(options));\r\n  }\r\n\r\n  async changeFileParentsMutation(options: ChangeFileParentsOptions) {\r\n    const fileKey = await this.getFileKey(options.fileId, options.fileKeyId);\r\n\r\n    return new LrMutation({\r\n      mutation: ChangeFileParentsMutation,\r\n      variables: {\r\n        input: {\r\n          ...(await this.getChangeItemParentsInput(options, fileKey.jwk)),\r\n          fileId: options.fileId,\r\n        },\r\n      },\r\n    });\r\n  }\r\n}\r\n"]}