payment-kit 1.13.18 → 1.13.19

package/README.md

@@ -1,3 +1,17 @@
 # Payment Kit
 
 The decentralized stripe for blocklet platform.
+
+## Contribution
+
+### Development
+
+1. clone the repo
+2. run `make build`
+3. run `cd blocklets/core && blocklet dev`
+
+### Debug Stripe
+
+1. Install and login with instructions from: https://stripe.com/docs/stripe-cli
+2. Start your local payment-kit server, get it's port
+3. Run `stripe listen --forward-to http://127.0.0.1:8188/api/integrations/stripe/webhook --log-level=debug --latest`

package/api/src/index.ts

@@ -9,6 +9,7 @@ import dotenv from 'dotenv-flow';
 import express, { ErrorRequestHandler, Request, Response } from 'express';
 import morgan from 'morgan';
 
+import { ensureWebhookRegistered } from './integrations/stripe/setup';
 import { startEventQueue } from './jobs/event';
 import { startInvoiceQueue } from './jobs/invoice';
 import { startPaymentQueue } from './jobs/payment';
@@ -26,15 +27,19 @@ import { sequelize } from './store/sequelize';
 
 dotenv.config();
 
-const { name, version } = require('../../package.json');
-
 initialize(sequelize);
 
 export const app = express();
 
 app.set('trust proxy', true);
 app.use(cookieParser());
-app.use(express.json({ limit: '1 mb' }));
+app.use((req, res, next) => {
+  if (req.originalUrl.startsWith('/api/integrations/stripe/webhook')) {
+    next();
+  } else {
+    express.json({ limit: '1 mb' })(req, res, next);
+  }
+});
 app.use(express.urlencoded({ extended: true, limit: '1 mb' }));
 app.use(cors());
 app.use(ensureI18n());
@@ -73,9 +78,13 @@ if (isProduction) {
   app.use(fallback('index.html', { root: staticDir }));
 
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  app.use(<ErrorRequestHandler>((err, _req, res, _next) => {
+  app.use(<ErrorRequestHandler>((err, req, res, _next) => {
     logger.error(err.stack);
-    res.status(500).send('Something broke!');
+    if (req.accepts('json')) {
+      res.status(500).send({ error: err.message });
+    } else {
+      res.status(500).send('Something broke!');
+    }
   }));
 }
 
@@ -83,10 +92,12 @@ const port = parseInt(process.env.BLOCKLET_PORT!, 10);
 
 export const server = app.listen(port, (err?: any) => {
   if (err) throw err;
-  logger.info(`> ${name} v${version} ready on ${port}`);
+  logger.info(`> payment-kit ready on ${port}`);
 
   startPaymentQueue().then(() => logger.info('payment queue started'));
   startInvoiceQueue().then(() => logger.info('invoice queue started'));
   startSubscriptionQueue().then(() => logger.info('subscription queue started'));
   startEventQueue().then(() => logger.info('event queue started'));
+
+  ensureWebhookRegistered().catch(console.error);
 });

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

@@ -0,0 +1,53 @@
+import type Stripe from 'stripe';
+
+import { handleInvoiceEvent } from './invoice';
+import { handlePaymentIntentEvent } from './payment-intent';
+import { handleSetupIntentEvent } from './setup-intent';
+import { handleSubscriptionEvent } from './subscription';
+
+export default function handleStripeEvent(event: any, client: Stripe) {
+  switch (event.type) {
+    case 'payment_intent.canceled':
+    case 'payment_intent.created':
+    case 'payment_intent.partially_funded':
+    case 'payment_intent.payment_failed':
+    case 'payment_intent.processing':
+    case 'payment_intent.requires_action':
+    case 'payment_intent.succeeded':
+      return handlePaymentIntentEvent(event, client);
+
+    // case 'setup_intent.created':
+    case 'setup_intent.canceled':
+    case 'setup_intent.requires_action':
+    case 'setup_intent.setup_failed':
+    case 'setup_intent.succeeded':
+      return handleSetupIntentEvent(event, client);
+
+    case 'customer.subscription.deleted':
+    case 'customer.subscription.paused':
+    case 'customer.subscription.pending_update_applied':
+    case 'customer.subscription.pending_update_expired':
+    case 'customer.subscription.resumed':
+    case 'customer.subscription.trial_will_end':
+    case 'customer.subscription.updated':
+      return handleSubscriptionEvent(event, client);
+
+    case 'invoice.created':
+    case 'invoice.deleted':
+    case 'invoice.finalization_failed':
+    case 'invoice.finalized':
+    case 'invoice.marked_uncollectible':
+    case 'invoice.paid':
+    case 'invoice.payment_action_required':
+    case 'invoice.payment_failed':
+    case 'invoice.payment_succeeded':
+    case 'invoice.sent':
+    case 'invoice.upcoming':
+    case 'invoice.updated':
+    case 'invoice.voided':
+      return handleInvoiceEvent(event, client);
+
+    default:
+      return Promise.resolve(true);
+  }
+}

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

@@ -0,0 +1,252 @@
+import env from '@blocklet/sdk/lib/env';
+import pick from 'lodash/pick';
+import pWaitFor from 'p-wait-for';
+import type Stripe from 'stripe';
+
+import logger from '../../../libs/logger';
+import {
+  CheckoutSession,
+  Customer,
+  Invoice,
+  InvoiceItem,
+  Subscription,
+  SubscriptionItem,
+  TEventExpanded,
+} from '../../../store/models';
+
+export async function handleStripeInvoicePaid(invoice: Invoice, event: TEventExpanded) {
+  logger.info('invoice paid on stripe event', { locale: invoice.id });
+  await invoice.update({
+    status: 'paid',
+    ...pick(event.data.object, [
+      'paid',
+      'paid_out_of_band',
+      'amount_due',
+      'amount_paid',
+      'amount_remaining',
+      'status_transitions',
+    ]),
+  });
+}
+
+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 });
+    return null;
+  }
+
+  const stripeInvoiceId = event.type === 'invoice.created' ? event.data.object.id : event.data.object.invoice;
+  const stripeInvoice = await client.invoices.retrieve(stripeInvoiceId);
+  if (!stripeInvoice) {
+    logger.warn('abort because stripe invoice not found', { id: event.id, type: event.type });
+    return null;
+  }
+  if (!stripeInvoice.subscription) {
+    logger.warn('abort because invoice have no subscription', { id: event.id, type: event.type });
+    return null;
+  }
+
+  const stripeSubscription = await client.subscriptions.retrieve(stripeInvoice.subscription as string);
+  if (!stripeSubscription) {
+    logger.warn('abort because subscription not found', { id: event.id, type: event.type });
+    return null;
+  }
+  if (stripeSubscription.metadata?.appPid !== env.appPid) {
+    logger.warn('abort because subscription not interested', { id: event.id, type: event.type });
+    return null;
+  }
+
+  const subscription = await Subscription.findByPk(stripeSubscription.metadata.id);
+  if (!subscription) {
+    logger.warn('abort because local subscription not exist', { id: event.id, type: event.type });
+    return null;
+  }
+
+  logger.info('valid event for subscription detected', {
+    id: event.id,
+    type: event.type,
+    stripeInvoiceId: stripeInvoice.id,
+    stripeSubscriptionId: stripeSubscription.id,
+    localSubscriptionId: subscription.id,
+  });
+
+  const customer = await Customer.findByPk(subscription.customer_id);
+  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;
+      })
+    );
+  }
+
+  return { subscription, invoice, customer, checkoutSession };
+}
+
+const waitForStripeInvoiceMirrored = (stripeInvoiceId: string) => {
+  return pWaitFor(
+    async () => {
+      const invoice = await Invoice.findOne({ where: { 'metadata.stripe_id': stripeInvoiceId } });
+      return !!invoice;
+    },
+    { interval: 1000, timeout: 20 * 1000 }
+  );
+};
+
+export async function handleInvoiceEvent(event: TEventExpanded, client: Stripe) {
+  if (event.type === 'invoice.created') {
+    await handleStripeInvoiceCreated(event, client);
+    return;
+  }
+
+  const localInvoiceId = event.data.object.metadata?.id;
+  if (!localInvoiceId) {
+    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;
+  }
+
+  const invoice = await Invoice.findByPk(localInvoiceId);
+  if (!invoice) {
+    logger.warn('local invoice not found', { localInvoiceId });
+    return;
+  }
+
+  logger.info('received invoice event', { id: event.id, type: event.type, localInvoiceId });
+
+  if (event.type === 'invoice.paid') {
+    await handleStripeInvoicePaid(invoice, event);
+    return;
+  }
+
+  if (event.type === 'invoice.finalized') {
+    await invoice.update({ status: 'finalized', status_transitions: event.data.object.status_transitions });
+    logger.info('invoice finalized on stripe event', { locale: invoice.id });
+    return;
+  }
+
+  if (event.type === 'invoice.voided') {
+    await invoice.update({ status: 'void', status_transitions: event.data.object.status_transitions });
+    logger.info('invoice voided on stripe event', { locale: invoice.id });
+    return;
+  }
+
+  if (event.type === 'invoice.marked_uncollectible') {
+    await invoice.update({
+      status: 'uncollectible',
+      status_transitions: event.data.object.status_transitions,
+    });
+    logger.info('invoice uncollectible on stripe event', { locale: invoice.id });
+    return;
+  }
+
+  // TODO: handle upcoming invoices?
+  if (event.type === 'invoice.upcoming') {
+    logger.info('received invoice upcoming event', event);
+  }
+
+  if (event.type === 'invoice.finalization_failed') {
+    await invoice.update({
+      status: 'finalization_failed',
+      last_finalization_error: event.data.object.last_finalization_error,
+    });
+    logger.info('invoice finalization failed on stripe event', { locale: invoice.id });
+  }
+
+  if (event.type === 'invoice.payment_failed') {
+    await invoice.update({ status: 'payment_failed' });
+    logger.info('invoice payment failed on stripe event', { locale: invoice.id });
+  }
+}

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

@@ -0,0 +1,172 @@
+import env from '@blocklet/sdk/lib/env';
+import merge from 'lodash/merge';
+import pick from 'lodash/pick';
+import pWaitFor from 'p-wait-for';
+import type Stripe from 'stripe';
+
+import dayjs from '../../../libs/dayjs';
+import logger from '../../../libs/logger';
+import { CheckoutSession, Invoice, PaymentIntent, TEventExpanded } from '../../../store/models';
+import { handleStripeInvoiceCreated } from './invoice';
+
+export async function handleStripePaymentSucceed(paymentIntent: PaymentIntent, event?: TEventExpanded) {
+  await paymentIntent.update({
+    status: 'succeeded',
+    amount_received: paymentIntent.amount,
+    payment_details: merge(
+      paymentIntent.metadata,
+      event ? { stripe: { payment_intent_id: event.data.object.id, customer_id: event.data.object.customer } } : {}
+    ),
+  });
+  logger.info('payment intent succeeded on stripe event', { locale: paymentIntent.id });
+
+  const checkoutSession = await CheckoutSession.findOne({ where: { payment_intent_id: paymentIntent.id } });
+  if (checkoutSession) {
+    await checkoutSession.update({
+      status: 'complete',
+      payment_status: 'paid',
+      payment_details: paymentIntent.payment_details,
+    });
+  }
+
+  if (paymentIntent.invoice_id) {
+    const invoice = await Invoice.findByPk(paymentIntent.invoice_id);
+    if (invoice && invoice.status !== 'paid') {
+      await invoice.update({
+        paid: true,
+        status: 'paid',
+        amount_due: '0',
+        amount_paid: paymentIntent.amount,
+        amount_remaining: '0',
+        attempt_count: invoice.attempt_count + 1,
+        attempted: true,
+        status_transitions: { ...invoice.status_transitions, paid_at: dayjs().unix() },
+      });
+    }
+  }
+}
+
+export async function handleStripePaymentCreated(event: TEventExpanded, client: Stripe) {
+  logger.info('possible payment intent from subscription', { id: event.id, type: event.type });
+
+  const result = await handleStripeInvoiceCreated(event, client);
+  if (!result) {
+    return;
+  }
+
+  const { invoice, checkoutSession } = result;
+
+  // create stripe intent
+  const stripeIntent = event.data.object;
+  let paymentIntent = await PaymentIntent.findOne({ where: { 'metadata.stripe_id': stripeIntent.id } });
+  if (!paymentIntent) {
+    // @ts-ignore
+    paymentIntent = await PaymentIntent.create({
+      customer_id: invoice.customer_id,
+      currency_id: invoice.currency_id,
+      payment_method_id: invoice.default_payment_method_id,
+      invoice_id: invoice.id,
+      payment_method_types: ['stripe'],
+
+      amount: String(stripeIntent.amount),
+      amount_received: '0',
+      amount_capturable: String(stripeIntent.amount_capturable),
+      amount_details: { tip: '0' },
+
+      ...pick(stripeIntent, [
+        'livemode',
+        'description',
+        'status',
+        'confirmation_method',
+        'capture_method',
+        'receipt_email',
+        'statement_descriptor',
+        'statement_descriptor_suffix',
+        'setup_future_usage',
+      ]),
+
+      metadata: {
+        stripe_id: stripeIntent.id,
+      },
+    });
+    await client.paymentIntents.update(stripeIntent.id, { metadata: { appPid: env.appPid, id: paymentIntent.id } });
+    await invoice.update({ payment_intent_id: paymentIntent.id });
+    if (checkoutSession) {
+      checkoutSession.update({ payment_intent_id: paymentIntent.id });
+    }
+
+    logger.info('stripe payment intent mirrored', { locale: paymentIntent.id, remote: stripeIntent.id });
+  }
+}
+
+const waitForStripePaymentMirrored = (stripeInvoiceId: string) => {
+  return pWaitFor(
+    async () => {
+      const invoice = await Invoice.findOne({ where: { 'metadata.stripe_id': stripeInvoiceId } });
+      return !!invoice;
+    },
+    { interval: 1000, timeout: 20 * 1000 }
+  );
+};
+
+export async function handlePaymentIntentEvent(event: TEventExpanded, client: Stripe) {
+  const localIntentId = event.data.object.metadata?.id;
+  if (!localIntentId) {
+    // We only handle payment_intents created from subscriptions
+    if (event.type === 'payment_intent.created') {
+      if (event.data.object.invoice) {
+        await handleStripePaymentCreated(event, client);
+        return;
+      }
+    }
+
+    try {
+      await waitForStripePaymentMirrored(event.data.object.id);
+    } catch (err) {
+      logger.error('wait for stripe payment intent mirror error', { localIntentId, error: err });
+    }
+
+    logger.warn('local payment intent id not found in strip event', { localIntentId });
+    return;
+  }
+
+  const paymentIntent = await PaymentIntent.findByPk(localIntentId);
+  if (!paymentIntent) {
+    logger.warn('local payment intent not found', { localIntentId });
+    return;
+  }
+
+  logger.info('received payment intent event', { id: event.id, type: event.type, localIntentId });
+
+  if (event.type === 'payment_intent.succeeded') {
+    await handleStripePaymentSucceed(paymentIntent, event);
+    return;
+  }
+
+  if (event.type === 'payment_intent.canceled') {
+    await paymentIntent.update({
+      status: 'canceled',
+      canceled_at: event.data.object.canceled_at,
+      cancellation_reason: event.data.object.cancellation_reason,
+    });
+    logger.info('payment intent canceled on stripe event', { locale: paymentIntent.id });
+    return;
+  }
+
+  if (event.type === 'payment_intent.payment_failed') {
+    await paymentIntent.update({ status: 'requires_action' });
+    logger.info('payment intent failed on stripe event', { locale: paymentIntent.id });
+
+    if (paymentIntent.invoice_id) {
+      const invoice = await Invoice.findByPk(paymentIntent.invoice_id);
+      if (invoice) {
+        await invoice.update({
+          status: 'uncollectible',
+          attempt_count: invoice.attempt_count + 1,
+          attempted: true,
+          status_transitions: { ...invoice.status_transitions, marked_uncollectible_at: dayjs().unix() },
+        });
+      }
+    }
+  }
+}

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

@@ -0,0 +1,42 @@
+import type Stripe from 'stripe';
+
+import logger from '../../../libs/logger';
+import { CheckoutSession, Subscription, TEventExpanded } from '../../../store/models';
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export async function handleSetupIntentEvent(event: TEventExpanded, _: Stripe) {
+  const stripeIntentId = event.data.object.id;
+  const subscription = await Subscription.findOne({
+    where: { 'payment_details.stripe.setup_intent_id': stripeIntentId },
+  });
+
+  if (!subscription) {
+    logger.warn('local subscription not found for setup intent', { stripeIntentId });
+    return;
+  }
+
+  logger.info('received setup intent event', { id: event.id, type: event.type, subscriptionId: subscription.id });
+
+  if (event.type === 'setup_intent.succeeded') {
+    if (subscription.status === 'incomplete') {
+      await subscription.update({ status: subscription.trail_end ? 'trialing' : 'active' });
+      logger.info('subscription become active on stripe intent succeeded', subscription.id);
+    }
+
+    const checkoutSession = await CheckoutSession.findOne({ where: { subscription_id: subscription.id } });
+    if (checkoutSession && checkoutSession.status === 'open') {
+      await checkoutSession.update({ status: 'complete', payment_status: 'no_payment_required' });
+      logger.info('checkout session become complete on stripe intent succeeded', checkoutSession.id);
+    }
+
+    return;
+  }
+
+  if (event.type === 'setup_intent.canceled') {
+    // FIXME:
+  }
+
+  if (event.type === 'setup_intent.payment_failed') {
+    // FIXME:
+  }
+}

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

@@ -0,0 +1,61 @@
+import pick from 'lodash/pick';
+import type Stripe from 'stripe';
+
+import logger from '../../../libs/logger';
+import { CheckoutSession, Subscription, TEventExpanded } from '../../../store/models';
+
+export async function handleStripeSubscriptionSucceed(subscription: Subscription) {
+  await subscription.update({
+    status: 'active',
+  });
+  logger.info('subscription become active on stripe event', { id: subscription.id, status: subscription.status });
+
+  const checkoutSession = await CheckoutSession.findOne({ where: { payment_intent_id: subscription.id } });
+  if (checkoutSession) {
+    await checkoutSession.update({
+      status: 'complete',
+      payment_status: 'paid',
+      payment_details: subscription.payment_details,
+    });
+    logger.info('checkout session become complete on stripe event', { id: checkoutSession.id });
+  }
+}
+
+// https://stripe.com/docs/billing/subscriptions/webhooks#events
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export async function handleSubscriptionEvent(event: TEventExpanded, _: Stripe) {
+  const localSubscriptionId = event.data.object.metadata?.id;
+  if (!localSubscriptionId) {
+    logger.warn('local subscription id not found in strip event', { localSubscriptionId });
+    return;
+  }
+  const subscription = await Subscription.findByPk(localSubscriptionId);
+  if (!subscription) {
+    logger.warn('local subscription not found', { localSubscriptionId });
+    return;
+  }
+
+  logger.info('received subscription event', { id: event.id, type: event.type, localSubscriptionId });
+
+  if (event.type === 'customer.subscription.updated') {
+    if (event.data.previous_attributes?.status === 'incomplete' && event.data.object.status === 'active') {
+      await handleStripeSubscriptionSucceed(subscription);
+      return;
+    }
+
+    await subscription.update(
+      pick(event.data.object, ['cancel_at', 'cancel_at_period_end', 'canceled_at', 'pause_collection'])
+    );
+    return;
+  }
+
+  if (event.type === 'customer.subscription.deleted') {
+    await subscription.update({ status: 'canceled', ended_at: event.data.object.ended_at });
+    logger.info('subscription ended on stripe event', { id: subscription.id });
+  }
+
+  if (event.type === 'customer.subscription.paused') {
+    await subscription.update({ status: 'paused', pause_collection: event.data.object.pause_collection });
+    logger.info('subscription paused on stripe event', { id: subscription.id });
+  }
+}