payment-kit 1.13.72 → 1.13.74

package/api/src/{schedule → crons}/base.ts

@@ -2,10 +2,10 @@ import dayjs from 'dayjs';
 import { clone } from 'lodash';
 import pAll from 'p-all';
 
-import { NotificationQueueJob, notificationQueue } from '../jobs/notification';
 import { notificationCronConcurrency } from '../libs/env';
 import logger from '../libs/logger';
 import type { SubscriptionTrialWillEndEmailTemplateOptions } from '../libs/notification/template/subscription-trial-will-end';
+import { NotificationQueueJob, notificationQueue } from '../queues/notification';
 import type { Subscription } from '../store/models';
 import type { Diff } from './interface/diff';
 

package/api/src/index.ts

@@ -1,6 +1,6 @@
 import 'express-async-errors';
 
-import './schedule';
+import './crons';
 
 import path from 'path';
 
@@ -13,15 +13,15 @@ import morgan from 'morgan';
 
 import { ensureStakedForGas } from './integrations/blockchain/stake';
 import { ensureWebhookRegistered } from './integrations/stripe/setup';
-import { startCheckoutSessionQueue } from './jobs/checkout-session';
-import { startEventQueue } from './jobs/event';
-import { startInvoiceQueue } from './jobs/invoice';
-import { startNotificationQueue } from './jobs/notification';
-import { startPaymentQueue } from './jobs/payment';
-import { startSubscriptionQueue } from './jobs/subscription';
 import { handlers } from './libs/auth';
 import logger, { accessLogStream } from './libs/logger';
 import { ensureI18n } from './libs/middleware';
+import { startCheckoutSessionQueue } from './queues/checkout-session';
+import { startEventQueue } from './queues/event';
+import { startInvoiceQueue } from './queues/invoice';
+import { startNotificationQueue } from './queues/notification';
+import { startPaymentQueue } from './queues/payment';
+import { startSubscriptionQueue } from './queues/subscription';
 import routes from './routes';
 import collectHandlers from './routes/connect/collect';
 import payHandlers from './routes/connect/pay';

package/api/src/integrations/stripe/handlers/customer.ts

@@ -0,0 +1,24 @@
+import logger from '../../../libs/logger';
+import { Customer, TEventExpanded } from '../../../store/models';
+
+export async function handleCustomerEvent(event: TEventExpanded) {
+  const localId = event.data.object.metadata?.id;
+  if (!localId) {
+    logger.warn('local customer id not found in strip event', { id: event.id, type: event.type });
+    return;
+  }
+
+  const customer = await Customer.findByPk(localId);
+  if (!customer) {
+    logger.warn('local customer not found', { localId });
+    return;
+  }
+
+  logger.info('received customer event', { id: event.id, type: event.type, localId });
+
+  if (event.type === 'customer.updated') {
+    if (event.data.object.balance !== customer.balance) {
+      await customer.update({ balance: event.data.object.balance });
+    }
+  }
+}

package/api/src/integrations/stripe/handlers/index.ts

@@ -1,5 +1,6 @@
 import type Stripe from 'stripe';
 
+import { handleCustomerEvent } from './customer';
 import { handleInvoiceEvent } from './invoice';
 import { handlePaymentIntentEvent } from './payment-intent';
 import { handleSetupIntentEvent } from './setup-intent';
@@ -32,6 +33,9 @@ export default function handleStripeEvent(event: any, client: Stripe) {
     case 'customer.subscription.updated':
       return handleSubscriptionEvent(event, client);
 
+    case 'customer.updated':
+      return handleCustomerEvent(event);
+
     case 'invoice.created':
     case 'invoice.deleted':
     case 'invoice.finalization_failed':

package/api/src/integrations/stripe/handlers/payment-intent.ts

@@ -4,9 +4,9 @@ import pick from 'lodash/pick';
 import pWaitFor from 'p-wait-for';
 import type Stripe from 'stripe';
 
-import { handlePaymentSucceed } from '../../../jobs/payment';
 import dayjs from '../../../libs/dayjs';
 import logger from '../../../libs/logger';
+import { handlePaymentSucceed } from '../../../queues/payment';
 import { Invoice, PaymentIntent, PaymentMethod, TEventExpanded } from '../../../store/models';
 import { handleStripeInvoiceCreated } from './invoice';
 

package/api/src/integrations/stripe/resource.ts

@@ -90,7 +90,7 @@ export async function ensureStripePrice(internal: Price, method: PaymentMethod,
   if (internal.custom_unit_amount) {
     attrs.custom_unit_amount = internal.custom_unit_amount;
   } else {
-    attrs.unit_amount = Number(getPriceUintAmountByCurrency(internal, currency));
+    attrs.unit_amount = Number(getPriceUintAmountByCurrency(internal, currency.id));
   }
 
   // create stripe price

package/api/src/libs/audit.ts

@@ -16,21 +16,24 @@ export async function createEvent(scope: string, type: LiteralUnion<EventType, s
     data.previous_attributes = pick(model._previousDataValues, options.fields);
   }
 
-  const event = await Event.create({
-    type,
-    api_version: API_VERSION,
-    livemode: !!model.livemode,
-    object_id: model.id,
-    object_type: scope,
-    data,
-    request: {
-      // FIXME:
-      id: '',
-      idempotency_key: '',
+  const event = await Event.create(
+    {
+      type,
+      api_version: API_VERSION,
+      livemode: !!model.livemode,
+      object_id: model.id,
+      object_type: scope,
+      data,
+      request: {
+        // FIXME:
+        id: '',
+        idempotency_key: '',
+      },
+      metadata: {},
+      pending_webhooks: 99, // force all events goto the event queue
     },
-    metadata: {},
-    pending_webhooks: 99, // force all events goto the event queue
-  });
+    { transaction: null }
+  );
 
   events.emit('event.created', { id: event.id });
   events.emit(event.type, data.object);
@@ -58,21 +61,24 @@ export async function createStatusEvent(
   }
 
   const suffix = config[data.object.status];
-  const event = await Event.create({
-    type: [prefix, suffix].join('.'),
-    api_version: API_VERSION,
-    livemode: !!model.livemode,
-    object_id: model.id,
-    object_type: scope,
-    data,
-    request: {
-      // FIXME:
-      id: '',
-      idempotency_key: '',
+  const event = await Event.create(
+    {
+      type: [prefix, suffix].join('.'),
+      api_version: API_VERSION,
+      livemode: !!model.livemode,
+      object_id: model.id,
+      object_type: scope,
+      data,
+      request: {
+        // FIXME:
+        id: '',
+        idempotency_key: '',
+      },
+      metadata: {},
+      pending_webhooks: 99, // force all events goto the event queue
     },
-    metadata: {},
-    pending_webhooks: 99, // force all events goto the event queue
-  });
+    { transaction: null }
+  );
 
   events.emit('event.created', { id: event.id });
   events.emit(event.type, data.object);

package/api/src/libs/payment.ts

@@ -8,7 +8,15 @@ import { BN, fromUnitToToken } from '@ocap/util';
 import cloneDeep from 'lodash/cloneDeep';
 import type { LiteralUnion } from 'type-fest';
 
-import { Invoice, PaymentCurrency, PaymentIntent, PaymentMethod } from '../store/models';
+import {
+  CheckoutSession,
+  Invoice,
+  PaymentCurrency,
+  PaymentIntent,
+  PaymentMethod,
+  TCustomer,
+  TLineItemExpanded,
+} from '../store/models';
 import type { TPaymentCurrency } from '../store/models/payment-currency';
 import { blocklet, wallet } from './auth';
 import logger from './logger';
@@ -80,7 +88,7 @@ export async function isDelegationSufficientForPayment(args: {
 
       const requested = new BN(amount);
       const allowance = new BN(tokenLimit.txAllowance);
-      if (requested.gt(allowance)) {
+      if (tokenLimit.txAllowance !== '0' && requested.gt(allowance)) {
         return { sufficient: false, reason: 'NO_ENOUGH_ALLOWANCE' };
       }
     }
@@ -105,6 +113,31 @@ export async function isDelegationSufficientForPayment(args: {
   throw new Error(`Payment method ${paymentMethod.type} not supported`);
 }
 
+export function isBalanceSufficientForPayment(args: {
+  paymentMethod: PaymentMethod;
+  paymentCurrency: TPaymentCurrency;
+  customer: TCustomer;
+  amount: string;
+}): { sufficient: boolean; balance: string; reason?: string } {
+  const { paymentMethod, paymentCurrency, customer, amount } = args;
+  if (paymentMethod.type === 'stripe') {
+    return { sufficient: false, balance: customer.balance || '0', reason: 'NOT_SUPPORTED' };
+  }
+
+  const tokens = customer.token_balance || {};
+  const balance = tokens[paymentCurrency.id] || '0';
+
+  if (amount === '0') {
+    return { sufficient: false, balance, reason: 'NO_REQUIREMENT' };
+  }
+
+  if (new BN(balance).lt(new BN(amount))) {
+    return { sufficient: false, balance, reason: 'NO_ENOUGH_TOKEN' };
+  }
+
+  return { sufficient: true, balance };
+}
+
 export function getGasPayerExtra(txBuffer: Buffer) {
   const txHash = toTxHash(txBuffer);
   return {
@@ -181,6 +214,7 @@ export async function getPaymentDetail(userDid: string, invoice: Invoice): Promi
 }
 
 export async function getTokenLimitsForDelegation(
+  checkoutSession: CheckoutSession,
   paymentMethod: PaymentMethod,
   paymentCurrency: PaymentCurrency,
   address: string,
@@ -189,11 +223,15 @@ export async function getTokenLimitsForDelegation(
   const client = paymentMethod.getOcapClient();
   const { state } = await client.getDelegateState({ address });
 
+  const items = checkoutSession.line_items as TLineItemExpanded[];
+  const hasMetered = items.some((x) => x.price.recurring?.usage_type === 'metered');
+  const allowance = hasMetered ? '0' : amount;
+
   // @ts-ignore
   const entry: TokenLimit = {
     address: paymentCurrency.contract as string,
     to: [wallet.address], // FIXME: may broken if we have vault, migrated
-    txAllowance: amount,
+    txAllowance: allowance,
     totalAllowance: '0',
     txCount: 0,
     validUntil: 0,
@@ -204,6 +242,11 @@ export async function getTokenLimitsForDelegation(
     return [entry];
   }
 
+  // If we have metered items, we should not limit tx allowance(set to 0)
+  if (hasMetered) {
+    return [entry];
+  }
+
   const op = (state as DelegateState).ops.find((x) => x.key === OCAP_PAYMENT_TX_TYPE);
   if (op && Array.isArray(op.value.limit?.tokens) && op.value.limit.tokens.length > 0) {
     const tokenLimits = cloneDeep(op.value.limit.tokens);
@@ -212,7 +255,8 @@ export async function getTokenLimitsForDelegation(
     if (index > -1) {
       const limit = op.value.limit.tokens[index] as TokenLimit;
       // If we have a previous delegation and the txAllowance is smaller than requested amount
-      if (new BN(limit.txAllowance).lt(new BN(amount))) {
+      // If txAllowance is 0 (unlimited), we should not update it
+      if (limit.txAllowance !== '0' && new BN(limit.txAllowance).lt(new BN(amount))) {
         tokenLimits[index] = entry;
       }
     } else {

package/api/src/libs/queue/index.ts

@@ -125,7 +125,7 @@ export default function createQueue<T = any>({ name, onJob, options = defaults }
 
     const onJobComplete = async (err: any, result: any) => {
       if (result === CANCELLED) {
-        emit('cancelled', { id: jobId, job, result });
+        emit('cancelled', { id: jobId, job });
         clearJob(jobId);
         return;
       }
@@ -188,6 +188,22 @@ export default function createQueue<T = any>({ name, onJob, options = defaults }
     return jobEvents;
   };
 
+  const pushAndWait = (params: PushParams<T>) =>
+    new Promise((resolve, reject) => {
+      try {
+        if (params.runAt || params.delay) {
+          console.warn('You may have to wait for a long time to get the result of the delayed job');
+        }
+
+        const job = push(params);
+        job.on('finished', (data: { id: string; job: T; result: any }) => resolve(data));
+        job.on('canceled', (data: { id: string; job: T }) => resolve(data));
+        job.on('failed', (data: { id: string; job: T; error: Error }) => reject(data));
+      } catch (err) {
+        reject(err);
+      }
+    });
+
   const cancel = async (id: string) => {
     const doc = await store.updateJob(id, { cancelled: true });
     return doc ? doc.job : null;
@@ -258,6 +274,7 @@ export default function createQueue<T = any>({ name, onJob, options = defaults }
   return Object.assign(queueEvents, {
     store,
     push,
+    pushAndWait,
     drain: (cb: any) => (queue.drain = cb),
     empty: (cb: any) => (queue.empty = cb),
     saturated: (cb: any) => (queue.saturated = cb),

package/api/src/libs/queue/store.ts

@@ -6,23 +6,24 @@ import CustomError from '../error';
 export default function createQueueStore(queue: string) {
   return {
     async isCancelled(id: string): Promise<boolean> {
-      const job = await Job.findOne({ where: { queue, id } });
+      const job = await Job.findOne({ where: { queue, id }, transaction: null });
       return !!job && !!job.cancelled;
     },
     getJob(id: string): Promise<TJob | null> {
-      return Job.findOne({ where: { queue, id } });
+      return Job.findOne({ where: { queue, id }, transaction: null });
     },
     getJobs(): Promise<TJob[]> {
-      return Job.findAll({ where: { queue, delay: -1 }, order: [['created_at', 'ASC']] });
+      return Job.findAll({ where: { queue, delay: -1 }, order: [['created_at', 'ASC']], transaction: null });
     },
     getScheduledJobs(): Promise<TJob[]> {
       return Job.findAll({
         where: { queue, delay: { [Op.not]: -1 }, will_run_at: { [Op.lte]: Date.now() } },
         order: [['created_at', 'ASC']],
+        transaction: null,
       });
     },
     async updateJob(id: string, updates: Partial<TJob>): Promise<TJob> {
-      const job = await Job.findOne({ where: { queue, id } });
+      const job = await Job.findOne({ where: { queue, id }, transaction: null });
       if (!job) {
         throw new CustomError('JOB_NOT_FOUND', `Job ${id} does not exist`);
       }
@@ -30,7 +31,7 @@ export default function createQueueStore(queue: string) {
       return job.update(updates);
     },
     async addJob(id: string, job: any, attrs: Partial<TJob> = {}): Promise<TJob> {
-      const exist = await Job.findOne({ where: { queue, id } });
+      const exist = await Job.findOne({ where: { queue, id }, transaction: null });
       if (exist) {
         throw new CustomError('JOB_DUPLICATE', `Job ${queue}#${id} already exist`);
       }

package/api/src/libs/session.ts

@@ -36,9 +36,9 @@ export function getCheckoutMode(items: TLineItemExpanded[] = []) {
   return 'payment';
 }
 
-export function getPriceUintAmountByCurrency(price: TPrice, currency: TPaymentCurrency) {
+export function getPriceUintAmountByCurrency(price: TPrice, currencyId: string) {
   const options = getPriceCurrencyOptions(price);
-  const option = options.find((x) => x.currency_id === currency.id);
+  const option = options.find((x) => x.currency_id === currencyId);
   if (option) {
     return option.unit_amount;
   }
@@ -55,14 +55,14 @@ export function getPriceCurrencyOptions(price: TPrice): PriceCurrency[] {
 }
 
 // FIXME: apply coupon for discounts
-export function getCheckoutAmount(items: TLineItemExpanded[], currency: TPaymentCurrency, includeFreeTrial = false) {
+export function getCheckoutAmount(items: TLineItemExpanded[], currencyId: string, includeFreeTrial = false) {
   let renew = new BN(0);
 
   const total = items
     .reduce((acc, x) => {
       const price = x.upsell_price || x.price;
       if (price.type === 'recurring') {
-        renew = renew.add(new BN(getPriceUintAmountByCurrency(price, currency)).mul(new BN(x.quantity)));
+        renew = renew.add(new BN(getPriceUintAmountByCurrency(price, currencyId)).mul(new BN(x.quantity)));
 
         if (includeFreeTrial) {
           return acc;
@@ -71,7 +71,7 @@ export function getCheckoutAmount(items: TLineItemExpanded[], currency: TPayment
           return acc;
         }
       }
-      return acc.add(new BN(getPriceUintAmountByCurrency(price, currency)).mul(new BN(x.quantity)));
+      return acc.add(new BN(getPriceUintAmountByCurrency(price, currencyId)).mul(new BN(x.quantity)));
     }, new BN(0))
     .toString();
 
@@ -99,16 +99,17 @@ export function getRecurringPeriod(recurring: PriceRecurring) {
   }
 }
 
-export function getSubscriptionCreateSetup(items: TLineItemExpanded[], currency: TPaymentCurrency, trialInDays = 0) {
+export function getSubscriptionCreateSetup(items: TLineItemExpanded[], currencyId: string, trialInDays = 0) {
   let setup = new BN(0);
   let subscription = new BN(0);
 
   items.forEach((x) => {
     const price = x.upsell_price || x.price;
-    setup = setup.add(new BN(price.unit_amount).mul(new BN(x.quantity)));
+    const unit = getPriceUintAmountByCurrency(price, currencyId);
+    setup = setup.add(new BN(unit).mul(new BN(x.quantity)));
     if (price.type === 'recurring') {
       if (trialInDays === 0) {
-        subscription = setup.add(new BN(getPriceUintAmountByCurrency(price, currency)).mul(new BN(x.quantity)));
+        subscription = setup.add(new BN(unit).mul(new BN(x.quantity)));
       }
     }
   });
@@ -154,11 +155,11 @@ export function getSubscriptionCycleSetup(recurring: PriceRecurring, previousPer
   };
 }
 
-export function getSubscriptionCycleAmount(items: TLineItemExpanded[], currency: TPaymentCurrency) {
+export function getSubscriptionCycleAmount(items: TLineItemExpanded[], currencyId: string) {
   let amount = new BN(0);
 
   items.forEach((x) => {
-    amount = amount.add(new BN(getPriceUintAmountByCurrency(x.price, currency)).mul(new BN(x.quantity)));
+    amount = amount.add(new BN(getPriceUintAmountByCurrency(x.price, currencyId)).mul(new BN(x.quantity)));
   });
 
   return {
@@ -287,7 +288,7 @@ export function canUpsell(from: TPrice, to: TPrice) {
 export function getFastCheckoutAmount(
   items: TLineItemExpanded[],
   mode: string,
-  currency: TPaymentCurrency,
+  currencyId: string,
   includeFreeTrial = false,
   minimumCycle = 1
 ) {
@@ -296,7 +297,7 @@ export function getFastCheckoutAmount(
     minimumCycle = 1;
   }
 
-  const { total, renew } = getCheckoutAmount(items, currency, includeFreeTrial);
+  const { total, renew } = getCheckoutAmount(items, currencyId, includeFreeTrial);
   if (mode === 'payment') {
     return total;
   }

package/api/src/libs/subscription.ts

@@ -3,3 +3,29 @@ import { component } from '@blocklet/sdk';
 export function getCustomerSubscriptionPageUrl(subscriptionId: string, locale: string = 'en') {
   return component.getUrl(`customer/subscription/${subscriptionId}?locale=${locale}`);
 }
+
+// FIXME: make this configurable from preferences
+export function getDaysUntilDue(query: Record<string, any> = {}): number | null {
+  const raw = query.days_until_due || process.env.PAYMENT_DAYS_UNTIL_DUE;
+  if (raw) {
+    const days = parseInt(raw, 10);
+    // eslint-disable-next-line no-restricted-globals
+    if (isNaN(days) === false) {
+      return days;
+    }
+  }
+
+  return null;
+}
+
+export const getDueUnit = (interval: string) => {
+  if (interval === 'hour') {
+    return 60;
+  }
+
+  if (interval === 'day') {
+    return 60 * 60;
+  }
+
+  return 60 * 60 * 24;
+};

package/api/src/libs/util.ts

@@ -9,8 +9,11 @@ import dayjs from './dayjs';
 
 export const OCAP_PAYMENT_TX_TYPE = 'fg:t:transfer_v2';
 
-export const MAX_RETRY_COUNT = 18; // 2^18 seconds ~~ 3 days, total retry time: 6 days
+export const MAX_SUBSCRIPTION_ITEM_COUNT = 20;
+
+export const MAX_RETRY_COUNT = 20; // 2^20 seconds ~~ 12 days, total retry time: 24 days
 export const MIN_RETRY_MAIL = 13; // total retry time before sending first mail: 6 hours
+
 export const STRIPE_API_VERSION = '2023-08-16';
 export const STRIPE_ENDPOINT: string = getUrl('/api/integrations/stripe/webhook');
 export const STRIPE_EVENTS: any[] = [
@@ -27,6 +30,7 @@ export const STRIPE_EVENTS: any[] = [
   'customer.subscription.resumed',
   'customer.subscription.trial_will_end',
   'customer.subscription.updated',
+  'customer.updated',
 
   'invoice.created',
   'invoice.deleted',

package/api/src/{jobs → queues}/checkout-session.ts

@@ -2,7 +2,8 @@ import { mintNftForCheckoutSession } from '../integrations/blockchain/nft';
 import { ensurePassportIssued, ensurePassportRevoked } from '../integrations/blocklet/passport';
 import { events } from '../libs/event';
 import logger from '../libs/logger';
-import type { CheckoutSession, Subscription } from '../store/models';
+import { CheckoutSession, Price, Subscription } from '../store/models';
+import { subscriptionQueue } from './subscription';
 
 // eslint-disable-next-line require-await
 export async function startCheckoutSessionQueue() {
@@ -13,11 +14,32 @@ export async function startCheckoutSessionQueue() {
     mintNftForCheckoutSession(checkoutSession.id).catch((err) => {
       logger.error('mintNftForCheckoutSession failed', { error: err, checkoutSession: checkoutSession.id });
     });
+
+    // lock prices used
+    Price.update(
+      { locked: true },
+      { where: { id: checkoutSession.line_items.map((x) => x.upsell_price_id || x.price_id) } }
+    ).catch((err) => {
+      logger.error('lock price on checkout session complete failed', {
+        error: err,
+        checkoutSession: checkoutSession.id,
+      });
+    });
   });
 
   events.on('customer.subscription.deleted', (subscription: Subscription) => {
     ensurePassportRevoked(subscription).catch((err) => {
       logger.error('ensurePassportRevoked failed', { error: err, subscription: subscription.id });
     });
+
+    // FIXME: ensure invoices that are open or uncollectible are voided
+  });
+
+  events.on('customer.subscription.past_due', (subscription: Subscription) => {
+    subscriptionQueue.push({
+      id: `cancel-${subscription.id}`,
+      job: { subscriptionId: subscription.id, action: 'cancel' },
+      runAt: subscription.current_period_end,
+    });
   });
 }

package/api/src/{jobs → queues}/invoice.ts

@@ -13,10 +13,10 @@ import { paymentQueue } from './payment';
 type InvoiceJob = {
   invoiceId: string;
   retryOnError?: boolean;
+  waitForPayment?: boolean;
 };
 
 // handle invoice payment
-// TODO: send invoice to user with email
 export const handleInvoice = async (job: InvoiceJob) => {
   logger.info('handle invoice', job);
 
@@ -79,14 +79,16 @@ export const handleInvoice = async (job: InvoiceJob) => {
   if (invoice.payment_intent_id) {
     logger.warn(`PaymentIntent exist: ${invoice.payment_intent_id} for invoice ${job.invoiceId}`);
     paymentIntent = await PaymentIntent.findByPk(invoice.payment_intent_id);
-    if (paymentIntent && ['succeeded', 'canceled'].includes(paymentIntent.status) === false) {
+    if (paymentIntent && paymentIntent.isImmutable() === false) {
       await paymentIntent.update({ status: 'requires_capture' });
     }
   } else {
     const descriptionMap: any = {
       subscription_create: 'Subscription creation',
       subscription_cycle: 'Subscription cycle',
+      subscription_update: 'Subscription update',
     };
+    // TODO: support partial payment from user balance
     paymentIntent = await PaymentIntent.create({
       livemode: !!invoice.livemode,
       amount: invoice.total,
@@ -120,10 +122,17 @@ export const handleInvoice = async (job: InvoiceJob) => {
   }
   if (paymentIntent) {
     logger.info(`Payment job created: ${paymentIntent.id}`);
-    paymentQueue.push({
-      id: paymentIntent.id,
-      job: { paymentIntentId: paymentIntent.id, retryOnError: job.retryOnError },
-    });
+    if (job.waitForPayment) {
+      await paymentQueue.pushAndWait({
+        id: paymentIntent.id,
+        job: { paymentIntentId: paymentIntent.id, retryOnError: job.retryOnError },
+      });
+    } else {
+      paymentQueue.push({
+        id: paymentIntent.id,
+        job: { paymentIntentId: paymentIntent.id, retryOnError: job.retryOnError },
+      });
+    }
   }
 };