@lifeready/core 1.0.1 → 1.0.2

package/esm2015/lib/plan/plan.gql.js

@@ -0,0 +1,123 @@
+import gql from 'graphql-tag';
+export const CreateStripeCheckoutSessionMutation = gql `
+  mutation CreateStripeCheckoutSession(
+    $priceId: String!
+    $successUrl: String!
+    $cancelUrl: String!
+  ) {
+    createStripeCheckoutSession(
+      input: {
+        priceId: $priceId
+        successUrl: $successUrl
+        cancelUrl: $cancelUrl
+      }
+    ) {
+      sessionId
+    }
+  }
+`;
+export const CreateStripeBillingPortalSessionMutation = gql `
+  mutation CreateStripeBillingPortalSession($returnUrl: String!) {
+    createStripeBillingPortalSession(input: { returnUrl: $returnUrl }) {
+      sessionUrl
+    }
+  }
+`;
+export const planFields = `
+  name
+  data
+  state
+`;
+export const CreateUserIssuedPlanMutation = gql `
+mutation CreateUserIssuedPlan($input: CreateUserIssuedPlanInput!){
+  createUserIssuedPlan(input: $input) {
+    userIssuedPlan {
+      id
+      plan {
+        ${planFields}
+      }
+      token
+      tokenExpiryTime
+      planPeriodEnd
+      planPeriodEndAfterSeconds
+    }
+  }
+}`;
+export const DeleteUserIssuedPlanMutation = gql `
+  mutation DeleteUserIssuedPlan($input: DeleteUserIssuedPlanInput!) {
+    deleteUserIssuedPlan(input: $input) {
+      id
+    }
+  }
+`;
+export const UserIssuablePlansQuery = gql `
+query UserIssuablePlans {
+  userIssuablePlans {
+    plan {
+      ${planFields}
+    }
+  }
+}
+`;
+// Put other fields in as needed.
+export const UserIssuedPlansQuery = gql `
+  query UserIssuedPlans {
+    userIssuedPlans {
+      edges {
+        node {
+          id
+        }
+      }
+    }
+  }
+`;
+export const UserIssuedPlanQuery = gql `
+query UserIssuedPlan(
+  $id: LrRelayIdInput!
+  $token: String
+) {
+  userIssuedPlan(
+    id: $id
+    token: $token
+  ) {
+    id
+    plan {
+      ${planFields}
+    }
+    planPeriodEnd
+    planPeriodEndAfterSeconds
+  }
+}
+`;
+export const AssociateUserIssuedPlanMutation = gql `
+mutation AssociateUserIssuedPlan($input: AssociateUserIssuedPlanInput!){
+  associateUserIssuedPlan(input: $input) {
+    userPlan {
+      id
+      plan {
+        ${planFields}
+      }
+      periodEnd
+    }
+  }
+}`;
+export const UserPlansQuery = gql `
+query UserPlans {
+  userPlans {
+    id
+    periodEnd
+    plan {
+      ${planFields}
+    }
+  }
+}
+`;
+export const StripeQuery = gql `
+  query Stripe {
+    stripe {
+      id
+      customer
+    }
+  }
+`;
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/plan/plan.service.js

@@ -0,0 +1,149 @@
+import { __awaiter } from "tslib";
+import { Injectable } from '@angular/core';
+import { CreateStripeCheckoutSessionMutation, CreateStripeBillingPortalSessionMutation, UserIssuablePlansQuery, CreateUserIssuedPlanMutation, DeleteUserIssuedPlanMutation, UserIssuedPlansQuery, AssociateUserIssuedPlanMutation, UserPlansQuery, StripeQuery, UserIssuedPlanQuery, } from './plan.gql';
+import { LrApolloService } from '../api/lr-apollo.service';
+import { LrBadArgumentException } from '../_common/exceptions';
+import * as i0 from "@angular/core";
+import * as i1 from "../api/lr-apollo.service";
+export function mapUserPlans(userPlans) {
+    return userPlans.map((t) => {
+        var _a;
+        return (Object.assign(Object.assign({}, t), { periodEnd: t.periodEnd && new Date(t.periodEnd), subscription: { id: (_a = t.stripe) === null || _a === void 0 ? void 0 : _a.subscriptionId } }));
+    });
+}
+export class PlanService {
+    constructor(lrApollo) {
+        this.lrApollo = lrApollo;
+    }
+    createStripeCheckoutSession(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.lrApollo.mutate({
+                mutation: CreateStripeCheckoutSessionMutation,
+                variables: Object.assign({}, input),
+            });
+            return {
+                id: res.createStripeCheckoutSession.sessionId,
+            };
+        });
+    }
+    createStripeBillingPortalSession(returnUrl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.lrApollo.mutate({
+                mutation: CreateStripeBillingPortalSessionMutation,
+                variables: {
+                    returnUrl,
+                },
+            });
+            return {
+                url: res.createStripeBillingPortalSession.sessionUrl,
+            };
+        });
+    }
+    getUserIssuablePlans() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { userIssuablePlans } = yield this.lrApollo.query({
+                query: UserIssuablePlansQuery,
+            });
+            return userIssuablePlans;
+        });
+    }
+    createUserIssuedPlan({ planName, tokenExpiryTime, planPeriodEnd, planPeriodEndAfterSeconds, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (planPeriodEnd == null && planPeriodEndAfterSeconds == null) {
+                throw new LrBadArgumentException('Must specify either "planPeriodEnd" or "planPeriodEndAfterSeconds"');
+            }
+            const { createUserIssuedPlan } = yield this.lrApollo.mutate({
+                mutation: CreateUserIssuedPlanMutation,
+                variables: {
+                    input: {
+                        planName,
+                        tokenExpiryTime: tokenExpiryTime.toISOString(),
+                        planPeriodEnd: planPeriodEnd && planPeriodEnd.toISOString(),
+                        planPeriodEndAfterSeconds,
+                    },
+                },
+            });
+            const { userIssuedPlan } = createUserIssuedPlan;
+            return Object.assign(Object.assign({}, userIssuedPlan), { tokenExpiryTime: new Date(userIssuedPlan.tokenExpiryTime), planPeriodEnd: new Date(userIssuedPlan.planPeriodEnd) });
+        });
+    }
+    deleteUserIssuedPlan(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.lrApollo.mutate({
+                mutation: DeleteUserIssuedPlanMutation,
+                variables: {
+                    input: {
+                        id,
+                    },
+                },
+            });
+        });
+    }
+    getUserIssuedPlans() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { userIssuedPlans } = yield this.lrApollo.query({
+                query: UserIssuedPlansQuery,
+            });
+            return userIssuedPlans.edges.map((edge) => edge.node);
+        });
+    }
+    getUserIssuedPlan(id, token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { userIssuedPlan } = yield this.lrApollo.query({
+                query: UserIssuedPlanQuery,
+                variables: {
+                    id,
+                    token,
+                },
+            });
+            return userIssuedPlan;
+        });
+    }
+    associateUserIssuedPlan({ id, token, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { associateUserIssuedPlan } = yield this.lrApollo.query({
+                query: AssociateUserIssuedPlanMutation,
+                variables: {
+                    input: {
+                        id,
+                        token,
+                    },
+                },
+            });
+            const { userPlan } = associateUserIssuedPlan;
+            return Object.assign(Object.assign({}, userPlan), { periodEnd: new Date(userPlan.periodEnd) });
+        });
+    }
+    getUserPlans() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { userPlans } = yield this.lrApollo.query({
+                query: UserPlansQuery,
+            });
+            return mapUserPlans(userPlans);
+        });
+    }
+    getPlanType(subscriptionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const stripe = yield this.getStripe();
+            return stripe.customer.subscriptions.data.filter((sub) => sub.id === subscriptionId)[0].items.data[0].plan.interval;
+        });
+    }
+    getStripe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { stripe } = yield this.lrApollo.query({
+                query: StripeQuery,
+            });
+            return stripe;
+        });
+    }
+}
+PlanService.ɵprov = i0.ɵɵdefineInjectable({ factory: function PlanService_Factory() { return new PlanService(i0.ɵɵinject(i1.LrApolloService)); }, token: PlanService, providedIn: "root" });
+PlanService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+PlanService.ctorParameters = () => [
+    { type: LrApolloService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plan.service.js","sourceRoot":"/opt/atlassian/pipelines/agent/build/projects/core/src/","sources":["lib/plan/plan.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  CreateStripeCheckoutSessionMutation,\n  CreateStripeBillingPortalSessionMutation,\n  UserIssuablePlansQuery,\n  CreateUserIssuedPlanMutation,\n  DeleteUserIssuedPlanMutation,\n  UserIssuedPlansQuery,\n  AssociateUserIssuedPlanMutation,\n  UserPlansQuery,\n  StripeQuery,\n  UserIssuedPlanQuery,\n} from './plan.gql';\nimport { LrApolloService } from '../api/lr-apollo.service';\nimport {\n  StripeCheckoutSession,\n  StripeBillingPortalSession,\n  UserIssuablePlan,\n  UserIssuedPlan,\n  UserPlan,\n} from './plan.types';\nimport { LrBadArgumentException } from '../_common/exceptions';\n\nexport function mapUserPlans(userPlans: any[]): UserPlan[] {\n  return userPlans.map((t) => ({\n    ...t,\n    periodEnd: t.periodEnd && new Date(t.periodEnd),\n    subscription: { id: t.stripe?.subscriptionId },\n  }));\n}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class PlanService {\n  constructor(private lrApollo: LrApolloService) {}\n\n  async createStripeCheckoutSession(input: {\n    priceId: string;\n    successUrl: string;\n    cancelUrl: string;\n  }): Promise<StripeCheckoutSession> {\n    const res = await this.lrApollo.mutate<{\n      createStripeCheckoutSession: any;\n    }>({\n      mutation: CreateStripeCheckoutSessionMutation,\n      variables: {\n        ...input,\n      },\n    });\n    return {\n      id: res.createStripeCheckoutSession.sessionId,\n    };\n  }\n\n  async createStripeBillingPortalSession(\n    returnUrl: string\n  ): Promise<StripeBillingPortalSession> {\n    const res = await this.lrApollo.mutate<{\n      createStripeBillingPortalSession: any;\n    }>({\n      mutation: CreateStripeBillingPortalSessionMutation,\n      variables: {\n        returnUrl,\n      },\n    });\n    return {\n      url: res.createStripeBillingPortalSession.sessionUrl,\n    };\n  }\n\n  async getUserIssuablePlans(): Promise<UserIssuablePlan[]> {\n    const { userIssuablePlans } = await this.lrApollo.query<{\n      userIssuablePlans: any;\n    }>({\n      query: UserIssuablePlansQuery,\n    });\n\n    return userIssuablePlans;\n  }\n\n  async createUserIssuedPlan({\n    planName,\n    tokenExpiryTime,\n    planPeriodEnd,\n    planPeriodEndAfterSeconds,\n  }: {\n    planName: string;\n    tokenExpiryTime: Date;\n    planPeriodEnd?: Date;\n    planPeriodEndAfterSeconds?: number;\n  }): Promise<UserIssuedPlan> {\n    if (planPeriodEnd == null && planPeriodEndAfterSeconds == null) {\n      throw new LrBadArgumentException(\n        'Must specify either \"planPeriodEnd\" or \"planPeriodEndAfterSeconds\"'\n      );\n    }\n\n    const { createUserIssuedPlan } = await this.lrApollo.mutate<any>({\n      mutation: CreateUserIssuedPlanMutation,\n      variables: {\n        input: {\n          planName,\n          tokenExpiryTime: tokenExpiryTime.toISOString(),\n          planPeriodEnd: planPeriodEnd && planPeriodEnd.toISOString(),\n          planPeriodEndAfterSeconds,\n        },\n      },\n    });\n\n    const { userIssuedPlan } = createUserIssuedPlan;\n\n    return {\n      ...userIssuedPlan,\n      tokenExpiryTime: new Date(userIssuedPlan.tokenExpiryTime),\n      planPeriodEnd: new Date(userIssuedPlan.planPeriodEnd),\n    };\n  }\n\n  async deleteUserIssuedPlan(id: string): Promise<void> {\n    return await this.lrApollo.mutate<any>({\n      mutation: DeleteUserIssuedPlanMutation,\n      variables: {\n        input: {\n          id,\n        },\n      },\n    });\n  }\n\n  async getUserIssuedPlans(): Promise<any[]> {\n    const { userIssuedPlans } = await this.lrApollo.query<any>({\n      query: UserIssuedPlansQuery,\n    });\n\n    return userIssuedPlans.edges.map((edge) => edge.node);\n  }\n\n  async getUserIssuedPlan(id: string, token?: string): Promise<any> {\n    const { userIssuedPlan } = await this.lrApollo.query<any>({\n      query: UserIssuedPlanQuery,\n      variables: {\n        id,\n        token,\n      },\n    });\n\n    return userIssuedPlan;\n  }\n\n  async associateUserIssuedPlan({\n    id,\n    token,\n  }: {\n    id: string;\n    token: string;\n  }): Promise<UserPlan> {\n    const { associateUserIssuedPlan } = await this.lrApollo.query<any>({\n      query: AssociateUserIssuedPlanMutation,\n      variables: {\n        input: {\n          id,\n          token,\n        },\n      },\n    });\n\n    const { userPlan } = associateUserIssuedPlan;\n\n    return {\n      ...userPlan,\n      periodEnd: new Date(userPlan.periodEnd),\n    };\n  }\n\n  async getUserPlans(): Promise<UserPlan[]> {\n    const { userPlans } = await this.lrApollo.query<any>({\n      query: UserPlansQuery,\n    });\n\n    return mapUserPlans(userPlans);\n  }\n\n  async getPlanType(subscriptionId: string): Promise<string> {\n    const stripe: any = await this.getStripe();\n    return stripe.customer.subscriptions.data.filter(\n      (sub) => sub.id === subscriptionId\n    )[0].items.data[0].plan.interval;\n  }\n\n  async getStripe(): Promise<{ id: string; customer: object }> {\n    const { stripe } = await this.lrApollo.query<any>({\n      query: StripeQuery,\n    });\n\n    return stripe;\n  }\n}\n"]}

package/esm2015/lib/plan/plan.types.js

@@ -0,0 +1,11 @@
+export class Plan {
+}
+export class Subscription {
+}
+export class UserPlan {
+}
+export class StripeCheckoutSession {
+}
+export class StripeBillingPortalSession {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGxhbi50eXBlcy5qcyIsInNvdXJjZVJvb3QiOiIvb3B0L2F0bGFzc2lhbi9waXBlbGluZXMvYWdlbnQvYnVpbGQvcHJvamVjdHMvY29yZS9zcmMvIiwic291cmNlcyI6WyJsaWIvcGxhbi9wbGFuLnR5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sT0FBTyxJQUFJO0NBSWhCO0FBRUQsTUFBTSxPQUFPLFlBQVk7Q0FFeEI7QUFFRCxNQUFNLE9BQU8sUUFBUTtDQUtwQjtBQUVELE1BQU0sT0FBTyxxQkFBcUI7Q0FFakM7QUFFRCxNQUFNLE9BQU8sMEJBQTBCO0NBRXRDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNsYXNzIFBsYW4ge1xuICBuYW1lOiBzdHJpbmc7XG4gIGRhdGE6IG9iamVjdDtcbiAgc3RhdGU6IHN0cmluZztcbn1cblxuZXhwb3J0IGNsYXNzIFN1YnNjcmlwdGlvbiB7XG4gIGlkOiBzdHJpbmc7XG59XG5cbmV4cG9ydCBjbGFzcyBVc2VyUGxhbiB7XG4gIGlkOiBzdHJpbmc7XG4gIHBsYW46IFBsYW47XG4gIHBlcmlvZEVuZDogRGF0ZTtcbiAgc3Vic2NyaXB0aW9uOiBTdWJzY3JpcHRpb247XG59XG5cbmV4cG9ydCBjbGFzcyBTdHJpcGVDaGVja291dFNlc3Npb24ge1xuICBpZDogc3RyaW5nO1xufVxuXG5leHBvcnQgY2xhc3MgU3RyaXBlQmlsbGluZ1BvcnRhbFNlc3Npb24ge1xuICB1cmw6IHN0cmluZztcbn1cblxuZXhwb3J0IGludGVyZmFjZSBVc2VySXNzdWFibGVQbGFuIHtcbiAgcGxhbjogUGxhbjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBVc2VySXNzdWVkUGxhbiB7XG4gIGlkOiBzdHJpbmc7XG4gIHBsYW46IFBsYW47XG4gIHRva2VuOiBzdHJpbmc7XG4gIHRva2VuRXhwaXJ5VGltZTogRGF0ZTtcbiAgcGxhblBlcmlvZEVuZDogRGF0ZTtcbiAgcGxhblBlcmlvZEVuZEFmdGVyU2Vjb25kczogbnVtYmVyO1xufVxuIl19

package/esm2015/lib/record/record-attachment.service.js

@@ -0,0 +1,101 @@
+import { __awaiter } from "tslib";
+import { Injectable } from '@angular/core';
+import { FileType, DeleteFileMutation, CreateFileMutation } from './record.gql';
+import { LrApolloService } from '../api/lr-apollo.service';
+import { KeyMetaService } from '../cryptography/key-meta.service';
+import { FileService } from '../api/file.service';
+import { KeyGraphService } from '../cryptography/key-graph.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../api/file.service";
+import * as i2 from "../api/lr-apollo.service";
+import * as i3 from "../cryptography/key-meta.service";
+import * as i4 from "../cryptography/key-graph.service";
+export class RecordAttachmentService {
+    constructor(fileService, lrApollo, keyMetaService, keyGraph) {
+        this.fileService = fileService;
+        this.lrApollo = lrApollo;
+        this.keyMetaService = keyMetaService;
+        this.keyGraph = keyGraph;
+    }
+    downloadAttachment(fileStateNodeId, keyId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const encryptedFile = yield this.fileService.downloadEncryptedFile(fileStateNodeId);
+            return yield this.keyGraph.decryptFile(keyId, encryptedFile);
+        });
+    }
+    uploadAttachments(recordId, attachments) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fileIds = yield Promise.all((attachments || []).map((x) => __awaiter(this, void 0, void 0, function* () {
+                if (x.fileId) {
+                    if (x.isDeleted) {
+                        yield this.deleteAttachment(x.fileId);
+                        return null;
+                    }
+                    else {
+                        return x.fileId;
+                    }
+                }
+                else {
+                    return yield this.addAttachment(recordId, x);
+                }
+            })));
+            return fileIds.filter((x) => x);
+        });
+    }
+    addAttachment(recordId, attachment) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const secureContent = {
+                name: attachment.name,
+                fieldId: attachment.fieldId,
+                fileType: attachment.file.type,
+                fileSize: attachment.file.size,
+                lastModified: attachment.file.lastModified,
+            };
+            const fileContent = yield this.fileService.loadFile(attachment.file);
+            const doubleWrappedContent = yield this.keyMetaService.doubleWrapContent(secureContent, [recordId], fileContent);
+            const contentId = yield this.fileService.uploadEncryptedFile({
+                encryptedContent: doubleWrappedContent.cipherFileContent,
+                fileName: attachment.name,
+            });
+            // Save file
+            const response = yield this.lrApollo.mutate({
+                mutation: CreateFileMutation,
+                variables: {
+                    input: {
+                        plainMeta: JSON.stringify({ fileType: FileType.RecordAttachment }),
+                        wrappedStateKey: doubleWrappedContent.doubleWrappedKey,
+                        cipherMeta: doubleWrappedContent.cipherMeta,
+                        parentDirectories: doubleWrappedContent.wrappedKeys.map((x) => ({
+                            directoryId: x.directoryId,
+                            wrappingKeyId: x.wrappingKeyId,
+                            wrappedFileKey: x.wrappedKey,
+                        })),
+                        contentResource: contentId,
+                    },
+                },
+            });
+            return response.createFile.file.id;
+        });
+    }
+    deleteAttachment(fileId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.lrApollo.mutate({
+                mutation: DeleteFileMutation,
+                variables: { fileId },
+            });
+        });
+    }
+}
+RecordAttachmentService.ɵprov = i0.ɵɵdefineInjectable({ factory: function RecordAttachmentService_Factory() { return new RecordAttachmentService(i0.ɵɵinject(i1.FileService), i0.ɵɵinject(i2.LrApolloService), i0.ɵɵinject(i3.KeyMetaService), i0.ɵɵinject(i4.KeyGraphService)); }, token: RecordAttachmentService, providedIn: "root" });
+RecordAttachmentService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+RecordAttachmentService.ctorParameters = () => [
+    { type: FileService },
+    { type: LrApolloService },
+    { type: KeyMetaService },
+    { type: KeyGraphService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"record-attachment.service.js","sourceRoot":"/opt/atlassian/pipelines/agent/build/projects/core/src/","sources":["lib/record/record-attachment.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { FileType, DeleteFileMutation, CreateFileMutation } from './record.gql';\nimport { NewAttachment, NewOrUpdatedAttachment } from './record.types';\nimport { LrApolloService } from '../api/lr-apollo.service';\nimport { KeyMetaService } from '../cryptography/key-meta.service';\nimport { FileService } from '../api/file.service';\nimport { KeyGraphService } from '../cryptography/key-graph.service';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class RecordAttachmentService {\n  constructor(\n    private fileService: FileService,\n    private lrApollo: LrApolloService,\n    private keyMetaService: KeyMetaService,\n    private keyGraph: KeyGraphService\n  ) {}\n\n  async downloadAttachment(\n    fileStateNodeId: string,\n    keyId: string\n  ): Promise<any> {\n    const encryptedFile = await this.fileService.downloadEncryptedFile(\n      fileStateNodeId\n    );\n\n    return await this.keyGraph.decryptFile(keyId, encryptedFile);\n  }\n\n  async uploadAttachments(\n    recordId: string,\n    attachments: NewOrUpdatedAttachment[]\n  ): Promise<string[]> {\n    const fileIds = await Promise.all(\n      (attachments || []).map(async (x) => {\n        if (x.fileId) {\n          if (x.isDeleted) {\n            await this.deleteAttachment(x.fileId);\n            return null;\n          } else {\n            return x.fileId;\n          }\n        } else {\n          return await this.addAttachment(recordId, x);\n        }\n      })\n    );\n    return fileIds.filter((x) => x);\n  }\n\n  private async addAttachment(\n    recordId: string,\n    attachment: NewAttachment\n  ): Promise<string> {\n    const secureContent = {\n      name: attachment.name,\n      fieldId: attachment.fieldId,\n      fileType: attachment.file.type,\n      fileSize: attachment.file.size,\n      lastModified: attachment.file.lastModified,\n    };\n    const fileContent = await this.fileService.loadFile(attachment.file);\n    const doubleWrappedContent = await this.keyMetaService.doubleWrapContent(\n      secureContent,\n      [recordId],\n      fileContent\n    );\n\n    const contentId = await this.fileService.uploadEncryptedFile({\n      encryptedContent: doubleWrappedContent.cipherFileContent,\n      fileName: attachment.name,\n    });\n\n    // Save file\n    const response = await this.lrApollo.mutate<any>({\n      mutation: CreateFileMutation,\n      variables: {\n        input: {\n          plainMeta: JSON.stringify({ fileType: FileType.RecordAttachment }),\n          wrappedStateKey: doubleWrappedContent.doubleWrappedKey,\n          cipherMeta: doubleWrappedContent.cipherMeta,\n          parentDirectories: doubleWrappedContent.wrappedKeys.map((x) => ({\n            directoryId: x.directoryId,\n            wrappingKeyId: x.wrappingKeyId,\n            wrappedFileKey: x.wrappedKey,\n          })),\n          contentResource: contentId,\n        },\n      },\n    });\n    return response.createFile.file.id;\n  }\n\n  async deleteAttachment(fileId: string): Promise<void> {\n    await this.lrApollo.mutate({\n      mutation: DeleteFileMutation,\n      variables: { fileId },\n    });\n  }\n}\n"]}

package/esm2015/lib/record/record.gql.js

@@ -0,0 +1,179 @@
+import gql from 'graphql-tag';
+import { KeyGraphFragment } from '../_common/queries.gql';
+import { DEFAULT_BREADCRUMB_DEPTH, parentCategoriesField, AccessFields, } from '../category/category.gql';
+export var FileType;
+(function (FileType) {
+    FileType["RecordContent"] = "record-content";
+    FileType["RecordAttachment"] = "record-attachment";
+})(FileType || (FileType = {}));
+export const RecordContentFilter = JSON.stringify({
+    filter: [
+        {
+            contains: {
+                fileType: FileType.RecordContent,
+            },
+        },
+    ],
+});
+export const RecordAttachmentFilter = JSON.stringify({
+    filter: [
+        {
+            contains: {
+                fileType: FileType.RecordAttachment,
+            },
+        },
+    ],
+});
+export const GetRecordQuery = (depth = DEFAULT_BREADCRUMB_DEPTH) => gql `
+query Record(
+  $id: LrRelayIdInput!,
+  $cachedKeyIds: [LrRelayIdInput!],
+  $categoryFilter: LrJSONFilter,
+  $contentFilter: LrJSONFilter,
+  $attachmentsFilter: LrJSONFilter,
+) {
+  record: directory(id: $id) {
+    id
+    keyId
+    archived
+    plainMeta
+    cipherMeta
+    created
+    modified
+    ${AccessFields}
+    ${parentCategoriesField(depth)}
+    content: childFileLinks(plainMeta: $contentFilter) {
+      edges {
+        node {
+          childFile {
+            id
+            keyId
+            archived
+            currentVersion {
+              state {
+                id
+                keyId
+                plainMeta
+                cipherMeta
+                created
+                modified
+              }
+            }
+            versions {
+              edges {
+                node {
+                  operation
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    attachments: childFileLinks(plainMeta: $attachmentsFilter) {
+      edges {
+        node {
+          childFile {
+            id
+            keyId
+            archived
+            currentVersion {
+              state {
+                id
+                keyId
+                plainMeta
+                cipherMeta
+                contentResource
+              }
+            }
+            versions {
+              edges {
+                node {
+                  operation
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  keyGraph(cachedKeyIds: $cachedKeyIds) {
+    ...KeyGraphFragment
+  }
+}
+${KeyGraphFragment}
+`;
+export const CreateRecordContainerMutation = gql `
+  mutation CreateRecordContainer(
+    $plainMeta: LrJSONString
+    $cipherMeta: String
+    $parentDirectories: [ParentDirectoryInput!]
+    $parentRootDirectory: ParentRootDirectoryInput
+  ) {
+    new: createDirectory(
+      input: {
+        plainMeta: $plainMeta
+        cipherMeta: $cipherMeta
+        parentDirectories: $parentDirectories
+        parentRootDirectory: $parentRootDirectory
+      }
+    ) {
+      category: directory {
+        id
+        keyId
+      }
+    }
+  }
+`;
+export const CreateRecordMutation = gql `
+  mutation CreateFile($input: CreateFileInput!) {
+    createFile(input: $input) {
+      file {
+        id
+      }
+    }
+  }
+`;
+export const UpdateRecordContainerMutation = gql `
+  mutation UpdateRecord($input: UpdateDirectoryInput!) {
+    updateDirectory(input: $input) {
+      directory {
+        id
+      }
+    }
+  }
+`;
+export const UpdateRecordMutation = gql `
+  mutation UpdateFile($input: UpdateFileInput!) {
+    updateFile(input: $input) {
+      file {
+        id
+      }
+    }
+  }
+`;
+export const DeleteRecordMutation = gql `
+  mutation DeleteRecord($recordId: LrRelayIdInput!) {
+    deleteDirectory(input: { directoryId: $recordId }) {
+      id
+    }
+  }
+`;
+export const CreateFileMutation = gql `
+  mutation CreateFile($input: CreateFileInput!) {
+    createFile(input: $input) {
+      file {
+        id
+      }
+    }
+  }
+`;
+export const DeleteFileMutation = gql `
+  mutation DeleteFile($fileId: LrRelayIdInput!) {
+    deleteFile(input: { fileId: $fileId }) {
+      id
+    }
+  }
+`;
+//# sourceMappingURL=data:application/json;base64,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