payment-kit 1.13.15

package/api/src/store/models/payment-method.ts

@@ -0,0 +1,169 @@
+/* eslint-disable @typescript-eslint/lines-between-class-members */
+import { CreationOptional, DataTypes, InferAttributes, InferCreationAttributes, Model } from 'sequelize';
+import type { LiteralUnion } from 'type-fest';
+
+import { createIdGenerator } from '../../libs/util';
+import { sequelize } from '../sequelize';
+
+const nextId = createIdGenerator('pm', 24);
+
+type StripeConfig = {
+  publishable_key: string;
+  secret_key: string;
+};
+
+type ArcblockConfig = {
+  chain_id: string;
+  api_host: string;
+  explorer_host: string;
+};
+
+type EthereumConfig = {
+  chain_id: number;
+  api_host: string;
+  explorer_host: string;
+};
+
+type BitcoinConfig = {
+  chain_id: number;
+  api_host: string;
+  explorer_host: string;
+};
+
+// eslint-disable-next-line prettier/prettier
+export class PaymentMethod extends Model<InferAttributes<PaymentMethod>, InferCreationAttributes<PaymentMethod>> {
+  // Unique identifier for the object.
+  declare id: CreationOptional<string>;
+
+  declare active: boolean;
+  declare livemode: boolean;
+  declare locked: boolean;
+
+  declare type: LiteralUnion<'stripe' | 'arcblock' | 'ethereum' | 'bitcoin', string>;
+
+  declare name: string;
+
+  declare description: string;
+
+  declare logo: string;
+
+  declare default_currency_id?: string;
+
+  // How do we confirm transactions
+  declare confirmation: {
+    type: LiteralUnion<'immediate' | 'callback' | 'block', string>;
+    block?: number;
+  };
+
+  // Extra settings to make the payment method work
+  declare settings: {
+    stripe?: StripeConfig;
+    arcblock?: ArcblockConfig;
+    ethereum?: EthereumConfig;
+    bitcoin?: BitcoinConfig;
+  };
+
+  // What features are supported
+  declare features: {
+    recurring: boolean;
+    refund: boolean;
+    dispute: boolean;
+  };
+
+  declare metadata: Record<string, any>;
+
+  declare created_at: CreationOptional<Date>;
+
+  declare updated_at: CreationOptional<Date>;
+
+  public static readonly GENESIS_ATTRIBUTES = {
+    id: {
+      type: DataTypes.STRING(30),
+      primaryKey: true,
+      allowNull: false,
+      defaultValue: nextId,
+    },
+    active: {
+      type: DataTypes.BOOLEAN,
+      allowNull: false,
+    },
+    livemode: {
+      type: DataTypes.BOOLEAN,
+      allowNull: false,
+    },
+    locked: {
+      type: DataTypes.BOOLEAN,
+      defaultValue: false,
+    },
+    type: {
+      type: DataTypes.ENUM('stripe', 'arcblock', 'ethereum', 'bitcoin'),
+    },
+    name: {
+      type: DataTypes.STRING(64),
+    },
+    description: {
+      type: DataTypes.STRING(512),
+    },
+    logo: {
+      type: DataTypes.STRING(512),
+    },
+    default_currency_id: {
+      type: DataTypes.STRING(15),
+      allowNull: true,
+    },
+    confirmation: {
+      type: DataTypes.JSON,
+      allowNull: false,
+    },
+    settings: {
+      type: DataTypes.JSON,
+      allowNull: false,
+    },
+    features: {
+      type: DataTypes.JSON,
+      allowNull: false,
+    },
+    metadata: {
+      type: DataTypes.JSON,
+      allowNull: true,
+    },
+    created_at: {
+      type: DataTypes.DATE,
+      defaultValue: DataTypes.NOW,
+      allowNull: false,
+    },
+    updated_at: {
+      type: DataTypes.DATE,
+      defaultValue: DataTypes.NOW,
+      allowNull: false,
+    },
+  };
+
+  // eslint-disable-next-line @typescript-eslint/no-shadow
+  public static initialize(sequelize: any) {
+    this.init(PaymentMethod.GENESIS_ATTRIBUTES, {
+      sequelize,
+      modelName: 'PaymentMethod',
+      tableName: 'payment_methods',
+      createdAt: 'created_at',
+      updatedAt: 'updated_at',
+    });
+  }
+
+  public static associate(models: any) {
+    this.hasMany(models.PaymentCurrency, {
+      foreignKey: 'payment_method_id',
+      as: 'payment_currencies',
+    });
+  }
+
+  public static expand(livemode?: boolean) {
+    return PaymentMethod.findAll({
+      where: { livemode: !!livemode },
+      order: [['created_at', 'DESC']],
+      include: [{ model: sequelize.models.PaymentCurrency, as: 'payment_currencies' }],
+    });
+  }
+}
+
+export type TPaymentMethod = InferAttributes<PaymentMethod>;

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

@@ -0,0 +1,266 @@
+import isEmpty from 'lodash/isEmpty';
+import {
+  CreationOptional,
+  DataTypes,
+  FindOptions,
+  InferAttributes,
+  InferCreationAttributes,
+  Model,
+  Op,
+} from 'sequelize';
+import type { LiteralUnion } from 'type-fest';
+
+import { createEvent } from '../../libs/audit';
+import { createIdGenerator, formatMetadata } from '../../libs/util';
+import { sequelize } from '../sequelize';
+import type { CustomUnitAmount, LineItem, PriceRecurring, PriceTier, TransformQuantity } from './types';
+
+const nextId = createIdGenerator('price', 24);
+
+// @link https://stripe.com/docs/api/prices
+export class Price extends Model<InferAttributes<Price>, InferCreationAttributes<Price>> {
+  // Unique identifier for the object.
+  declare id: CreationOptional<string>;
+
+  // the product id
+  declare product_id: string;
+
+  // A brief description of the price, hidden from customers.
+  declare nickname?: string;
+
+  // Whether the price can be used for new purchases.
+  declare active: boolean;
+  declare livemode: boolean;
+  declare locked: CreationOptional<boolean>;
+
+  // One of one_time or recurring depending on whether the price is for a one-time purchase or a recurring (subscription) purchase.
+  declare type: LiteralUnion<'one_time' | 'recurring', string>;
+
+  // Describes how to compute the price per period.
+  declare billing_scheme: LiteralUnion<'per_unit' | 'tiered', string>;
+
+  // The unit amount in big number to be charged, represented as a whole integer if possible
+  declare unit_amount: string;
+
+  // The recurring components of a price such as interval and usage_type.
+  declare recurring?: PriceRecurring;
+
+  // Defines if the tiering price should be graduated or volume based.
+  declare tiers_mode?: LiteralUnion<'graduated' | 'volume', string>;
+
+  // Each element represents a pricing tier. This parameter requires billing_scheme to be set to tiered
+  declare tiers?: PriceTier[];
+
+  // When set, provides configuration for the amount to be adjusted by the customer during Checkout Sessions and Payment Links.
+  declare custom_unit_amount?: CustomUnitAmount;
+
+  // A lookup key used to retrieve prices dynamically from a static string
+  declare lookup_key?: string;
+
+  // Set of key-value pairs that you can attach to an object.
+  declare metadata: Record<string, any>;
+
+  declare transform_quantity?: TransformQuantity;
+
+  // Payment currency id
+  declare currency_id: string;
+
+  declare upsell?: {
+    upsells_to_id: string;
+  };
+
+  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(32),
+      primaryKey: true,
+      allowNull: false,
+      defaultValue: nextId,
+    },
+    product_id: {
+      type: DataTypes.STRING(32),
+      allowNull: false,
+    },
+    nickname: {
+      type: DataTypes.STRING(512),
+    },
+    active: {
+      type: DataTypes.BOOLEAN,
+      allowNull: false,
+    },
+    livemode: {
+      type: DataTypes.BOOLEAN,
+      allowNull: false,
+    },
+    locked: {
+      type: DataTypes.BOOLEAN,
+      defaultValue: false,
+    },
+    type: {
+      type: DataTypes.ENUM('one_time', 'recurring'),
+    },
+    billing_scheme: {
+      type: DataTypes.ENUM('per_unit', 'tiered'),
+    },
+    unit_amount: {
+      type: DataTypes.STRING(32),
+      allowNull: false,
+    },
+    recurring: {
+      type: DataTypes.JSON,
+      allowNull: true,
+    },
+    tiers_mode: {
+      type: DataTypes.ENUM('graduated', 'volume'),
+      allowNull: true,
+    },
+    tiers: {
+      type: DataTypes.JSON,
+      allowNull: true,
+    },
+    custom_unit_amount: {
+      type: DataTypes.JSON,
+      allowNull: true,
+    },
+    lookup_key: {
+      type: DataTypes.STRING(128),
+      allowNull: true,
+    },
+    metadata: {
+      type: DataTypes.JSON,
+      allowNull: true,
+    },
+    transform_quantity: {
+      type: DataTypes.JSON,
+      allowNull: true,
+    },
+    currency_id: {
+      type: DataTypes.STRING(16),
+    },
+    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,
+    },
+  };
+
+  // eslint-disable-next-line @typescript-eslint/no-shadow
+  public static initialize(sequelize: any) {
+    this.init(Price.GENESIS_ATTRIBUTES, {
+      sequelize,
+      modelName: 'Price',
+      tableName: 'prices',
+      createdAt: 'created_at',
+      updatedAt: 'updated_at',
+      hooks: {
+        afterCreate: (model: Price, options) =>
+          createEvent('Price', 'price.created', model, options).catch(console.error),
+        afterUpdate: (model: Price, options) =>
+          createEvent('Price', 'price.updated', model, options).catch(console.error),
+        afterDestroy: (model: Price, options) =>
+          createEvent('Price', 'price.deleted', model, options).catch(console.error),
+      },
+    });
+  }
+
+  public static associate(models: any) {
+    this.hasOne(models.Product, {
+      sourceKey: 'product_id',
+      foreignKey: 'id',
+      as: 'product',
+    });
+    this.hasOne(models.PaymentCurrency, {
+      sourceKey: 'currency_id',
+      foreignKey: 'id',
+      as: 'currency',
+    });
+  }
+
+  public static getModel(price: TPrice) {
+    if (price.billing_scheme === 'tiered') {
+      return price.tiers_mode;
+    }
+
+    if (price.transform_quantity) {
+      return 'package';
+    }
+
+    return 'standard';
+  }
+
+  public static format(price: Partial<TPrice & { model: string }>) {
+    if (price.type === 'recurring') {
+      if (price.recurring) {
+        price.recurring.usage_type = price.recurring?.metered ? 'metered' : 'licensed';
+      } else {
+        throw new Error('recurring config is required for recurring prices');
+      }
+    } else {
+      price.recurring = undefined;
+    }
+
+    if (price.model && ['graduated', 'volume'].includes(price.model)) {
+      price.billing_scheme = 'tiered';
+      price.tiers_mode = price.model;
+      if (isEmpty(price.tiers)) {
+        throw new Error('tiers is required for graduated and volume prices');
+      }
+    } else {
+      price.billing_scheme = 'per_unit';
+      delete price.tiers;
+    }
+
+    if (price.model !== 'package') {
+      delete price.transform_quantity;
+    }
+
+    price.metadata = formatMetadata(price.metadata);
+
+    return price;
+  }
+
+  public static async expand(items: LineItem[], deep: boolean = true): Promise<(LineItem & { price: TPrice })[]> {
+    const priceIds: string[] = items.map((i) => i.price_id);
+    const prices = await Price.findAll({
+      where: { id: priceIds },
+      include: deep ? [{ model: sequelize.models.Product, as: 'product' }] : [],
+    });
+
+    return items.map((x) => ({
+      ...x,
+      price: prices.find((p) => p.id === x.price_id),
+    })) as (LineItem & { price: TPrice })[];
+  }
+
+  public static async insert(price: TPrice & { model: string }) {
+    if (price.lookup_key) {
+      const exist = await this.count({ where: { lookup_key: price.lookup_key } });
+      if (exist) {
+        throw new Error('lookup_key already exists');
+      }
+    }
+
+    // @ts-ignore
+    return this.create(this.format(price));
+  }
+
+  public static findByPkOrLookupKey(id: string, options: FindOptions<Price> = {}) {
+    return this.findOne({
+      where: { [Op.or]: [{ id }, { lookup_key: id }] },
+      ...options,
+    });
+  }
+}
+
+export type TPrice = InferAttributes<Price>;

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

@@ -0,0 +1,162 @@
+/* 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';
+
+const nextId = createIdGenerator('prod', 14);
+
+export type ProductFeature = { name: string };
+
+// FIXME: default_price_id is not implemented
+// @link https://stripe.com/docs/api/products
+export class Product extends Model<InferAttributes<Product>, InferCreationAttributes<Product>> {
+  // Unique identifier for the object.
+  declare id: CreationOptional<string>;
+
+  // Whether the product is currently available for purchase.
+  declare active: boolean;
+  declare livemode: boolean;
+  declare locked: CreationOptional<boolean>;
+
+  declare type: LiteralUnion<'service' | 'good', string>;
+
+  // The product’s name, meant to be displayable to the customer.
+  declare name: string;
+
+  // The product’s description, meant to be displayable to the customer.
+  declare description: string;
+
+  // A list of up to 8 URLs of images for this product, meant to be displayable to the customer.
+  declare images: any[];
+
+  // A list of up to 15 features for this product. These are displayed in pricing tables.
+  declare features: ProductFeature[];
+
+  // A label that represents units of this product.
+  declare unit_label?: string;
+
+  // The ID of the Price object that is the default price for this product.
+  declare default_price_id?: string;
+
+  declare metadata?: Record<string, any>;
+
+  declare statement_descriptor?: string;
+
+  // If set, we will mint an nft to consumer on purchase
+  declare nft_factory?: string;
+
+  // TODO: goods related props are not supported
+  // declare package_dimensions?: any;
+  // declare shippable?: boolean;
+
+  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(18),
+      primaryKey: true,
+      allowNull: false,
+      defaultValue: nextId,
+    },
+    active: {
+      type: DataTypes.BOOLEAN,
+      allowNull: false,
+    },
+    livemode: {
+      type: DataTypes.BOOLEAN,
+      allowNull: false,
+    },
+    locked: {
+      type: DataTypes.BOOLEAN,
+      defaultValue: false,
+    },
+    type: {
+      type: DataTypes.ENUM('service', 'good'),
+    },
+    name: {
+      type: DataTypes.STRING(512),
+    },
+    description: {
+      type: DataTypes.STRING(2048),
+    },
+    images: {
+      type: DataTypes.JSON,
+      defaultValue: [],
+    },
+    features: {
+      type: DataTypes.JSON,
+      defaultValue: [],
+    },
+    unit_label: {
+      type: DataTypes.STRING(32),
+      allowNull: true,
+    },
+    default_price_id: {
+      type: DataTypes.STRING(32),
+      allowNull: true,
+    },
+    metadata: {
+      type: DataTypes.JSON,
+      allowNull: true,
+    },
+    statement_descriptor: {
+      type: DataTypes.STRING(32),
+      allowNull: true,
+    },
+    nft_factory: {
+      type: DataTypes.STRING(40),
+      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(Product.GENESIS_ATTRIBUTES, {
+      sequelize,
+      modelName: 'Product',
+      tableName: 'products',
+      createdAt: 'created_at',
+      updatedAt: 'updated_at',
+      hooks: {
+        afterCreate: (model: Product, options) =>
+          createEvent('Product', 'product.created', model, options).catch(console.error),
+        afterUpdate: (model: Product, options) =>
+          createEvent('Product', 'product.updated', model, options).catch(console.error),
+        afterDestroy: (model: Product, options) =>
+          createEvent('Product', 'product.deleted', model, options).catch(console.error),
+      },
+    });
+  }
+
+  public static associate(models: any) {
+    this.hasMany(models.Price, {
+      foreignKey: 'product_id',
+      as: 'prices',
+    });
+    this.hasOne(models.Price, {
+      sourceKey: 'default_price_id',
+      foreignKey: 'id',
+      as: 'default_price',
+    });
+  }
+}
+
+export type TProduct = InferAttributes<Product>;

package/api/src/store/models/promotion-code.ts

@@ -0,0 +1,112 @@
+/* eslint-disable @typescript-eslint/lines-between-class-members */
+import { CreationOptional, DataTypes, InferAttributes, InferCreationAttributes, Model } from 'sequelize';
+
+import { createIdGenerator } from '../../libs/util';
+
+const nextId = createIdGenerator('promo', 24);
+
+// @link https://stripe.com/docs/api/promotion_codes
+// eslint-disable-next-line prettier/prettier
+export class PromotionCode extends Model<InferAttributes<PromotionCode>, InferCreationAttributes<PromotionCode>> {
+  declare id: CreationOptional<string>;
+  declare livemode: boolean;
+  declare active: boolean;
+
+  declare code: string;
+
+  declare coupon_id: string;
+
+  // redeem conditions
+  declare max_redemptions?: number;
+  declare restrictions?: {
+    currency_options?: Record<string, number>;
+    first_time_transaction?: boolean;
+    minimum_amount?: number;
+    minimum_amount_currency?: string;
+  };
+  declare customer_id?: string;
+
+  declare times_redeemed?: number;
+
+  declare expires_at: CreationOptional<Date>;
+  declare created_at: CreationOptional<Date>;
+  declare updated_at: CreationOptional<Date>;
+
+  public static readonly GENESIS_ATTRIBUTES = {
+    id: {
+      type: DataTypes.STRING(30),
+      primaryKey: true,
+      allowNull: false,
+      defaultValue: nextId,
+    },
+    livemode: {
+      type: DataTypes.BOOLEAN,
+      allowNull: false,
+    },
+    active: {
+      type: DataTypes.BOOLEAN,
+      defaultValue: true,
+    },
+    code: {
+      type: DataTypes.STRING(16),
+      allowNull: false,
+    },
+    coupon_id: {
+      type: DataTypes.STRING(30),
+      allowNull: true,
+    },
+    max_redemptions: {
+      type: DataTypes.INTEGER,
+      allowNull: true,
+    },
+    restrictions: {
+      type: DataTypes.JSON,
+      defaultValue: {},
+    },
+    customer_id: {
+      type: DataTypes.STRING(30),
+      allowNull: true,
+    },
+    times_redeemed: {
+      type: DataTypes.INTEGER,
+      defaultValue: 0,
+    },
+    metadata: {
+      type: DataTypes.JSON,
+      allowNull: true,
+    },
+    expires_at: {
+      type: DataTypes.DATE,
+      allowNull: true,
+    },
+    created_at: {
+      type: DataTypes.DATE,
+      defaultValue: DataTypes.NOW,
+      allowNull: false,
+    },
+    updated_at: {
+      type: DataTypes.DATE,
+      defaultValue: DataTypes.NOW,
+      allowNull: false,
+    },
+  };
+
+  public static initialize(sequelize: any) {
+    this.init(PromotionCode.GENESIS_ATTRIBUTES, {
+      sequelize,
+      modelName: 'PromotionCode',
+      tableName: 'promotion_codes',
+      createdAt: 'created_at',
+      updatedAt: 'updated_at',
+    });
+  }
+
+  public static associate(models: any) {
+    this.belongsTo(models.Coupon, {
+      foreignKey: 'coupon_id',
+      as: 'coupon',
+    });
+  }
+}
+
+export type TPromotionCode = InferAttributes<PromotionCode>;