@deenruv/payments-plugin 1.0.0

package/package/braintree/braintree.plugin.d.ts

@@ -0,0 +1,238 @@
+import { Type } from "@deenruv/core";
+import { BraintreePluginOptions } from "./types";
+/**
+ * @description
+ * This plugin enables payments to be processed by [Braintree](https://www.braintreepayments.com/), a popular payment provider.
+ *
+ * ## Requirements
+ *
+ * 1. You will need to create a Braintree sandbox account as outlined in https://developers.braintreepayments.com/start/overview.
+ * 2. Then install `braintree` and `@types/braintree` from npm. This plugin was written with `v3.x` of the Braintree lib.
+ *     ```shell
+ *     yarn add \@deenruv/payments-plugin braintree
+ *     yarn add -D \@types/braintree
+ *     ```
+ *     or
+ *     ```shell
+ *     npm install \@deenruv/payments-plugin braintree
+ *     npm install -D \@types/braintree
+ *     ```
+ *
+ * ## Setup
+ *
+ * 1. Add the plugin to your DeenruvConfig `plugins` array:
+ *     ```ts
+ *     import { BraintreePlugin } from '\@deenruv/payments-plugin/package/braintree';
+ *     import { Environment } from 'braintree';
+ *
+ *     // ...
+ *
+ *     plugins: [
+ *       BraintreePlugin.init({
+ *         environment: Environment.Sandbox,
+ *         // This allows saving customer payment
+ *         // methods with Braintree (see "vaulting"
+ *         // section below for details)
+ *         storeCustomersInBraintree: true,
+ *       }),
+ *     ]
+ *     ```
+ * 2. Create a new PaymentMethod in the Admin UI, and select "Braintree payments" as the handler.
+ * 2. Fill in the `Merchant ID`, `Public Key` & `Private Key` from your Braintree sandbox account.
+ *
+ * ## Storefront usage
+ *
+ * The plugin is designed to work with the [Braintree drop-in UI](https://developers.braintreepayments.com/guides/drop-in/overview/javascript/v3).
+ * This is a library provided by Braintree which will handle the payment UI for you. You can install it in your storefront project
+ * with:
+ *
+ * ```shell
+ * yarn add braintree-web-drop-in
+ * # or
+ * npm install braintree-web-drop-in
+ * ```
+ *
+ * The high-level workflow is:
+ * 1. Generate a "client token" on the server by executing the `generateBraintreeClientToken` mutation which is exposed by this plugin.
+ * 2. Use this client token to instantiate the Braintree Dropin UI.
+ * 3. Listen for the `"paymentMethodRequestable"` event which emitted by the Dropin.
+ * 4. Use the Dropin's `requestPaymentMethod()` method to get the required payment metadata.
+ * 5. Pass that metadata to the `addPaymentToOrder` mutation. The metadata should be an object of type `{ nonce: string; }`
+ *
+ * Here is an example of how your storefront code will look. Note that this example is attempting to
+ * be framework-agnostic, so you'll need to adapt it to fit to your framework of choice.
+ *
+ * ```ts
+ * // The Braintree Dropin instance
+ * let dropin: import('braintree-web-drop-in').Dropin;
+ *
+ * // Used to show/hide a "submit" button, which would be bound to the
+ * // `submitPayment()` method below.
+ * let showSubmitButton = false;
+ *
+ * // Used to display a "processing..." spinner
+ * let processing = false;
+ *
+ * //
+ * // This method would be invoked when the payment screen is mounted/created.
+ * //
+ * async function renderDropin(order: Order, clientToken: string) {
+ *   // Lazy load braintree dropin because it has a reference
+ *   // to `window` which breaks SSR
+ *   dropin = await import('braintree-web-drop-in').then((module) =>
+ *     module.default.create({
+ *       authorization: clientToken,
+ *       // This assumes a div in your view with the corresponding ID
+ *       container: '#dropin-container',
+ *       card: {
+ *         cardholderName: {
+ *             required: true,
+ *         },
+ *         overrides: {},
+ *       },
+ *       // Additional config is passed here depending on
+ *       // which payment methods you have enabled in your
+ *       // Braintree account.
+ *       paypal: {
+ *         flow: 'checkout',
+ *         amount: order.totalWithTax / 100,
+ *         currency: 'GBP',
+ *       },
+ *     }),
+ *   );
+ *
+ *   // If you are using the `storeCustomersInBraintree` option, then the
+ *   // customer might already have a stored payment method selected as
+ *   // soon as the dropin script loads. In this case, show the submit
+ *   // button immediately.
+ *   if (dropin.isPaymentMethodRequestable()) {
+ *     showSubmitButton = true;
+ *   }
+ *
+ *   dropin.on('paymentMethodRequestable', (payload) => {
+ *     if (payload.type === 'CreditCard') {
+ *       showSubmitButton = true;
+ *     }
+ *     if (payload.type === 'PayPalAccount') {
+ *       this.submitPayment();
+ *     }
+ *   });
+ *
+ *   dropin.on('noPaymentMethodRequestable', () => {
+ *     // Display an error
+ *   });
+ * }
+ *
+ * async function generateClientToken() {
+ *   const { generateBraintreeClientToken } = await graphQlClient.query(gql`
+ *     query GenerateBraintreeClientToken {
+ *       generateBraintreeClientToken
+ *     }
+ *   `);
+ *   return generateBraintreeClientToken;
+ * }
+ *
+ * async submitPayment() {
+ *   if (!dropin.isPaymentMethodRequestable()) {
+ *     return;
+ *   }
+ *   showSubmitButton = false;
+ *   processing = true;
+ *
+ *   const paymentResult = await dropin.requestPaymentMethod();
+ *
+ *   const { addPaymentToOrder } = await graphQlClient.query(gql`
+ *     mutation AddPayment($input: PaymentInput!) {
+ *       addPaymentToOrder(input: $input) {
+ *         ... on Order {
+ *           id
+ *           payments {
+ *             id
+ *             amount
+ *             errorMessage
+ *             method
+ *             state
+ *             transactionId
+ *             createdAt
+ *           }
+ *         }
+ *         ... on ErrorResult {
+ *           errorCode
+ *           message
+ *         }
+ *       }
+ *     }`, {
+ *       input: {
+ *         method: 'braintree', // The code of you Braintree PaymentMethod
+ *         metadata: paymentResult,
+ *       },
+ *     },
+ *   );
+ *
+ *   switch (addPaymentToOrder?.__typename) {
+ *       case 'Order':
+ *           // Adding payment succeeded!
+ *           break;
+ *       case 'OrderStateTransitionError':
+ *       case 'OrderPaymentStateError':
+ *       case 'PaymentDeclinedError':
+ *       case 'PaymentFailedError':
+ *         // Display an error to the customer
+ *         dropin.clearSelectedPaymentMethod();
+ *   }
+ * }
+ * ```
+ *
+ * ## Storing payment details (vaulting)
+ *
+ * Braintree has a [vault feature](https://developer.paypal.com/braintree/articles/control-panel/vault/overview) which allows the secure storage
+ * of customer's payment information. Using the vault allows you to offer a faster checkout for repeat customers without needing to worry about
+ * how to securely store payment details.
+ *
+ * To enable this feature, set the `storeCustomersInBraintree` option to `true`.
+ *
+ * ```ts
+ * BraintreePlugin.init({
+ *   environment: Environment.Sandbox,
+ *   storeCustomersInBraintree: true,
+ * }),
+ * ```
+ *
+ * Since v1.8, it is possible to override vaulting on a per-payment basis by passing `includeCustomerId: false` to the `generateBraintreeClientToken`
+ * mutation:
+ *
+ * ```GraphQL
+ * const { generateBraintreeClientToken } = await graphQlClient.query(gql`
+ *   query GenerateBraintreeClientToken($includeCustomerId: Boolean) {
+ *     generateBraintreeClientToken(includeCustomerId: $includeCustomerId)
+ *   }
+ * `, { includeCustomerId: false });
+ * ```
+ *
+ * as well as in the metadata of the `addPaymentToOrder` mutation:
+ *
+ * ```ts
+ * const { addPaymentToOrder } = await graphQlClient.query(gql`
+ *   mutation AddPayment($input: PaymentInput!) {
+ *     addPaymentToOrder(input: $input) {
+ *       ...Order
+ *       ...ErrorResult
+ *     }
+ *   }`, {
+ *     input: {
+ *       method: 'braintree',
+ *       metadata: {
+ *         ...paymentResult,
+ *         includeCustomerId: false,
+ *       },
+ *     }
+ *   );
+ * ```
+ *
+ * @docsCategory core plugins/PaymentsPlugin
+ * @docsPage BraintreePlugin
+ */
+export declare class BraintreePlugin {
+    static options: BraintreePluginOptions;
+    static init(options: BraintreePluginOptions): Type<BraintreePlugin>;
+}

package/package/braintree/braintree.plugin.js

@@ -0,0 +1,294 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var BraintreePlugin_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BraintreePlugin = void 0;
+const core_1 = require("@deenruv/core");
+const graphql_tag_1 = require("graphql-tag");
+const braintree_handler_1 = require("./braintree.handler");
+const braintree_resolver_1 = require("./braintree.resolver");
+const constants_1 = require("./constants");
+/**
+ * @description
+ * This plugin enables payments to be processed by [Braintree](https://www.braintreepayments.com/), a popular payment provider.
+ *
+ * ## Requirements
+ *
+ * 1. You will need to create a Braintree sandbox account as outlined in https://developers.braintreepayments.com/start/overview.
+ * 2. Then install `braintree` and `@types/braintree` from npm. This plugin was written with `v3.x` of the Braintree lib.
+ *     ```shell
+ *     yarn add \@deenruv/payments-plugin braintree
+ *     yarn add -D \@types/braintree
+ *     ```
+ *     or
+ *     ```shell
+ *     npm install \@deenruv/payments-plugin braintree
+ *     npm install -D \@types/braintree
+ *     ```
+ *
+ * ## Setup
+ *
+ * 1. Add the plugin to your DeenruvConfig `plugins` array:
+ *     ```ts
+ *     import { BraintreePlugin } from '\@deenruv/payments-plugin/package/braintree';
+ *     import { Environment } from 'braintree';
+ *
+ *     // ...
+ *
+ *     plugins: [
+ *       BraintreePlugin.init({
+ *         environment: Environment.Sandbox,
+ *         // This allows saving customer payment
+ *         // methods with Braintree (see "vaulting"
+ *         // section below for details)
+ *         storeCustomersInBraintree: true,
+ *       }),
+ *     ]
+ *     ```
+ * 2. Create a new PaymentMethod in the Admin UI, and select "Braintree payments" as the handler.
+ * 2. Fill in the `Merchant ID`, `Public Key` & `Private Key` from your Braintree sandbox account.
+ *
+ * ## Storefront usage
+ *
+ * The plugin is designed to work with the [Braintree drop-in UI](https://developers.braintreepayments.com/guides/drop-in/overview/javascript/v3).
+ * This is a library provided by Braintree which will handle the payment UI for you. You can install it in your storefront project
+ * with:
+ *
+ * ```shell
+ * yarn add braintree-web-drop-in
+ * # or
+ * npm install braintree-web-drop-in
+ * ```
+ *
+ * The high-level workflow is:
+ * 1. Generate a "client token" on the server by executing the `generateBraintreeClientToken` mutation which is exposed by this plugin.
+ * 2. Use this client token to instantiate the Braintree Dropin UI.
+ * 3. Listen for the `"paymentMethodRequestable"` event which emitted by the Dropin.
+ * 4. Use the Dropin's `requestPaymentMethod()` method to get the required payment metadata.
+ * 5. Pass that metadata to the `addPaymentToOrder` mutation. The metadata should be an object of type `{ nonce: string; }`
+ *
+ * Here is an example of how your storefront code will look. Note that this example is attempting to
+ * be framework-agnostic, so you'll need to adapt it to fit to your framework of choice.
+ *
+ * ```ts
+ * // The Braintree Dropin instance
+ * let dropin: import('braintree-web-drop-in').Dropin;
+ *
+ * // Used to show/hide a "submit" button, which would be bound to the
+ * // `submitPayment()` method below.
+ * let showSubmitButton = false;
+ *
+ * // Used to display a "processing..." spinner
+ * let processing = false;
+ *
+ * //
+ * // This method would be invoked when the payment screen is mounted/created.
+ * //
+ * async function renderDropin(order: Order, clientToken: string) {
+ *   // Lazy load braintree dropin because it has a reference
+ *   // to `window` which breaks SSR
+ *   dropin = await import('braintree-web-drop-in').then((module) =>
+ *     module.default.create({
+ *       authorization: clientToken,
+ *       // This assumes a div in your view with the corresponding ID
+ *       container: '#dropin-container',
+ *       card: {
+ *         cardholderName: {
+ *             required: true,
+ *         },
+ *         overrides: {},
+ *       },
+ *       // Additional config is passed here depending on
+ *       // which payment methods you have enabled in your
+ *       // Braintree account.
+ *       paypal: {
+ *         flow: 'checkout',
+ *         amount: order.totalWithTax / 100,
+ *         currency: 'GBP',
+ *       },
+ *     }),
+ *   );
+ *
+ *   // If you are using the `storeCustomersInBraintree` option, then the
+ *   // customer might already have a stored payment method selected as
+ *   // soon as the dropin script loads. In this case, show the submit
+ *   // button immediately.
+ *   if (dropin.isPaymentMethodRequestable()) {
+ *     showSubmitButton = true;
+ *   }
+ *
+ *   dropin.on('paymentMethodRequestable', (payload) => {
+ *     if (payload.type === 'CreditCard') {
+ *       showSubmitButton = true;
+ *     }
+ *     if (payload.type === 'PayPalAccount') {
+ *       this.submitPayment();
+ *     }
+ *   });
+ *
+ *   dropin.on('noPaymentMethodRequestable', () => {
+ *     // Display an error
+ *   });
+ * }
+ *
+ * async function generateClientToken() {
+ *   const { generateBraintreeClientToken } = await graphQlClient.query(gql`
+ *     query GenerateBraintreeClientToken {
+ *       generateBraintreeClientToken
+ *     }
+ *   `);
+ *   return generateBraintreeClientToken;
+ * }
+ *
+ * async submitPayment() {
+ *   if (!dropin.isPaymentMethodRequestable()) {
+ *     return;
+ *   }
+ *   showSubmitButton = false;
+ *   processing = true;
+ *
+ *   const paymentResult = await dropin.requestPaymentMethod();
+ *
+ *   const { addPaymentToOrder } = await graphQlClient.query(gql`
+ *     mutation AddPayment($input: PaymentInput!) {
+ *       addPaymentToOrder(input: $input) {
+ *         ... on Order {
+ *           id
+ *           payments {
+ *             id
+ *             amount
+ *             errorMessage
+ *             method
+ *             state
+ *             transactionId
+ *             createdAt
+ *           }
+ *         }
+ *         ... on ErrorResult {
+ *           errorCode
+ *           message
+ *         }
+ *       }
+ *     }`, {
+ *       input: {
+ *         method: 'braintree', // The code of you Braintree PaymentMethod
+ *         metadata: paymentResult,
+ *       },
+ *     },
+ *   );
+ *
+ *   switch (addPaymentToOrder?.__typename) {
+ *       case 'Order':
+ *           // Adding payment succeeded!
+ *           break;
+ *       case 'OrderStateTransitionError':
+ *       case 'OrderPaymentStateError':
+ *       case 'PaymentDeclinedError':
+ *       case 'PaymentFailedError':
+ *         // Display an error to the customer
+ *         dropin.clearSelectedPaymentMethod();
+ *   }
+ * }
+ * ```
+ *
+ * ## Storing payment details (vaulting)
+ *
+ * Braintree has a [vault feature](https://developer.paypal.com/braintree/articles/control-panel/vault/overview) which allows the secure storage
+ * of customer's payment information. Using the vault allows you to offer a faster checkout for repeat customers without needing to worry about
+ * how to securely store payment details.
+ *
+ * To enable this feature, set the `storeCustomersInBraintree` option to `true`.
+ *
+ * ```ts
+ * BraintreePlugin.init({
+ *   environment: Environment.Sandbox,
+ *   storeCustomersInBraintree: true,
+ * }),
+ * ```
+ *
+ * Since v1.8, it is possible to override vaulting on a per-payment basis by passing `includeCustomerId: false` to the `generateBraintreeClientToken`
+ * mutation:
+ *
+ * ```GraphQL
+ * const { generateBraintreeClientToken } = await graphQlClient.query(gql`
+ *   query GenerateBraintreeClientToken($includeCustomerId: Boolean) {
+ *     generateBraintreeClientToken(includeCustomerId: $includeCustomerId)
+ *   }
+ * `, { includeCustomerId: false });
+ * ```
+ *
+ * as well as in the metadata of the `addPaymentToOrder` mutation:
+ *
+ * ```ts
+ * const { addPaymentToOrder } = await graphQlClient.query(gql`
+ *   mutation AddPayment($input: PaymentInput!) {
+ *     addPaymentToOrder(input: $input) {
+ *       ...Order
+ *       ...ErrorResult
+ *     }
+ *   }`, {
+ *     input: {
+ *       method: 'braintree',
+ *       metadata: {
+ *         ...paymentResult,
+ *         includeCustomerId: false,
+ *       },
+ *     }
+ *   );
+ * ```
+ *
+ * @docsCategory core plugins/PaymentsPlugin
+ * @docsPage BraintreePlugin
+ */
+let BraintreePlugin = exports.BraintreePlugin = BraintreePlugin_1 = class BraintreePlugin {
+    static init(options) {
+        this.options = options;
+        return BraintreePlugin_1;
+    }
+};
+BraintreePlugin.options = {};
+exports.BraintreePlugin = BraintreePlugin = BraintreePlugin_1 = __decorate([
+    (0, core_1.DeenruvPlugin)({
+        imports: [core_1.PluginCommonModule],
+        providers: [
+            {
+                provide: constants_1.BRAINTREE_PLUGIN_OPTIONS,
+                useFactory: () => BraintreePlugin_1.options,
+            },
+        ],
+        configuration: (config) => {
+            config.paymentOptions.paymentMethodHandlers.push(braintree_handler_1.braintreePaymentMethodHandler);
+            if (BraintreePlugin_1.options.storeCustomersInBraintree === true) {
+                config.customFields.Customer.push({
+                    name: "braintreeCustomerId",
+                    type: "string",
+                    label: [
+                        { languageCode: core_1.LanguageCode.en, value: "Braintree Customer ID" },
+                    ],
+                    nullable: true,
+                    public: false,
+                    readonly: true,
+                });
+            }
+            return config;
+        },
+        shopApiExtensions: {
+            schema: (0, graphql_tag_1.gql) `
+      extend type Query {
+        generateBraintreeClientToken(
+          orderId: ID
+          includeCustomerId: Boolean
+        ): String!
+      }
+    `,
+            resolvers: [braintree_resolver_1.BraintreeResolver],
+        },
+        compatibility: "^0.0.0",
+    })
+], BraintreePlugin);
+//# sourceMappingURL=braintree.plugin.js.map

package/package/braintree/braintree.plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"braintree.plugin.js","sourceRoot":"","sources":["../../src/braintree/braintree.plugin.ts"],"names":[],"mappings":";;;;;;;;;;AAAA,wCAKuB;AACvB,6CAAkC;AAElC,2DAAoE;AACpE,6DAAyD;AACzD,2CAAuD;AAGvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuOG;AAwCI,IAAM,eAAe,iDAArB,MAAM,eAAe;IAE1B,MAAM,CAAC,IAAI,CAAC,OAA+B;QACzC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,OAAO,iBAAe,CAAC;IACzB,CAAC;;AAJM,uBAAO,GAA2B,EAAE,AAA7B,CAA8B;0BADjC,eAAe;IAvC3B,IAAA,oBAAa,EAAC;QACb,OAAO,EAAE,CAAC,yBAAkB,CAAC;QAC7B,SAAS,EAAE;YACT;gBACE,OAAO,EAAE,oCAAwB;gBACjC,UAAU,EAAE,GAAG,EAAE,CAAC,iBAAe,CAAC,OAAO;aAC1C;SACF;QACD,aAAa,EAAE,CAAC,MAAM,EAAE,EAAE;YACxB,MAAM,CAAC,cAAc,CAAC,qBAAqB,CAAC,IAAI,CAC9C,iDAA6B,CAC9B,CAAC;YACF,IAAI,iBAAe,CAAC,OAAO,CAAC,yBAAyB,KAAK,IAAI,EAAE;gBAC9D,MAAM,CAAC,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC;oBAChC,IAAI,EAAE,qBAAqB;oBAC3B,IAAI,EAAE,QAAQ;oBACd,KAAK,EAAE;wBACL,EAAE,YAAY,EAAE,mBAAY,CAAC,EAAE,EAAE,KAAK,EAAE,uBAAuB,EAAE;qBAClE;oBACD,QAAQ,EAAE,IAAI;oBACd,MAAM,EAAE,KAAK;oBACb,QAAQ,EAAE,IAAI;iBACf,CAAC,CAAC;aACJ;YACD,OAAO,MAAM,CAAC;QAChB,CAAC;QACD,iBAAiB,EAAE;YACjB,MAAM,EAAE,IAAA,iBAAG,EAAA;;;;;;;KAOV;YACD,SAAS,EAAE,CAAC,sCAAiB,CAAC;SAC/B;QACD,aAAa,EAAE,QAAQ;KACxB,CAAC;GACW,eAAe,CAM3B"}

package/package/braintree/braintree.resolver.d.ts

@@ -0,0 +1,14 @@
+import { ActiveOrderService, ID, OrderService, RequestContext, TransactionalConnection } from "@deenruv/core";
+import { BraintreePluginOptions } from "./types";
+export declare class BraintreeResolver {
+    private connection;
+    private orderService;
+    private activeOrderService;
+    private options;
+    constructor(connection: TransactionalConnection, orderService: OrderService, activeOrderService: ActiveOrderService, options: BraintreePluginOptions);
+    generateBraintreeClientToken(ctx: RequestContext, { orderId, includeCustomerId, }: {
+        orderId?: ID;
+        includeCustomerId?: boolean;
+    }): Promise<string>;
+    private getPaymentMethodArgs;
+}

package/package/braintree/braintree.resolver.js

@@ -0,0 +1,109 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BraintreeResolver = void 0;
+const common_1 = require("@nestjs/common");
+const graphql_1 = require("@nestjs/graphql");
+const core_1 = require("@deenruv/core");
+const braintree_common_1 = require("./braintree-common");
+const braintree_handler_1 = require("./braintree.handler");
+const constants_1 = require("./constants");
+let BraintreeResolver = exports.BraintreeResolver = class BraintreeResolver {
+    constructor(connection, orderService, activeOrderService, options) {
+        this.connection = connection;
+        this.orderService = orderService;
+        this.activeOrderService = activeOrderService;
+        this.options = options;
+    }
+    async generateBraintreeClientToken(ctx, { orderId, includeCustomerId, }) {
+        var _a, _b, _c;
+        if (orderId) {
+            core_1.Logger.warn("The orderId argument to the generateBraintreeClientToken mutation has been deprecated and may be omitted.");
+        }
+        const sessionOrder = await this.activeOrderService.getOrderFromContext(ctx);
+        if (!sessionOrder) {
+            throw new core_1.InternalServerError("Cannot generate Braintree clientToken as there is no active Order.");
+        }
+        const order = await this.orderService.findOne(ctx, sessionOrder.id);
+        if (order) {
+            const customerId = (_b = (_a = order.customer) === null || _a === void 0 ? void 0 : _a.customFields.braintreeCustomerId) !== null && _b !== void 0 ? _b : undefined;
+            const args = await this.getPaymentMethodArgs(ctx);
+            const gateway = (0, braintree_common_1.getGateway)(args, this.options);
+            try {
+                let result = await gateway.clientToken.generate({
+                    customerId: includeCustomerId === false ? undefined : customerId,
+                });
+                if (result.success === true) {
+                    return result.clientToken;
+                }
+                else {
+                    if (result.message ===
+                        "Customer specified by customer_id does not exist") {
+                        // For some reason the custom_id is invalid. This could occur e.g. if the ID was created on the Sandbox endpoint and now
+                        // we switched to Production. In this case, we will remove it and allow a new one
+                        // to be generated when the payment is created.
+                        if (this.options.storeCustomersInBraintree) {
+                            if ((_c = order.customer) === null || _c === void 0 ? void 0 : _c.customFields.braintreeCustomerId) {
+                                order.customer.customFields.braintreeCustomerId = undefined;
+                                await this.connection
+                                    .getRepository(ctx, core_1.Customer)
+                                    .save(order.customer);
+                            }
+                        }
+                        result = await gateway.clientToken.generate({
+                            customerId: undefined,
+                        });
+                        if (result.success === true) {
+                            return result.clientToken;
+                        }
+                    }
+                    core_1.Logger.error(`Could not generate Braintree clientToken: ${result.message}`, constants_1.loggerCtx);
+                    throw new core_1.InternalServerError(`Could not generate Braintree clientToken: ${result.message}`);
+                }
+            }
+            catch (e) {
+                core_1.Logger.error("Could not generate Braintree clientToken. Check the configured credentials.", constants_1.loggerCtx);
+                throw e;
+            }
+        }
+        else {
+            throw new core_1.InternalServerError(`[${constants_1.loggerCtx}] Could not find a Customer for the given Order`);
+        }
+    }
+    async getPaymentMethodArgs(ctx) {
+        const method = (await this.connection.getRepository(ctx, core_1.PaymentMethod).find()).find((m) => m.handler.code === braintree_handler_1.braintreePaymentMethodHandler.code);
+        if (!method) {
+            throw new core_1.InternalServerError(`[${constants_1.loggerCtx}] Could not find Braintree PaymentMethod`);
+        }
+        return method.handler.args.reduce((hash, arg) => {
+            return Object.assign(Object.assign({}, hash), { [arg.name]: arg.value });
+        }, {});
+    }
+};
+__decorate([
+    (0, graphql_1.Query)(),
+    __param(0, (0, core_1.Ctx)()),
+    __param(1, (0, graphql_1.Args)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [core_1.RequestContext, Object]),
+    __metadata("design:returntype", Promise)
+], BraintreeResolver.prototype, "generateBraintreeClientToken", null);
+exports.BraintreeResolver = BraintreeResolver = __decorate([
+    (0, graphql_1.Resolver)(),
+    __param(3, (0, common_1.Inject)(constants_1.BRAINTREE_PLUGIN_OPTIONS)),
+    __metadata("design:paramtypes", [core_1.TransactionalConnection,
+        core_1.OrderService,
+        core_1.ActiveOrderService, Object])
+], BraintreeResolver);
+//# sourceMappingURL=braintree.resolver.js.map

package/package/braintree/braintree.resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"braintree.resolver.js","sourceRoot":"","sources":["../../src/braintree/braintree.resolver.ts"],"names":[],"mappings":"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"}

package/package/braintree/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const loggerCtx = "BraintreePlugin";
+export declare const BRAINTREE_PLUGIN_OPTIONS: unique symbol;

package/package/braintree/constants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BRAINTREE_PLUGIN_OPTIONS = exports.loggerCtx = void 0;
+exports.loggerCtx = "BraintreePlugin";
+exports.BRAINTREE_PLUGIN_OPTIONS = Symbol("BRAINTREE_PLUGIN_OPTIONS");
+//# sourceMappingURL=constants.js.map

package/package/braintree/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/braintree/constants.ts"],"names":[],"mappings":";;;AAAa,QAAA,SAAS,GAAG,iBAAiB,CAAC;AAC9B,QAAA,wBAAwB,GAAG,MAAM,CAAC,0BAA0B,CAAC,CAAC"}