@nlabs/reaktor 0.10.2 → 0.10.6

package/lib/actions/payments.js

@@ -1,32 +1,449 @@
-import{parseNum as A}from"@nlabs/utils/parsers/numbers";import{createHash as Y,parseChar as x,parseId as K,parseString as B,parseVarChar as _}from"@nlabs/utils/parsers/strings";import{aql as T}from"arangojs";import{ErrorTypes as V}from"../types/error.types.js";import{logError as L,UserError as h}from"../utils/analyticsUtils.js";import{useDb as I}from"../utils/arangodbUtils.js";import{getStripeClient as N}from"../utils/stripeUtils.js";import{getUser as H}from"./users.js";const M="payments",pe=r=>{const t="addCustomerAccount",{databaseName:c,session:{userId:n,username:s}={}}=r;return N().customers.create({metadata:{userId:n,username:s}}).then(o=>{const d={modified:Date.now(),stripeCustomerId:o.id},m=T`UPDATE ${n} WITH ${d} IN users LIMIT 1 RETURN NEW`;return I(c).query(m).then(y=>y.next()).then(y=>!!y).catch(y=>L({action:t,category:M,label:V.DATABASE_ERROR},y,r).then(()=>null))})},le=(r,t)=>{const c="addPaymentAccountBank",{databaseName:n,session:{userId:s}={}}=r,{accountNumber:a,fullName:o,routing:u}=t,d=B(a,32);if(d==="")throw new h("required_account_number");const m=_(o,128);if(m==="")throw new h("required_full_name");const y=B(u,32);if(y==="")throw new h("required_routing_number");return H(r,{userId:s}).then(p=>{const{stripeAccountId:l}=p,f=N();return f.tokens.create({bank_account:{account_holder_name:m,account_holder_type:"individual",account_number:d,country:"US",currency:"USD",routing_number:y}}).then(e=>f.customers.createSource(l,{source:e.id})).then(e=>{const i=Date.now(),E={bankAccount:t,bankFullName:m,bankId:e.id,bankRouting:y,modified:i},b=T`UPDATE ${s} WITH ${E} IN users LIMIT 1 RETURN NEW`;return I(n).query(b).then(g=>g.next()).then(g=>g)}).catch(e=>e.message==="A bank account with that routing number and account number already exists for this customer."?L({action:c,category:M,label:"bank_account_exists"},e,r).then(()=>null):L({action:c,category:M,label:"payment_error"},e,r).then(()=>null))})},fe=(r,t)=>{const c="addCreditCard",{databaseName:n,session:{userId:s}}=r;return H(r,{userId:s}).then(a=>{const{stripeAccountId:o}=a,{accountNumber:u,city:d,country:m,cvc:y,expMonth:p,expYear:l,fullName:f,street1:e,street2:i,state:E,zip:b}=t,g=A(u,16);if(!g)throw new h("required_credit_card_number");const P=A(p,2);if(!P)throw new h("required_credit_card_exp_month");const q=A(l,2);if(!q)throw new h("required_credit_card_exp_year");const U=A(y,3),C={},v=_(d,32);v&&(C.city=v);const S=x(m,2);S&&(C.country=S);const R=_(f,32);R&&(C.fullName=R);const k=_(e,32);k&&(C.street1=k);const F=_(i,32);F&&(C.street2=F);const Q=x(E,2);Q&&(C.state=Q);const $=_(b,10);$&&(C.zip=$);const W=N();return W.tokens.create({card:{address_city:v,address_country:S,address_line1:k,address_line2:F,address_state:Q,address_zip:$,cvc:U.toString(),exp_month:P.toString(),exp_year:q.toString(),name:f,number:g.toString()}}).then(D=>W.customers.createSource(o,{source:D.id})).then(D=>{const O=D,Z=O.brand||"",j=O.cvc_check||"",G=O.last4||"",z=Date.now(),J={...C,_key:Y(`user-payment-${s}`),accountNumber:G,added:z,brand:Z,cvcCheck:j,expMonth:p,expYear:l,modified:z,userId:s},X=T`INSERT ${J} IN creditCards RETURN NEW`;return I(n).query(X).then(w=>w.next()).then(w=>{if(w){const{_id:ee,_key:re}=t,te=I(n).collection("hasPayment"),ne=Y(`payment-${re}`),se={_from:`users/${s}`,_key:ne,_to:ee};return te.save(se,{returnNew:!0}).then(()=>t)}return w}).catch(w=>L({action:c,category:M,label:"payment_error"},w,r).then(()=>null))})})},Ce=(r,t)=>{const{databaseName:c,session:{userId:n}}=r,{city:s,country:a,expMonth:o,expYear:u,fullName:d,id:m,street1:y,state:p,zip:l}=t,f=K(m);if(f)throw new h("required_credit_card_id");const e={},i=A(o,2),E=A(u,2),b=_(s,32),g=x(a,2),P=_(d,32),q=B(y,32),U=x(p,2),C=_(l,10);i&&(e.expMonth=i),E&&(e.expYear=E),b&&(e.city=b),g&&(e.country=g),P&&(e.fullName=P),q&&(e.street1=q),U&&(e.state=U),C&&(e.zip=C);const S=T`
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { parseNum } from '@nlabs/utils/parsers/numbers';
+import { createHash, parseChar, parseId, parseString, parseVarChar } from '@nlabs/utils/parsers/strings';
+import { aql } from 'arangojs';
+import { ErrorTypes } from '../types/error.types.js';
+import { logError, UserError } from '../utils/analyticsUtils.js';
+import { useDb } from '../utils/arangodbUtils.js';
+import { getStripeClient } from '../utils/stripeUtils.js';
+import { getUser } from './users.js';
+const eventCategory = 'payments';
+export const addCustomerAccount = (context)=>{
+    const action = 'addCustomerAccount';
+    const { databaseName, session: { userId: sessionId, username } = {} } = context;
+    const stripeClient = getStripeClient();
+    return stripeClient.customers.create({
+        metadata: {
+            userId: sessionId,
+            username
+        }
+    }).then((customer)=>{
+        // Create session
+        const now = Date.now();
+        const update = {
+            modified: now,
+            stripeCustomerId: customer.id
+        };
+        const aqlQry = aql`UPDATE ${sessionId} WITH ${update} IN users LIMIT 1 RETURN NEW`;
+        return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).then((updatedUser)=>!!updatedUser).catch((error)=>logError({
+                action,
+                category: eventCategory,
+                label: ErrorTypes.DATABASE_ERROR
+            }, error, context).then(()=>null));
+    });
+};
+export const addBankAccount = (context, bankAccount)=>{
+    const action = 'addPaymentAccountBank';
+    const { databaseName, session: { userId: sessionId } = {} } = context;
+    // Params
+    const { accountNumber, fullName, routing } = bankAccount;
+    const formatAccount = parseString(accountNumber, 32);
+    if (formatAccount === '') {
+        throw new UserError('required_account_number');
+    }
+    const formatFullName = parseVarChar(fullName, 128);
+    if (formatFullName === '') {
+        throw new UserError('required_full_name');
+    }
+    const formatRouting = parseString(routing, 32);
+    if (formatRouting === '') {
+        throw new UserError('required_routing_number');
+    }
+    return getUser(context, {
+        userId: sessionId
+    }).then((user)=>{
+        const { stripeAccountId } = user;
+        const stripeClient = getStripeClient();
+        // Create a token first, then use the token as the source
+        return stripeClient.tokens.create({
+            bank_account: {
+                account_holder_name: formatFullName,
+                account_holder_type: 'individual',
+                account_number: formatAccount,
+                country: 'US',
+                currency: 'USD',
+                routing_number: formatRouting
+            }
+        }).then((token)=>stripeClient.customers.createSource(stripeAccountId, {
+                source: token.id
+            })).then((account)=>{
+            // Use type assertion for card properties
+            // const cardSource = account as unknown as Card;
+            // const brand = cardSource.brand || '';
+            // const cvcCheck = cardSource.cvc_check || '';
+            // const last4 = cardSource.last4 || '';
+            // Create session
+            const now = Date.now();
+            const update = {
+                bankAccount,
+                bankFullName: formatFullName,
+                bankId: account.id,
+                bankRouting: formatRouting,
+                modified: now
+            };
+            const aqlQry = aql`UPDATE ${sessionId} WITH ${update} IN users LIMIT 1 RETURN NEW`;
+            return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).then((updatedUser)=>updatedUser);
+        }).catch((error)=>{
+            const msg = error.message;
+            if (msg === 'A bank account with that routing number and account number ' + 'already exists for this customer.') {
+                return logError({
+                    action,
+                    category: eventCategory,
+                    label: 'bank_account_exists'
+                }, error, context).then(()=>null);
+            }
+            return logError({
+                action,
+                category: eventCategory,
+                label: 'payment_error'
+            }, error, context).then(()=>null);
+        });
+    });
+};
+export const addCreditCard = (context, card)=>{
+    const action = 'addCreditCard';
+    const { databaseName, session: { userId: sessionId } } = context;
+    return getUser(context, {
+        userId: sessionId
+    }).then((user)=>{
+        // User
+        const { stripeAccountId } = user;
+        // Card
+        const { accountNumber, city, country, cvc, expMonth, expYear, fullName, street1, street2, state, zip } = card;
+        const formatNumber = parseNum(accountNumber, 16);
+        if (!formatNumber) {
+            throw new UserError('required_credit_card_number');
+        }
+        const formatExpMonth = parseNum(expMonth, 2);
+        if (!formatExpMonth) {
+            throw new UserError('required_credit_card_exp_month');
+        }
+        const formatExpYear = parseNum(expYear, 2);
+        if (!formatExpYear) {
+            throw new UserError('required_credit_card_exp_year');
+        }
+        const formatCvc = parseNum(cvc, 3);
+        // Address
+        const paymentCard = {};
+        const formatCity = parseVarChar(city, 32);
+        if (formatCity) {
+            paymentCard.city = formatCity;
+        }
+        const formatCountry = parseChar(country, 2);
+        if (formatCountry) {
+            paymentCard.country = formatCountry;
+        }
+        const formatFullName = parseVarChar(fullName, 32);
+        if (formatFullName) {
+            paymentCard.fullName = formatFullName;
+        }
+        const formatStreet1 = parseVarChar(street1, 32);
+        if (formatStreet1) {
+            paymentCard.street1 = formatStreet1;
+        }
+        const formatStreet2 = parseVarChar(street2, 32);
+        if (formatStreet2) {
+            paymentCard.street2 = formatStreet2;
+        }
+        const formatState = parseChar(state, 2);
+        if (formatState) {
+            paymentCard.state = formatState;
+        }
+        const formatZip = parseVarChar(zip, 10);
+        if (formatZip) {
+            paymentCard.zip = formatZip;
+        }
+        const stripeClient = getStripeClient();
+        // Create a token first, then use the token as the source
+        return stripeClient.tokens.create({
+            card: {
+                address_city: formatCity,
+                address_country: formatCountry,
+                address_line1: formatStreet1,
+                address_line2: formatStreet2,
+                address_state: formatState,
+                address_zip: formatZip,
+                cvc: formatCvc.toString(),
+                exp_month: formatExpMonth.toString(),
+                exp_year: formatExpYear.toString(),
+                name: fullName,
+                number: formatNumber.toString()
+            }
+        }).then((token)=>stripeClient.customers.createSource(stripeAccountId, {
+                source: token.id
+            })).then((newSource)=>{
+            // Use type assertion for card properties
+            const cardSource = newSource;
+            const brand = cardSource.brand || '';
+            const cvcCheck = cardSource.cvc_check || '';
+            const last4 = cardSource.last4 || '';
+            // Create session
+            const now = Date.now();
+            const insert = {
+                ...paymentCard,
+                _key: createHash(`user-payment-${sessionId}`),
+                accountNumber: last4,
+                added: now,
+                brand,
+                cvcCheck,
+                expMonth,
+                expYear,
+                modified: now,
+                userId: sessionId
+            };
+            const insertAqlQry = aql`INSERT ${insert} IN creditCards RETURN NEW`;
+            return useDb(databaseName).query(insertAqlQry).then((cursor)=>cursor.next()).then((newCard)=>{
+                if (newCard) {
+                    // Add linked edge
+                    const { _id: cardId, _key: cardKey } = card;
+                    const edgeCollection = useDb(databaseName).collection('hasPayment');
+                    const edgeId = createHash(`payment-${cardKey}`);
+                    const edge = {
+                        _from: `users/${sessionId}`,
+                        _key: edgeId,
+                        _to: cardId
+                    };
+                    return edgeCollection.save(edge, {
+                        returnNew: true
+                    }).then(()=>card);
+                }
+                return newCard;
+            }).catch((error)=>logError({
+                    action,
+                    category: eventCategory,
+                    label: 'payment_error'
+                }, error, context).then(()=>null));
+        });
+    });
+};
+export const updateCreditCard = (context, card)=>{
+    const { databaseName, session: { userId: sessionId } } = context;
+    const { city, country, expMonth, expYear, fullName, id, street1, state, zip } = card;
+    const formatId = parseId(id);
+    if (formatId) {
+        throw new UserError('required_credit_card_id');
+    }
+    const paymentCard = {};
+    const formatExpMonth = parseNum(expMonth, 2);
+    const formatExpYear = parseNum(expYear, 2);
+    const formatCity = parseVarChar(city, 32);
+    const formatCountry = parseChar(country, 2);
+    const formatFullName = parseVarChar(fullName, 32);
+    const formatStreet1 = parseString(street1, 32);
+    const formatState = parseChar(state, 2);
+    const formatZip = parseVarChar(zip, 10);
+    if (formatExpMonth) {
+        paymentCard.expMonth = formatExpMonth;
+    }
+    if (formatExpYear) {
+        paymentCard.expYear = formatExpYear;
+    }
+    if (formatCity) {
+        paymentCard.city = formatCity;
+    }
+    if (formatCountry) {
+        paymentCard.country = formatCountry;
+    }
+    if (formatFullName) {
+        paymentCard.fullName = formatFullName;
+    }
+    if (formatStreet1) {
+        paymentCard.street1 = formatStreet1;
+    }
+    if (formatState) {
+        paymentCard.state = formatState;
+    }
+    if (formatZip) {
+        paymentCard.zip = formatZip;
+    }
+    const update = paymentCard;
+    const aqlQry = aql`
       LET updatedCard = FIRST(
         FOR c IN creditCards
-        FILTER c._key == ${f} && c.userId == ${n}
-        UPDATE c WITH ${e} IN creditCards
+        FILTER c._key == ${formatId} && c.userId == ${sessionId}
+        UPDATE c WITH ${update} IN creditCards
         LIMIT 1
         RETURN NEW
       )
       LET user = FIRST(
         FOR u IN users
-        FILTER u._key == ${n}
+        FILTER u._key == ${sessionId}
         LIMIT 1
         RETURN u
       )
-      RETURN {user: user, card: updatedCard}`;return I(c).query(S).then(R=>R.next()).then((R={card:{},user:{}})=>{const k=R.card,{user:F}=R;if(!k)throw new h("not_found");const{stripeCustomerId:Q}=F,{stripeId:$}=t,W=N(),D={address_city:b,address_country:g,address_line1:q,address_state:U,address_zip:C,exp_month:i.toString(),exp_year:E.toString(),name:P};return W.customers.updateSource(Q,$,D).then(()=>t).catch(O=>{throw new h("payment_error")})})},Ie=r=>{const t="getCreditCards",{databaseName:c,session:{userId:n}}=r,s=T`FOR c IN creditCards
-    FILTER c.userId == ${n}
-    RETURN c`;return I(c).query(s).then(a=>a.all()).then((a=[])=>a).catch(a=>L({action:t,category:M,label:V.DATABASE_ERROR},a,r).then(()=>null))},he=(r,t)=>{const{databaseName:c,session:{userId:n}}=r,s=K(t),a=T`
+      RETURN {user: user, card: updatedCard}`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).then((results = {
+        card: {},
+        user: {}
+    })=>{
+        const updatedCard = results.card;
+        const { user } = results;
+        if (!updatedCard) {
+            throw new UserError('not_found');
+        }
+        const { stripeCustomerId } = user;
+        const { stripeId } = card;
+        const stripeClient = getStripeClient();
+        const update = {
+            address_city: formatCity,
+            address_country: formatCountry,
+            address_line1: formatStreet1,
+            address_state: formatState,
+            address_zip: formatZip,
+            exp_month: formatExpMonth.toString(),
+            exp_year: formatExpYear.toString(),
+            name: formatFullName
+        };
+        return stripeClient.customers.updateSource(stripeCustomerId, stripeId, update).then(()=>card).catch((error)=>{
+            console.log('payments::updateCard::error', error);
+            throw new UserError('payment_error');
+        });
+    });
+};
+export const getCreditCards = (context)=>{
+    const action = 'getCreditCards';
+    const { databaseName, session: { userId: sessionId } } = context;
+    const aqlQry = aql`FOR c IN creditCards
+    FILTER c.userId == ${sessionId}
+    RETURN c`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.all()).then((list = [])=>list).catch((error)=>logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR
+        }, error, context).then(()=>null));
+};
+export const deleteCreditCard = (context, cardId)=>{
+    const { databaseName, session: { userId: sessionId } } = context;
+    const formatCardId = parseId(cardId);
+    const aqlQry = aql`
     LET card = FIRST(
       FOR c IN creditCards
-      FILTER c._key == ${s} && c.userId == ${n}
+      FILTER c._key == ${formatCardId} && c.userId == ${sessionId}
       LIMIT 1
       REMOVE c IN creditCards
       RETURN OLD
     )
     LET user = FIRST(
       FOR u IN users
-      FILTER u._key == ${n}
+      FILTER u._key == ${sessionId}
       LIMIT 1
       RETURN u
     )
-    RETURN {user: user, card: card}`;return I(c).query(a).then(o=>o.next()).then((o={card:{},user:{}})=>{if(!o)return!1;const{card:u,user:d}=o,{_key:m}=u;return I(c).collection("hasPayment").outEdges(m,{}).then(async p=>{const l=Array.isArray(p)?p:[];return l.length?(await Promise.all(l.map(f=>{const{_key:e}=f,i=T`REMOVE {_key:${e}} IN hasPayment`;return I(c).query(i)})).then(()=>N().customers.deleteSource(d.stripeCustomerId,u.stripeId).then(()=>!0).catch(e=>{throw new h("payment_error")})),!0):!1})})},ge=(r,t)=>{const{databaseName:c,session:{userId:n}}=r,s={bankAccount:"",bankFullName:"",bankId:"",bankRouting:"",modified:Date.now()},a=T`UPDATE ${n} WITH ${s} IN users LIMIT 1 RETURN NEW`;return I(c).query(a).then(o=>o.next()).then(o=>{const{stripeAccountId:u}=o;return N().customers.deleteSource(u,t).then(()=>!0).catch(()=>Promise.resolve(!1))})},Te=(r,t)=>{const{databaseName:c,session:{userId:n}}=r,{amount:s,currency:a}=t,o=A(s),u=x(a,3,"USD").toUpperCase();return H(r,{userId:n}).then(d=>{const{stripeAccountId:m}=d;return N().transfers.create({amount:o,currency:u,destination:m}).then(p=>{const l=Date.now(),e=T`INSERT ${{added:l,amount:o,currency:u,modified:l,userId:n}} IN transfers RETURN NEW`;return I(c).query(e).then(i=>i.next()).then(i=>i)})})},_e=(r,t)=>{const{databaseName:c,session:{userId:n}}=r,{amount:s,capture:a,cardId:o,currency:u,description:d}=t,m=x(u,3,"USD").toUpperCase();return N().charges.create({amount:s,capture:a,currency:m,description:d,source:o}).then(p=>{const l=Date.now(),f={added:l,amount:s,capture:a,cardId:o,chargeFailCode:p.failure_code,chargeFailMsg:p.failure_message,chargeId:p.id,chargeStatus:p.status,currency:m,description:d,modified:l,userId:n},e=T`INSERT ${f} IN payments RETURN NEW`;return I(c).query(e).then(i=>i.next()).then(i=>i)}).catch(p=>{throw new h("payment_error")})};export{le as addBankAccount,fe as addCreditCard,pe as addCustomerAccount,_e as createPaymentHold,Te as createPaymentTransfer,ge as deleteBankAccount,he as deleteCreditCard,Ie as getCreditCards,Ce as updateCreditCard};
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/actions/payments.ts"],
  "sourcesContent": ["/**\n * Copyright (c) 2019-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {parseNum} from '@nlabs/utils/parsers/numbers';\nimport {createHash, parseChar, parseId, parseString, parseVarChar} from '@nlabs/utils/parsers/strings';\nimport {aql} from 'arangojs';\nimport {AqlQuery} from 'arangojs/aql';\nimport stripe from 'stripe';\n\nimport {ApiContext} from '../types/auth.types.js';\nimport {ErrorTypes} from '../types/error.types.js';\nimport {PaymentBankAccount, PaymentCardType, PaymentCharge, PaymentTransfer} from '../types/payments.types.js';\nimport {UserType} from '../types/users.types.js';\nimport {logError, UserError} from '../utils/analyticsUtils.js';\nimport {useDb} from '../utils/arangodbUtils.js';\nimport {getStripeClient} from '../utils/stripeUtils.js';\nimport {getUser} from './users.js';\n\nimport type {EdgeCollection} from 'arangojs/collections';\n\nconst eventCategory = 'payments';\n\nexport const addCustomerAccount = (context: ApiContext): Promise<boolean> => {\n  const action = 'addCustomerAccount';\n  const {databaseName, session: {userId: sessionId, username} = {}} = context;\n\n  const stripeClient = getStripeClient();\n\n  return stripeClient.customers\n    .create({\n      metadata: {\n        userId: sessionId,\n        username\n      }\n    } as any)\n    .then((customer) => {\n      // Create session\n      const now: number = Date.now();\n      const update: UserType = {\n        modified: now,\n        stripeCustomerId: customer.id\n      };\n\n      const aqlQry: AqlQuery = aql`UPDATE ${sessionId} WITH ${update} IN users LIMIT 1 RETURN NEW`;\n\n      return useDb(databaseName).query(aqlQry)\n        .then((cursor) => cursor.next())\n        .then((updatedUser: UserType) => !!updatedUser)\n        .catch((error: Error) => logError({\n          action,\n          category: eventCategory,\n          label: ErrorTypes.DATABASE_ERROR\n        }, error, context).then(() => null));\n    });\n};\n\nexport const addBankAccount = (context: ApiContext, bankAccount: PaymentBankAccount): Promise<boolean> => {\n  const action = 'addPaymentAccountBank';\n  const {databaseName, session: {userId: sessionId} = {}} = context;\n\n  // Params\n  const {\n    accountNumber,\n    fullName,\n    routing\n  } = bankAccount;\n\n  const formatAccount: string = parseString(accountNumber, 32);\n\n  if(formatAccount === '') {\n    throw new UserError('required_account_number');\n  }\n\n  const formatFullName: string = parseVarChar(fullName, 128);\n\n  if(formatFullName === '') {\n    throw new UserError('required_full_name');\n  }\n\n  const formatRouting: string = parseString(routing, 32);\n\n  if(formatRouting === '') {\n    throw new UserError('required_routing_number');\n  }\n\n  return getUser(context, {userId: sessionId})\n    .then((user: UserType) => {\n      const {stripeAccountId} = user;\n      const stripeClient = getStripeClient();\n\n      // Create a token first, then use the token as the source\n      return stripeClient.tokens.create({\n        bank_account: {\n          account_holder_name: formatFullName,\n          account_holder_type: 'individual',\n          account_number: formatAccount,\n          country: 'US',\n          currency: 'USD',\n          routing_number: formatRouting\n        }\n      })\n        .then((token) => stripeClient.customers.createSource(\n          stripeAccountId,\n          {source: token.id}\n        ))\n        .then((account) => {\n          // Use type assertion for card properties\n          // const cardSource = account as unknown as Card;\n          // const brand = cardSource.brand || '';\n          // const cvcCheck = cardSource.cvc_check || '';\n          // const last4 = cardSource.last4 || '';\n\n          // Create session\n          const now: number = Date.now();\n          const update = {\n            bankAccount,\n            bankFullName: formatFullName,\n            bankId: account.id,\n            bankRouting: formatRouting,\n            modified: now\n          };\n\n          const aqlQry: AqlQuery = aql`UPDATE ${sessionId} WITH ${update} IN users LIMIT 1 RETURN NEW`;\n\n          return useDb(databaseName).query(aqlQry)\n            .then((cursor) => cursor.next())\n            .then((updatedUser: UserType) => updatedUser);\n        })\n        .catch((error: Error) => {\n          const msg = error.message;\n\n          if(msg === 'A bank account with that routing number and account number ' +\n            'already exists for this customer.') {\n            return logError({\n              action,\n              category: eventCategory,\n              label: 'bank_account_exists'\n            }, error, context).then(() => null);\n          }\n          return logError({\n            action,\n            category: eventCategory,\n            label: 'payment_error'\n          }, error, context).then(() => null);\n        });\n    });\n};\n\nexport const addCreditCard = (context: ApiContext, card: PaymentCardType): Promise<UserType> => {\n  const action = 'addCreditCard';\n  const {databaseName, session: {userId: sessionId}} = context;\n\n  return getUser(context, {userId: sessionId})\n    .then((user: UserType) => {\n      // User\n      const {stripeAccountId} = user;\n\n      // Card\n      const {\n        accountNumber,\n        city,\n        country,\n        cvc,\n        expMonth,\n        expYear,\n        fullName,\n        street1,\n        street2,\n        state,\n        zip\n      }: PaymentCardType = card;\n\n      const formatNumber: number = parseNum(accountNumber, 16);\n\n      if(!formatNumber) {\n        throw new UserError('required_credit_card_number');\n      }\n\n      const formatExpMonth: number = parseNum(expMonth, 2);\n\n      if(!formatExpMonth) {\n        throw new UserError('required_credit_card_exp_month');\n      }\n\n      const formatExpYear: number = parseNum(expYear, 2);\n\n      if(!formatExpYear) {\n        throw new UserError('required_credit_card_exp_year');\n      }\n\n      const formatCvc: number = parseNum(cvc, 3);\n\n      // Address\n      const paymentCard: PaymentCardType = {};\n      const formatCity: string = parseVarChar(city, 32);\n\n      if(formatCity) {\n        paymentCard.city = formatCity;\n      }\n\n      const formatCountry: string = parseChar(country, 2);\n\n      if(formatCountry) {\n        paymentCard.country = formatCountry;\n      }\n\n      const formatFullName: string = parseVarChar(fullName, 32);\n\n      if(formatFullName) {\n        paymentCard.fullName = formatFullName;\n      }\n\n      const formatStreet1: string = parseVarChar(street1, 32);\n\n      if(formatStreet1) {\n        paymentCard.street1 = formatStreet1;\n      }\n\n      const formatStreet2: string = parseVarChar(street2, 32);\n\n      if(formatStreet2) {\n        paymentCard.street2 = formatStreet2;\n      }\n\n      const formatState: string = parseChar(state, 2);\n\n      if(formatState) {\n        paymentCard.state = formatState;\n      }\n\n      const formatZip: string = parseVarChar(zip, 10);\n\n      if(formatZip) {\n        paymentCard.zip = formatZip;\n      }\n\n      const stripeClient = getStripeClient();\n\n      // Create a token first, then use the token as the source\n      return stripeClient.tokens.create({\n        card: {\n          address_city: formatCity,\n          address_country: formatCountry,\n          address_line1: formatStreet1,\n          address_line2: formatStreet2,\n          address_state: formatState,\n          address_zip: formatZip,\n          cvc: formatCvc.toString(),\n          exp_month: formatExpMonth.toString(),\n          exp_year: formatExpYear.toString(),\n          name: fullName,\n          number: formatNumber.toString()\n        }\n      })\n        .then((token) => stripeClient.customers.createSource(\n          stripeAccountId,\n          {source: token.id}\n        ))\n        .then((newSource) => {\n          // Use type assertion for card properties\n          const cardSource = newSource as unknown as Card;\n          const brand = cardSource.brand || '';\n          const cvcCheck = cardSource.cvc_check || '';\n          const last4 = cardSource.last4 || '';\n\n          // Create session\n          const now: number = Date.now();\n          const insert = {\n            ...paymentCard,\n            _key: createHash(`user-payment-${sessionId}`),\n            accountNumber: last4,\n            added: now,\n            brand,\n            cvcCheck,\n            expMonth,\n            expYear,\n            modified: now,\n            userId: sessionId\n          };\n          const insertAqlQry: AqlQuery = aql`INSERT ${insert} IN creditCards RETURN NEW`;\n\n          return useDb(databaseName).query(insertAqlQry)\n            .then((cursor) => cursor.next())\n            .then((newCard: PaymentCardType) => {\n              if(newCard) {\n                // Add linked edge\n                const {_id: cardId, _key: cardKey} = card;\n                const edgeCollection: EdgeCollection = useDb(databaseName).collection('hasPayment');\n                const edgeId = createHash(`payment-${cardKey}`);\n                const edge = {\n                  _from: `users/${sessionId}`,\n                  _key: edgeId,\n                  _to: cardId\n                };\n\n                return edgeCollection.save(edge, {returnNew: true}).then(() => card);\n              }\n\n              return newCard;\n            })\n            .catch((error: Error) => logError({\n              action,\n              category: eventCategory,\n              label: 'payment_error'\n            }, error, context).then(() => null));\n        });\n    });\n};\n\nexport const updateCreditCard = (context: ApiContext, card: PaymentCardType): Promise<PaymentCardType> => {\n  const {databaseName, session: {userId: sessionId}} = context;\n\n  const {\n    city,\n    country,\n    expMonth,\n    expYear,\n    fullName,\n    id,\n    street1,\n    state,\n    zip\n  }: PaymentCardType = card;\n\n  const formatId: string = parseId(id);\n\n  if(formatId) {\n    throw new UserError('required_credit_card_id');\n  }\n\n  const paymentCard: PaymentCardType = {};\n  const formatExpMonth: number = parseNum(expMonth, 2);\n  const formatExpYear: number = parseNum(expYear, 2);\n  const formatCity: string = parseVarChar(city, 32);\n  const formatCountry: string = parseChar(country, 2);\n  const formatFullName: string = parseVarChar(fullName, 32);\n  const formatStreet1: string = parseString(street1, 32);\n  const formatState: string = parseChar(state, 2);\n  const formatZip: string = parseVarChar(zip, 10);\n\n  if(formatExpMonth) {\n    paymentCard.expMonth = formatExpMonth;\n  }\n\n  if(formatExpYear) {\n    paymentCard.expYear = formatExpYear;\n  }\n\n  if(formatCity) {\n    paymentCard.city = formatCity;\n  }\n\n  if(formatCountry) {\n    paymentCard.country = formatCountry;\n  }\n\n  if(formatFullName) {\n    paymentCard.fullName = formatFullName;\n  }\n\n  if(formatStreet1) {\n    paymentCard.street1 = formatStreet1;\n  }\n\n  if(formatState) {\n    paymentCard.state = formatState;\n  }\n\n  if(formatZip) {\n    paymentCard.zip = formatZip;\n  }\n\n  const update = paymentCard;\n  const aqlQry: AqlQuery = aql`\n      LET updatedCard = FIRST(\n        FOR c IN creditCards\n        FILTER c._key == ${formatId} && c.userId == ${sessionId}\n        UPDATE c WITH ${update} IN creditCards\n        LIMIT 1\n        RETURN NEW\n      )\n      LET user = FIRST(\n        FOR u IN users\n        FILTER u._key == ${sessionId}\n        LIMIT 1\n        RETURN u\n      )\n      RETURN {user: user, card: updatedCard}`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.next())\n    .then((results = {card: {}, user: {}}) => {\n      const updatedCard: PaymentCardType = results.card;\n      const {user} = results;\n\n      if(!updatedCard) {\n        throw new UserError('not_found');\n      }\n\n      const {stripeCustomerId} = user;\n      const {stripeId} = card;\n      const stripeClient = getStripeClient();\n      const update: stripe.CustomerUpdateSourceParams = {\n        address_city: formatCity,\n        address_country: formatCountry,\n        address_line1: formatStreet1,\n        address_state: formatState,\n        address_zip: formatZip,\n        exp_month: formatExpMonth.toString(),\n        exp_year: formatExpYear.toString(),\n        name: formatFullName\n      };\n\n      return stripeClient.customers\n        .updateSource(stripeCustomerId, stripeId, update)\n        .then(() => card)\n        .catch((error: Error) => {\n          console.log('payments::updateCard::error', error);\n          throw new UserError('payment_error');\n        });\n    });\n};\n\nexport const getCreditCards = (context: ApiContext): Promise<PaymentCardType[]> => {\n  const action = 'getCreditCards';\n  const {databaseName, session: {userId: sessionId}} = context;\n  const aqlQry: AqlQuery = aql`FOR c IN creditCards\n    FILTER c.userId == ${sessionId}\n    RETURN c`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.all())\n    .then((list: PaymentCardType[] = []) => list)\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context).then(() => null));\n};\n\nexport const deleteCreditCard = (context: ApiContext, cardId: string): Promise<boolean> => {\n  const {databaseName, session: {userId: sessionId}} = context;\n  const formatCardId: string = parseId(cardId);\n  const aqlQry: AqlQuery = aql`\n    LET card = FIRST(\n      FOR c IN creditCards\n      FILTER c._key == ${formatCardId} && c.userId == ${sessionId}\n      LIMIT 1\n      REMOVE c IN creditCards\n      RETURN OLD\n    )\n    LET user = FIRST(\n      FOR u IN users\n      FILTER u._key == ${sessionId}\n      LIMIT 1\n      RETURN u\n    )\n    RETURN {user: user, card: card}`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.next())\n    .then((result = {card: {}, user: {}}) => {\n      if(!result) {\n        return false;\n      }\n\n      const {card, user} = result;\n      const {_key: cardKey} = card;\n\n      // Remove linked edges\n      const edgeCollection = useDb(databaseName).collection('hasPayment');\n\n      return edgeCollection.outEdges(cardKey, {})\n        .then(async (response) => {\n          // Extract edges from the response\n          const edges = Array.isArray(response) ? response : [];\n\n          if(edges.length) {\n            await Promise.all(\n              edges.map((edge) => {\n                const {_key: edgeKey} = edge;\n                const removeAqlQry: AqlQuery = aql`REMOVE {_key:${edgeKey}} IN hasPayment`;\n                return useDb(databaseName).query(removeAqlQry);\n              }))\n              .then(() => {\n                // Stripe\n                const stripeClient = getStripeClient();\n\n                return stripeClient.customers\n                  .deleteSource(user.stripeCustomerId, card.stripeId)\n                  .then(() => true)\n                  .catch((error: Error) => {\n                    console.log('payments::deleteCard::error', error);\n                    throw new UserError('payment_error');\n                  });\n              });\n\n            return true;\n          }\n\n          return false;\n        });\n    });\n};\n\nexport const deleteBankAccount = (context: ApiContext, bankId: string): Promise<boolean> => {\n  const {databaseName, session: {userId: sessionId}} = context;\n\n  // Clean db\n  const update: UserType = {\n    bankAccount: '',\n    bankFullName: '',\n    bankId: '',\n    bankRouting: '',\n    modified: Date.now()\n  };\n  const aqlQry: AqlQuery = aql`UPDATE ${sessionId} WITH ${update} IN users LIMIT 1 RETURN NEW`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.next())\n    .then((user: UserType) => {\n      const {stripeAccountId} = user;\n      const stripeClient = getStripeClient();\n\n      return stripeClient.customers\n        .deleteSource(stripeAccountId, bankId)\n        .then(() => true)\n        .catch(() => Promise.resolve(false));\n    });\n};\n\nexport const createPaymentTransfer = (context: ApiContext, transfer: PaymentTransfer): Promise<PaymentTransfer> => {\n  const {databaseName, session: {userId: sessionId}} = context;\n  const {amount, currency} = transfer;\n  const formatAmount: number = parseNum(amount);\n  const formatCurrency: string = parseChar(currency, 3, 'USD').toUpperCase();\n\n  return getUser(context, {userId: sessionId})\n    .then((user: UserType) => {\n      const {stripeAccountId} = user;\n      const stripeClient = getStripeClient();\n\n      return stripeClient.transfers\n        .create({\n          amount: formatAmount,\n          currency: formatCurrency,\n          destination: stripeAccountId\n        })\n        .then((stripeTransfer) => {\n          console.log(stripeTransfer);\n          const now: number = Date.now();\n          const insert: PaymentTransfer = {\n            added: now,\n            amount: formatAmount,\n            currency: formatCurrency,\n            modified: now,\n            userId: sessionId\n          };\n          const aqlQry: AqlQuery = aql`INSERT ${insert} IN transfers RETURN NEW`;\n\n          return useDb(databaseName).query(aqlQry)\n            .then((cursor) => cursor.next())\n            .then((newTransfer: PaymentTransfer) => newTransfer);\n        });\n    });\n};\n\nexport const createPaymentHold = (context: ApiContext, payment: PaymentCharge): Promise<PaymentCharge> => {\n  const {databaseName, session: {userId: sessionId}} = context;\n  const {amount, capture, cardId, currency, description} = payment;\n  const formatCurrency = parseChar(currency, 3, 'USD').toUpperCase();\n  const stripeClient = getStripeClient();\n\n  return stripeClient.charges\n    .create({\n      amount,\n      capture,\n      currency: formatCurrency,\n      description,\n      source: cardId\n    })\n    .then((stripeCharge) => {\n      const now: number = Date.now();\n      const insert: PaymentCharge = {\n        added: now,\n        amount,\n        capture,\n        cardId,\n        chargeFailCode: stripeCharge.failure_code,\n        chargeFailMsg: stripeCharge.failure_message,\n        chargeId: stripeCharge.id,\n        chargeStatus: stripeCharge.status,\n        currency: formatCurrency,\n        description,\n        modified: now,\n        userId: sessionId\n      };\n      const aqlQry: AqlQuery = aql`INSERT ${insert} IN payments RETURN NEW`;\n\n      return useDb(databaseName).query(aqlQry)\n        .then((cursor) => cursor.next())\n        .then((newPayment: PaymentCharge) => newPayment);\n    })\n    .catch((error: Error) => {\n      console.log('payments::createHold::error', error);\n      throw new UserError('payment_error');\n    });\n};\n\ninterface Card {\n  id: string;\n  brand?: string;\n  cvc_check?: string;\n  last4?: string;\n}\n"],
  "mappings": "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",
  "names": ["parseNum", "createHash", "parseChar", "parseId", "parseString", "parseVarChar", "aql", "ErrorTypes", "logError", "UserError", "useDb", "getStripeClient", "getUser", "eventCategory", "addCustomerAccount", "context", "action", "databaseName", "sessionId", "username", "customer", "update", "aqlQry", "cursor", "updatedUser", "error", "addBankAccount", "bankAccount", "accountNumber", "fullName", "routing", "formatAccount", "formatFullName", "formatRouting", "user", "stripeAccountId", "stripeClient", "token", "account", "now", "addCreditCard", "card", "city", "country", "cvc", "expMonth", "expYear", "street1", "street2", "state", "zip", "formatNumber", "formatExpMonth", "formatExpYear", "formatCvc", "paymentCard", "formatCity", "formatCountry", "formatStreet1", "formatStreet2", "formatState", "formatZip", "newSource", "cardSource", "brand", "cvcCheck", "last4", "insert", "insertAqlQry", "newCard", "cardId", "cardKey", "edgeCollection", "edgeId", "edge", "updateCreditCard", "id", "formatId", "results", "updatedCard", "stripeCustomerId", "stripeId", "getCreditCards", "list", "deleteCreditCard", "formatCardId", "result", "response", "edges", "edgeKey", "removeAqlQry", "deleteBankAccount", "bankId", "createPaymentTransfer", "transfer", "amount", "currency", "formatAmount", "formatCurrency", "stripeTransfer", "newTransfer", "createPaymentHold", "payment", "capture", "description", "stripeCharge", "newPayment"]
}

+    RETURN {user: user, card: card}`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).then((result = {
+        card: {},
+        user: {}
+    })=>{
+        if (!result) {
+            return false;
+        }
+        const { card, user } = result;
+        const { _key: cardKey } = card;
+        // Remove linked edges
+        const edgeCollection = useDb(databaseName).collection('hasPayment');
+        return edgeCollection.outEdges(cardKey, {}).then(async (response)=>{
+            // Extract edges from the response
+            const edges = Array.isArray(response) ? response : [];
+            if (edges.length) {
+                await Promise.all(edges.map((edge)=>{
+                    const { _key: edgeKey } = edge;
+                    const removeAqlQry = aql`REMOVE {_key:${edgeKey}} IN hasPayment`;
+                    return useDb(databaseName).query(removeAqlQry);
+                })).then(()=>{
+                    // Stripe
+                    const stripeClient = getStripeClient();
+                    return stripeClient.customers.deleteSource(user.stripeCustomerId, card.stripeId).then(()=>true).catch((error)=>{
+                        console.log('payments::deleteCard::error', error);
+                        throw new UserError('payment_error');
+                    });
+                });
+                return true;
+            }
+            return false;
+        });
+    });
+};
+export const deleteBankAccount = (context, bankId)=>{
+    const { databaseName, session: { userId: sessionId } } = context;
+    // Clean db
+    const update = {
+        bankAccount: '',
+        bankFullName: '',
+        bankId: '',
+        bankRouting: '',
+        modified: Date.now()
+    };
+    const aqlQry = aql`UPDATE ${sessionId} WITH ${update} IN users LIMIT 1 RETURN NEW`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).then((user)=>{
+        const { stripeAccountId } = user;
+        const stripeClient = getStripeClient();
+        return stripeClient.customers.deleteSource(stripeAccountId, bankId).then(()=>true).catch(()=>Promise.resolve(false));
+    });
+};
+export const createPaymentTransfer = (context, transfer)=>{
+    const { databaseName, session: { userId: sessionId } } = context;
+    const { amount, currency } = transfer;
+    const formatAmount = parseNum(amount);
+    const formatCurrency = parseChar(currency, 3, 'USD').toUpperCase();
+    return getUser(context, {
+        userId: sessionId
+    }).then((user)=>{
+        const { stripeAccountId } = user;
+        const stripeClient = getStripeClient();
+        return stripeClient.transfers.create({
+            amount: formatAmount,
+            currency: formatCurrency,
+            destination: stripeAccountId
+        }).then((stripeTransfer)=>{
+            console.log(stripeTransfer);
+            const now = Date.now();
+            const insert = {
+                added: now,
+                amount: formatAmount,
+                currency: formatCurrency,
+                modified: now,
+                userId: sessionId
+            };
+            const aqlQry = aql`INSERT ${insert} IN transfers RETURN NEW`;
+            return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).then((newTransfer)=>newTransfer);
+        });
+    });
+};
+export const createPaymentHold = (context, payment)=>{
+    const { databaseName, session: { userId: sessionId } } = context;
+    const { amount, capture, cardId, currency, description } = payment;
+    const formatCurrency = parseChar(currency, 3, 'USD').toUpperCase();
+    const stripeClient = getStripeClient();
+    return stripeClient.charges.create({
+        amount,
+        capture,
+        currency: formatCurrency,
+        description,
+        source: cardId
+    }).then((stripeCharge)=>{
+        const now = Date.now();
+        const insert = {
+            added: now,
+            amount,
+            capture,
+            cardId,
+            chargeFailCode: stripeCharge.failure_code,
+            chargeFailMsg: stripeCharge.failure_message,
+            chargeId: stripeCharge.id,
+            chargeStatus: stripeCharge.status,
+            currency: formatCurrency,
+            description,
+            modified: now,
+            userId: sessionId
+        };
+        const aqlQry = aql`INSERT ${insert} IN payments RETURN NEW`;
+        return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).then((newPayment)=>newPayment);
+    }).catch((error)=>{
+        console.log('payments::createHold::error', error);
+        throw new UserError('payment_error');
+    });
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/src/actions/payments.ts"],"sourcesContent":["/**\n * Copyright (c) 2019-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {parseNum} from '@nlabs/utils/parsers/numbers';\nimport {createHash, parseChar, parseId, parseString, parseVarChar} from '@nlabs/utils/parsers/strings';\nimport {aql} from 'arangojs';\nimport {AqlQuery} from 'arangojs/aql';\nimport stripe from 'stripe';\n\nimport {ApiContext} from '../types/auth.types.js';\nimport {ErrorTypes} from '../types/error.types.js';\nimport {PaymentBankAccount, PaymentCardType, PaymentCharge, PaymentTransfer} from '../types/payments.types.js';\nimport {UserType} from '../types/users.types.js';\nimport {logError, UserError} from '../utils/analyticsUtils.js';\nimport {useDb} from '../utils/arangodbUtils.js';\nimport {getStripeClient} from '../utils/stripeUtils.js';\nimport {getUser} from './users.js';\n\nimport type {EdgeCollection} from 'arangojs/collections';\n\nconst eventCategory = 'payments';\n\nexport const addCustomerAccount = (context: ApiContext): Promise<boolean> => {\n  const action = 'addCustomerAccount';\n  const {databaseName, session: {userId: sessionId, username} = {}} = context;\n\n  const stripeClient = getStripeClient();\n\n  return stripeClient.customers\n    .create({\n      metadata: {\n        userId: sessionId,\n        username\n      }\n    } as any)\n    .then((customer) => {\n      // Create session\n      const now: number = Date.now();\n      const update: UserType = {\n        modified: now,\n        stripeCustomerId: customer.id\n      };\n\n      const aqlQry: AqlQuery = aql`UPDATE ${sessionId} WITH ${update} IN users LIMIT 1 RETURN NEW`;\n\n      return useDb(databaseName).query(aqlQry)\n        .then((cursor) => cursor.next())\n        .then((updatedUser: UserType) => !!updatedUser)\n        .catch((error: Error) => logError({\n          action,\n          category: eventCategory,\n          label: ErrorTypes.DATABASE_ERROR\n        }, error, context).then(() => null));\n    });\n};\n\nexport const addBankAccount = (context: ApiContext, bankAccount: PaymentBankAccount): Promise<boolean> => {\n  const action = 'addPaymentAccountBank';\n  const {databaseName, session: {userId: sessionId} = {}} = context;\n\n  // Params\n  const {\n    accountNumber,\n    fullName,\n    routing\n  } = bankAccount;\n\n  const formatAccount: string = parseString(accountNumber, 32);\n\n  if(formatAccount === '') {\n    throw new UserError('required_account_number');\n  }\n\n  const formatFullName: string = parseVarChar(fullName, 128);\n\n  if(formatFullName === '') {\n    throw new UserError('required_full_name');\n  }\n\n  const formatRouting: string = parseString(routing, 32);\n\n  if(formatRouting === '') {\n    throw new UserError('required_routing_number');\n  }\n\n  return getUser(context, {userId: sessionId})\n    .then((user: UserType) => {\n      const {stripeAccountId} = user;\n      const stripeClient = getStripeClient();\n\n      // Create a token first, then use the token as the source\n      return stripeClient.tokens.create({\n        bank_account: {\n          account_holder_name: formatFullName,\n          account_holder_type: 'individual',\n          account_number: formatAccount,\n          country: 'US',\n          currency: 'USD',\n          routing_number: formatRouting\n        }\n      })\n        .then((token) => stripeClient.customers.createSource(\n          stripeAccountId,\n          {source: token.id}\n        ))\n        .then((account) => {\n          // Use type assertion for card properties\n          // const cardSource = account as unknown as Card;\n          // const brand = cardSource.brand || '';\n          // const cvcCheck = cardSource.cvc_check || '';\n          // const last4 = cardSource.last4 || '';\n\n          // Create session\n          const now: number = Date.now();\n          const update = {\n            bankAccount,\n            bankFullName: formatFullName,\n            bankId: account.id,\n            bankRouting: formatRouting,\n            modified: now\n          };\n\n          const aqlQry: AqlQuery = aql`UPDATE ${sessionId} WITH ${update} IN users LIMIT 1 RETURN NEW`;\n\n          return useDb(databaseName).query(aqlQry)\n            .then((cursor) => cursor.next())\n            .then((updatedUser: UserType) => updatedUser);\n        })\n        .catch((error: Error) => {\n          const msg = error.message;\n\n          if(msg === 'A bank account with that routing number and account number ' +\n            'already exists for this customer.') {\n            return logError({\n              action,\n              category: eventCategory,\n              label: 'bank_account_exists'\n            }, error, context).then(() => null);\n          }\n          return logError({\n            action,\n            category: eventCategory,\n            label: 'payment_error'\n          }, error, context).then(() => null);\n        });\n    });\n};\n\nexport const addCreditCard = (context: ApiContext, card: PaymentCardType): Promise<UserType> => {\n  const action = 'addCreditCard';\n  const {databaseName, session: {userId: sessionId}} = context;\n\n  return getUser(context, {userId: sessionId})\n    .then((user: UserType) => {\n      // User\n      const {stripeAccountId} = user;\n\n      // Card\n      const {\n        accountNumber,\n        city,\n        country,\n        cvc,\n        expMonth,\n        expYear,\n        fullName,\n        street1,\n        street2,\n        state,\n        zip\n      }: PaymentCardType = card;\n\n      const formatNumber: number = parseNum(accountNumber, 16);\n\n      if(!formatNumber) {\n        throw new UserError('required_credit_card_number');\n      }\n\n      const formatExpMonth: number = parseNum(expMonth, 2);\n\n      if(!formatExpMonth) {\n        throw new UserError('required_credit_card_exp_month');\n      }\n\n      const formatExpYear: number = parseNum(expYear, 2);\n\n      if(!formatExpYear) {\n        throw new UserError('required_credit_card_exp_year');\n      }\n\n      const formatCvc: number = parseNum(cvc, 3);\n\n      // Address\n      const paymentCard: PaymentCardType = {};\n      const formatCity: string = parseVarChar(city, 32);\n\n      if(formatCity) {\n        paymentCard.city = formatCity;\n      }\n\n      const formatCountry: string = parseChar(country, 2);\n\n      if(formatCountry) {\n        paymentCard.country = formatCountry;\n      }\n\n      const formatFullName: string = parseVarChar(fullName, 32);\n\n      if(formatFullName) {\n        paymentCard.fullName = formatFullName;\n      }\n\n      const formatStreet1: string = parseVarChar(street1, 32);\n\n      if(formatStreet1) {\n        paymentCard.street1 = formatStreet1;\n      }\n\n      const formatStreet2: string = parseVarChar(street2, 32);\n\n      if(formatStreet2) {\n        paymentCard.street2 = formatStreet2;\n      }\n\n      const formatState: string = parseChar(state, 2);\n\n      if(formatState) {\n        paymentCard.state = formatState;\n      }\n\n      const formatZip: string = parseVarChar(zip, 10);\n\n      if(formatZip) {\n        paymentCard.zip = formatZip;\n      }\n\n      const stripeClient = getStripeClient();\n\n      // Create a token first, then use the token as the source\n      return stripeClient.tokens.create({\n        card: {\n          address_city: formatCity,\n          address_country: formatCountry,\n          address_line1: formatStreet1,\n          address_line2: formatStreet2,\n          address_state: formatState,\n          address_zip: formatZip,\n          cvc: formatCvc.toString(),\n          exp_month: formatExpMonth.toString(),\n          exp_year: formatExpYear.toString(),\n          name: fullName,\n          number: formatNumber.toString()\n        }\n      })\n        .then((token) => stripeClient.customers.createSource(\n          stripeAccountId,\n          {source: token.id}\n        ))\n        .then((newSource) => {\n          // Use type assertion for card properties\n          const cardSource = newSource as unknown as Card;\n          const brand = cardSource.brand || '';\n          const cvcCheck = cardSource.cvc_check || '';\n          const last4 = cardSource.last4 || '';\n\n          // Create session\n          const now: number = Date.now();\n          const insert = {\n            ...paymentCard,\n            _key: createHash(`user-payment-${sessionId}`),\n            accountNumber: last4,\n            added: now,\n            brand,\n            cvcCheck,\n            expMonth,\n            expYear,\n            modified: now,\n            userId: sessionId\n          };\n          const insertAqlQry: AqlQuery = aql`INSERT ${insert} IN creditCards RETURN NEW`;\n\n          return useDb(databaseName).query(insertAqlQry)\n            .then((cursor) => cursor.next())\n            .then((newCard: PaymentCardType) => {\n              if(newCard) {\n                // Add linked edge\n                const {_id: cardId, _key: cardKey} = card;\n                const edgeCollection: EdgeCollection = useDb(databaseName).collection('hasPayment');\n                const edgeId = createHash(`payment-${cardKey}`);\n                const edge = {\n                  _from: `users/${sessionId}`,\n                  _key: edgeId,\n                  _to: cardId\n                };\n\n                return edgeCollection.save(edge, {returnNew: true}).then(() => card);\n              }\n\n              return newCard;\n            })\n            .catch((error: Error) => logError({\n              action,\n              category: eventCategory,\n              label: 'payment_error'\n            }, error, context).then(() => null));\n        });\n    });\n};\n\nexport const updateCreditCard = (context: ApiContext, card: PaymentCardType): Promise<PaymentCardType> => {\n  const {databaseName, session: {userId: sessionId}} = context;\n\n  const {\n    city,\n    country,\n    expMonth,\n    expYear,\n    fullName,\n    id,\n    street1,\n    state,\n    zip\n  }: PaymentCardType = card;\n\n  const formatId: string = parseId(id);\n\n  if(formatId) {\n    throw new UserError('required_credit_card_id');\n  }\n\n  const paymentCard: PaymentCardType = {};\n  const formatExpMonth: number = parseNum(expMonth, 2);\n  const formatExpYear: number = parseNum(expYear, 2);\n  const formatCity: string = parseVarChar(city, 32);\n  const formatCountry: string = parseChar(country, 2);\n  const formatFullName: string = parseVarChar(fullName, 32);\n  const formatStreet1: string = parseString(street1, 32);\n  const formatState: string = parseChar(state, 2);\n  const formatZip: string = parseVarChar(zip, 10);\n\n  if(formatExpMonth) {\n    paymentCard.expMonth = formatExpMonth;\n  }\n\n  if(formatExpYear) {\n    paymentCard.expYear = formatExpYear;\n  }\n\n  if(formatCity) {\n    paymentCard.city = formatCity;\n  }\n\n  if(formatCountry) {\n    paymentCard.country = formatCountry;\n  }\n\n  if(formatFullName) {\n    paymentCard.fullName = formatFullName;\n  }\n\n  if(formatStreet1) {\n    paymentCard.street1 = formatStreet1;\n  }\n\n  if(formatState) {\n    paymentCard.state = formatState;\n  }\n\n  if(formatZip) {\n    paymentCard.zip = formatZip;\n  }\n\n  const update = paymentCard;\n  const aqlQry: AqlQuery = aql`\n      LET updatedCard = FIRST(\n        FOR c IN creditCards\n        FILTER c._key == ${formatId} && c.userId == ${sessionId}\n        UPDATE c WITH ${update} IN creditCards\n        LIMIT 1\n        RETURN NEW\n      )\n      LET user = FIRST(\n        FOR u IN users\n        FILTER u._key == ${sessionId}\n        LIMIT 1\n        RETURN u\n      )\n      RETURN {user: user, card: updatedCard}`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.next())\n    .then((results = {card: {}, user: {}}) => {\n      const updatedCard: PaymentCardType = results.card;\n      const {user} = results;\n\n      if(!updatedCard) {\n        throw new UserError('not_found');\n      }\n\n      const {stripeCustomerId} = user;\n      const {stripeId} = card;\n      const stripeClient = getStripeClient();\n      const update: stripe.CustomerUpdateSourceParams = {\n        address_city: formatCity,\n        address_country: formatCountry,\n        address_line1: formatStreet1,\n        address_state: formatState,\n        address_zip: formatZip,\n        exp_month: formatExpMonth.toString(),\n        exp_year: formatExpYear.toString(),\n        name: formatFullName\n      };\n\n      return stripeClient.customers\n        .updateSource(stripeCustomerId, stripeId, update)\n        .then(() => card)\n        .catch((error: Error) => {\n          console.log('payments::updateCard::error', error);\n          throw new UserError('payment_error');\n        });\n    });\n};\n\nexport const getCreditCards = (context: ApiContext): Promise<PaymentCardType[]> => {\n  const action = 'getCreditCards';\n  const {databaseName, session: {userId: sessionId}} = context;\n  const aqlQry: AqlQuery = aql`FOR c IN creditCards\n    FILTER c.userId == ${sessionId}\n    RETURN c`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.all())\n    .then((list: PaymentCardType[] = []) => list)\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context).then(() => null));\n};\n\nexport const deleteCreditCard = (context: ApiContext, cardId: string): Promise<boolean> => {\n  const {databaseName, session: {userId: sessionId}} = context;\n  const formatCardId: string = parseId(cardId);\n  const aqlQry: AqlQuery = aql`\n    LET card = FIRST(\n      FOR c IN creditCards\n      FILTER c._key == ${formatCardId} && c.userId == ${sessionId}\n      LIMIT 1\n      REMOVE c IN creditCards\n      RETURN OLD\n    )\n    LET user = FIRST(\n      FOR u IN users\n      FILTER u._key == ${sessionId}\n      LIMIT 1\n      RETURN u\n    )\n    RETURN {user: user, card: card}`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.next())\n    .then((result = {card: {}, user: {}}) => {\n      if(!result) {\n        return false;\n      }\n\n      const {card, user} = result;\n      const {_key: cardKey} = card;\n\n      // Remove linked edges\n      const edgeCollection = useDb(databaseName).collection('hasPayment');\n\n      return edgeCollection.outEdges(cardKey, {})\n        .then(async (response) => {\n          // Extract edges from the response\n          const edges = Array.isArray(response) ? response : [];\n\n          if(edges.length) {\n            await Promise.all(\n              edges.map((edge) => {\n                const {_key: edgeKey} = edge;\n                const removeAqlQry: AqlQuery = aql`REMOVE {_key:${edgeKey}} IN hasPayment`;\n                return useDb(databaseName).query(removeAqlQry);\n              }))\n              .then(() => {\n                // Stripe\n                const stripeClient = getStripeClient();\n\n                return stripeClient.customers\n                  .deleteSource(user.stripeCustomerId, card.stripeId)\n                  .then(() => true)\n                  .catch((error: Error) => {\n                    console.log('payments::deleteCard::error', error);\n                    throw new UserError('payment_error');\n                  });\n              });\n\n            return true;\n          }\n\n          return false;\n        });\n    });\n};\n\nexport const deleteBankAccount = (context: ApiContext, bankId: string): Promise<boolean> => {\n  const {databaseName, session: {userId: sessionId}} = context;\n\n  // Clean db\n  const update: UserType = {\n    bankAccount: '',\n    bankFullName: '',\n    bankId: '',\n    bankRouting: '',\n    modified: Date.now()\n  };\n  const aqlQry: AqlQuery = aql`UPDATE ${sessionId} WITH ${update} IN users LIMIT 1 RETURN NEW`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.next())\n    .then((user: UserType) => {\n      const {stripeAccountId} = user;\n      const stripeClient = getStripeClient();\n\n      return stripeClient.customers\n        .deleteSource(stripeAccountId, bankId)\n        .then(() => true)\n        .catch(() => Promise.resolve(false));\n    });\n};\n\nexport const createPaymentTransfer = (context: ApiContext, transfer: PaymentTransfer): Promise<PaymentTransfer> => {\n  const {databaseName, session: {userId: sessionId}} = context;\n  const {amount, currency} = transfer;\n  const formatAmount: number = parseNum(amount);\n  const formatCurrency: string = parseChar(currency, 3, 'USD').toUpperCase();\n\n  return getUser(context, {userId: sessionId})\n    .then((user: UserType) => {\n      const {stripeAccountId} = user;\n      const stripeClient = getStripeClient();\n\n      return stripeClient.transfers\n        .create({\n          amount: formatAmount,\n          currency: formatCurrency,\n          destination: stripeAccountId\n        })\n        .then((stripeTransfer) => {\n          console.log(stripeTransfer);\n          const now: number = Date.now();\n          const insert: PaymentTransfer = {\n            added: now,\n            amount: formatAmount,\n            currency: formatCurrency,\n            modified: now,\n            userId: sessionId\n          };\n          const aqlQry: AqlQuery = aql`INSERT ${insert} IN transfers RETURN NEW`;\n\n          return useDb(databaseName).query(aqlQry)\n            .then((cursor) => cursor.next())\n            .then((newTransfer: PaymentTransfer) => newTransfer);\n        });\n    });\n};\n\nexport const createPaymentHold = (context: ApiContext, payment: PaymentCharge): Promise<PaymentCharge> => {\n  const {databaseName, session: {userId: sessionId}} = context;\n  const {amount, capture, cardId, currency, description} = payment;\n  const formatCurrency = parseChar(currency, 3, 'USD').toUpperCase();\n  const stripeClient = getStripeClient();\n\n  return stripeClient.charges\n    .create({\n      amount,\n      capture,\n      currency: formatCurrency,\n      description,\n      source: cardId\n    })\n    .then((stripeCharge) => {\n      const now: number = Date.now();\n      const insert: PaymentCharge = {\n        added: now,\n        amount,\n        capture,\n        cardId,\n        chargeFailCode: stripeCharge.failure_code,\n        chargeFailMsg: stripeCharge.failure_message,\n        chargeId: stripeCharge.id,\n        chargeStatus: stripeCharge.status,\n        currency: formatCurrency,\n        description,\n        modified: now,\n        userId: sessionId\n      };\n      const aqlQry: AqlQuery = aql`INSERT ${insert} IN payments RETURN NEW`;\n\n      return useDb(databaseName).query(aqlQry)\n        .then((cursor) => cursor.next())\n        .then((newPayment: PaymentCharge) => newPayment);\n    })\n    .catch((error: Error) => {\n      console.log('payments::createHold::error', error);\n      throw new UserError('payment_error');\n    });\n};\n\ninterface Card {\n  id: string;\n  brand?: string;\n  cvc_check?: string;\n  last4?: string;\n}\n"],"names":["parseNum","createHash","parseChar","parseId","parseString","parseVarChar","aql","ErrorTypes","logError","UserError","useDb","getStripeClient","getUser","eventCategory","addCustomerAccount","context","action","databaseName","session","userId","sessionId","username","stripeClient","customers","create","metadata","then","customer","now","Date","update","modified","stripeCustomerId","id","aqlQry","query","cursor","next","updatedUser","catch","error","category","label","DATABASE_ERROR","addBankAccount","bankAccount","accountNumber","fullName","routing","formatAccount","formatFullName","formatRouting","user","stripeAccountId","tokens","bank_account","account_holder_name","account_holder_type","account_number","country","currency","routing_number","token","createSource","source","account","bankFullName","bankId","bankRouting","msg","message","addCreditCard","card","city","cvc","expMonth","expYear","street1","street2","state","zip","formatNumber","formatExpMonth","formatExpYear","formatCvc","paymentCard","formatCity","formatCountry","formatStreet1","formatStreet2","formatState","formatZip","address_city","address_country","address_line1","address_line2","address_state","address_zip","toString","exp_month","exp_year","name","number","newSource","cardSource","brand","cvcCheck","cvc_check","last4","insert","_key","added","insertAqlQry","newCard","_id","cardId","cardKey","edgeCollection","collection","edgeId","edge","_from","_to","save","returnNew","updateCreditCard","formatId","results","updatedCard","stripeId","updateSource","console","log","getCreditCards","all","list","deleteCreditCard","formatCardId","result","outEdges","response","edges","Array","isArray","length","Promise","map","edgeKey","removeAqlQry","deleteSource","deleteBankAccount","resolve","createPaymentTransfer","transfer","amount","formatAmount","formatCurrency","toUpperCase","transfers","destination","stripeTransfer","newTransfer","createPaymentHold","payment","capture","description","charges","stripeCharge","chargeFailCode","failure_code","chargeFailMsg","failure_message","chargeId","chargeStatus","status","newPayment"],"mappings":"AAAA;;;CAGC,GACD,SAAQA,QAAQ,QAAO,+BAA+B;AACtD,SAAQC,UAAU,EAAEC,SAAS,EAAEC,OAAO,EAAEC,WAAW,EAAEC,YAAY,QAAO,+BAA+B;AACvG,SAAQC,GAAG,QAAO,WAAW;AAK7B,SAAQC,UAAU,QAAO,0BAA0B;AAGnD,SAAQC,QAAQ,EAAEC,SAAS,QAAO,6BAA6B;AAC/D,SAAQC,KAAK,QAAO,4BAA4B;AAChD,SAAQC,eAAe,QAAO,0BAA0B;AACxD,SAAQC,OAAO,QAAO,aAAa;AAInC,MAAMC,gBAAgB;AAEtB,OAAO,MAAMC,qBAAqB,CAACC;IACjC,MAAMC,SAAS;IACf,MAAM,EAACC,YAAY,EAAEC,SAAS,EAACC,QAAQC,SAAS,EAAEC,QAAQ,EAAC,GAAG,CAAC,CAAC,EAAC,GAAGN;IAEpE,MAAMO,eAAeX;IAErB,OAAOW,aAAaC,SAAS,CAC1BC,MAAM,CAAC;QACNC,UAAU;YACRN,QAAQC;YACRC;QACF;IACF,GACCK,IAAI,CAAC,CAACC;QACL,iBAAiB;QACjB,MAAMC,MAAcC,KAAKD,GAAG;QAC5B,MAAME,SAAmB;YACvBC,UAAUH;YACVI,kBAAkBL,SAASM,EAAE;QAC/B;QAEA,MAAMC,SAAmB5B,GAAG,CAAC,OAAO,EAAEc,UAAU,MAAM,EAAEU,OAAO,4BAA4B,CAAC;QAE5F,OAAOpB,MAAMO,cAAckB,KAAK,CAACD,QAC9BR,IAAI,CAAC,CAACU,SAAWA,OAAOC,IAAI,IAC5BX,IAAI,CAAC,CAACY,cAA0B,CAAC,CAACA,aAClCC,KAAK,CAAC,CAACC,QAAiBhC,SAAS;gBAChCQ;gBACAyB,UAAU5B;gBACV6B,OAAOnC,WAAWoC,cAAc;YAClC,GAAGH,OAAOzB,SAASW,IAAI,CAAC,IAAM;IAClC;AACJ,EAAE;AAEF,OAAO,MAAMkB,iBAAiB,CAAC7B,SAAqB8B;IAClD,MAAM7B,SAAS;IACf,MAAM,EAACC,YAAY,EAAEC,SAAS,EAACC,QAAQC,SAAS,EAAC,GAAG,CAAC,CAAC,EAAC,GAAGL;IAE1D,SAAS;IACT,MAAM,EACJ+B,aAAa,EACbC,QAAQ,EACRC,OAAO,EACR,GAAGH;IAEJ,MAAMI,gBAAwB7C,YAAY0C,eAAe;IAEzD,IAAGG,kBAAkB,IAAI;QACvB,MAAM,IAAIxC,UAAU;IACtB;IAEA,MAAMyC,iBAAyB7C,aAAa0C,UAAU;IAEtD,IAAGG,mBAAmB,IAAI;QACxB,MAAM,IAAIzC,UAAU;IACtB;IAEA,MAAM0C,gBAAwB/C,YAAY4C,SAAS;IAEnD,IAAGG,kBAAkB,IAAI;QACvB,MAAM,IAAI1C,UAAU;IACtB;IAEA,OAAOG,QAAQG,SAAS;QAACI,QAAQC;IAAS,GACvCM,IAAI,CAAC,CAAC0B;QACL,MAAM,EAACC,eAAe,EAAC,GAAGD;QAC1B,MAAM9B,eAAeX;QAErB,yDAAyD;QACzD,OAAOW,aAAagC,MAAM,CAAC9B,MAAM,CAAC;YAChC+B,cAAc;gBACZC,qBAAqBN;gBACrBO,qBAAqB;gBACrBC,gBAAgBT;gBAChBU,SAAS;gBACTC,UAAU;gBACVC,gBAAgBV;YAClB;QACF,GACGzB,IAAI,CAAC,CAACoC,QAAUxC,aAAaC,SAAS,CAACwC,YAAY,CAClDV,iBACA;gBAACW,QAAQF,MAAM7B,EAAE;YAAA,IAElBP,IAAI,CAAC,CAACuC;YACL,yCAAyC;YACzC,iDAAiD;YACjD,wCAAwC;YACxC,+CAA+C;YAC/C,wCAAwC;YAExC,iBAAiB;YACjB,MAAMrC,MAAcC,KAAKD,GAAG;YAC5B,MAAME,SAAS;gBACbe;gBACAqB,cAAchB;gBACdiB,QAAQF,QAAQhC,EAAE;gBAClBmC,aAAajB;gBACbpB,UAAUH;YACZ;YAEA,MAAMM,SAAmB5B,GAAG,CAAC,OAAO,EAAEc,UAAU,MAAM,EAAEU,OAAO,4BAA4B,CAAC;YAE5F,OAAOpB,MAAMO,cAAckB,KAAK,CAACD,QAC9BR,IAAI,CAAC,CAACU,SAAWA,OAAOC,IAAI,IAC5BX,IAAI,CAAC,CAACY,cAA0BA;QACrC,GACCC,KAAK,CAAC,CAACC;YACN,MAAM6B,MAAM7B,MAAM8B,OAAO;YAEzB,IAAGD,QAAQ,gEACT,qCAAqC;gBACrC,OAAO7D,SAAS;oBACdQ;oBACAyB,UAAU5B;oBACV6B,OAAO;gBACT,GAAGF,OAAOzB,SAASW,IAAI,CAAC,IAAM;YAChC;YACA,OAAOlB,SAAS;gBACdQ;gBACAyB,UAAU5B;gBACV6B,OAAO;YACT,GAAGF,OAAOzB,SAASW,IAAI,CAAC,IAAM;QAChC;IACJ;AACJ,EAAE;AAEF,OAAO,MAAM6C,gBAAgB,CAACxD,SAAqByD;IACjD,MAAMxD,SAAS;IACf,MAAM,EAACC,YAAY,EAAEC,SAAS,EAACC,QAAQC,SAAS,EAAC,EAAC,GAAGL;IAErD,OAAOH,QAAQG,SAAS;QAACI,QAAQC;IAAS,GACvCM,IAAI,CAAC,CAAC0B;QACL,OAAO;QACP,MAAM,EAACC,eAAe,EAAC,GAAGD;QAE1B,OAAO;QACP,MAAM,EACJN,aAAa,EACb2B,IAAI,EACJd,OAAO,EACPe,GAAG,EACHC,QAAQ,EACRC,OAAO,EACP7B,QAAQ,EACR8B,OAAO,EACPC,OAAO,EACPC,KAAK,EACLC,GAAG,EACJ,GAAoBR;QAErB,MAAMS,eAAuBjF,SAAS8C,eAAe;QAErD,IAAG,CAACmC,cAAc;YAChB,MAAM,IAAIxE,UAAU;QACtB;QAEA,MAAMyE,iBAAyBlF,SAAS2E,UAAU;QAElD,IAAG,CAACO,gBAAgB;YAClB,MAAM,IAAIzE,UAAU;QACtB;QAEA,MAAM0E,gBAAwBnF,SAAS4E,SAAS;QAEhD,IAAG,CAACO,eAAe;YACjB,MAAM,IAAI1E,UAAU;QACtB;QAEA,MAAM2E,YAAoBpF,SAAS0E,KAAK;QAExC,UAAU;QACV,MAAMW,cAA+B,CAAC;QACtC,MAAMC,aAAqBjF,aAAaoE,MAAM;QAE9C,IAAGa,YAAY;YACbD,YAAYZ,IAAI,GAAGa;QACrB;QAEA,MAAMC,gBAAwBrF,UAAUyD,SAAS;QAEjD,IAAG4B,eAAe;YAChBF,YAAY1B,OAAO,GAAG4B;QACxB;QAEA,MAAMrC,iBAAyB7C,aAAa0C,UAAU;QAEtD,IAAGG,gBAAgB;YACjBmC,YAAYtC,QAAQ,GAAGG;QACzB;QAEA,MAAMsC,gBAAwBnF,aAAawE,SAAS;QAEpD,IAAGW,eAAe;YAChBH,YAAYR,OAAO,GAAGW;QACxB;QAEA,MAAMC,gBAAwBpF,aAAayE,SAAS;QAEpD,IAAGW,eAAe;YAChBJ,YAAYP,OAAO,GAAGW;QACxB;QAEA,MAAMC,cAAsBxF,UAAU6E,OAAO;QAE7C,IAAGW,aAAa;YACdL,YAAYN,KAAK,GAAGW;QACtB;QAEA,MAAMC,YAAoBtF,aAAa2E,KAAK;QAE5C,IAAGW,WAAW;YACZN,YAAYL,GAAG,GAAGW;QACpB;QAEA,MAAMrE,eAAeX;QAErB,yDAAyD;QACzD,OAAOW,aAAagC,MAAM,CAAC9B,MAAM,CAAC;YAChCgD,MAAM;gBACJoB,cAAcN;gBACdO,iBAAiBN;gBACjBO,eAAeN;gBACfO,eAAeN;gBACfO,eAAeN;gBACfO,aAAaN;gBACbjB,KAAKU,UAAUc,QAAQ;gBACvBC,WAAWjB,eAAegB,QAAQ;gBAClCE,UAAUjB,cAAce,QAAQ;gBAChCG,MAAMtD;gBACNuD,QAAQrB,aAAaiB,QAAQ;YAC/B;QACF,GACGxE,IAAI,CAAC,CAACoC,QAAUxC,aAAaC,SAAS,CAACwC,YAAY,CAClDV,iBACA;gBAACW,QAAQF,MAAM7B,EAAE;YAAA,IAElBP,IAAI,CAAC,CAAC6E;YACL,yCAAyC;YACzC,MAAMC,aAAaD;YACnB,MAAME,QAAQD,WAAWC,KAAK,IAAI;YAClC,MAAMC,WAAWF,WAAWG,SAAS,IAAI;YACzC,MAAMC,QAAQJ,WAAWI,KAAK,IAAI;YAElC,iBAAiB;YACjB,MAAMhF,MAAcC,KAAKD,GAAG;YAC5B,MAAMiF,SAAS;gBACb,GAAGxB,WAAW;gBACdyB,MAAM7G,WAAW,CAAC,aAAa,EAAEmB,WAAW;gBAC5C0B,eAAe8D;gBACfG,OAAOnF;gBACP6E;gBACAC;gBACA/B;gBACAC;gBACA7C,UAAUH;gBACVT,QAAQC;YACV;YACA,MAAM4F,eAAyB1G,GAAG,CAAC,OAAO,EAAEuG,OAAO,0BAA0B,CAAC;YAE9E,OAAOnG,MAAMO,cAAckB,KAAK,CAAC6E,cAC9BtF,IAAI,CAAC,CAACU,SAAWA,OAAOC,IAAI,IAC5BX,IAAI,CAAC,CAACuF;gBACL,IAAGA,SAAS;oBACV,kBAAkB;oBAClB,MAAM,EAACC,KAAKC,MAAM,EAAEL,MAAMM,OAAO,EAAC,GAAG5C;oBACrC,MAAM6C,iBAAiC3G,MAAMO,cAAcqG,UAAU,CAAC;oBACtE,MAAMC,SAAStH,WAAW,CAAC,QAAQ,EAAEmH,SAAS;oBAC9C,MAAMI,OAAO;wBACXC,OAAO,CAAC,MAAM,EAAErG,WAAW;wBAC3B0F,MAAMS;wBACNG,KAAKP;oBACP;oBAEA,OAAOE,eAAeM,IAAI,CAACH,MAAM;wBAACI,WAAW;oBAAI,GAAGlG,IAAI,CAAC,IAAM8C;gBACjE;gBAEA,OAAOyC;YACT,GACC1E,KAAK,CAAC,CAACC,QAAiBhC,SAAS;oBAChCQ;oBACAyB,UAAU5B;oBACV6B,OAAO;gBACT,GAAGF,OAAOzB,SAASW,IAAI,CAAC,IAAM;QAClC;IACJ;AACJ,EAAE;AAEF,OAAO,MAAMmG,mBAAmB,CAAC9G,SAAqByD;IACpD,MAAM,EAACvD,YAAY,EAAEC,SAAS,EAACC,QAAQC,SAAS,EAAC,EAAC,GAAGL;IAErD,MAAM,EACJ0D,IAAI,EACJd,OAAO,EACPgB,QAAQ,EACRC,OAAO,EACP7B,QAAQ,EACRd,EAAE,EACF4C,OAAO,EACPE,KAAK,EACLC,GAAG,EACJ,GAAoBR;IAErB,MAAMsD,WAAmB3H,QAAQ8B;IAEjC,IAAG6F,UAAU;QACX,MAAM,IAAIrH,UAAU;IACtB;IAEA,MAAM4E,cAA+B,CAAC;IACtC,MAAMH,iBAAyBlF,SAAS2E,UAAU;IAClD,MAAMQ,gBAAwBnF,SAAS4E,SAAS;IAChD,MAAMU,aAAqBjF,aAAaoE,MAAM;IAC9C,MAAMc,gBAAwBrF,UAAUyD,SAAS;IACjD,MAAMT,iBAAyB7C,aAAa0C,UAAU;IACtD,MAAMyC,gBAAwBpF,YAAYyE,SAAS;IACnD,MAAMa,cAAsBxF,UAAU6E,OAAO;IAC7C,MAAMY,YAAoBtF,aAAa2E,KAAK;IAE5C,IAAGE,gBAAgB;QACjBG,YAAYV,QAAQ,GAAGO;IACzB;IAEA,IAAGC,eAAe;QAChBE,YAAYT,OAAO,GAAGO;IACxB;IAEA,IAAGG,YAAY;QACbD,YAAYZ,IAAI,GAAGa;IACrB;IAEA,IAAGC,eAAe;QAChBF,YAAY1B,OAAO,GAAG4B;IACxB;IAEA,IAAGrC,gBAAgB;QACjBmC,YAAYtC,QAAQ,GAAGG;IACzB;IAEA,IAAGsC,eAAe;QAChBH,YAAYR,OAAO,GAAGW;IACxB;IAEA,IAAGE,aAAa;QACdL,YAAYN,KAAK,GAAGW;IACtB;IAEA,IAAGC,WAAW;QACZN,YAAYL,GAAG,GAAGW;IACpB;IAEA,MAAM7D,SAASuD;IACf,MAAMnD,SAAmB5B,GAAG,CAAC;;;yBAGN,EAAEwH,SAAS,gBAAgB,EAAE1G,UAAU;sBAC1C,EAAEU,OAAO;;;;;;yBAMN,EAAEV,UAAU;;;;4CAIO,CAAC;IAE3C,OAAOV,MAAMO,cAAckB,KAAK,CAACD,QAC9BR,IAAI,CAAC,CAACU,SAAWA,OAAOC,IAAI,IAC5BX,IAAI,CAAC,CAACqG,UAAU;QAACvD,MAAM,CAAC;QAAGpB,MAAM,CAAC;IAAC,CAAC;QACnC,MAAM4E,cAA+BD,QAAQvD,IAAI;QACjD,MAAM,EAACpB,IAAI,EAAC,GAAG2E;QAEf,IAAG,CAACC,aAAa;YACf,MAAM,IAAIvH,UAAU;QACtB;QAEA,MAAM,EAACuB,gBAAgB,EAAC,GAAGoB;QAC3B,MAAM,EAAC6E,QAAQ,EAAC,GAAGzD;QACnB,MAAMlD,eAAeX;QACrB,MAAMmB,SAA4C;YAChD8D,cAAcN;YACdO,iBAAiBN;YACjBO,eAAeN;YACfQ,eAAeN;YACfO,aAAaN;YACbQ,WAAWjB,eAAegB,QAAQ;YAClCE,UAAUjB,cAAce,QAAQ;YAChCG,MAAMnD;QACR;QAEA,OAAO5B,aAAaC,SAAS,CAC1B2G,YAAY,CAAClG,kBAAkBiG,UAAUnG,QACzCJ,IAAI,CAAC,IAAM8C,MACXjC,KAAK,CAAC,CAACC;YACN2F,QAAQC,GAAG,CAAC,+BAA+B5F;YAC3C,MAAM,IAAI/B,UAAU;QACtB;IACJ;AACJ,EAAE;AAEF,OAAO,MAAM4H,iBAAiB,CAACtH;IAC7B,MAAMC,SAAS;IACf,MAAM,EAACC,YAAY,EAAEC,SAAS,EAACC,QAAQC,SAAS,EAAC,EAAC,GAAGL;IACrD,MAAMmB,SAAmB5B,GAAG,CAAC;uBACR,EAAEc,UAAU;YACvB,CAAC;IAEX,OAAOV,MAAMO,cAAckB,KAAK,CAACD,QAC9BR,IAAI,CAAC,CAACU,SAAWA,OAAOkG,GAAG,IAC3B5G,IAAI,CAAC,CAAC6G,OAA0B,EAAE,GAAKA,MACvChG,KAAK,CAAC,CAACC,QAAiBhC,SAAS;YAChCQ;YACAyB,UAAU5B;YACV6B,OAAOnC,WAAWoC,cAAc;QAClC,GAAGH,OAAOzB,SAASW,IAAI,CAAC,IAAM;AAClC,EAAE;AAEF,OAAO,MAAM8G,mBAAmB,CAACzH,SAAqBoG;IACpD,MAAM,EAAClG,YAAY,EAAEC,SAAS,EAACC,QAAQC,SAAS,EAAC,EAAC,GAAGL;IACrD,MAAM0H,eAAuBtI,QAAQgH;IACrC,MAAMjF,SAAmB5B,GAAG,CAAC;;;uBAGR,EAAEmI,aAAa,gBAAgB,EAAErH,UAAU;;;;;;;uBAO3C,EAAEA,UAAU;;;;mCAIA,CAAC;IAElC,OAAOV,MAAMO,cAAckB,KAAK,CAACD,QAC9BR,IAAI,CAAC,CAACU,SAAWA,OAAOC,IAAI,IAC5BX,IAAI,CAAC,CAACgH,SAAS;QAAClE,MAAM,CAAC;QAAGpB,MAAM,CAAC;IAAC,CAAC;QAClC,IAAG,CAACsF,QAAQ;YACV,OAAO;QACT;QAEA,MAAM,EAAClE,IAAI,EAAEpB,IAAI,EAAC,GAAGsF;QACrB,MAAM,EAAC5B,MAAMM,OAAO,EAAC,GAAG5C;QAExB,sBAAsB;QACtB,MAAM6C,iBAAiB3G,MAAMO,cAAcqG,UAAU,CAAC;QAEtD,OAAOD,eAAesB,QAAQ,CAACvB,SAAS,CAAC,GACtC1F,IAAI,CAAC,OAAOkH;YACX,kCAAkC;YAClC,MAAMC,QAAQC,MAAMC,OAAO,CAACH,YAAYA,WAAW,EAAE;YAErD,IAAGC,MAAMG,MAAM,EAAE;gBACf,MAAMC,QAAQX,GAAG,CACfO,MAAMK,GAAG,CAAC,CAAC1B;oBACT,MAAM,EAACV,MAAMqC,OAAO,EAAC,GAAG3B;oBACxB,MAAM4B,eAAyB9I,GAAG,CAAC,aAAa,EAAE6I,QAAQ,eAAe,CAAC;oBAC1E,OAAOzI,MAAMO,cAAckB,KAAK,CAACiH;gBACnC,IACC1H,IAAI,CAAC;oBACJ,SAAS;oBACT,MAAMJ,eAAeX;oBAErB,OAAOW,aAAaC,SAAS,CAC1B8H,YAAY,CAACjG,KAAKpB,gBAAgB,EAAEwC,KAAKyD,QAAQ,EACjDvG,IAAI,CAAC,IAAM,MACXa,KAAK,CAAC,CAACC;wBACN2F,QAAQC,GAAG,CAAC,+BAA+B5F;wBAC3C,MAAM,IAAI/B,UAAU;oBACtB;gBACJ;gBAEF,OAAO;YACT;YAEA,OAAO;QACT;IACJ;AACJ,EAAE;AAEF,OAAO,MAAM6I,oBAAoB,CAACvI,SAAqBoD;IACrD,MAAM,EAAClD,YAAY,EAAEC,SAAS,EAACC,QAAQC,SAAS,EAAC,EAAC,GAAGL;IAErD,WAAW;IACX,MAAMe,SAAmB;QACvBe,aAAa;QACbqB,cAAc;QACdC,QAAQ;QACRC,aAAa;QACbrC,UAAUF,KAAKD,GAAG;IACpB;IACA,MAAMM,SAAmB5B,GAAG,CAAC,OAAO,EAAEc,UAAU,MAAM,EAAEU,OAAO,4BAA4B,CAAC;IAE5F,OAAOpB,MAAMO,cAAckB,KAAK,CAACD,QAC9BR,IAAI,CAAC,CAACU,SAAWA,OAAOC,IAAI,IAC5BX,IAAI,CAAC,CAAC0B;QACL,MAAM,EAACC,eAAe,EAAC,GAAGD;QAC1B,MAAM9B,eAAeX;QAErB,OAAOW,aAAaC,SAAS,CAC1B8H,YAAY,CAAChG,iBAAiBc,QAC9BzC,IAAI,CAAC,IAAM,MACXa,KAAK,CAAC,IAAM0G,QAAQM,OAAO,CAAC;IACjC;AACJ,EAAE;AAEF,OAAO,MAAMC,wBAAwB,CAACzI,SAAqB0I;IACzD,MAAM,EAACxI,YAAY,EAAEC,SAAS,EAACC,QAAQC,SAAS,EAAC,EAAC,GAAGL;IACrD,MAAM,EAAC2I,MAAM,EAAE9F,QAAQ,EAAC,GAAG6F;IAC3B,MAAME,eAAuB3J,SAAS0J;IACtC,MAAME,iBAAyB1J,UAAU0D,UAAU,GAAG,OAAOiG,WAAW;IAExE,OAAOjJ,QAAQG,SAAS;QAACI,QAAQC;IAAS,GACvCM,IAAI,CAAC,CAAC0B;QACL,MAAM,EAACC,eAAe,EAAC,GAAGD;QAC1B,MAAM9B,eAAeX;QAErB,OAAOW,aAAawI,SAAS,CAC1BtI,MAAM,CAAC;YACNkI,QAAQC;YACR/F,UAAUgG;YACVG,aAAa1G;QACf,GACC3B,IAAI,CAAC,CAACsI;YACL7B,QAAQC,GAAG,CAAC4B;YACZ,MAAMpI,MAAcC,KAAKD,GAAG;YAC5B,MAAMiF,SAA0B;gBAC9BE,OAAOnF;gBACP8H,QAAQC;gBACR/F,UAAUgG;gBACV7H,UAAUH;gBACVT,QAAQC;YACV;YACA,MAAMc,SAAmB5B,GAAG,CAAC,OAAO,EAAEuG,OAAO,wBAAwB,CAAC;YAEtE,OAAOnG,MAAMO,cAAckB,KAAK,CAACD,QAC9BR,IAAI,CAAC,CAACU,SAAWA,OAAOC,IAAI,IAC5BX,IAAI,CAAC,CAACuI,cAAiCA;QAC5C;IACJ;AACJ,EAAE;AAEF,OAAO,MAAMC,oBAAoB,CAACnJ,SAAqBoJ;IACrD,MAAM,EAAClJ,YAAY,EAAEC,SAAS,EAACC,QAAQC,SAAS,EAAC,EAAC,GAAGL;IACrD,MAAM,EAAC2I,MAAM,EAAEU,OAAO,EAAEjD,MAAM,EAAEvD,QAAQ,EAAEyG,WAAW,EAAC,GAAGF;IACzD,MAAMP,iBAAiB1J,UAAU0D,UAAU,GAAG,OAAOiG,WAAW;IAChE,MAAMvI,eAAeX;IAErB,OAAOW,aAAagJ,OAAO,CACxB9I,MAAM,CAAC;QACNkI;QACAU;QACAxG,UAAUgG;QACVS;QACArG,QAAQmD;IACV,GACCzF,IAAI,CAAC,CAAC6I;QACL,MAAM3I,MAAcC,KAAKD,GAAG;QAC5B,MAAMiF,SAAwB;YAC5BE,OAAOnF;YACP8H;YACAU;YACAjD;YACAqD,gBAAgBD,aAAaE,YAAY;YACzCC,eAAeH,aAAaI,eAAe;YAC3CC,UAAUL,aAAatI,EAAE;YACzB4I,cAAcN,aAAaO,MAAM;YACjClH,UAAUgG;YACVS;YACAtI,UAAUH;YACVT,QAAQC;QACV;QACA,MAAMc,SAAmB5B,GAAG,CAAC,OAAO,EAAEuG,OAAO,uBAAuB,CAAC;QAErE,OAAOnG,MAAMO,cAAckB,KAAK,CAACD,QAC9BR,IAAI,CAAC,CAACU,SAAWA,OAAOC,IAAI,IAC5BX,IAAI,CAAC,CAACqJ,aAA8BA;IACzC,GACCxI,KAAK,CAAC,CAACC;QACN2F,QAAQC,GAAG,CAAC,+BAA+B5F;QAC3C,MAAM,IAAI/B,UAAU;IACtB;AACJ,EAAE"}