@lifeready/core 1.0.1 → 1.0.3

package/esm2015/lib/api/contact-card.gql.js

@@ -0,0 +1,79 @@
+import { KeyGraphField } from '../_common/queries.gql';
+import gql from 'graphql-tag';
+export const ContactCardFields = `
+id
+publicData
+publicSearchable
+cipherData
+key {
+  id
+}
+`;
+export const ContactCardQuery = gql `
+query ContactCardQuery(
+$id: LrRelayIdInput!
+) {
+contactCard (
+  id: $id
+) {
+  ${ContactCardFields}
+}
+${KeyGraphField}
+}`;
+export const SearchContactCardQuery = gql `
+query SearchContactCardQuery(
+  $publicSearchable: LrJSONFilter!
+) {
+  searchContactCards(
+    publicSearchable: $publicSearchable
+    orderBy: "created"
+  ) {
+    edges {
+      node {
+        ${ContactCardFields}
+      }
+    }
+  }
+  ${KeyGraphField}
+}`;
+export const ContactCardListQuery = gql `
+query ContactCardListQuery {
+  contactCards(
+    orderBy: "created"
+  ) {
+    edges {
+      node {
+        ${ContactCardFields}
+      }
+    }
+  }
+  ${KeyGraphField}
+}`;
+export const CreateContactCardMutation = gql `
+mutation CreateContactCardMutation(
+  $input: CreateContactCardInput!
+) {
+  createContactCard(input: $input) {
+    contactCard {
+      ${ContactCardFields}
+    }
+  }
+}`;
+export const UpdateContactCardMutation = gql `
+mutation UpdateContactCardMutation(
+  $input: UpdateContactCardInput!
+) {
+  updateContactCard(input: $input) {
+    contactCard {
+      ${ContactCardFields}
+    }
+  }
+}`;
+export const DeleteContactCardMutation = gql `
+  mutation DeleteContactCardMutation($input: DeleteContactCardInput!) {
+    deleteContactCard(input: $input) {
+      id
+    }
+  }
+`;
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/api/contact-card.service.js

@@ -0,0 +1,154 @@
+import { __awaiter } from "tslib";
+import { Injectable } from '@angular/core';
+import { EncryptionService } from '../cryptography/encryption.service';
+import { KeyGraphService } from '../cryptography/key-graph.service';
+import { KeyService } from '../cryptography/key.service';
+import { LrApolloService } from './lr-apollo.service';
+import { SearchContactCardQuery, ContactCardListQuery, ContactCardQuery, CreateContactCardMutation, UpdateContactCardMutation, DeleteContactCardMutation, } from './contact-card.gql';
+import { KeyFactoryService } from '../cryptography/key-factory.service';
+import { KeyMetaService } from '../cryptography/key-meta.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../cryptography/key-factory.service";
+import * as i2 from "../cryptography/key.service";
+import * as i3 from "./lr-apollo.service";
+import * as i4 from "../cryptography/key-graph.service";
+import * as i5 from "../cryptography/encryption.service";
+import * as i6 from "../cryptography/key-meta.service";
+export class ContactCard {
+}
+export class ContactCardService {
+    constructor(keyFactory, keyService, lrApollo, keyGraph, encryptionService, keyMetaService) {
+        this.keyFactory = keyFactory;
+        this.keyService = keyService;
+        this.lrApollo = lrApollo;
+        this.keyGraph = keyGraph;
+        this.encryptionService = encryptionService;
+        this.keyMetaService = keyMetaService;
+    }
+    decryptContactCard(cc) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ret = Object.assign(Object.assign({}, cc), { publicDataJson: JSON.parse(cc.publicData), publicSearchableJson: JSON.parse(cc.publicSearchable) });
+            if (cc.key) {
+                const key = yield this.keyGraph.getJwkKey(cc.key.id);
+                // TODO: verify signature
+                ret.plainCipherDataJson = yield this.encryptionService.decrypt(key, cc.cipherData);
+            }
+            return ret;
+        });
+    }
+    decryptContactCardEdges(hasEdges) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Promise.all(hasEdges.edges.map((edge) => __awaiter(this, void 0, void 0, function* () {
+                const cc = edge.node;
+                return yield this.decryptContactCard(cc);
+            })));
+        });
+    }
+    // { "filter": [{ "contains": { "a": true } }] }
+    searchContactCard(publicSearchable) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this.lrApollo.query({
+                query: SearchContactCardQuery,
+                variables: {
+                    publicSearchable: JSON.stringify(publicSearchable),
+                },
+            });
+            return yield this.decryptContactCardEdges(data.searchContactCards);
+        });
+    }
+    getContactCardList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this.lrApollo.query({
+                query: ContactCardListQuery,
+            });
+            return yield this.decryptContactCardEdges(data.contactCards);
+        });
+    }
+    getContactCard(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this.lrApollo.query({
+                query: ContactCardQuery,
+                variables: {
+                    id,
+                },
+            });
+            return yield this.decryptContactCard(data.contactCard);
+        });
+    }
+    prepareContactCardInput(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sigPxk = yield this.keyService.getCurrentSigPxk();
+            const publicDataSig = JSON.stringify(yield this.encryptionService.sign(sigPxk.jwk, input.publicDataJson));
+            const publicSearchableSig = JSON.stringify(yield this.encryptionService.sign(sigPxk.jwk, input.publicSearchableJson));
+            const plainDataSig = JSON.stringify(yield this.encryptionService.sign(sigPxk.jwk, input.plainDataJson));
+            return {
+                sigPxkId: sigPxk.id,
+                publicDataSig,
+                publicSearchableSig,
+                plainDataSig,
+            };
+        });
+    }
+    createContactCard(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Get encryption key
+            const rootKey = yield this.keyService.getCurrentRootKey();
+            const key = yield this.keyFactory.createKey();
+            const wrappedKey = yield this.keyGraph.encryptToString(rootKey.jwk, key.toJSON(true));
+            const cipherData = yield this.keyGraph.encryptToString(key, input.plainCipherDataJson);
+            const params = yield this.prepareContactCardInput(input);
+            const data = yield this.lrApollo.mutate({
+                mutation: CreateContactCardMutation,
+                variables: {
+                    input: Object.assign(Object.assign({}, params), { wrappingKeyId: rootKey.id, wrappedKey,
+                        cipherData }),
+                },
+            });
+            return data.createContactCard.contactCard;
+        });
+    }
+    updateContactCard(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Get encryption key
+            const cc = yield this.getContactCard(input.id);
+            const key = yield this.keyGraph.getJwkKey(cc.key.id);
+            const cipherData = yield this.keyGraph.encryptToString(key, input.plainCipherDataJson);
+            const params = yield this.prepareContactCardInput(input);
+            const data = yield this.lrApollo.mutate({
+                mutation: UpdateContactCardMutation,
+                variables: {
+                    input: Object.assign(Object.assign({}, params), { id: input.id, cipherData }),
+                },
+            });
+            return data.updateContactCard.contactCard;
+        });
+    }
+    deleteContactCard(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this.lrApollo.mutate({
+                mutation: DeleteContactCardMutation,
+                variables: {
+                    input: {
+                        id,
+                    },
+                },
+            });
+            return data.deleteContactCard.id;
+        });
+    }
+}
+ContactCardService.ɵprov = i0.ɵɵdefineInjectable({ factory: function ContactCardService_Factory() { return new ContactCardService(i0.ɵɵinject(i1.KeyFactoryService), i0.ɵɵinject(i2.KeyService), i0.ɵɵinject(i3.LrApolloService), i0.ɵɵinject(i4.KeyGraphService), i0.ɵɵinject(i5.EncryptionService), i0.ɵɵinject(i6.KeyMetaService)); }, token: ContactCardService, providedIn: "root" });
+ContactCardService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+ContactCardService.ctorParameters = () => [
+    { type: KeyFactoryService },
+    { type: KeyService },
+    { type: LrApolloService },
+    { type: KeyGraphService },
+    { type: EncryptionService },
+    { type: KeyMetaService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"contact-card.service.js","sourceRoot":"C:/Projects/newrepo/kc-client/projects/core/src/","sources":["lib/api/contact-card.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { HasKeyGraph, Key } from '../cryptography/cryptography.types';\r\nimport { EncryptionService } from '../cryptography/encryption.service';\r\nimport { KeyGraphService } from '../cryptography/key-graph.service';\r\nimport { KeyService } from '../cryptography/key.service';\r\nimport { HasEdges } from '../_common/types';\r\nimport { LrApolloService } from './lr-apollo.service';\r\nimport {\r\n  SearchContactCardQuery,\r\n  ContactCardListQuery,\r\n  ContactCardQuery,\r\n  CreateContactCardMutation,\r\n  UpdateContactCardMutation,\r\n  DeleteContactCardMutation,\r\n} from './contact-card.gql';\r\nimport { KeyFactoryService } from '../cryptography/key-factory.service';\r\nimport { MainContactCardPlainFields } from '../users/profile.types';\r\nimport { KeyMetaService } from '../cryptography/key-meta.service';\r\n\r\ninterface ContactCardQuery extends HasKeyGraph {\r\n  contactCard: ContactCard;\r\n}\r\n\r\ninterface SearchContactCardQuery extends HasKeyGraph {\r\n  searchContactCards: HasEdges<ContactCard>;\r\n}\r\n\r\ninterface ContactCardListQuery extends HasKeyGraph {\r\n  contactCards: HasEdges<ContactCard>;\r\n}\r\n\r\nexport class ContactCard {\r\n  id: string;\r\n  key: Key;\r\n  sigPxk: Key;\r\n  publicData: string;\r\n  publicDataSig: string;\r\n  publicSearchable: string;\r\n  publicSearchableSig: string;\r\n  plainData: string;\r\n  plainDataSig: string;\r\n  cipherData: string;\r\n  // Parse/decrypted versions of the above.\r\n  publicDataJson: any;\r\n  publicSearchableJson: any;\r\n  plainCipherDataJson: any;\r\n  plainDataJson: any;\r\n}\r\n\r\nexport interface CreateContactCardInput {\r\n  publicDataJson: any;\r\n  publicSearchableJson: any;\r\n  plainCipherDataJson: any;\r\n  plainDataJson: MainContactCardPlainFields;\r\n}\r\n\r\nexport interface UpdateContactCardInput extends CreateContactCardInput {\r\n  id: string;\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class ContactCardService {\r\n  constructor(\r\n    private keyFactory: KeyFactoryService,\r\n    private keyService: KeyService,\r\n    private lrApollo: LrApolloService,\r\n    private keyGraph: KeyGraphService,\r\n    private encryptionService: EncryptionService,\r\n    private keyMetaService: KeyMetaService\r\n  ) {}\r\n\r\n  async decryptContactCard(cc: ContactCard): Promise<ContactCard> {\r\n    const ret = {\r\n      ...cc,\r\n      publicDataJson: JSON.parse(cc.publicData),\r\n      publicSearchableJson: JSON.parse(cc.publicSearchable),\r\n    };\r\n\r\n    if (cc.key) {\r\n      const key = await this.keyGraph.getJwkKey(cc.key.id);\r\n      // TODO: verify signature\r\n      ret.plainCipherDataJson = await this.encryptionService.decrypt(\r\n        key,\r\n        cc.cipherData\r\n      );\r\n    }\r\n\r\n    return ret;\r\n  }\r\n\r\n  async decryptContactCardEdges(\r\n    hasEdges: HasEdges<ContactCard>\r\n  ): Promise<ContactCard[]> {\r\n    return Promise.all(\r\n      hasEdges.edges.map(async (edge: any) => {\r\n        const cc = edge.node as ContactCard;\r\n        return await this.decryptContactCard(cc);\r\n      })\r\n    );\r\n  }\r\n\r\n  // { \"filter\": [{ \"contains\": { \"a\": true } }] }\r\n  async searchContactCard(publicSearchable: object): Promise<ContactCard[]> {\r\n    const data = await this.lrApollo.query<SearchContactCardQuery>({\r\n      query: SearchContactCardQuery,\r\n      variables: {\r\n        publicSearchable: JSON.stringify(publicSearchable),\r\n      },\r\n    });\r\n\r\n    return await this.decryptContactCardEdges(data.searchContactCards);\r\n  }\r\n\r\n  async getContactCardList(): Promise<ContactCard[]> {\r\n    const data = await this.lrApollo.query<ContactCardListQuery>({\r\n      query: ContactCardListQuery,\r\n    });\r\n\r\n    return await this.decryptContactCardEdges(data.contactCards);\r\n  }\r\n\r\n  async getContactCard(id: string): Promise<ContactCard> {\r\n    const data = await this.lrApollo.query<ContactCardQuery>({\r\n      query: ContactCardQuery,\r\n      variables: {\r\n        id,\r\n      },\r\n    });\r\n\r\n    return await this.decryptContactCard(data.contactCard);\r\n  }\r\n\r\n  private async prepareContactCardInput(\r\n    input: CreateContactCardInput\r\n  ): Promise<any> {\r\n    const sigPxk = await this.keyService.getCurrentSigPxk();\r\n    const publicDataSig = JSON.stringify(\r\n      await this.encryptionService.sign(sigPxk.jwk, input.publicDataJson)\r\n    );\r\n    const publicSearchableSig = JSON.stringify(\r\n      await this.encryptionService.sign(sigPxk.jwk, input.publicSearchableJson)\r\n    );\r\n    const plainDataSig = JSON.stringify(\r\n      await this.encryptionService.sign(sigPxk.jwk, input.plainDataJson)\r\n    );\r\n\r\n    return {\r\n      sigPxkId: sigPxk.id,\r\n      publicDataSig,\r\n      publicSearchableSig,\r\n      plainDataSig,\r\n    };\r\n  }\r\n\r\n  async createContactCard(input: CreateContactCardInput): Promise<ContactCard> {\r\n    // Get encryption key\r\n    const rootKey = await this.keyService.getCurrentRootKey();\r\n    const key = await this.keyFactory.createKey();\r\n    const wrappedKey = await this.keyGraph.encryptToString(\r\n      rootKey.jwk,\r\n      key.toJSON(true)\r\n    );\r\n    const cipherData = await this.keyGraph.encryptToString(\r\n      key,\r\n      input.plainCipherDataJson\r\n    );\r\n\r\n    const params = await this.prepareContactCardInput(input);\r\n\r\n    const data = await this.lrApollo.mutate<{\r\n      createContactCard: { contactCard: ContactCard };\r\n    }>({\r\n      mutation: CreateContactCardMutation,\r\n      variables: {\r\n        input: {\r\n          ...params,\r\n          wrappingKeyId: rootKey.id,\r\n          wrappedKey,\r\n          cipherData,\r\n        },\r\n      },\r\n    });\r\n\r\n    return data.createContactCard.contactCard;\r\n  }\r\n\r\n  async updateContactCard(input: UpdateContactCardInput): Promise<ContactCard> {\r\n    // Get encryption key\r\n    const cc = await this.getContactCard(input.id);\r\n    const key = await this.keyGraph.getJwkKey(cc.key.id);\r\n    const cipherData = await this.keyGraph.encryptToString(\r\n      key,\r\n      input.plainCipherDataJson\r\n    );\r\n\r\n    const params = await this.prepareContactCardInput(input);\r\n\r\n    const data = await this.lrApollo.mutate<{\r\n      updateContactCard: { contactCard: ContactCard };\r\n    }>({\r\n      mutation: UpdateContactCardMutation,\r\n      variables: {\r\n        input: {\r\n          ...params,\r\n          id: input.id,\r\n          cipherData,\r\n        },\r\n      },\r\n    });\r\n\r\n    return data.updateContactCard.contactCard;\r\n  }\r\n\r\n  async deleteContactCard(id: string): Promise<string> {\r\n    const data = await this.lrApollo.mutate<any>({\r\n      mutation: DeleteContactCardMutation,\r\n      variables: {\r\n        input: {\r\n          id,\r\n        },\r\n      },\r\n    });\r\n\r\n    return data.deleteContactCard.id;\r\n  }\r\n}\r\n"]}

package/esm2015/lib/api/contact-card2.gql.js

@@ -0,0 +1,60 @@
+import { gqlTyped } from '../_common/ast';
+export const ContactCardFragment = gqlTyped `
+  fragment ContactCardFragment on ContactCardNode {
+    id
+    publicData
+    publicSearchable
+    cipherData
+    key {
+        id
+    }
+  }
+`;
+export const CreateContactCardMutation = gqlTyped `
+  mutation CreateContactCardMutation(
+    $input: CreateContactCardInput!
+  ) {
+    createContactCard(input: $input) {
+      contactCard {
+        id
+      }
+    }
+  }
+`;
+export const UpdateContactCardMutation = gqlTyped `
+  mutation UpdateContactCardMutation($input: UpdateContactCardInput!) {
+    updateContactCard(input: $input) {
+      contactCard {
+        id
+      }
+    }
+  }
+`;
+export const DeleteContactCardMutation = gqlTyped `
+  mutation DeleteContactCardMutation($input: DeleteContactCardInput!) {
+    deleteContactCard(input: $input) {
+      id
+    }
+  }
+`;
+export const ContactCardsQuery = gqlTyped `
+  query ContactCardsQuery {
+    contactCards(orderBy: "created") {
+      edges {
+        node {
+          ...ContactCardFragment
+        }
+      }
+    }
+  }
+  ${ContactCardFragment}
+`;
+export const ContactCardQuery = gqlTyped `
+  query ContactCardQuery($id: LrRelayIdInput!) {
+    contactCard(id: $id) {
+      ...ContactCardFragment
+    }
+  }
+  ${ContactCardFragment}
+`;
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/api/contact-card2.service.js

@@ -0,0 +1,103 @@
+import { __awaiter, __decorate } from "tslib";
+import { Injectable, NgZone } from '@angular/core';
+import { EncryptionService } from '../cryptography/encryption.service';
+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 { RunOutsideAngular } from '../_common/run-outside-angular';
+import { CreateContactCardMutation, DeleteContactCardMutation, UpdateContactCardMutation, } from './contact-card2.gql';
+import { LrMutation } from './lr-graphql';
+import * as i0 from "@angular/core";
+import * as i1 from "../cryptography/key-factory.service";
+import * as i2 from "../cryptography/key.service";
+import * as i3 from "../cryptography/encryption.service";
+import * as i4 from "../cryptography/key-graph.service";
+import * as i5 from "../cryptography/key-meta.service";
+export class OwnerPlainDataJson {
+}
+let ContactCard2Service = class ContactCard2Service {
+    constructor(keyFactory, keyService, encryptionService, keyGraph, keyMetaService, ngZone) {
+        this.keyFactory = keyFactory;
+        this.keyService = keyService;
+        this.encryptionService = encryptionService;
+        this.keyGraph = keyGraph;
+        this.keyMetaService = keyMetaService;
+        this.ngZone = ngZone;
+    }
+    createContactCard(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Get encryption key
+            const rootKey = yield this.keyService.getCurrentRootKey();
+            const key = yield this.keyFactory.createKey();
+            const wrappedKey = yield this.keyGraph.encryptToString(rootKey.jwk, key.toJSON(true));
+            const cipherData = yield this.keyGraph.encryptToString(key, input.plainCipherDataJson);
+            const params = yield this.prepareContactCardInput(input);
+            return new LrMutation({
+                mutation: CreateContactCardMutation,
+                variables: {
+                    input: Object.assign(Object.assign({}, params), { wrappingKeyId: rootKey.id, wrappedKey,
+                        cipherData }),
+                },
+            });
+        });
+    }
+    updateContactCard(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Get encryption key
+            const cipherData = yield this.keyGraph.encryptToString(input.keyId, input.plainCipherDataJson);
+            const params = yield this.prepareContactCardInput(input);
+            return new LrMutation({
+                mutation: UpdateContactCardMutation,
+                variables: {
+                    input: Object.assign(Object.assign({}, params), { id: input.id, cipherData }),
+                },
+            });
+        });
+    }
+    deleteContactCard(id) {
+        return new LrMutation({
+            mutation: DeleteContactCardMutation,
+            variables: {
+                input: {
+                    id,
+                },
+            },
+        });
+    }
+    prepareContactCardInput(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sigPxk = yield this.keyService.getCurrentSigPxk();
+            const publicDataSig = JSON.stringify(yield this.encryptionService.sign(sigPxk.jwk, input.publicDataJson));
+            const publicSearchableSig = JSON.stringify(yield this.encryptionService.sign(sigPxk.jwk, input.publicSearchableJson));
+            const plainDataSig = JSON.stringify(yield this.encryptionService.sign(sigPxk.jwk, input.plainDataJson));
+            return {
+                sigPxkId: sigPxk.id,
+                publicDataSig,
+                publicSearchableSig,
+                plainDataSig,
+            };
+        });
+    }
+};
+ContactCard2Service.ɵprov = i0.ɵɵdefineInjectable({ factory: function ContactCard2Service_Factory() { return new ContactCard2Service(i0.ɵɵinject(i1.KeyFactoryService), i0.ɵɵinject(i2.KeyService), i0.ɵɵinject(i3.EncryptionService), i0.ɵɵinject(i4.KeyGraphService), i0.ɵɵinject(i5.KeyMetaService), i0.ɵɵinject(i0.NgZone)); }, token: ContactCard2Service, providedIn: "root" });
+ContactCard2Service.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+ContactCard2Service.ctorParameters = () => [
+    { type: KeyFactoryService },
+    { type: KeyService },
+    { type: EncryptionService },
+    { type: KeyGraphService },
+    { type: KeyMetaService },
+    { type: NgZone }
+];
+ContactCard2Service = __decorate([
+    RunOutsideAngular({
+        ngZoneName: 'ngZone',
+    })
+], ContactCard2Service);
+export { ContactCard2Service };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"contact-card2.service.js","sourceRoot":"C:/Projects/newrepo/kc-client/projects/core/src/","sources":["lib/api/contact-card2.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, NgZone } from '@angular/core';\r\nimport { EncryptionService } from '../cryptography/encryption.service';\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 { MainContactCardPlainFields } from '../users/profile.types';\r\nimport { RunOutsideAngular } from '../_common/run-outside-angular';\r\nimport {\r\n  CreateContactCardMutation,\r\n  DeleteContactCardMutation,\r\n  UpdateContactCardMutation,\r\n} from './contact-card2.gql';\r\nimport { LrMutation } from './lr-graphql';\r\n\r\nexport interface CreateContactCardInput2 {\r\n  publicDataJson: any;\r\n  publicSearchableJson: any;\r\n  plainCipherDataJson: any;\r\n  plainDataJson: MainContactCardPlainFields;\r\n}\r\n\r\n// These contact name fields are enforced by the server so that it can send out emails with\r\n// appropriate format.\r\nexport interface ContactCardName2 {\r\n  name: string;\r\n  title?: string;\r\n  firstName?: string;\r\n  lastName?: string;\r\n  // additional fields are not allowed by the server\r\n}\r\n\r\nexport class OwnerPlainDataJson {\r\n  name: ContactCardName2;\r\n}\r\n\r\nexport interface UpdateContactCardInput2 extends CreateContactCardInput2 {\r\n  id: string;\r\n  keyId: string;\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 ContactCard2Service {\r\n  constructor(\r\n    private keyFactory: KeyFactoryService,\r\n    private keyService: KeyService,\r\n    private encryptionService: EncryptionService,\r\n    private keyGraph: KeyGraphService,\r\n    private keyMetaService: KeyMetaService,\r\n    private ngZone: NgZone\r\n  ) {}\r\n\r\n  async createContactCard(input: CreateContactCardInput2) {\r\n    // Get encryption key\r\n    const rootKey = await this.keyService.getCurrentRootKey();\r\n    const key = await this.keyFactory.createKey();\r\n    const wrappedKey = await this.keyGraph.encryptToString(\r\n      rootKey.jwk,\r\n      key.toJSON(true)\r\n    );\r\n    const cipherData = await this.keyGraph.encryptToString(\r\n      key,\r\n      input.plainCipherDataJson\r\n    );\r\n\r\n    const params = await this.prepareContactCardInput(input);\r\n\r\n    return new LrMutation({\r\n      mutation: CreateContactCardMutation,\r\n      variables: {\r\n        input: {\r\n          ...params,\r\n          wrappingKeyId: rootKey.id,\r\n          wrappedKey,\r\n          cipherData,\r\n        },\r\n      },\r\n    });\r\n  }\r\n\r\n  async updateContactCard(input: UpdateContactCardInput2) {\r\n    // Get encryption key\r\n    const cipherData = await this.keyGraph.encryptToString(\r\n      input.keyId,\r\n      input.plainCipherDataJson\r\n    );\r\n\r\n    const params = await this.prepareContactCardInput(input);\r\n\r\n    return new LrMutation({\r\n      mutation: UpdateContactCardMutation,\r\n      variables: {\r\n        input: {\r\n          ...params,\r\n          id: input.id,\r\n          cipherData,\r\n        },\r\n      },\r\n    });\r\n  }\r\n\r\n  deleteContactCard(id: string) {\r\n    return new LrMutation({\r\n      mutation: DeleteContactCardMutation,\r\n      variables: {\r\n        input: {\r\n          id,\r\n        },\r\n      },\r\n    });\r\n  }\r\n\r\n  private async prepareContactCardInput(\r\n    input: CreateContactCardInput2\r\n  ): Promise<any> {\r\n    const sigPxk = await this.keyService.getCurrentSigPxk();\r\n    const publicDataSig = JSON.stringify(\r\n      await this.encryptionService.sign(sigPxk.jwk, input.publicDataJson)\r\n    );\r\n    const publicSearchableSig = JSON.stringify(\r\n      await this.encryptionService.sign(sigPxk.jwk, input.publicSearchableJson)\r\n    );\r\n    const plainDataSig = JSON.stringify(\r\n      await this.encryptionService.sign(sigPxk.jwk, input.plainDataJson)\r\n    );\r\n\r\n    return {\r\n      sigPxkId: sigPxk.id,\r\n      publicDataSig,\r\n      publicSearchableSig,\r\n      plainDataSig,\r\n    };\r\n  }\r\n}\r\n"]}

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

@@ -0,0 +1,74 @@
+import { __awaiter } from "tslib";
+import { HttpClient } from '@angular/common/http';
+import { Injectable, Inject } from '@angular/core';
+import { LR_CONFIG } from '../life-ready.config';
+import { LifeReadyAuthService } from '../auth/life-ready-auth.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../life-ready.config";
+import * as i2 from "@angular/common/http";
+import * as i3 from "../auth/life-ready-auth.service";
+export class FileService {
+    constructor(config, http, lrAuth) {
+        this.config = config;
+        this.http = http;
+        this.lrAuth = lrAuth;
+    }
+    downloadEncryptedFile(fileStateNodeId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return JSON.parse(yield this.downloadEncryptedFile2(fileStateNodeId));
+        });
+    }
+    downloadEncryptedFile2(fileStateNodeId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = `${this.config.apiUrl}files/download/?file_state_node_id=${fileStateNodeId}`;
+            const content = yield this.http
+                .get(url, {
+                responseType: 'text',
+                headers: {
+                    Authorization: `Bearer ${(yield this.lrAuth.getUser()).getAccessJwtToken()}`,
+                },
+            })
+                .toPromise();
+            return content;
+        });
+    }
+    loadFile(file) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const reader = new FileReader();
+                reader.onload = () => {
+                    // OK to type cast here since we are using readAsArrayBuffer.
+                    resolve(reader.result);
+                };
+                reader.readAsArrayBuffer(file);
+            });
+        });
+    }
+    uploadEncryptedFile(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { encryptedContent, fileName } = options;
+            const formData = new FormData();
+            formData.append('content', new Blob([encryptedContent]), fileName);
+            const { content_resource } = yield this.http
+                .post(`${this.config.apiUrl}files/upload/`, formData, {
+                headers: {
+                    Authorization: `Bearer ${(yield this.lrAuth.getUser()).getAccessJwtToken()}`,
+                },
+            })
+                .toPromise();
+            return content_resource;
+        });
+    }
+}
+FileService.ɵprov = i0.ɵɵdefineInjectable({ factory: function FileService_Factory() { return new FileService(i0.ɵɵinject(i1.LR_CONFIG), i0.ɵɵinject(i2.HttpClient), i0.ɵɵinject(i3.LifeReadyAuthService)); }, token: FileService, providedIn: "root" });
+FileService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+FileService.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [LR_CONFIG,] }] },
+    { type: HttpClient },
+    { type: LifeReadyAuthService }
+];
+//# sourceMappingURL=data:application/json;base64,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