payment-kit 1.13.15

package/api/src/jobs/subscription.ts

@@ -0,0 +1,301 @@
+import { BN } from '@ocap/util';
+import type { LiteralUnion } from 'type-fest';
+
+import dayjs from '../libs/dayjs';
+import logger from '../libs/logger';
+import createQueue from '../libs/queue';
+import { getStatementDescriptor, getSubscriptionCycleAmount, getSubscriptionCycleSetup } from '../libs/session';
+import { UsageRecord } from '../store/models';
+import { Customer } from '../store/models/customer';
+import { Invoice } from '../store/models/invoice';
+import { InvoiceItem } from '../store/models/invoice-item';
+import { Price } from '../store/models/price';
+import { Subscription } from '../store/models/subscription';
+import { SubscriptionItem } from '../store/models/subscription-item';
+import { invoiceQueue } from './invoice';
+
+type SubscriptionJob = {
+  subscriptionId: string;
+  action?: LiteralUnion<'cycle' | 'cancel' | 'pause' | 'resume', string>;
+};
+
+// generate invoice for subscription periodically
+export const handleSubscription = async (job: SubscriptionJob) => {
+  logger.info('handleSubscription', job);
+
+  const subscription = await Subscription.findByPk(job.subscriptionId);
+  if (!subscription) {
+    logger.warn(`Subscription not found: ${job.subscriptionId}`);
+    return;
+  }
+  if (['trialing', 'active', 'paused'].includes(subscription.status) === false) {
+    logger.warn(`Subscription status not expected: ${job.subscriptionId}`);
+    return;
+  }
+
+  const now = dayjs().unix();
+
+  // Do we need to cancel the subscription
+  if (subscription.status === 'active') {
+    if (subscription.cancel_at_period_end) {
+      await subscription.update({ status: 'canceled', canceled_at: now });
+      logger.warn(`Subscription canceled on period end: ${job.subscriptionId}`);
+      return;
+    }
+    if (subscription.cancel_at && subscription.cancel_at <= now) {
+      await subscription.update({ status: 'canceled', canceled_at: now });
+      logger.warn(`Subscription canceled on schedule: ${job.subscriptionId}`);
+      return;
+    }
+  }
+
+  // Do we need to resume the subscription
+  if (
+    subscription.status === 'paused' &&
+    subscription.pause_collection?.resumes_at &&
+    subscription.pause_collection?.resumes_at <= now
+  ) {
+    await subscription.update({ status: 'active', pause_collection: undefined });
+    logger.warn(`Subscription resumed as scheduled: ${job.subscriptionId}`);
+  }
+
+  // can we create new invoice for this subscription?
+  if (subscription.status === 'trialing' && subscription.trail_end && subscription.trail_end > now) {
+    logger.warn(`Subscription trialing period not ended: ${job.subscriptionId}`);
+    subscriptionQueue.push({
+      id: subscription.id,
+      job: { subscriptionId: subscription.id, action: 'cycle' },
+      runAt: subscription.trail_end,
+    });
+    return;
+  }
+  if (subscription.status === 'active' && subscription.current_period_end > now) {
+    logger.warn(`Subscription current period not ended: ${job.subscriptionId}`);
+    subscriptionQueue.push({
+      id: subscription.id,
+      job: { subscriptionId: subscription.id, action: 'cycle' },
+      runAt: subscription.current_period_end,
+    });
+    return;
+  }
+
+  // Do we still have the customer
+  const customer = await Customer.findByPk(subscription.customer_id);
+  if (!customer) {
+    logger.warn(`Customer ${subscription.customer_id} not found for subscription: ${subscription.id}`);
+    return;
+  }
+
+  // get setup for next subscription period
+  const previousPeriodEnd =
+    subscription.status === 'trialing' ? subscription.trail_end : subscription.current_period_end;
+  const setup = getSubscriptionCycleSetup(subscription.pending_invoice_item_interval, previousPeriodEnd as number);
+
+  // check if invoice already created
+  const exist = await Invoice.findOne({
+    where: {
+      subscription_id: subscription.id,
+      period_start: setup.period.start,
+      period_end: setup.period.end,
+    },
+  });
+  if (exist) {
+    logger.warn(`Invoice already created for subscription ${subscription.id} for next billing cycle: ${exist.id}`);
+    return;
+  }
+
+  // set invoice status if subscription paused
+  let status = 'open';
+  if (subscription.status === 'paused') {
+    if (subscription.pause_collection?.behavior === 'mark_uncollectible') {
+      status = 'uncollectible';
+    }
+    if (subscription.pause_collection?.behavior === 'void') {
+      status = 'void';
+    }
+    if (subscription.pause_collection?.behavior === 'keep_as_draft') {
+      status = 'draft';
+    }
+  }
+
+  // expand subscription items
+  const subscriptionItems = await SubscriptionItem.findAll({ where: { subscription_id: subscription.id } });
+  let expandedItems = await Price.expand(
+    subscriptionItems.map((x) => ({ id: x.id, price_id: x.price_id, quantity: x.quantity })),
+    true
+  );
+
+  // get usage summaries for this billing cycle
+  expandedItems = await Promise.all(
+    expandedItems.map(async (x: any) => {
+      // For metered billing, we need to get usage summary for this billing cycle
+      // @link https://stripe.com/docs/products-prices/pricing-models#usage-types
+      if (x.price.recurring?.usage_type === 'metered') {
+        const duration = setup.cycle / 1000;
+        x.quantity = await UsageRecord.getSummary(
+          x.id,
+          // FIXME: this causes inconsistency when subscription is paused or billing_cycle_anchor reset
+          setup.period.start - duration,
+          setup.period.end - duration,
+          x.price.recurring?.aggregate_usage
+        );
+        logger.info('Invoice.usageRecordSummary', {
+          subscriptionId: subscription.id,
+          subscriptionItemId: x.id,
+          priceId: x.price_id,
+          quantity: x.quantity,
+          start: setup.period.start - duration,
+          end: setup.period.end - duration,
+          usage: x.price.recurring?.aggregate_usage,
+        });
+      }
+
+      return x;
+    })
+  );
+
+  const amount = getSubscriptionCycleAmount(expandedItems);
+
+  // create invoice
+  const invoice = await Invoice.create({
+    livemode: subscription.livemode,
+    number: await customer.getInvoiceNumber(),
+    description: 'Subscription cycle',
+    statement_descriptor: getStatementDescriptor(expandedItems),
+    period_start: subscription.current_period_start,
+    period_end: subscription.current_period_end,
+
+    auto_advance: true,
+    paid: false,
+    paid_out_of_band: false,
+
+    status,
+    collection_method: 'charge_automatically',
+    billing_reason: 'subscription_cycle',
+
+    currency_id: subscription.currency_id,
+    customer_id: customer.id,
+    payment_intent_id: '',
+    subscription_id: subscription?.id,
+    checkout_session_id: '',
+
+    subtotal: amount.total,
+    subtotal_excluding_tax: amount.total,
+    tax: '0',
+    total: amount.total,
+    amount_due: amount.total,
+    amount_paid: '0',
+    amount_remaining: amount.total,
+    amount_shipping: '0',
+
+    starting_balance: '0',
+    ending_balance: '0',
+
+    attempt_count: 0,
+    attempted: false,
+    // next_payment_attempt: undefined,
+
+    custom_fields: [],
+    customer_address: customer.address,
+    customer_email: customer.email,
+    customer_name: customer.name,
+    customer_phone: customer.phone,
+
+    discounts: [],
+    total_discount_amounts: [],
+
+    due_date: undefined, // The date on which payment for this invoice is due
+    effective_at: dayjs().unix(), // The date when this invoice is in effect
+    status_transitions: {
+      finalized_at: dayjs().unix(),
+    },
+
+    payment_settings: subscription.payment_settings,
+    default_payment_method_id: subscription.default_payment_method_id as string,
+
+    account_country: '',
+    account_name: '',
+    metadata: {},
+  });
+  logger.info(`Invoice created for subscription ${subscription.id}: ${invoice.id}`);
+
+  // create invoice items
+  await Promise.all(
+    expandedItems.map((x: any) =>
+      InvoiceItem.create({
+        livemode: subscription.livemode,
+        amount: new BN(x.price.unit_amount).mul(new BN(x.quantity)).toString(),
+        quantity: x.quantity,
+        description: x.price.product.name,
+        period: { start: setup.period.start, end: setup.period.end },
+        currency_id: subscription.currency_id,
+        customer_id: customer.id,
+        price_id: x.price_id,
+        invoice_id: invoice.id,
+        subscription_id: subscription.id,
+        subscription_item_id: subscriptionItems.find((si) => si.price_id === x.price_id)?.id,
+        discountable: false,
+        discounts: [],
+        discount_amounts: [],
+        proration: false,
+        proration_details: {},
+        metadata: {},
+      })
+    )
+  );
+
+  // schedule invoice job
+  invoiceQueue.push({ id: invoice.id, job: { invoiceId: invoice.id, retryOnError: true } });
+  logger.info(`Invoice job scheduled for new billing cycle: ${invoice.id}`);
+
+  // persist invoice id
+  await subscription.update({
+    latest_invoice_id: invoice.id,
+    current_period_start: setup.period.start,
+    current_period_end: setup.period.end,
+  });
+  logger.info(`Subscription updated for new billing cycle: ${subscription.id}`);
+
+  // schedule next billing cycle if we are not cancelling
+  if (!subscription.cancel_at_period_end) {
+    subscriptionQueue.push({
+      id: subscription.id,
+      job: { subscriptionId: subscription.id, action: 'cycle' },
+      runAt: setup.period.end,
+    });
+    logger.info(`Subscription job scheduled for next billing cycle: ${subscription.id}`);
+  }
+};
+
+export const subscriptionQueue = createQueue<SubscriptionJob>({
+  name: 'subscription',
+  onJob: handleSubscription,
+  options: {
+    concurrency: 1,
+    maxRetries: 5,
+    enableScheduledJob: true,
+  },
+});
+
+export const startSubscriptionQueue = async () => {
+  const subscriptions = await Subscription.findAll({
+    where: {
+      status: ['trialing', 'active', 'paused'],
+    },
+  });
+
+  subscriptions.forEach(async (x) => {
+    const exist = await subscriptionQueue.get(x.id);
+    if (!exist) {
+      subscriptionQueue.push({
+        id: x.id,
+        job: { subscriptionId: x.id, action: 'cycle' },
+        runAt: x.current_period_end,
+      });
+    }
+  });
+};
+
+subscriptionQueue.on('failed', ({ id, job, error }) => {
+  logger.error('Subscription job failed', { id, job, error });
+});

package/api/src/jobs/webhook.ts

@@ -0,0 +1,113 @@
+import { sign } from '@blocklet/sdk/lib/util/verify-sign';
+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 { Event } from '../store/models/event';
+import { WebhookAttempt } from '../store/models/webhook-attempt';
+import { WebhookEndpoint } from '../store/models/webhook-endpoint';
+
+type WebhookJob = {
+  eventId: string;
+  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);
+
+  const event = await Event.findByPk(job.eventId);
+  if (!event) {
+    logger.warn(`Event not found when attempt webhook: ${job.eventId}`);
+    return;
+  }
+
+  const webhook = await WebhookEndpoint.findByPk(job.webhookId);
+  if (!webhook) {
+    logger.warn(`Webhook not found on attempt: ${job.webhookId}`);
+    return;
+  }
+  if (webhook.status !== 'enabled') {
+    logger.warn(`Webhook disabled on attempt: ${job.webhookId}`);
+    return;
+  }
+
+  const lastAttempt = await WebhookAttempt.findOne({
+    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;
+
+  try {
+    // verify similar to component call, but supports external urls
+    const result = await axios({
+      url: webhook.url,
+      method: 'POST',
+      timeout: 60 * 1000,
+      data: event.toJSON(),
+      headers: {
+        'x-app-id': wallet.address,
+        'x-app-pk': wallet.publicKey,
+        'x-component-sig': sign(event.toJSON()),
+        'x-component-did': process.env.BLOCKLET_COMPONENT_DID as string,
+      },
+    });
+
+    await WebhookAttempt.create({
+      livemode: event.livemode,
+      event_id: event.id,
+      webhook_endpoint_id: webhook.id,
+      status: 'succeeded',
+      response_status: result.status,
+      response_body: result.data || {},
+      retry_count: retryCount,
+    });
+
+    await event.decrement('pending_webhooks');
+    logger.info(`Webhook attempt success: ${job.webhookId}`);
+  } catch (err: any) {
+    logger.error(`Webhook attempt error: ${job.webhookId}`, { message: err.message });
+    await WebhookAttempt.create({
+      livemode: event.livemode,
+      event_id: event.id,
+      webhook_endpoint_id: webhook.id,
+      status: 'failed',
+      response_status: (err as AxiosError).response?.status || 500,
+      response_body: (err as AxiosError).response?.data || {},
+      retry_count: retryCount,
+    });
+
+    // reschedule next attempt
+    if (retryCount < MAX_RETRY_COUNT) {
+      process.nextTick(() => {
+        webhookQueue.push({
+          id: getJobId(event.id, webhook.id),
+          job: { eventId: event.id, webhookId: webhook.id },
+          runAt: getNextRetry(retryCount + 1),
+        });
+      });
+    }
+  }
+};
+
+export const webhookQueue = createQueue<WebhookJob>({
+  name: 'webhook',
+  onJob: handleWebhook,
+  options: {
+    concurrency: 2,
+    maxRetries: 3,
+    enableScheduledJob: true,
+  },
+});
+
+webhookQueue.on('failed', ({ id, job, error }) => {
+  logger.error('webhook job failed', { id, job, error });
+});

package/api/src/libs/audit.ts

@@ -0,0 +1,73 @@
+import pick from 'lodash/pick';
+
+import { eventQueue } from '../jobs/event';
+import { Event } from '../store/models/event';
+
+export async function createEvent(scope: string, type: string, model: any, options: any) {
+  // console.log('createEvent', scope, type, model, options);
+  const data: any = {
+    object: model.dataValues,
+  };
+  if (type.endsWith('updated')) {
+    data.previous_attributes = pick(model._previousDataValues, options.fields);
+  }
+
+  const event = await Event.create({
+    type,
+    api_version: 'v1',
+    livemode: !!model.livemode,
+    object_id: model.id,
+    object_type: scope,
+    data,
+    request: {
+      // FIXME:
+      id: '',
+      idempotency_key: '',
+    },
+    metadata: {},
+    pending_webhooks: 99, // force all events goto the event queue
+  });
+
+  eventQueue.push({ id: event.id, job: { eventId: event.id } });
+}
+
+export async function createStatusEvent(
+  scope: string,
+  prefix: string,
+  config: Record<string, string>,
+  model: any,
+  options: any
+) {
+  // console.log('createStatusEvent', scope, prefix, config, model, options);
+  if (options.fields.includes('status') === false) {
+    return;
+  }
+
+  const data: any = {
+    object: model.dataValues,
+    previous_attributes: pick(model._previousDataValues, options.fields),
+  };
+
+  if (!config[data.object.status]) {
+    return;
+  }
+
+  const suffix = config[data.object.status];
+  const event = await Event.create({
+    type: [prefix, suffix].join('.'),
+    api_version: 'v1',
+    livemode: !!model.livemode,
+    object_id: model.id,
+    object_type: scope,
+    data,
+    request: {
+      // FIXME:
+      id: '',
+      idempotency_key: '',
+    },
+    metadata: {},
+    pending_webhooks: 99, // force all events goto the event queue
+  });
+
+  eventQueue.push({ id: event.id, job: { eventId: event.id } });
+}

package/api/src/libs/auth.ts

@@ -0,0 +1,40 @@
+import path from 'path';
+
+import AuthStorage from '@arcblock/did-auth-storage-nedb';
+import AuthService from '@blocklet/sdk/lib/service/auth';
+import getWallet from '@blocklet/sdk/lib/wallet';
+import WalletAuthenticator from '@blocklet/sdk/lib/wallet-authenticator';
+import WalletHandler from '@blocklet/sdk/lib/wallet-handler';
+import type { Request } from 'express';
+import type { LiteralUnion } from 'type-fest';
+
+import env from './env';
+
+export const wallet = getWallet();
+export const authenticator = new WalletAuthenticator();
+export const handlers = new WalletHandler({
+  authenticator,
+  tokenStorage: new AuthStorage({
+    dbPath: path.join(env.dataDir, 'auth.db'),
+  }),
+});
+
+export const blocklet = new AuthService();
+
+export type CallbackArgs = {
+  request: Request;
+  userDid: string;
+  userPk: string;
+  didwallet: {
+    os: LiteralUnion<'ios' | 'android' | 'web', string>;
+    version: string;
+    jwt: string;
+  };
+  extraParams: Record<string, any>;
+  updateSession: Function;
+  claims: any[];
+  step?: number;
+  challenge?: string;
+  pathname?: string;
+  baseUrl?: string;
+};

package/api/src/libs/chain/arcblock.ts

@@ -0,0 +1,13 @@
+import Client from '@ocap/client';
+
+const cache = new Map<string, Client>();
+export function getClient(host: string) {
+  const cached = cache.has(host);
+  if (!cached) {
+    const created = new Client(host);
+    cache.set(host, created);
+    return created;
+  }
+
+  return cache.get(host) as Client;
+}

package/api/src/libs/dayjs.ts

@@ -0,0 +1,17 @@
+import dayjs from 'dayjs';
+import duration from 'dayjs/plugin/duration';
+import localizedFormat from 'dayjs/plugin/localizedFormat';
+import relativeTime from 'dayjs/plugin/relativeTime';
+import timezone from 'dayjs/plugin/timezone'; // dependent on utc plugin
+import utc from 'dayjs/plugin/utc';
+
+import('dayjs/locale/en');
+import('dayjs/locale/zh');
+
+dayjs.extend(relativeTime);
+dayjs.extend(localizedFormat);
+dayjs.extend(duration);
+dayjs.extend(utc);
+dayjs.extend(timezone);
+
+export default dayjs;

package/api/src/libs/env.ts

@@ -0,0 +1,5 @@
+import env from '@blocklet/sdk/lib/env';
+
+export default {
+  ...env,
+};

package/api/src/libs/hooks.ts

@@ -0,0 +1,42 @@
+import { spawnSync } from 'child_process';
+import { chmodSync, existsSync, mkdirSync, symlinkSync } from 'fs';
+import { dirname, join } from 'path';
+
+import logger from './logger';
+
+const { name } = require('../../../package.json');
+
+// eslint-disable-next-line import/prefer-default-export
+export async function ensureSqliteBinaryFile() {
+  logger.info(`${name} ensure sqlite3 installed`);
+
+  try {
+    await import('sqlite3');
+    logger.info(`${name} sqlite3 already installed`);
+    return;
+  } catch {
+    /* empty */
+  }
+  logger.info(`${name} try install sqlite3`);
+
+  const appDir = process.env.BLOCKLET_APP_DIR!;
+
+  // link `node-pre-gyp` to .bin for download or build sqlite3
+  try {
+    const srcPath = join(appDir, 'node_modules/@mapbox/node-pre-gyp/bin/node-pre-gyp');
+    const binPath = join(appDir, 'node_modules/.bin/node-pre-gyp');
+    if (!existsSync(binPath) && existsSync(srcPath)) {
+      mkdirSync(dirname(binPath), { recursive: true });
+      symlinkSync(srcPath, binPath);
+      chmodSync(binPath, '755');
+    }
+  } catch (error) {
+    logger.warn(error.message);
+  }
+
+  spawnSync('npm', ['run', 'install'], {
+    cwd: join(appDir, 'node_modules/sqlite3'),
+    stdio: 'inherit',
+    shell: true,
+  });
+}

package/api/src/libs/logger.ts

@@ -0,0 +1,27 @@
+/* eslint-disable no-console */
+const createLogger = require('@blocklet/logger');
+
+interface Logger {
+  debug: (...args: any[]) => void;
+  info: (...args: any[]) => void;
+  error: (...args: any[]) => void;
+  warn: (...args: any[]) => void;
+}
+
+const consoleLogger: Logger = {
+  debug: console.log,
+  info: console.log,
+  error: console.log,
+  warn: console.warn,
+};
+
+const init = (label: string): Logger => {
+  const instance = createLogger(label || '');
+  return instance;
+};
+
+const logger = process.env.NODE_ENV === 'production' ? consoleLogger : init('app');
+
+export default logger;
+
+export const accessLogStream = createLogger.getAccessLogStream();

package/api/src/libs/middleware.ts

@@ -0,0 +1,12 @@
+/* eslint-disable import/prefer-default-export */
+import type { NextFunction, Request, Response } from 'express';
+
+import { translate } from '../locales';
+
+export function ensureI18n() {
+  return (req: Request, _: Response, next: NextFunction) => {
+    req.locale = String(req.query.locale || 'en');
+    req.t = translate;
+    next();
+  };
+}