@lifeready/core 8.0.6 → 8.0.7

package/fesm2015/lifeready-core.js

@@ -279,6 +279,18 @@ function getAccessJwtToken(auth) {
         }
     });
 }
+function assert_xor(options) {
+    const keys = Object.keys(options);
+    if (keys.length != 2) {
+        throw new KcBadLogicException('You must provide exactly 2 fields in the argument.');
+    }
+    if (options[keys[0]] != null && options[keys[1]] != null) {
+        throw new KcBadLogicException(`You can not specify both ${keys[0]} and ${keys[1]}`);
+    }
+    if (options[keys[0]] == null && options[keys[1]] == null) {
+        throw new KcBadLogicException(`You must specify either ${keys[0]} and ${keys[1]}`);
+    }
+}
 
 // Ref: https://stackoverflow.com/questions/59735280/angular-8-moment-error-cannot-call-a-namespace-moment
 const moment = moment_;
@@ -8583,6 +8595,9 @@ query ScenarioQuery(
                     id
                   }
                   accessRole
+
+                  # The itemKey is the same as directory.keyId. It's here so we can detect
+                  # when the directory key has been rotated.
                   itemKey {
                     id
                   }
@@ -8602,9 +8617,16 @@ query ScenarioQuery(
                     id
                   }
                   accessRole
+
+                  # The itemKey is the same as file.keyId. It's here so we can detect
+                  # when the file key has been rotated.
                   itemKey {
                     id
                   }
+                  file {
+                    id
+                    keyId
+                  }
                 }
               }
             }
@@ -8726,6 +8748,8 @@ let ScenarioService = class ScenarioService extends LrService {
         this.encryptionService = encryptionService;
         this.prepareAddReceiverDirectory = this.prepareReceiverDirectory;
         this.prepareUpdateReceiverDirectory = this.prepareReceiverDirectory;
+        this.prepareAddReceiverFile = this.prepareReceiverFile;
+        this.prepareUpdateReceiverFile = this.prepareReceiverFile;
     }
     // Scenarios
     createScenario(options) {
@@ -9018,38 +9042,86 @@ let ScenarioService = class ScenarioService extends LrService {
             };
         });
     }
-    prepareReceiverDirectory(options, receiverSharedKey, assemblyKey) {
+    prepareReceiverItem(options) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (options.accessRole == AccessRoleChoice.DENY) {
-                // Cryptographic access to item is not required.
-                return {
-                    directoryId: options.directoryId,
-                    accessRole: options.accessRole,
+            const { receiverItemOptions, receiverSharedKey, assemblyKey, directory, file, } = options;
+            assert_xor({ directory, file });
+            const { accessRole } = receiverItemOptions;
+            if (accessRole == AccessRoleChoice.DENY) {
+                const ret = {
+                    accessRole,
                     wrappedItemKey: null,
                     sharedCipherData: null,
                 };
+                if (directory) {
+                    // Cryptographic access to item is not required.
+                    return Object.assign(Object.assign({}, ret), { directoryId: directory.id });
+                }
+                else {
+                    return Object.assign(Object.assign({}, ret), { fileId: file.id });
+                }
             }
             else {
                 // TODO this should be batched
-                const directoryKey = yield this.itemService.getDirectoryKey(options.directoryId, options.directoryKeyId);
-                const sharedCipherData = yield this.keyGraph.encryptToString(receiverSharedKey, options.sharedCipherDataClearJson || '');
-                let wrappedItemKey = yield this.keyGraph.encryptToString(receiverSharedKey, directoryKey.jwk.toJSON(true));
+                let itemKey;
+                if (directory) {
+                    itemKey = yield this.itemService.getDirectoryKey(directory.id, directory.keyId);
+                }
+                else {
+                    itemKey = yield this.itemService.getFileKey(file.id, file.keyId);
+                }
+                let wrappedItemKey = yield this.keyGraph.encryptToString(receiverSharedKey, itemKey.jwk.toJSON(true));
+                const sharedCipherData = yield this.keyGraph.encryptToString(receiverSharedKey, receiverItemOptions.sharedCipherDataClearJson || '');
                 wrappedItemKey = yield this.keyGraph.encryptToString(assemblyKey, wrappedItemKey);
-                return {
-                    directoryId: options.directoryId,
-                    accessRole: options.accessRole,
+                const ret = {
+                    accessRole,
                     wrappedItemKey,
                     sharedCipherData,
                 };
+                if (directory) {
+                    return Object.assign(Object.assign({}, ret), { directoryId: directory.id });
+                }
+                else {
+                    return Object.assign(Object.assign({}, ret), { fileId: file.id });
+                }
             }
         });
     }
+    prepareReceiverDirectory(options, receiverSharedKey, assemblyKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.prepareReceiverItem({
+                receiverItemOptions: options,
+                receiverSharedKey,
+                assemblyKey,
+                directory: {
+                    id: options.directoryId,
+                    keyId: options.directoryKeyId,
+                },
+            });
+        });
+    }
+    prepareReceiverFile(options, receiverSharedKey, assemblyKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.prepareReceiverItem({
+                receiverItemOptions: options,
+                receiverSharedKey,
+                assemblyKey,
+                file: {
+                    id: options.fileId,
+                    keyId: options.fileKeyId,
+                },
+            });
+        });
+    }
     prepareCreateReceiver(options, assemblyKey) {
         return __awaiter(this, void 0, void 0, function* () {
             const { sharedKey, mutationInput } = yield this.prepareCreateParticipant(options);
             const addDirectories = options.addDirectories &&
                 (yield Promise.all(options.addDirectories.map((x) => this.prepareAddReceiverDirectory(x, sharedKey.key, assemblyKey))));
-            return Object.assign(Object.assign({}, mutationInput), { addDirectories });
+            const addFiles = options.addFiles &&
+                (yield Promise.all(options.addFiles.map((x) => this.prepareAddReceiverFile(x, sharedKey.key, assemblyKey))));
+            return Object.assign(Object.assign({}, mutationInput), { addDirectories,
+                addFiles });
         });
     }
     prepareUpdateReceiver(options, assemblyKey, existingReceiver) {
@@ -9057,6 +9129,8 @@ let ScenarioService = class ScenarioService extends LrService {
             const sharedKeyId = existingReceiver.sharedKey.id;
             const deleteDirectoriesOptions = options.deleteDirectories || [];
             const updateDirectoriesOptions = options.updateDirectories || [];
+            const deleteFilesOptions = options.deleteFiles || [];
+            const updateFilesOptions = options.updateFiles || [];
             // Fill in any missing update directories
             mapEdges(existingReceiver.receiverItems.receiverDirectories).forEach((existingDirectory) => {
                 if (deleteDirectoriesOptions.includes(existingDirectory.directory.id)) {
@@ -9068,30 +9142,58 @@ let ScenarioService = class ScenarioService extends LrService {
                 updateDirectoriesOptions.push({
                     accessRole: existingDirectory.accessRole,
                     directoryId: existingDirectory.directory.id,
+                    directoryKeyId: existingDirectory.directory.keyId,
                     sharedCipherDataClearJson: existingDirectory.sharedCipherDataClearJson,
                 });
             });
+            // Fill in any missing update directories
+            mapEdges(existingReceiver.receiverItems.receiverFiles).forEach((existingFile) => {
+                if (deleteFilesOptions.includes(existingFile.file.id)) {
+                    return;
+                }
+                if (updateFilesOptions.find((x) => x.fileId === existingFile.file.id)) {
+                    return;
+                }
+                updateFilesOptions.push({
+                    accessRole: existingFile.accessRole,
+                    fileId: existingFile.file.id,
+                    fileKeyId: existingFile.file.keyId,
+                    sharedCipherDataClearJson: existingFile.sharedCipherDataClearJson,
+                });
+            });
             const { sharedKey, mutationInput } = yield this.prepareUpdateParticipant(options, sharedKeyId);
             const addDirectories = options.addDirectories &&
                 (yield Promise.all(options.addDirectories.map((x) => this.prepareAddReceiverDirectory(x, sharedKey, assemblyKey))));
+            const addFiles = options.addFiles &&
+                (yield Promise.all(options.addFiles.map((x) => this.prepareAddReceiverFile(x, sharedKey, assemblyKey))));
             const updateDirectories = yield Promise.all(updateDirectoriesOptions.map((x) => this.prepareUpdateReceiverDirectory(x, sharedKey, assemblyKey)));
+            const updateFiles = yield Promise.all(updateFilesOptions.map((x) => this.prepareUpdateReceiverFile(x, sharedKey, assemblyKey)));
             return Object.assign(Object.assign({}, mutationInput), { addDirectories,
-                updateDirectories, deleteDirectories: options.deleteDirectories });
+                addFiles,
+                updateDirectories,
+                updateFiles, deleteDirectories: options.deleteDirectories, deleteFiles: options.deleteFiles });
         });
     }
     prepareExistingReceiver(existingReceiver, assemblyKey) {
         return __awaiter(this, void 0, void 0, function* () {
-            const updateDirectories = mapEdges(existingReceiver.receiverItems.receiverDirectories).map((receiverDirectory) => ({
-                directoryId: receiverDirectory.directory.id,
-                directoryKeyId: receiverDirectory.directory.keyId,
-                accessRole: receiverDirectory.accessRole,
-                sharedCipherDataClearJson: receiverDirectory.sharedCipherDataClearJson,
+            const updateDirectories = mapEdges(existingReceiver.receiverItems.receiverDirectories).map(({ accessRole, sharedCipherDataClearJson, directory }) => ({
+                accessRole,
+                sharedCipherDataClearJson,
+                directoryId: directory.id,
+                directoryKeyId: directory.keyId,
+            }));
+            const updateFiles = mapEdges(existingReceiver.receiverItems.receiverFiles).map(({ accessRole, sharedCipherDataClearJson, file }) => ({
+                accessRole,
+                sharedCipherDataClearJson,
+                fileId: file.id,
+                fileKeyId: file.keyId,
             }));
             // Fill it in with existing receiver.
             return this.prepareUpdateReceiver({
                 tpId: existingReceiver.tp.id,
                 sharedCipherDataClearJson: existingReceiver.sharedCipherDataClearJson,
                 updateDirectories,
+                updateFiles,
             }, assemblyKey, existingReceiver);
         });
     }