payment-kit 1.21.12 → 1.21.14

package/api/src/routes/products.ts

@@ -37,6 +37,7 @@ const ProductAndPriceSchema = Joi.object({
   description: Joi.string().max(250).empty('').optional(),
   images: Joi.any().optional(),
   metadata: MetadataSchema,
+  tax_code: Joi.string().max(30).empty('').optional(),
   statement_descriptor: Joi.string()
     .max(22)
     .pattern(/^(?=.*[A-Za-z])[^\u4e00-\u9fa5<>"’\\]*$/)
@@ -92,6 +93,7 @@ export async function createProductAndPrices(payload: any) {
     'nft_factory',
     'features',
     'metadata',
+    'tax_code',
   ]);
 
   if (Array.isArray(payload.vendor_config) && payload.vendor_config.length > 0) {
@@ -431,6 +433,7 @@ router.put('/:id', auth, async (req, res) => {
     'nft_factory',
     'metadata',
     'cross_sell',
+    'tax_code',
   ]);
 
   if (Array.isArray(req.body.vendor_config)) {

package/api/src/routes/subscriptions.ts

@@ -538,7 +538,8 @@ router.put('/:id/recover', authPortal, async (req, res) => {
     cancel_at: 0,
   };
 
-  await updateStripeSubscription(doc, { ...updates, cancellation_details: null });
+  await updateStripeSubscription(doc, { cancel_at_period_end: false });
+  await updateStripeSubscription(doc, { cancel_at: null });
 
   // @ts-ignore
   await doc.update({

package/api/src/routes/tax-rates.ts

@@ -0,0 +1,220 @@
+import { Router } from 'express';
+import Joi from 'joi';
+
+import { CustomError } from '@blocklet/error';
+import { literal } from 'sequelize';
+import { authenticate } from '../libs/security';
+import { createListParamSchema, getOrder, getWhereFromKvQuery, MetadataSchema } from '../libs/api';
+import { formatMetadata } from '../libs/util';
+import { InvoiceItem, TaxRate } from '../store/models';
+
+const router = Router();
+const auth = authenticate({ component: true, roles: ['owner', 'admin'] });
+
+const createTaxRateSchema = Joi.object({
+  country: Joi.string().length(2).uppercase().required(),
+  state: Joi.string().max(50).empty('').optional(),
+  postal_code: Joi.string().max(20).empty('').optional(),
+  tax_code: Joi.string().max(20).empty('').optional(),
+  percentage: Joi.number().min(0).max(99.9999).required(),
+  display_name: Joi.string().max(100).required(),
+  description: Joi.string().max(500).empty('').optional(),
+  active: Joi.boolean().default(true),
+  metadata: MetadataSchema,
+}).unknown(true);
+
+const updateTaxRateSchema = Joi.object({
+  active: Joi.boolean().optional(),
+  percentage: Joi.number().min(0).max(99.9999).optional(),
+  display_name: Joi.string().max(100).optional(),
+  description: Joi.string().max(500).empty('').optional(),
+  metadata: MetadataSchema,
+}).unknown(true);
+
+const listSchema = createListParamSchema<{
+  country?: string;
+  state?: string;
+  active?: boolean;
+}>({
+  country: Joi.string().length(2).uppercase().optional(),
+  state: Joi.string().max(50).optional(),
+  active: Joi.boolean().optional(),
+});
+
+// List tax rates
+router.get('/', auth, async (req, res) => {
+  try {
+    const { error, value: validated } = listSchema.validate(req.query, { stripUnknown: true });
+    if (error) {
+      res.status(400).json({ error: `Validation error: ${error.message}` });
+      return;
+    }
+
+    const { page, pageSize, ...query } = validated;
+    const where = getWhereFromKvQuery(query.q);
+
+    if (typeof req.livemode === 'boolean') {
+      where.livemode = req.livemode;
+    }
+    if (query.country) {
+      where.country = query.country;
+    }
+    if (query.state) {
+      where.state = query.state;
+    }
+    if (typeof query.active === 'boolean') {
+      where.active = query.active;
+    }
+
+    const { rows: list, count } = await TaxRate.findAndCountAll({
+      where,
+      order: getOrder(req.query, [['created_at', 'DESC']]),
+      offset: (page - 1) * pageSize,
+      limit: pageSize,
+      attributes: {
+        include: [
+          [
+            literal(`(
+              SELECT COUNT(DISTINCT ii.invoice_id)
+              FROM invoice_items AS ii
+              WHERE ii.tax_rate_id = TaxRate.id
+            )`),
+            'invoice_count',
+          ],
+        ],
+      },
+    });
+
+    res.json({ count, list });
+  } catch (error) {
+    res.status(400).json({ error: error?.message });
+  }
+});
+
+// Get a specific tax rate
+router.get('/:id', auth, async (req, res) => {
+  const taxRate = await TaxRate.findOne({
+    where: {
+      id: req.params.id,
+      livemode: req.livemode,
+    },
+  });
+
+  if (!taxRate) {
+    throw new CustomError(404, 'Tax rate not found');
+  }
+
+  res.json(taxRate);
+});
+
+// Create a new tax rate
+router.post('/', auth, async (req, res) => {
+  const { error, value: data } = createTaxRateSchema.validate(req.body, { stripUnknown: true });
+  if (error) {
+    res.status(400).json({ error: `Validation failed: ${error.message}` });
+    return;
+  }
+
+  const existingRate = await TaxRate.findOne({
+    where: {
+      livemode: req.livemode,
+      country: data.country,
+      state: data.state || null,
+      postal_code: data.postal_code || null,
+      tax_code: data.tax_code || null,
+    },
+  });
+
+  if (existingRate) {
+    throw new CustomError(
+      400,
+      `Tax rate ${existingRate.id} already exists, you can create a new tax rate with different region or update the existing tax rate`
+    );
+  }
+
+  const taxRate = await TaxRate.create({
+    ...data,
+    livemode: req.livemode,
+    metadata: formatMetadata(data.metadata),
+  });
+
+  res.json(taxRate);
+});
+
+// Update a tax rate
+router.put('/:id', auth, async (req, res) => {
+  const { error, value: data } = updateTaxRateSchema.validate(req.body, { stripUnknown: true });
+  if (error) {
+    res.status(400).json({ error: `Validation failed: ${error.message}` });
+    return;
+  }
+
+  const taxRate = await TaxRate.findOne({
+    where: {
+      id: req.params.id,
+      livemode: req.livemode,
+    },
+  });
+
+  if (!taxRate) {
+    throw new CustomError(404, 'Tax rate not found');
+  }
+
+  await taxRate.update({
+    ...data,
+    metadata: data.metadata ? formatMetadata(data.metadata) : taxRate.metadata,
+  });
+
+  res.json(taxRate);
+});
+
+// Delete a tax rate
+router.delete('/:id', auth, async (req, res) => {
+  const taxRate = await TaxRate.findOne({
+    where: {
+      id: req.params.id,
+      livemode: req.livemode,
+    },
+  });
+
+  if (!taxRate) {
+    throw new CustomError(404, 'Tax rate not found');
+  }
+
+  const existInvoice = await InvoiceItem.findOne({ where: { tax_rate_id: taxRate.id } });
+  if (existInvoice) {
+    throw new CustomError(400, 'Tax rate is used in an invoice, you can not delete it');
+  }
+
+  await taxRate.destroy();
+
+  res.json({ deleted: true, id: req.params.id });
+});
+
+// Find matching tax rate for a given location and tax code
+router.post('/match', auth, async (req, res) => {
+  const schema = Joi.object({
+    country: Joi.string().length(2).uppercase().required(),
+    state: Joi.string().max(50).empty('').optional(),
+    postal_code: Joi.string().max(20).empty('').optional(),
+    tax_code: Joi.string().max(20).empty('').optional(),
+  });
+
+  const { error, value: data } = schema.validate(req.body, { stripUnknown: true });
+  if (error) {
+    res.status(400).json({ error: error.message });
+    return;
+  }
+
+  const matchedRate = await TaxRate.findMatchingRate({
+    country: data.country,
+    state: data.state,
+    postalCode: data.postal_code,
+    taxCode: data.tax_code,
+    livemode: req.livemode,
+  });
+
+  res.json(matchedRate);
+});
+
+export default router;

package/api/src/store/migrations/20251001-add-tax-code-to-products.ts

@@ -0,0 +1,20 @@
+import { DataTypes } from 'sequelize';
+import { safeApplyColumnChanges, type Migration } from '../migrate';
+
+export const up: Migration = async ({ context }) => {
+  await safeApplyColumnChanges(context, {
+    products: [
+      {
+        name: 'tax_code',
+        field: {
+          type: DataTypes.STRING(20),
+          allowNull: true,
+        },
+      },
+    ],
+  });
+};
+
+export const down: Migration = async ({ context }) => {
+  await context.removeColumn('products', 'tax_code');
+};

package/api/src/store/migrations/20251001-create-tax-rates.ts

@@ -0,0 +1,17 @@
+import { createIndexIfNotExists, type Migration } from '../migrate';
+import models from '../models';
+
+export const up: Migration = async ({ context }) => {
+  await context.createTable('tax_rates', models.TaxRate.GENESIS_ATTRIBUTES);
+
+  await createIndexIfNotExists(
+    context,
+    'tax_rates',
+    ['country', 'state', 'postal_code', 'tax_code'],
+    'tax_rates_query_index'
+  );
+};
+
+export const down: Migration = async ({ context }) => {
+  await context.dropTable('tax_rates');
+};

package/api/src/store/migrations/20251007-relate-tax-rate-to-invoice.ts

@@ -0,0 +1,24 @@
+import { DataTypes } from 'sequelize';
+import { createIndexIfNotExists, safeApplyColumnChanges, type Migration } from '../migrate';
+
+export const up: Migration = async ({ context }) => {
+  await safeApplyColumnChanges(context, {
+    invoice_items: [
+      {
+        name: 'tax_rate_id',
+        field: {
+          type: DataTypes.STRING(30),
+          allowNull: true,
+        },
+      },
+    ],
+  });
+  await createIndexIfNotExists(context, 'invoice_items', ['tax_rate_id'], 'idx_invoice_items_tax_rate_id');
+  await createIndexIfNotExists(context, 'invoice_items', ['invoice_id'], 'idx_invoice_items_invoice_id');
+};
+
+export const down: Migration = async ({ context }) => {
+  await context.removeColumn('invoice_items', 'tax_rate_id');
+  await context.removeIndex('invoice_items', 'idx_invoice_items_tax_rate_id');
+  await context.removeIndex('invoice_items', 'idx_invoice_items_invoice_id');
+};

package/api/src/store/migrations/20251009-add-tax-behavior.ts

@@ -0,0 +1,21 @@
+import { DataTypes } from 'sequelize';
+import { safeApplyColumnChanges, type Migration } from '../migrate';
+
+export const up: Migration = async ({ context }) => {
+  await safeApplyColumnChanges(context, {
+    prices: [
+      {
+        name: 'tax_behavior',
+        field: {
+          type: DataTypes.ENUM('inclusive', 'exclusive'),
+          allowNull: false,
+          defaultValue: 'inclusive',
+        },
+      },
+    ],
+  });
+};
+
+export const down: Migration = async ({ context }) => {
+  await context.removeColumn('prices', 'tax_behavior');
+};

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

@@ -33,6 +33,7 @@ import { Meter, TMeter } from './meter';
 import { MeterEvent, TMeterEvent } from './meter-event';
 import { AutoRechargeConfig } from './auto-recharge-config';
 import { ProductVendor } from './product-vendor';
+import { TaxRate } from './tax-rate';
 
 const models = {
   CheckoutSession,
@@ -69,6 +70,7 @@ const models = {
   MeterEvent,
   AutoRechargeConfig,
   ProductVendor,
+  TaxRate,
 };
 
 export function initialize(sequelize: any) {
@@ -119,6 +121,7 @@ export * from './meter';
 export * from './meter-event';
 export * from './auto-recharge-config';
 export * from './product-vendor';
+export * from './tax-rate';
 
 export type TPriceExpanded = TPrice & {
   object: 'price';

package/api/src/store/models/invoice-item.ts

@@ -32,6 +32,7 @@ export class InvoiceItem extends Model<InferAttributes<InvoiceItem>, InferCreati
   declare subscription_id?: string;
   declare subscription_item_id?: string;
   declare test_clock_id?: string;
+  declare tax_rate_id?: string;
 
   declare discountable: boolean;
   declare discount_amounts: DiscountAmount[];
@@ -106,6 +107,10 @@ export class InvoiceItem extends Model<InferAttributes<InvoiceItem>, InferCreati
       type: DataTypes.STRING(30),
       allowNull: true,
     },
+    tax_rate_id: {
+      type: DataTypes.STRING(30),
+      allowNull: true,
+    },
     discountable: {
       type: DataTypes.BOOLEAN,
       allowNull: false,
@@ -184,6 +189,11 @@ export class InvoiceItem extends Model<InferAttributes<InvoiceItem>, InferCreati
       foreignKey: 'id',
       as: 'subscriptionItem',
     });
+    this.hasOne(models.TaxRate, {
+      sourceKey: 'tax_rate_id',
+      foreignKey: 'id',
+      as: 'tax_rate',
+    });
   }
 
   public static async isPriceUsed(priceId: string) {

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

@@ -99,6 +99,8 @@ export class Price extends Model<InferAttributes<Price>, InferCreationAttributes
   // Quantity limit per checkout, 0 means no limit
   declare quantity_limit_per_checkout: number;
 
+  declare tax_behavior?: LiteralUnion<'inclusive' | 'exclusive', string>;
+
   public static readonly GENESIS_ATTRIBUTES = {
     id: {
       type: DataTypes.STRING(32),
@@ -211,6 +213,11 @@ export class Price extends Model<InferAttributes<Price>, InferCreationAttributes
           defaultValue: 0,
           allowNull: false,
         },
+        tax_behavior: {
+          type: DataTypes.ENUM('inclusive', 'exclusive'),
+          allowNull: false,
+          defaultValue: 'inclusive',
+        },
       },
       {
         sequelize,

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

@@ -47,6 +47,9 @@ export class Product extends Model<InferAttributes<Product>, InferCreationAttrib
   // If set, we will mint an nft to consumer on purchase
   declare nft_factory?: string;
 
+  // Tax code for this product (e.g., txcd_10103000)
+  declare tax_code?: string;
+
   declare cross_sell?: {
     cross_sells_to_id: string;
   };
@@ -128,6 +131,10 @@ export class Product extends Model<InferAttributes<Product>, InferCreationAttrib
       type: DataTypes.STRING(40),
       allowNull: true,
     },
+    tax_code: {
+      type: DataTypes.STRING(20),
+      allowNull: true,
+    },
     created_at: {
       type: DataTypes.DATE,
       defaultValue: DataTypes.NOW,