@lifeready/core 6.1.1 → 6.1.2

package/bundles/lifeready-core.umd.js

@@ -341,6 +341,22 @@
         return value;
     }
 
+    var KeyGraphNodeType;
+    (function (KeyGraphNodeType) {
+        KeyGraphNodeType["Key"] = "key";
+        KeyGraphNodeType["PassKey"] = "passKey";
+    })(KeyGraphNodeType || (KeyGraphNodeType = {}));
+    var KeyGraphEdgeType;
+    (function (KeyGraphEdgeType) {
+        KeyGraphEdgeType["KeyLink"] = "keyLink";
+        KeyGraphEdgeType["PassKeyLink"] = "passKeyLink";
+    })(KeyGraphEdgeType || (KeyGraphEdgeType = {}));
+    var PayloadType;
+    (function (PayloadType) {
+        PayloadType["JSON"] = "JSON";
+        PayloadType["UINT_8_ARRAY"] = "UINT_8_ARRAY";
+    })(PayloadType || (PayloadType = {}));
+
     function handleApolloError(errors) {
         if (!errors || !errors.length)
             return;
@@ -803,11 +819,11 @@
         JoseSerialization["COMPACT"] = "COMPACT";
     })(JoseSerialization || (JoseSerialization = {}));
     var VERIFY_OPTIONS_DEFAULT = {
-        payloadType: 'json',
+        payloadType: PayloadType.JSON,
         returnOnlyPayload: true,
     };
     var DECRYPT_OPTIONS_DEFAULT = {
-        payloadType: 'json',
+        payloadType: PayloadType.JSON,
         returnOnlyPayload: true,
         serializations: [JoseSerialization.JSON],
     };
@@ -878,7 +894,7 @@
                 });
             });
         };
-        // TODO rename this to encrypt() and use as the most common usecase
+        // TODO rename this to encrypt() and use as the most common use case
         EncryptionService.prototype.encryptToString = function (key, content) {
             return __awaiter(this, void 0, void 0, function () {
                 var _a, _b;
@@ -1017,9 +1033,9 @@
         };
         EncryptionService.prototype.decodePayload = function (payloadType, payload) {
             switch (payloadType) {
-                case 'json':
+                case PayloadType.JSON:
                     return JSON.parse(new TextDecoder().decode(payload));
-                case 'ArrayBuffer':
+                case PayloadType.UINT_8_ARRAY:
                     return payload;
                 default:
                     throw new KcBadArgumentException("Unknown payloadType: " + payloadType);
@@ -1850,17 +1866,6 @@
         { type: PersistService }
     ]; };
 
-    var KeyGraphNodeType;
-    (function (KeyGraphNodeType) {
-        KeyGraphNodeType["Key"] = "key";
-        KeyGraphNodeType["PassKey"] = "passKey";
-    })(KeyGraphNodeType || (KeyGraphNodeType = {}));
-    var KeyGraphEdgeType;
-    (function (KeyGraphEdgeType) {
-        KeyGraphEdgeType["KeyLink"] = "keyLink";
-        KeyGraphEdgeType["PassKeyLink"] = "passKeyLink";
-    })(KeyGraphEdgeType || (KeyGraphEdgeType = {}));
-
     var KeyGraphService = /** @class */ (function () {
         // private keyCache: {
         //   [id: string]: Key;
@@ -2210,7 +2215,7 @@
                         case 1:
                             key = _a.sent();
                             return [4 /*yield*/, this.encryptionService.decrypt(key, file, {
-                                    payloadType: 'ArrayBuffer',
+                                    payloadType: PayloadType.UINT_8_ARRAY,
                                 })];
                         case 2: return [2 /*return*/, (_a.sent())];
                     }
@@ -4133,21 +4138,6 @@
             this.keyService = keyService;
             this.keyFactory = keyFactory;
         }
-        // async decryptFromString<T>(
-        //   keyOrId: string | Key,
-        //   cipherData: string,
-        //   options?: DecryptOptions
-        // ): Promise<T> {
-        //   if (cipherData) {
-        //     const key = await this.keyGraphService.getJwkKey(keyOrId);
-        //     return (await this.encryptionService.decrypt(
-        //       key,
-        //       JSON.parse(cipherData),
-        //       options
-        //     )) as any;
-        //   }
-        //   return null;
-        // }
         KeyMetaService.prototype.decryptMeta = function (metaHaver) {
             return __awaiter(this, void 0, void 0, function () {
                 var key;
@@ -4165,47 +4155,6 @@
                 });
             });
         };
-        // async decryptFile(keyId: string, file: any): Promise<any> {
-        //   const key = await this.keyGraphService.getJwkKey(keyId);
-        //   return (await this.encryptionService.decrypt(key, file, {
-        //     payloadType: 'ArrayBuffer',
-        //   })) as any;
-        // }
-        // // TODO rename this to encrypt() and use as the most common usecase
-        // async encryptToString(
-        //   key: string | Key | JWK.Key,
-        //   content: any
-        // ): Promise<string> {
-        //   // Empty string should be encrypted since you want to clear the field.
-        //   // Null is not encrypted because it's not valid JSON in the old JSON spec. Use
-        //   // empty string instead. It'll function as a logic false as well.
-        //   // Note that passing in empty string means it'll be encrypted which verifies
-        //   // it's integrity. But we still want to have a way to set the DB field
-        //   // to NULL, so we explicitly return null when content == null. A null
-        //   // variable in graphql mutation on KC server clears the field to NULL.
-        //   if (content == null) {
-        //     return null;
-        //   }
-        //   const jwk =
-        //     asJwk(key) || (await this.keyGraphService.getJwkKey(key as string | Key));
-        //   return JSON.stringify(await this.encryptionService.encrypt(jwk, content));
-        // }
-        // // Wraps a symmetric encryption key.
-        // // Throws exception if wrapping public keys.
-        // async wrapKey<T>(
-        //   wrappingKey: string | Key | JWK.Key,
-        //   key: JWK.Key
-        // ): Promise<string> {
-        //   if (!isSymmetricKey(key)) {
-        //     throw new LrBadArgumentException(
-        //       'Only allowing wrapping of symmetric keys.'
-        //     );
-        //   }
-        //   return this.encryptToString(wrappingKey, key.toJSON(true));
-        // }
-        // // TODO
-        // // async wrapPublicKey<T>();
-        // // async wrapPrivateKey<T>();
         KeyMetaService.prototype.doubleWrapContent = function (secureContent, categoryIds, fileContent) {
             return __awaiter(this, void 0, void 0, function () {
                 var key, wrappedContent, _a, _b, _c, _d, _e, _f, _g;
@@ -7267,7 +7216,7 @@
                         case 2:
                             fileStateKey = _d.sent();
                             return [2 /*return*/, this.keyGraph.decryptFromString(fileStateKey, fileContent, {
-                                    payloadType: 'ArrayBuffer',
+                                    payloadType: PayloadType.UINT_8_ARRAY,
                                 })];
                     }
                 });