payment-kit 1.13.22 → 1.13.24

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

@@ -9,6 +9,7 @@ import {
   Customer,
   Invoice,
   InvoiceItem,
+  PaymentMethod,
   Subscription,
   SubscriptionItem,
   TEventExpanded,
@@ -29,6 +30,109 @@ export async function handleStripeInvoicePaid(invoice: Invoice, event: TEventExp
   });
 }
 
+export async function ensureStripeInvoice(stripeInvoice: any, subscription: Subscription, client: Stripe) {
+  const customer = await Customer.findByPk(subscription.customer_id);
+  const checkoutSession = await CheckoutSession.findOne({ where: { subscription_id: subscription.id } });
+
+  let invoice = await Invoice.findOne({ where: { 'metadata.stripe_id': stripeInvoice.id } });
+  if (invoice) {
+    return invoice;
+  }
+
+  // @ts-ignore
+  invoice = await Invoice.create({
+    // @ts-ignore
+    number: await customer.getInvoiceNumber(),
+    ...pick(stripeInvoice, [
+      'amount_due',
+      'amount_paid',
+      'amount_remaining',
+      'amount_shipping',
+      'attempt_count',
+      'attempted',
+      'auto_advance',
+      'billing_reason',
+      'collection_method',
+      'custom_fields',
+      'customer_address',
+      'customer_email',
+      'customer_name',
+      'customer_phone',
+      'description',
+      'discounts',
+      'due_date',
+      'effective_at',
+      'ending_balance',
+      'livemode',
+      'paid_out_of_band',
+      'paid',
+      'period_end',
+      'period_start',
+      'starting_balance',
+      'status_transitions',
+      'status',
+      'subtotal_excluding_tax',
+      'subtotal',
+      'tax',
+      'total_discount_amounts',
+      'total',
+    ]),
+
+    currency_id: subscription.currency_id,
+    customer_id: subscription.customer_id,
+    default_payment_method_id: subscription.default_payment_method_id as string,
+    payment_intent_id: '',
+    subscription_id: subscription.id,
+    checkout_session_id: checkoutSession?.id,
+    statement_descriptor: stripeInvoice.statement_descriptor || '',
+
+    payment_settings: subscription.payment_settings,
+    metadata: {
+      stripe_id: stripeInvoice.id,
+    },
+  });
+  await client.invoices.update(stripeInvoice.id, { metadata: { appPid: env.appPid, id: invoice.id } });
+  logger.info('stripe invoice mirrored', { local: invoice.id, remote: stripeInvoice.id });
+
+  await Promise.all(
+    stripeInvoice.lines.data.map(async (line: any) => {
+      const subscriptionItem = line.subscription_item
+        ? await SubscriptionItem.findOne({ where: { 'metadata.stripe_id': line.subscription_item } })
+        : null;
+
+      // @ts-ignore
+      const item = await InvoiceItem.create({
+        currency_id: subscription.currency_id,
+        customer_id: subscription.customer_id,
+        price_id: line.price?.metadata.id as string,
+        invoice_id: invoice?.id as string,
+        subscription_id: subscription.id,
+        subscription_item_id: subscriptionItem?.id,
+        ...pick(line, [
+          'livemode',
+          'amount',
+          'quantity',
+          'description',
+          'period',
+          'discountable',
+          'discount_amounts',
+          'discounts',
+          'proration',
+          'proration_details',
+        ]),
+        metadata: {
+          stripe_id: line.id,
+        },
+      });
+
+      logger.info('stripe invoice items mirrored', { local: item.id, remote: line.id });
+      return item;
+    })
+  );
+
+  return invoice;
+}
+
 export async function handleStripeInvoiceCreated(event: TEventExpanded, client: Stripe) {
   if (['invoice.created', 'payment_intent.created'].includes(event.type) === false) {
     logger.warn('abort because event type not expected', { id: event.id, type: event.type });
@@ -74,98 +178,7 @@ export async function handleStripeInvoiceCreated(event: TEventExpanded, client:
   const checkoutSession = await CheckoutSession.findOne({ where: { subscription_id: subscription.id } });
 
   // create stripe invoice
-  let invoice = await Invoice.findOne({ where: { 'metadata.stripe_id': stripeInvoice.id } });
-  if (!invoice) {
-    invoice = await Invoice.create({
-      // @ts-ignore
-      number: await customer.getInvoiceNumber(),
-      ...pick(stripeInvoice, [
-        'amount_due',
-        'amount_paid',
-        'amount_remaining',
-        'amount_shipping',
-        'attempt_count',
-        'attempted',
-        'auto_advance',
-        'billing_reason',
-        'collection_method',
-        'custom_fields',
-        'customer_address',
-        'customer_email',
-        'customer_name',
-        'customer_phone',
-        'description',
-        'discounts',
-        'due_date',
-        'effective_at',
-        'ending_balance',
-        'livemode',
-        'paid_out_of_band',
-        'paid',
-        'period_end',
-        'period_start',
-        'starting_balance',
-        'status_transitions',
-        'status',
-        'subtotal_excluding_tax',
-        'subtotal',
-        'tax',
-        'total_discount_amounts',
-        'total',
-      ]),
-
-      currency_id: subscription.currency_id,
-      customer_id: subscription.customer_id,
-      default_payment_method_id: subscription.default_payment_method_id as string,
-      payment_intent_id: '',
-      subscription_id: subscription.id,
-      checkout_session_id: checkoutSession?.id,
-      statement_descriptor: stripeInvoice.statement_descriptor || '',
-
-      payment_settings: subscription.payment_settings,
-      metadata: {
-        stripe_id: stripeInvoice.id,
-      },
-    });
-    await client.invoices.update(stripeInvoice.id, { metadata: { appPid: env.appPid, id: invoice.id } });
-    logger.info('stripe invoice mirrored', { local: invoice.id, remote: stripeInvoice.id });
-
-    await Promise.all(
-      stripeInvoice.lines.data.map(async (line) => {
-        const subscriptionItem = line.subscription_item
-          ? await SubscriptionItem.findOne({ where: { 'metadata.stripe_id': line.subscription_item } })
-          : null;
-
-        // @ts-ignore
-        const item = await InvoiceItem.create({
-          currency_id: subscription.currency_id,
-          customer_id: subscription.customer_id,
-          price_id: line.price?.metadata.id as string,
-          invoice_id: invoice?.id as string,
-          subscription_id: subscription.id,
-          subscription_item_id: subscriptionItem?.id,
-          ...pick(line, [
-            'livemode',
-            'amount',
-            'quantity',
-            'description',
-            'period',
-            'discountable',
-            'discount_amounts',
-            'discounts',
-            'proration',
-            'proration_details',
-          ]),
-          metadata: {
-            stripe_id: line.id,
-          },
-        });
-
-        logger.info('stripe invoice items mirrored', { local: item.id, remote: line.id });
-        return item;
-      })
-    );
-  }
+  const invoice = await ensureStripeInvoice(stripeInvoice, subscription, client);
 
   return { subscription, invoice, customer, checkoutSession };
 }
@@ -186,16 +199,32 @@ export async function handleInvoiceEvent(event: TEventExpanded, client: Stripe)
     return;
   }
 
-  const localInvoiceId = event.data.object.metadata?.id;
+  let localInvoiceId = event.data.object.metadata?.id;
+
+  // in case we missed some of the events
+  const subscriptionId = event.data.object.subscription_details?.metadata?.id;
+  const appPid = event.data.object.subscription_details?.metadata?.appPid;
   if (!localInvoiceId) {
-    try {
-      await waitForStripeInvoiceMirrored(event.data.object.id);
-    } catch (err) {
-      logger.error('wait for stripe invoice mirror error', { localInvoiceId, error: err });
-    }
+    if (subscriptionId && appPid && appPid === env.appPid) {
+      logger.warn('try mirror invoice from stripe', { invoiceId: event.data.object.id });
+      const subscription = await Subscription.findByPk(subscriptionId);
+      if (subscription) {
+        const method = await PaymentMethod.findByPk(subscription.default_payment_method_id);
+        if (method && method.type === 'stripe') {
+          const tmp = await ensureStripeInvoice(event.data.object, subscription, method.getStripe());
+          localInvoiceId = tmp.id;
+        }
+      }
+    } else {
+      try {
+        await waitForStripeInvoiceMirrored(event.data.object.id);
+      } catch (err) {
+        logger.error('wait for stripe invoice mirror error', { localInvoiceId, error: err });
+      }
 
-    logger.warn('local invoice id not found in strip event', { localInvoiceId });
-    return;
+      logger.warn('local invoice id not found in strip event', { localInvoiceId });
+      return;
+    }
   }
 
   const invoice = await Invoice.findByPk(localInvoiceId);
@@ -232,7 +261,6 @@ export async function handleInvoiceEvent(event: TEventExpanded, client: Stripe)
     return;
   }
 
-  // TODO: handle upcoming invoices?
   if (event.type === 'invoice.upcoming') {
     logger.info('received invoice upcoming event', event);
   }

package/api/src/jobs/event.ts

@@ -1,44 +1,54 @@
 import { Op } from 'sequelize';
 
+import { events } from '../libs/event';
 import logger from '../libs/logger';
 import createQueue from '../libs/queue';
+import { getWebhookJobId } from '../libs/util';
 import { Event } from '../store/models/event';
+import { WebhookAttempt } from '../store/models/webhook-attempt';
 import { WebhookEndpoint } from '../store/models/webhook-endpoint';
-import { getJobId, webhookQueue } from './webhook';
+import { webhookQueue } from './webhook';
 
 type EventJob = {
   eventId: string;
 };
 
 export const handleEvent = async (job: EventJob) => {
-  logger.info('handleEvent', job);
+  logger.info('handle event', job);
 
   const event = await Event.findByPk(job.eventId);
   if (!event) {
-    logger.warn(`Event not found: ${job.eventId}`);
+    logger.warn('event not found', job);
     return;
   }
 
   if (!event.pending_webhooks) {
-    logger.warn(`Event already processed: ${job.eventId}`);
+    logger.warn('event already processed', job);
     return;
   }
 
   const webhooks = await WebhookEndpoint.findAll({ where: { status: 'enabled', livemode: event.livemode } });
   const eventWebhooks = webhooks.filter((webhook) => webhook.enabled_events.includes(event.type));
   if (eventWebhooks.length === 0) {
-    logger.info(`No webhook endpoint for event: ${job.eventId}`);
+    logger.info('no webhook endpoint for event', job);
     await event.update({ pending_webhooks: 0 });
     return;
   }
 
   await event.update({ pending_webhooks: eventWebhooks.length });
-  eventWebhooks.forEach((webhook) => {
-    logger.info(`Schedule webhook ${webhook.id} attempt for event: ${job.eventId}`);
-    webhookQueue.push({
-      id: getJobId(event.id, webhook.id),
-      job: { eventId: event.id, webhookId: webhook.id },
+  eventWebhooks.forEach(async (webhook) => {
+    const attempted = await WebhookAttempt.findOne({
+      where: { event_id: event.id, webhook_endpoint_id: webhook.id },
     });
+
+    // we should only push webhook if it's not attempted before
+    if (!attempted) {
+      logger.info('schedule initial attempt for event', job);
+      webhookQueue.push({
+        id: getWebhookJobId(event.id, webhook.id),
+        job: { eventId: event.id, webhookId: webhook.id },
+      });
+    }
   });
 };
 
@@ -52,14 +62,14 @@ export const eventQueue = createQueue<EventJob>({
 });
 
 export const startEventQueue = async () => {
-  const events = await Event.findAll({
+  const docs = await Event.findAll({
     where: {
       pending_webhooks: { [Op.gt]: 0 },
     },
     attributes: ['id'],
   });
 
-  events.forEach(async (x) => {
+  docs.forEach(async (x) => {
     const exist = await eventQueue.get(x.id);
     if (!exist) {
       eventQueue.push({ id: x.id, job: { eventId: x.id } });
@@ -68,5 +78,9 @@ export const startEventQueue = async () => {
 };
 
 eventQueue.on('failed', ({ id, job, error }) => {
-  logger.error('Event job failed', { id, job, error });
+  logger.error('event job failed', { id, job, error });
+});
+
+events.on('event.created', (event) => {
+  eventQueue.push({ id: event.id, job: { eventId: event.id } });
 });

package/api/src/jobs/invoice.ts

@@ -18,31 +18,31 @@ type InvoiceJob = {
 // handle invoice payment
 // TODO: send invoice to user with email
 export const handleInvoice = async (job: InvoiceJob) => {
-  logger.info('handleInvoice', job);
+  logger.info('handle invoice', job);
 
   const invoice = await Invoice.findByPk(job.invoiceId);
   if (!invoice) {
-    logger.warn(`Invoice not found: ${job.invoiceId}`);
+    logger.warn(`invoice not found: ${job.invoiceId}`);
     return;
   }
   if (invoice.status !== 'open') {
-    logger.warn(`Invoice not open: ${job.invoiceId}`);
+    logger.warn(`invoice not open: ${job.invoiceId}`);
     return;
   }
   if (invoice.auto_advance === false) {
-    logger.warn(`Invoice not configured to auto advance: ${job.invoiceId}`);
+    logger.warn(`invoice not configured to auto advance: ${job.invoiceId}`);
     return;
   }
 
   const supportAutoCharge = await PaymentMethod.supportAutoCharge(invoice.default_payment_method_id);
   if (supportAutoCharge === false) {
-    logger.warn(`Invoice does not support auto charge: ${job.invoiceId}`);
+    logger.warn(`invoice does not support auto charge: ${job.invoiceId}`);
     return;
   }
 
   // no payment required
   if (invoice.total === '0') {
-    logger.warn(`Invoice does not require payment: ${job.invoiceId}`);
+    logger.warn(`invoice does not require payment: ${job.invoiceId}`);
 
     await invoice.update({
       paid: true,
@@ -59,7 +59,7 @@ export const handleInvoice = async (job: InvoiceJob) => {
       const subscription = await Subscription.findByPk(invoice.subscription_id);
       if (subscription && subscription.status === 'incomplete') {
         await subscription.update({ status: subscription.trail_end ? 'trialing' : 'active' });
-        logger.info('Invoice subscription updated', subscription.id);
+        logger.info('invoice subscription updated', subscription.id);
       }
     }
 
@@ -67,7 +67,7 @@ export const handleInvoice = async (job: InvoiceJob) => {
       const checkoutSession = await CheckoutSession.findByPk(invoice.checkout_session_id);
       if (checkoutSession && checkoutSession.status === 'open') {
         await checkoutSession.update({ status: 'complete', payment_status: 'no_payment_required' });
-        logger.info('Invoice checkout session updated', checkoutSession.id);
+        logger.info('invoice checkout session updated', checkoutSession.id);
       }
     }
 

package/api/src/jobs/payment.ts

@@ -19,7 +19,7 @@ type PaymentJob = {
 };
 
 export const handlePayment = async (job: PaymentJob) => {
-  logger.info('handlePayment', job);
+  logger.info('handle payment', job);
 
   const paymentIntent = await PaymentIntent.findByPk(job.paymentIntentId);
   if (!paymentIntent) {

package/api/src/jobs/subscription.ts

@@ -21,7 +21,7 @@ type SubscriptionJob = {
 
 // generate invoice for subscription periodically
 export const handleSubscription = async (job: SubscriptionJob) => {
-  logger.info('handleSubscription', job);
+  logger.info('handle subscription', job);
 
   const subscription = await Subscription.findByPk(job.subscriptionId);
   if (!subscription) {

package/api/src/jobs/webhook.ts

@@ -4,8 +4,10 @@ import axios, { AxiosError } from 'axios';
 import { wallet } from '../libs/auth';
 import logger from '../libs/logger';
 import createQueue from '../libs/queue';
-import { MAX_RETRY_COUNT, getNextRetry, md5 } from '../libs/util';
+import { MAX_RETRY_COUNT, getNextRetry, getWebhookJobId } from '../libs/util';
+import { Customer } from '../store/models/customer';
 import { Event } from '../store/models/event';
+import { PaymentCurrency } from '../store/models/payment-currency';
 import { WebhookAttempt } from '../store/models/webhook-attempt';
 import { WebhookEndpoint } from '../store/models/webhook-endpoint';
 
@@ -14,49 +16,54 @@ type WebhookJob = {
   webhookId: string;
 };
 
-export const getJobId = (eventId: string, webhookId: string) => {
-  return md5([eventId, webhookId].join('-'));
-};
-
 // https://stripe.com/docs/webhooks
 export const handleWebhook = async (job: WebhookJob) => {
-  logger.info('handleWebhook', job);
+  logger.info('handle webhook', job);
 
   const event = await Event.findByPk(job.eventId);
   if (!event) {
-    logger.warn(`Event not found when attempt webhook: ${job.eventId}`);
+    logger.warn('event not found when attempt webhook', job);
     return;
   }
 
   const webhook = await WebhookEndpoint.findByPk(job.webhookId);
   if (!webhook) {
-    logger.warn(`Webhook not found on attempt: ${job.webhookId}`);
+    logger.warn('webhook not found on attempt', job);
     return;
   }
   if (webhook.status !== 'enabled') {
-    logger.warn(`Webhook disabled on attempt: ${job.webhookId}`);
+    logger.warn('webhook disabled on attempt', job);
     return;
   }
 
-  const lastAttempt = await WebhookAttempt.findOne({
+  const lastRetryCount = await WebhookAttempt.max('retry_count', {
     where: { event_id: event.id, webhook_endpoint_id: webhook.id },
-    order: [['retry_count', 'DESC']],
-    attributes: ['retry_count'],
   });
 
-  const retryCount = lastAttempt ? lastAttempt.retry_count + 1 : 0;
+  const retryCount = lastRetryCount ? +lastRetryCount + 1 : 1;
 
   try {
+    const json = event.toJSON();
+
+    // expand basic fields
+    const { object } = json.data;
+    if (object.customer_id && !object.customer) {
+      object.customer = await Customer.findByPk(object.customer_id);
+    }
+    if (object.currency_id && !object.currency) {
+      object.currency = await PaymentCurrency.findByPk(object.currency_id);
+    }
+
     // verify similar to component call, but supports external urls
     const result = await axios({
       url: webhook.url,
       method: 'POST',
       timeout: 60 * 1000,
-      data: event.toJSON(),
+      data: json,
       headers: {
         'x-app-id': wallet.address,
         'x-app-pk': wallet.publicKey,
-        'x-component-sig': sign(event.toJSON()),
+        'x-component-sig': sign(json),
         'x-component-did': process.env.BLOCKLET_COMPONENT_DID as string,
       },
     });
@@ -72,9 +79,9 @@ export const handleWebhook = async (job: WebhookJob) => {
     });
 
     await event.decrement('pending_webhooks');
-    logger.info(`Webhook attempt success: ${job.webhookId}`);
+    logger.info('webhook attempt success', { ...job, retryCount });
   } catch (err: any) {
-    logger.error(`Webhook attempt error: ${job.webhookId}`, { message: err.message });
+    logger.warn('webhook attempt error', { ...job, retryCount, message: err.message });
     await WebhookAttempt.create({
       livemode: event.livemode,
       event_id: event.id,
@@ -89,9 +96,9 @@ export const handleWebhook = async (job: WebhookJob) => {
     if (retryCount < MAX_RETRY_COUNT) {
       process.nextTick(() => {
         webhookQueue.push({
-          id: getJobId(event.id, webhook.id),
+          id: getWebhookJobId(event.id, webhook.id),
           job: { eventId: event.id, webhookId: webhook.id },
-          runAt: getNextRetry(retryCount + 1),
+          runAt: getNextRetry(retryCount),
         });
       });
     }

package/api/src/libs/audit.ts

@@ -1,7 +1,7 @@
 import pick from 'lodash/pick';
 
-import { eventQueue } from '../jobs/event';
 import { Event } from '../store/models/event';
+import { events } from './event';
 
 export async function createEvent(scope: string, type: string, model: any, options: any) {
   // console.log('createEvent', scope, type, model, options);
@@ -28,7 +28,7 @@ export async function createEvent(scope: string, type: string, model: any, optio
     pending_webhooks: 99, // force all events goto the event queue
   });
 
-  eventQueue.push({ id: event.id, job: { eventId: event.id } });
+  events.emit('event.created', { id: event.id });
 }
 
 export async function createStatusEvent(
@@ -69,5 +69,5 @@ export async function createStatusEvent(
     pending_webhooks: 99, // force all events goto the event queue
   });
 
-  eventQueue.push({ id: event.id, job: { eventId: event.id } });
+  events.emit('event.created', { id: event.id });
 }

package/api/src/libs/event.ts

@@ -0,0 +1,3 @@
+import EventEmitter from 'events';
+
+export const events = new EventEmitter();

package/api/src/libs/util.ts

@@ -66,6 +66,7 @@ export function createCodeGenerator(prefix: string, size: number = 24) {
   return prefix ? () => `${prefix}_${generator()}` : generator;
 }
 
+// FIXME: merge with old metadata
 export function formatMetadata(metadata?: Record<string, any>): Record<string, any> {
   if (!metadata) {
     return {};
@@ -137,3 +138,7 @@ export const getNextRetry = (retryCount: number) => {
   const now = dayjs().unix();
   return now + delay;
 };
+
+export const getWebhookJobId = (eventId: string, webhookId: string) => {
+  return md5([eventId, webhookId].join('-'));
+};

package/api/src/routes/connect/pay.ts

@@ -8,7 +8,7 @@ import dayjs from '../../libs/dayjs';
 import { ensureInvoiceForCheckout, ensurePaymentIntent, getAuthPrincipalClaim } from './shared';
 
 export default {
-  action: 'pay',
+  action: 'payment',
   authPrincipal: false,
   claims: {
     authPrincipal: async ({ extraParams }: CallbackArgs) => {

package/api/src/routes/subscriptions.ts

@@ -8,6 +8,7 @@ import dayjs from '../libs/dayjs';
 import logger from '../libs/logger';
 import { authenticate } from '../libs/security';
 import { expandLineItems } from '../libs/session';
+import { formatMetadata } from '../libs/util';
 import { Customer } from '../store/models/customer';
 import { PaymentCurrency } from '../store/models/payment-currency';
 import { PaymentMethod } from '../store/models/payment-method';
@@ -302,4 +303,18 @@ router.put('/:id/resume', auth, async (req, res) => {
   return res.json(doc);
 });
 
+router.put('/:id', auth, async (req, res) => {
+  const doc = await Subscription.findByPk(req.params.id);
+
+  if (!doc) {
+    return res.status(404).json({ error: 'Subscription not found' });
+  }
+
+  if (req.body.metadata) {
+    await doc.update({ metadata: formatMetadata(req.body.metadata) });
+  }
+
+  return res.json(doc);
+});
+
 export default router;

package/api/src/store/models/types.ts

@@ -210,6 +210,7 @@ export type PaymentMethodOptions = {
 
 export type PaymentMethodSettings = {
   stripe?: {
+    dashboard: string;
     publishable_key: string;
     secret_key: string;
     webhook_signing_secret: string;

package/blocklet.yml

@@ -14,7 +14,7 @@ repository:
   type: git
   url: git+https://github.com/blocklet/payment-kit.git
 specVersion: 1.2.8
-version: 1.13.22
+version: 1.13.24
 logo: logo.png
 files:
   - dist
@@ -40,7 +40,7 @@ payment:
 timeout:
   start: 60
 requirements:
-  server: '>=1.16.15'
+  server: '>=1.16.10'
   os: '*'
   cpu: '*'
 scripts: