@lifeready/core 1.0.1 → 1.0.2

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":"/opt/atlassian/pipelines/agent/build/projects/core/src/","sources":["lib/api/contact-card.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { HasKeyGraph, Key } from '../cryptography/cryptography.types';\nimport { EncryptionService } from '../cryptography/encryption.service';\nimport { KeyGraphService } from '../cryptography/key-graph.service';\nimport { KeyService } from '../cryptography/key.service';\nimport { HasEdges } from '../_common/types';\nimport { LrApolloService } from './lr-apollo.service';\nimport {\n  SearchContactCardQuery,\n  ContactCardListQuery,\n  ContactCardQuery,\n  CreateContactCardMutation,\n  UpdateContactCardMutation,\n  DeleteContactCardMutation,\n} from './contact-card.gql';\nimport { KeyFactoryService } from '../cryptography/key-factory.service';\nimport { MainContactCardPlainFields } from '../users/profile.types';\nimport { KeyMetaService } from '../cryptography/key-meta.service';\n\ninterface ContactCardQuery extends HasKeyGraph {\n  contactCard: ContactCard;\n}\n\ninterface SearchContactCardQuery extends HasKeyGraph {\n  searchContactCards: HasEdges<ContactCard>;\n}\n\ninterface ContactCardListQuery extends HasKeyGraph {\n  contactCards: HasEdges<ContactCard>;\n}\n\nexport class ContactCard {\n  id: string;\n  key: Key;\n  sigPxk: Key;\n  publicData: string;\n  publicDataSig: string;\n  publicSearchable: string;\n  publicSearchableSig: string;\n  plainData: string;\n  plainDataSig: string;\n  cipherData: string;\n  // Parse/decrypted versions of the above.\n  publicDataJson: any;\n  publicSearchableJson: any;\n  plainCipherDataJson: any;\n  plainDataJson: any;\n}\n\nexport interface CreateContactCardInput {\n  publicDataJson: any;\n  publicSearchableJson: any;\n  plainCipherDataJson: any;\n  plainDataJson: MainContactCardPlainFields;\n}\n\nexport interface UpdateContactCardInput extends CreateContactCardInput {\n  id: string;\n}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ContactCardService {\n  constructor(\n    private keyFactory: KeyFactoryService,\n    private keyService: KeyService,\n    private lrApollo: LrApolloService,\n    private keyGraph: KeyGraphService,\n    private encryptionService: EncryptionService,\n    private keyMetaService: KeyMetaService\n  ) {}\n\n  async decryptContactCard(cc: ContactCard): Promise<ContactCard> {\n    const ret = {\n      ...cc,\n      publicDataJson: JSON.parse(cc.publicData),\n      publicSearchableJson: JSON.parse(cc.publicSearchable),\n    };\n\n    if (cc.key) {\n      const key = await this.keyGraph.getJwkKey(cc.key.id);\n      // TODO: verify signature\n      ret.plainCipherDataJson = await this.encryptionService.decrypt(\n        key,\n        cc.cipherData\n      );\n    }\n\n    return ret;\n  }\n\n  async decryptContactCardEdges(\n    hasEdges: HasEdges<ContactCard>\n  ): Promise<ContactCard[]> {\n    return Promise.all(\n      hasEdges.edges.map(async (edge: any) => {\n        const cc = edge.node as ContactCard;\n        return await this.decryptContactCard(cc);\n      })\n    );\n  }\n\n  // { \"filter\": [{ \"contains\": { \"a\": true } }] }\n  async searchContactCard(publicSearchable: object): Promise<ContactCard[]> {\n    const data = await this.lrApollo.query<SearchContactCardQuery>({\n      query: SearchContactCardQuery,\n      variables: {\n        publicSearchable: JSON.stringify(publicSearchable),\n      },\n    });\n\n    return await this.decryptContactCardEdges(data.searchContactCards);\n  }\n\n  async getContactCardList(): Promise<ContactCard[]> {\n    const data = await this.lrApollo.query<ContactCardListQuery>({\n      query: ContactCardListQuery,\n    });\n\n    return await this.decryptContactCardEdges(data.contactCards);\n  }\n\n  async getContactCard(id: string): Promise<ContactCard> {\n    const data = await this.lrApollo.query<ContactCardQuery>({\n      query: ContactCardQuery,\n      variables: {\n        id,\n      },\n    });\n\n    return await this.decryptContactCard(data.contactCard);\n  }\n\n  private async prepareContactCardInput(\n    input: CreateContactCardInput\n  ): Promise<any> {\n    const sigPxk = await this.keyService.getCurrentSigPxk();\n    const publicDataSig = JSON.stringify(\n      await this.encryptionService.sign(sigPxk.jwk, input.publicDataJson)\n    );\n    const publicSearchableSig = JSON.stringify(\n      await this.encryptionService.sign(sigPxk.jwk, input.publicSearchableJson)\n    );\n    const plainDataSig = JSON.stringify(\n      await this.encryptionService.sign(sigPxk.jwk, input.plainDataJson)\n    );\n\n    return {\n      sigPxkId: sigPxk.id,\n      publicDataSig,\n      publicSearchableSig,\n      plainDataSig,\n    };\n  }\n\n  async createContactCard(input: CreateContactCardInput): Promise<ContactCard> {\n    // Get encryption key\n    const rootKey = await this.keyService.getCurrentRootKey();\n    const key = await this.keyFactory.createKey();\n    const wrappedKey = await this.keyGraph.encryptToString(\n      rootKey.jwk,\n      key.toJSON(true)\n    );\n    const cipherData = await this.keyGraph.encryptToString(\n      key,\n      input.plainCipherDataJson\n    );\n\n    const params = await this.prepareContactCardInput(input);\n\n    const data = await this.lrApollo.mutate<{\n      createContactCard: { contactCard: ContactCard };\n    }>({\n      mutation: CreateContactCardMutation,\n      variables: {\n        input: {\n          ...params,\n          wrappingKeyId: rootKey.id,\n          wrappedKey,\n          cipherData,\n        },\n      },\n    });\n\n    return data.createContactCard.contactCard;\n  }\n\n  async updateContactCard(input: UpdateContactCardInput): Promise<ContactCard> {\n    // Get encryption key\n    const cc = await this.getContactCard(input.id);\n    const key = await this.keyGraph.getJwkKey(cc.key.id);\n    const cipherData = await this.keyGraph.encryptToString(\n      key,\n      input.plainCipherDataJson\n    );\n\n    const params = await this.prepareContactCardInput(input);\n\n    const data = await this.lrApollo.mutate<{\n      updateContactCard: { contactCard: ContactCard };\n    }>({\n      mutation: UpdateContactCardMutation,\n      variables: {\n        input: {\n          ...params,\n          id: input.id,\n          cipherData,\n        },\n      },\n    });\n\n    return data.updateContactCard.contactCard;\n  }\n\n  async deleteContactCard(id: string): Promise<string> {\n    const data = await this.lrApollo.mutate<any>({\n      mutation: DeleteContactCardMutation,\n      variables: {\n        input: {\n          id,\n        },\n      },\n    });\n\n    return data.deleteContactCard.id;\n  }\n}\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":"/opt/atlassian/pipelines/agent/build/projects/core/src/","sources":["lib/api/contact-card2.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, NgZone } from '@angular/core';\nimport { EncryptionService } from '../cryptography/encryption.service';\nimport { KeyFactoryService } from '../cryptography/key-factory.service';\nimport { KeyGraphService } from '../cryptography/key-graph.service';\nimport { KeyMetaService } from '../cryptography/key-meta.service';\nimport { KeyService } from '../cryptography/key.service';\nimport { MainContactCardPlainFields } from '../users/profile.types';\nimport { RunOutsideAngular } from '../_common/run-outside-angular';\nimport {\n  CreateContactCardMutation,\n  DeleteContactCardMutation,\n  UpdateContactCardMutation,\n} from './contact-card2.gql';\nimport { LrMutation } from './lr-graphql';\n\nexport interface CreateContactCardInput2 {\n  publicDataJson: any;\n  publicSearchableJson: any;\n  plainCipherDataJson: any;\n  plainDataJson: MainContactCardPlainFields;\n}\n\n// These contact name fields are enforced by the server so that it can send out emails with\n// appropriate format.\nexport interface ContactCardName2 {\n  name: string;\n  title?: string;\n  firstName?: string;\n  lastName?: string;\n  // additional fields are not allowed by the server\n}\n\nexport class OwnerPlainDataJson {\n  name: ContactCardName2;\n}\n\nexport interface UpdateContactCardInput2 extends CreateContactCardInput2 {\n  id: string;\n  keyId: string;\n}\n\n@RunOutsideAngular({\n  ngZoneName: 'ngZone',\n})\n@Injectable({\n  providedIn: 'root',\n})\nexport class ContactCard2Service {\n  constructor(\n    private keyFactory: KeyFactoryService,\n    private keyService: KeyService,\n    private encryptionService: EncryptionService,\n    private keyGraph: KeyGraphService,\n    private keyMetaService: KeyMetaService,\n    private ngZone: NgZone\n  ) {}\n\n  async createContactCard(input: CreateContactCardInput2) {\n    // Get encryption key\n    const rootKey = await this.keyService.getCurrentRootKey();\n    const key = await this.keyFactory.createKey();\n    const wrappedKey = await this.keyGraph.encryptToString(\n      rootKey.jwk,\n      key.toJSON(true)\n    );\n    const cipherData = await this.keyGraph.encryptToString(\n      key,\n      input.plainCipherDataJson\n    );\n\n    const params = await this.prepareContactCardInput(input);\n\n    return new LrMutation({\n      mutation: CreateContactCardMutation,\n      variables: {\n        input: {\n          ...params,\n          wrappingKeyId: rootKey.id,\n          wrappedKey,\n          cipherData,\n        },\n      },\n    });\n  }\n\n  async updateContactCard(input: UpdateContactCardInput2) {\n    // Get encryption key\n    const cipherData = await this.keyGraph.encryptToString(\n      input.keyId,\n      input.plainCipherDataJson\n    );\n\n    const params = await this.prepareContactCardInput(input);\n\n    return new LrMutation({\n      mutation: UpdateContactCardMutation,\n      variables: {\n        input: {\n          ...params,\n          id: input.id,\n          cipherData,\n        },\n      },\n    });\n  }\n\n  deleteContactCard(id: string) {\n    return new LrMutation({\n      mutation: DeleteContactCardMutation,\n      variables: {\n        input: {\n          id,\n        },\n      },\n    });\n  }\n\n  private async prepareContactCardInput(\n    input: CreateContactCardInput2\n  ): Promise<any> {\n    const sigPxk = await this.keyService.getCurrentSigPxk();\n    const publicDataSig = JSON.stringify(\n      await this.encryptionService.sign(sigPxk.jwk, input.publicDataJson)\n    );\n    const publicSearchableSig = JSON.stringify(\n      await this.encryptionService.sign(sigPxk.jwk, input.publicSearchableJson)\n    );\n    const plainDataSig = JSON.stringify(\n      await this.encryptionService.sign(sigPxk.jwk, input.plainDataJson)\n    );\n\n    return {\n      sigPxkId: sigPxk.id,\n      publicDataSig,\n      publicSearchableSig,\n      plainDataSig,\n    };\n  }\n}\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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

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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