payment-kit 1.13.24 → 1.13.25

package/README.md

@@ -15,3 +15,7 @@ The decentralized stripe for blocklet platform.
 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`
+
+### Test Stripe
+
+Invoices for subscriptions are not finalized automatically. You can use stripe postman collection to finalize it and then confirm the payment.

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

@@ -219,10 +219,10 @@ export async function handleInvoiceEvent(event: TEventExpanded, client: Stripe)
       try {
         await waitForStripeInvoiceMirrored(event.data.object.id);
       } catch (err) {
-        logger.error('wait for stripe invoice mirror error', { localInvoiceId, error: err });
+        logger.error('wait for stripe invoice mirror error', { id: event.id, type: event.type, error: err });
       }
 
-      logger.warn('local invoice id not found in strip event', { localInvoiceId });
+      logger.warn('local invoice id not found in strip event', { id: event.id, type: event.type });
       return;
     }
   }

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

@@ -123,10 +123,10 @@ export async function handlePaymentIntentEvent(event: TEventExpanded, client: St
     try {
       await waitForStripePaymentMirrored(event.data.object.id);
     } catch (err) {
-      logger.error('wait for stripe payment intent mirror error', { localIntentId, error: err });
+      logger.error('wait for stripe payment intent mirror error', { id: event.id, type: event.type, error: err });
     }
 
-    logger.warn('local payment intent id not found in strip event', { localIntentId });
+    logger.warn('local payment intent id not found in strip event', { id: event.id, type: event.type });
     return;
   }
 

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

@@ -11,7 +11,7 @@ export async function handleSetupIntentEvent(event: TEventExpanded, _: Stripe) {
   });
 
   if (!subscription) {
-    logger.warn('local subscription not found for setup intent', { stripeIntentId });
+    logger.warn('local subscription not found for setup intent', { id: event.id, type: event.type, stripeIntentId });
     return;
   }
 

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

@@ -26,12 +26,12 @@ export async function handleStripeSubscriptionSucceed(subscription: Subscription
 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 });
+    logger.warn('local subscription id not found in strip event', { id: event.id, type: event.type });
     return;
   }
   const subscription = await Subscription.findByPk(localSubscriptionId);
   if (!subscription) {
-    logger.warn('local subscription not found', { localSubscriptionId });
+    logger.warn('local subscription not found', { id: event.id, type: event.type, localSubscriptionId });
     return;
   }
 

package/api/src/routes/checkout-sessions.ts

@@ -61,7 +61,7 @@ const getPaymentTypes = async (items: any[]) => {
   return methods.map((x) => x.type);
 };
 
-const formatBeforeSave = async (payload: any, throwOnEmptyItems = true) => {
+export const formatCheckoutSession = async (payload: any, throwOnEmptyItems = true) => {
   const raw: Partial<CheckoutSession> = Object.assign(
     {
       allow_promotion_codes: false,
@@ -172,7 +172,7 @@ const formatBeforeSave = async (payload: any, throwOnEmptyItems = true) => {
 
 // create checkout session
 router.post('/', auth, async (req, res) => {
-  const raw: Partial<CheckoutSession> = await formatBeforeSave(req.body);
+  const raw: Partial<CheckoutSession> = await formatCheckoutSession(req.body);
   raw.livemode = !!req.livemode;
   raw.created_via = req.user?.via as string;
 
@@ -197,7 +197,7 @@ router.post('/start/:id', user, async (req, res) => {
 
   const items = await Price.expand(link.line_items);
 
-  const raw: Partial<CheckoutSession> = await formatBeforeSave(link, false);
+  const raw: Partial<CheckoutSession> = await formatCheckoutSession(link, false);
   raw.livemode = link.livemode;
   raw.created_via = 'portal';
   raw.currency_id = link.currency_id || req.currency.id;

package/api/src/routes/index.ts

@@ -11,6 +11,7 @@ import paymentIntents from './payment-intents';
 import paymentLinks from './payment-links';
 import paymentMethods from './payment-methods';
 import prices from './prices';
+import pricingTables from './pricing-table';
 import products from './products';
 import settings from './settings';
 import subscriptionItems from './subscription-items';
@@ -50,6 +51,7 @@ router.use('/payment-links', paymentLinks);
 router.use('/payment-methods', paymentMethods);
 router.use('/payment-currencies', paymentCurrencies);
 router.use('/prices', prices);
+router.use('/pricing-tables', pricingTables);
 router.use('/products', products);
 router.use('/settings', settings);
 router.use('/subscription-items', subscriptionItems);

package/api/src/routes/payment-links.ts

@@ -244,7 +244,6 @@ router.post('/stash', auth, async (req, res) => {
     raw.active = true;
     raw.livemode = !!req.livemode;
     raw.created_via = req.user?.via;
-    raw.created_via = 'portal';
     raw.currency_id = raw.currency_id || req.currency.id;
 
     let doc = await PaymentLink.findByPk(raw.id);

package/api/src/routes/pricing-table.ts

@@ -0,0 +1,342 @@
+import { getUrl } from '@blocklet/sdk/lib/component';
+import { Router } from 'express';
+import Joi from 'joi';
+import pick from 'lodash/pick';
+import uniq from 'lodash/uniq';
+import { Op, WhereOptions } from 'sequelize';
+
+import { authenticate } from '../libs/security';
+import { isLineItemCurrencyAligned } from '../libs/session';
+import { formatMetadata } from '../libs/util';
+import { CheckoutSession } from '../store/models/checkout-session';
+import { PaymentCurrency } from '../store/models/payment-currency';
+import { Price } from '../store/models/price';
+import { PricingTable } from '../store/models/pricing-table';
+import { Product } from '../store/models/product';
+import { formatCheckoutSession } from './checkout-sessions';
+
+const router = Router();
+const auth = authenticate<PricingTable>({ component: true, roles: ['owner', 'admin'] });
+
+const formatPricingTable = (payload: any) => {
+  const raw: Partial<PricingTable> = Object.assign(
+    {
+      branding_settings: {
+        background_color: '#ffffff',
+        border_style: 'default',
+        button_color: '#0074d4',
+        font_family: 'default',
+      },
+    },
+    pick(payload, ['name', 'items', 'metadata', 'brand_settings'])
+  );
+
+  raw.items = raw.items?.map((x) => {
+    const item = Object.assign(
+      {
+        adjustable_quantity: {
+          enabled: false,
+          maximum: 1,
+          minimum: 0,
+        },
+        after_completion: {
+          type: 'hosted_confirmation',
+          hosted_confirmation: {
+            custom_message: '',
+          },
+        },
+        allow_promotion_codes: false,
+        customer_creation: 'always',
+        consent_collection: {
+          promotions: 'none',
+          terms_of_service: 'none',
+        },
+        invoice_creation: {
+          enabled: true,
+        },
+        phone_number_collection: {
+          enabled: false,
+        },
+        billing_address_collection: 'auto',
+        subscription_data: {
+          description: '',
+          trial_period_days: 0,
+        },
+        submit_type: 'auto',
+      },
+      pick(x, [
+        'product_id',
+        'price_id',
+        'is_highlight',
+        'highlight_text',
+        'adjustable_quantity',
+        'after_completion',
+        'allow_promotion_codes',
+        'consent_collection',
+        'custom_fields',
+        'phone_number_collection',
+        'billing_address_collection',
+        'submit_type',
+        'subscription_data',
+      ])
+    );
+
+    if (item.adjustable_quantity?.enabled) {
+      item.adjustable_quantity.minimum = Number(item.adjustable_quantity?.minimum);
+      item.adjustable_quantity.maximum = Number(item.adjustable_quantity?.maximum);
+    }
+    if (item.after_completion?.type === 'hosted_confirmation') {
+      // @ts-ignore
+      item.after_completion.redirect = null;
+    }
+    if (item.after_completion?.type === 'redirect') {
+      // @ts-ignore
+      item.after_completion.hosted_confirmation = null;
+    }
+
+    return item;
+  });
+
+  if (payload.highlight && payload.highlight_product_id) {
+    raw.items?.forEach((x) => {
+      if (x.product_id === payload.highlight_product_id) {
+        x.is_highlight = x.product_id === payload.highlight_product_id;
+        x.highlight_text = payload.highlight_text || 'popular';
+      } else {
+        x.is_highlight = false;
+        x.highlight_text = 'popular';
+      }
+    });
+  }
+
+  raw.metadata = formatMetadata(raw.metadata);
+
+  return raw;
+};
+
+// FIXME: @wangshijun use schema validation
+// eslint-disable-next-line consistent-return
+router.post('/', auth, async (req, res) => {
+  const raw: Partial<PricingTable> = formatPricingTable(req.body);
+  raw.active = true;
+  raw.locked = false;
+  raw.livemode = !!req.livemode;
+  raw.created_via = req.user?.via;
+
+  if (!raw.items?.length) {
+    return res.status(400).json({ error: 'items should not be empty for pricing table' });
+  }
+
+  // @ts-ignore
+  const items = await Price.expand(raw.items);
+  for (let i = 0; i < items.length; i++) {
+    if (isLineItemCurrencyAligned(items, i) === false) {
+      return res.status(400).json({ error: 'items should have same currency' });
+    }
+  }
+
+  const link = await PricingTable.create(raw as PricingTable);
+
+  res.json(link);
+});
+
+// list pricing tables
+const paginationSchema = Joi.object<{
+  page: number;
+  pageSize: number;
+  active?: boolean;
+  livemode?: boolean;
+}>({
+  page: Joi.number().integer().min(1).default(1),
+  pageSize: Joi.number().integer().min(1).max(100).default(20),
+  active: Joi.boolean().empty(''),
+  livemode: Joi.boolean().empty(''),
+});
+router.get('/', auth, async (req, res) => {
+  const { page, pageSize, ...query } = await paginationSchema.validateAsync(req.query, { stripUnknown: true });
+  const where: WhereOptions<PricingTable> = { id: { [Op.notIn]: [`prctbl_${req.user?.did}`] } };
+
+  if (typeof query.active === 'boolean') {
+    where.active = query.active;
+  }
+  if (typeof query.livemode === 'boolean') {
+    where.livemode = query.livemode;
+  }
+
+  try {
+    const { rows: list, count } = await PricingTable.findAndCountAll({
+      where,
+      order: [['created_at', 'DESC']],
+      offset: (page - 1) * pageSize,
+      limit: pageSize,
+      include: [],
+    });
+
+    const priceIds: string[] = uniq(list.reduce((acc: string[], x) => acc.concat(x.items.map((i) => i.price_id)), []));
+    const prices = await Price.findAll({ where: { id: priceIds }, include: [{ model: Product, as: 'product' }] });
+    const products = await Product.findAll({ where: { id: uniq(prices.map((x) => x.product_id)) } });
+
+    list.forEach((x) => {
+      x.items.forEach((i) => {
+        // @ts-ignore
+        i.price = prices.find((p) => p.id === i.price_id);
+        // @ts-ignore
+        i.product = products.find((p) => p.id === i.product_id);
+      });
+    });
+
+    res.json({ count, list });
+  } catch (err) {
+    console.error(err);
+    res.json({ count: 0, list: [] });
+  }
+});
+
+// eslint-disable-next-line consistent-return
+router.get('/:id', async (req, res) => {
+  const doc = await PricingTable.findByPk(req.params.id);
+
+  if (!doc) {
+    return res.status(404).json({ error: 'pricing table not found' });
+  }
+
+  const prices = await Price.findAll({ where: { id: uniq(doc.items.map((x) => x.price_id)) } });
+  const products = await Product.findAll({ where: { id: uniq(doc.items.map((x) => x.product_id)) } });
+
+  doc.items.forEach((i) => {
+    // @ts-ignore
+    i.price = prices.find((p) => p.id === i.price_id);
+    // @ts-ignore
+    i.product = products.find((p) => p.id === i.product_id);
+  });
+
+  const currency = await PaymentCurrency.findOne({ where: { livemode: doc.livemode, is_base_currency: true } });
+
+  res.json({ ...doc.toJSON(), currency });
+});
+
+// update
+// eslint-disable-next-line consistent-return
+router.put('/:id', auth, async (req, res) => {
+  const doc = await PricingTable.findByPk(req.params.id);
+
+  if (!doc) {
+    return res.status(404).json({ error: 'pricing table not found' });
+  }
+  if (doc.active === false) {
+    return res.status(403).json({ error: 'pricing table archived' });
+  }
+  // if (doc.locked) {
+  //   return res.status(403).json({ error: 'pricing table locked' });
+  // }
+
+  // FIXME: should only allow update some fields
+  await doc.update(formatPricingTable(req.body));
+
+  res.json(doc);
+});
+
+// archive
+router.put('/:id/archive', auth, async (req, res) => {
+  const doc = await PricingTable.findByPk(req.params.id);
+
+  if (!doc) {
+    return res.status(404).json({ error: 'pricing table not found' });
+  }
+
+  if (doc.active === false) {
+    return res.status(403).json({ error: 'pricing table already archived' });
+  }
+
+  await doc.update({ active: false });
+  return res.json(doc);
+});
+
+// delete
+router.delete('/:id', auth, async (req, res) => {
+  const doc = await PricingTable.findByPk(req.params.id);
+
+  if (!doc) {
+    return res.status(404).json({ error: 'pricing table not found' });
+  }
+
+  if (doc.active === false) {
+    return res.status(403).json({ error: 'pricing table archived' });
+  }
+
+  if (doc.locked) {
+    return res.status(403).json({ error: 'pricing table locked' });
+  }
+
+  await doc.destroy();
+  return res.json(doc);
+});
+
+router.post('/stash', auth, async (req, res) => {
+  try {
+    const raw: Partial<PricingTable> = req.body;
+    raw.id = `prctbl_${req.user?.did}`;
+    raw.active = true;
+    raw.locked = false;
+    raw.livemode = !!req.livemode;
+    raw.created_via = req.user?.via;
+
+    let doc = await PricingTable.findByPk(raw.id);
+    if (doc) {
+      await doc.update(formatPricingTable(req.body));
+    } else {
+      doc = await PricingTable.create(raw as PricingTable);
+    }
+    res.json(doc);
+  } catch (err) {
+    console.error(err);
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// eslint-disable-next-line consistent-return
+router.post('/:id/checkout/:priceId', async (req, res) => {
+  const doc = await PricingTable.findByPk(req.params.id);
+
+  if (!doc) {
+    return res.status(404).json({ error: 'pricing table not found' });
+  }
+  if (doc.active === false) {
+    return res.status(403).json({ error: 'pricing table archived' });
+  }
+  if (doc.locked) {
+    return res.status(403).json({ error: 'pricing table locked' });
+  }
+
+  const price = await doc.items.find((x) => x.price_id === req.params.priceId);
+  if (!price) {
+    return res.status(403).json({ error: 'pricing table item not valid' });
+  }
+
+  const raw: Partial<CheckoutSession> = await formatCheckoutSession({
+    line_items: [{ price_id: price.price_id, quantity: 1, adjustable_quantity: price.adjustable_quantity }],
+    ...pick(price, [
+      'allow_promotion_codes',
+      'consent_collection',
+      'custom_fields',
+      'customer_creation',
+      'invoice_creation',
+      'phone_number_collection',
+      'billing_address_collection',
+      'submit_type',
+      'subscription_data',
+    ]),
+    metadata: {
+      pricing_table: doc.id,
+    },
+  });
+
+  raw.livemode = doc.livemode;
+  raw.created_via = 'portal';
+  raw.currency_id = req.currency.id;
+
+  const session = await CheckoutSession.create(raw as any);
+  res.json({ ...session.toJSON(), url: getUrl(`/checkout/pay/${session.id}`) });
+});
+
+export default router;

package/api/src/store/migrations/20231017-pricing-table.ts

@@ -0,0 +1,10 @@
+import type { Migration } from '../migrate';
+import models from '../models';
+
+export const up: Migration = async ({ context: queryInterface }) => {
+  await queryInterface.createTable('pricing_tables', models.PricingTable.GENESIS_ATTRIBUTES);
+};
+
+export const down: Migration = async ({ context: queryInterface }) => {
+  await queryInterface.dropTable('pricing_tables');
+};

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

@@ -11,13 +11,14 @@ import { PaymentIntent, TPaymentIntent } from './payment-intent';
 import { PaymentLink, TPaymentLink } from './payment-link';
 import { PaymentMethod, TPaymentMethod } from './payment-method';
 import { Price, TPrice } from './price';
+import { PricingTable, TPricingTable } from './pricing-table';
 import { Product, TProduct } from './product';
 import { PromotionCode } from './promotion-code';
 import { SetupIntent, TSetupIntent } from './setup-intent';
 import { Subscription, TSubscription } from './subscription';
 import { SubscriptionItem, TSubscriptionItem } from './subscription-item';
 import { SubscriptionSchedule } from './subscription-schedule';
-import type { LineItem } from './types';
+import type { LineItem, PricingTableItem } from './types';
 import { TUsageRecord, UsageRecord } from './usage-record';
 import { TWebhookAttempt, WebhookAttempt } from './webhook-attempt';
 import { TWebhookEndpoint, WebhookEndpoint } from './webhook-endpoint';
@@ -35,6 +36,7 @@ const models = {
   PaymentLink,
   PaymentMethod,
   Price,
+  PricingTable,
   Product,
   PromotionCode,
   SetupIntent,
@@ -71,6 +73,7 @@ export * from './payment-intent';
 export * from './payment-link';
 export * from './payment-method';
 export * from './price';
+export * from './pricing-table';
 export * from './product';
 export * from './promotion-code';
 export * from './setup-intent';
@@ -187,3 +190,13 @@ export type TUsageRecordSummary = {
 export type TSetupIntentExpanded = TSetupIntent & {
   object: 'setup_intent';
 };
+
+export type TPricingTableItem = PricingTableItem & {
+  price: TPrice;
+  product: TProduct;
+};
+
+export type TPricingTableExpanded = TPricingTable & {
+  items: TPricingTableItem[];
+  currency: TPaymentCurrency;
+};

package/api/src/store/models/pricing-table.ts

@@ -0,0 +1,107 @@
+/* eslint-disable @typescript-eslint/lines-between-class-members */
+import { CreationOptional, DataTypes, InferAttributes, InferCreationAttributes, Model } from 'sequelize';
+import type { LiteralUnion } from 'type-fest';
+
+import { createEvent } from '../../libs/audit';
+import { createIdGenerator } from '../../libs/util';
+import type { BrandSettings, PricingTableItem } from './types';
+
+const nextId = createIdGenerator('prctbl', 24);
+
+// @link https://stripe.com/docs/api/payment_links/payment_links
+export class PricingTable extends Model<InferAttributes<PricingTable>, InferCreationAttributes<PricingTable>> {
+  // Unique identifier for the object.
+  declare id: CreationOptional<string>;
+
+  // Whether the PricingTable is currently available for purchase.
+  declare active: boolean;
+  declare livemode: boolean;
+  declare locked: boolean;
+
+  declare name: string;
+
+  // The items representing what is being sold. Each line item represents an item being sold. Up to 20 line items are supported.
+  declare items: PricingTableItem[];
+
+  declare branding_settings: BrandSettings;
+
+  declare metadata?: Record<string, any>;
+
+  declare created_at: CreationOptional<Date>;
+  declare created_via: LiteralUnion<'api' | 'dashboard' | 'portal', string>;
+  declare updated_at: CreationOptional<Date>;
+
+  public static readonly GENESIS_ATTRIBUTES = {
+    id: {
+      type: DataTypes.STRING(42),
+      primaryKey: true,
+      allowNull: false,
+      defaultValue: nextId,
+    },
+    active: {
+      type: DataTypes.BOOLEAN,
+      allowNull: false,
+    },
+    livemode: {
+      type: DataTypes.BOOLEAN,
+      allowNull: false,
+    },
+    locked: {
+      type: DataTypes.BOOLEAN,
+      allowNull: false,
+    },
+    name: {
+      type: DataTypes.STRING(255),
+      allowNull: true,
+    },
+    items: {
+      type: DataTypes.JSON,
+      defaultValue: [],
+    },
+    branding_settings: {
+      type: DataTypes.JSON,
+      allowNull: false,
+    },
+    metadata: {
+      type: DataTypes.JSON,
+      allowNull: true,
+    },
+    created_at: {
+      type: DataTypes.DATE,
+      defaultValue: DataTypes.NOW,
+      allowNull: false,
+    },
+    created_via: {
+      type: DataTypes.ENUM('api', 'dashboard', 'portal'),
+    },
+    updated_at: {
+      type: DataTypes.DATE,
+      defaultValue: DataTypes.NOW,
+      allowNull: false,
+    },
+  };
+
+  public static initialize(sequelize: any) {
+    this.init(PricingTable.GENESIS_ATTRIBUTES, {
+      sequelize,
+      modelName: 'PricingTable',
+      tableName: 'pricing_tables',
+      createdAt: 'created_at',
+      updatedAt: 'updated_at',
+      hooks: {
+        afterCreate: (model: PricingTable, options) =>
+          createEvent('PricingTable', 'pricing_table.created', model, options).catch(console.error),
+        afterUpdate: (model: PricingTable, options) =>
+          createEvent('PricingTable', 'pricing_table.updated', model, options).catch(console.error),
+        afterDestroy: (model: PricingTable, options) =>
+          createEvent('PricingTable', 'pricing_table.deleted', model, options).catch(console.error),
+      },
+    });
+  }
+
+  public static associate() {
+    // Do nothing
+  }
+}
+
+export type TPricingTable = InferAttributes<PricingTable>;

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

@@ -262,6 +262,59 @@ export type PaymentDetails = {
   };
 };
 
+// Very similar to PaymentLink
+export type PricingTableItem = {
+  price_id: string;
+  product_id: string;
+
+  adjustable_quantity: {
+    enabled: boolean;
+    maximum: number;
+    minimum: number;
+  };
+
+  // The specified behavior after the purchase is complete.
+  after_completion?: AfterPayment;
+
+  // Enables user redeemable promotion codes.
+  allow_promotion_codes: boolean;
+
+  // Configuration for collecting the customer’s billing address.
+  billing_address_collection?: LiteralUnion<'auto' | 'required', string>;
+
+  is_highlight: boolean;
+  highlight_text?: LiteralUnion<'deal' | 'popular' | 'recommended', string>;
+
+  consent_collection?: {
+    promotions?: LiteralUnion<'auto' | 'none', string>;
+    terms_of_service?: LiteralUnion<'required' | 'none', string>;
+  };
+
+  // Collect additional information from your customer using custom fields. Up to 2 fields are supported.
+  custom_fields: CustomField[];
+
+  // Controls phone number collection settings during checkout.
+  phone_number_collection?: {
+    enabled: boolean;
+  };
+
+  // Describes the type of transaction being performed in order to customize relevant text
+  submit_type: LiteralUnion<'auto' | 'book' | 'donate' | 'pay', string>;
+
+  // When creating a subscription, the specified configuration data will be used.
+  subscription_data?: {
+    description: string;
+    trial_period_days: number;
+  };
+};
+
+export type BrandSettings = {
+  background_color: string;
+  border_style: string;
+  button_color: string;
+  font_family: string;
+};
+
 export type EventType = LiteralUnion<
   | 'account.application.authorized'
   | 'account.application.deauthorized'

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.24
+version: 1.13.25
 logo: logo.png
 files:
   - dist