payment-kit 1.13.15

package/api/src/libs/payment.ts

@@ -0,0 +1,53 @@
+import { toDelegateAddress } from '@arcblock/did-util';
+import { getWalletDid } from '@blocklet/sdk/lib/did';
+import type { DelegateState } from '@ocap/client';
+import { BN } from '@ocap/util';
+
+import type { TPaymentCurrency } from '../store/models/payment-currency';
+import type { TPaymentMethod } from '../store/models/payment-method';
+import { blocklet, wallet } from './auth';
+import { getClient } from './chain/arcblock';
+
+export async function isDelegationSufficientForPayment(args: {
+  paymentMethod: TPaymentMethod;
+  paymentCurrency: TPaymentCurrency;
+  userDid: string;
+  amount: string;
+}): Promise<{ sufficient: boolean; reason?: string; delegator?: string; state?: DelegateState }> {
+  const { paymentCurrency, paymentMethod, userDid, amount } = args;
+  if (paymentMethod.type === 'arcblock') {
+    // user have bond wallet did?
+    const { user } = await blocklet.getUser(userDid, { enableConnectedAccount: true });
+    const delegator = getWalletDid(user);
+    if (!delegator) {
+      return { sufficient: false, reason: 'NO_DID_WALLET' };
+    }
+
+    const client = await getClient(paymentMethod.settings?.arcblock?.api_host as string);
+
+    // have delegated before?
+    const address = toDelegateAddress(delegator, wallet.address);
+    const { state } = await client.getDelegateState({ address });
+    if (!state) {
+      return { sufficient: false, reason: 'NO_DELEGATION' };
+    }
+
+    // balance enough token for payment?
+    const { tokens } = await client.getAccountTokens({ address: delegator, token: paymentCurrency.contract as string });
+    const [token] = tokens;
+    if (!token) {
+      return { sufficient: false, reason: 'NO_TOKEN' };
+    }
+    if (new BN(amount).gt(new BN(token.balance))) {
+      return { sufficient: false, reason: 'NO_ENOUGH_TOKEN' };
+    }
+
+    return { sufficient: true, delegator, state };
+  }
+
+  if (paymentMethod.type === 'stripe') {
+    return { sufficient: false, reason: 'NOT_SUPPORTED' };
+  }
+
+  throw new Error(`Payment method ${paymentMethod.type} not supported`);
+}

package/api/src/libs/queue/index.ts

@@ -0,0 +1,263 @@
+/* eslint-disable no-await-in-loop */
+/* eslint-disable no-return-assign */
+import EventEmitter from 'events';
+
+import fastq from 'fastq';
+import { nanoid } from 'nanoid';
+
+import logger from '../logger';
+import { sleep, tryWithTimeout } from '../util';
+import createQueueStore from './store';
+
+const CANCELLED = '__CANCELLED__';
+const MIN_DELAY = process.env.NODE_ENV === 'test' ? 2 : 8;
+
+type QueueOptions<T> = {
+  id?: (job: T) => string;
+  concurrency?: number;
+  maxRetries?: number;
+  maxTimeout?: number;
+  retryDelay?: number;
+  enableScheduledJob?: boolean;
+};
+
+type QueueParams<T> = {
+  name: string;
+  onJob: (job: T) => Promise<any>;
+  options?: QueueOptions<T>;
+};
+
+const defaults: QueueOptions<any> = {
+  concurrency: 1,
+  maxRetries: 1,
+  maxTimeout: 24 * 60 * 60 * 1000,
+  retryDelay: 0,
+  enableScheduledJob: false,
+};
+
+type PushParams<T> = {
+  job: T;
+  id?: string;
+  persist?: boolean;
+  delay?: number; // in seconds
+  runAt?: number; // unix timestamp in seconds
+};
+
+export default function createQueue<T = any>({ name, onJob, options = defaults }: QueueParams<T>) {
+  const store = createQueueStore(name);
+  const { concurrency, maxRetries, maxTimeout, retryDelay, enableScheduledJob } = Object.assign({}, defaults, options);
+
+  const getJobId = (id: string | undefined, job: any) => id || (options.id ? options.id(job) : nanoid()) || nanoid();
+
+  const queueEvents = new EventEmitter();
+  const queue = fastq(async ({ job, id, persist }: { job: any; id: string; persist: boolean }, cb: Function) => {
+    if (persist) {
+      try {
+        const cancelled = await store.isCancelled(id);
+        if (cancelled) {
+          cb(null, CANCELLED);
+          return;
+        }
+      } catch (err) {
+        cb(err);
+        return;
+      }
+    }
+
+    try {
+      const result = await tryWithTimeout(() => onJob(job), maxTimeout);
+      cb(null, result);
+    } catch (err) {
+      cb(err);
+    }
+    // @ts-ignore
+  }, concurrency);
+
+  const push = ({ job, id, persist, delay, runAt }: PushParams<T>) => {
+    const jobEvents = new EventEmitter();
+    const emit = (e: string, data: any) => {
+      queueEvents.emit(e, data);
+      jobEvents.emit(e, data);
+    };
+
+    if (!job) {
+      throw new Error('Can not queue empty job');
+    }
+
+    const jobId = getJobId(id, job);
+
+    if (delay || runAt) {
+      if (!enableScheduledJob) {
+        throw new Error('Must set options.enableScheduledJob to true to run delay jobs');
+      }
+
+      // 这里不是精确的 delay, 延迟的时间太短没有意义，所以这里限制了最小 delay
+      if (delay && delay < MIN_DELAY) {
+        throw new Error(`minimum delay is ${MIN_DELAY}s`);
+      }
+
+      const attrs: { delay?: number; will_run_at?: number } = {};
+      if (delay) {
+        attrs.delay = delay;
+        attrs.will_run_at = Date.now() + delay * 1000;
+      }
+      if (runAt) {
+        attrs.delay = 1;
+        attrs.will_run_at = runAt * 1000;
+      }
+
+      store
+        .addJob(jobId, job, attrs)
+        .then(() => {
+          emit('queued', { id: jobId, job, attrs });
+        })
+        .catch((err) => {
+          logger.error('Can not add scheduled job to store', { error: err });
+        });
+
+      // @ts-ignore
+      jobEvents.id = jobId;
+      return jobEvents;
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-shadow
+    const clearJob = (id: string) => store.deleteJob(id);
+
+    const onJobComplete = async (err: any, result: any) => {
+      if (result === CANCELLED) {
+        emit('cancelled', { id: jobId, job, result });
+        clearJob(jobId);
+        return;
+      }
+
+      if (!err) {
+        emit('finished', { id: jobId, job, result });
+        clearJob(jobId);
+        return;
+      }
+
+      try {
+        const doc = await store.getJob(jobId);
+        if (!doc) {
+          emit('failed', { id: jobId, job, error: err });
+          return;
+        }
+
+        // @ts-ignore
+        if (doc.retry_count >= maxRetries) {
+          logger.info('fail job on max retry exceed', { id: jobId, job });
+          await clearJob(jobId);
+          emit('failed', { id: jobId, job, error: err });
+          return;
+        }
+
+        await store.updateJob(jobId, { retry_count: doc.retry_count + 1 });
+        logger.info('retry job', { id: jobId, count: doc.retry_count + 1 });
+        setTimeout(() => {
+          emit('retry', { id: jobId, job, doc });
+          queue.unshift({ id: jobId, job }, onJobComplete);
+        }, retryDelay);
+        // eslint-disable-next-line no-shadow, @typescript-eslint/no-shadow
+      } catch (err: any) {
+        console.error(err);
+        await clearJob(jobId);
+        emit('failed', { id: jobId, job, error: err });
+      }
+    };
+
+    const queueJob = () =>
+      setImmediate(() => {
+        emit('queued', { id: jobId, job, persist });
+        logger.info('queue job', { id: jobId, job });
+        queue.push({ id: jobId, job, persist }, onJobComplete);
+      });
+
+    if (persist) {
+      store
+        .addJob(jobId, job)
+        .then(queueJob)
+        .catch((err) => {
+          logger.error('Can not add job to store', { error: err });
+        });
+    } else {
+      queueJob();
+    }
+
+    // @ts-ignore
+    jobEvents.id = jobId;
+    return jobEvents;
+  };
+
+  const cancel = async (id: string) => {
+    const doc = await store.updateJob(id, { cancelled: true });
+    return doc ? doc.job : null;
+  };
+
+  const getJob = async (id: string) => {
+    const doc = await store.getJob(id);
+    return doc ? doc.job : null;
+  };
+
+  // Populate the queue on startup
+  process.nextTick(async () => {
+    try {
+      const jobs = await store.getJobs();
+      logger.info(`${name} jobs to populate`, { count: jobs.length });
+      jobs.forEach((x) => {
+        if (x.job && x.id) {
+          push({ job: x.job, id: x.id, persist: false });
+        } else {
+          logger.info('skip invalid job from db', { job: x });
+        }
+      });
+      // eslint-disable-next-line no-shadow
+    } catch (err) {
+      console.error(err);
+      logger.error(`Can not load existing ${name} jobs`, { error: err });
+    }
+  });
+
+  const loop = async () => {
+    if (enableScheduledJob === true) {
+      // eslint-disable-next-line no-constant-condition
+      while (true) {
+        await sleep((MIN_DELAY * 1000) / 2);
+
+        try {
+          /* eslint-disable no-await-in-loop */
+          const jobs = await store.getScheduledJobs();
+          for (const x of jobs) {
+            if (x.job && x.id) {
+              push({ job: x.job, id: x.id, persist: false });
+            } else {
+              logger.info('skip invalid job from db', { job: x });
+            }
+          }
+        } catch (err) {
+          console.error(err);
+          logger.error(`Can not load scheduled ${name} jobs`, { error: err });
+        }
+      }
+    }
+  };
+
+  loop();
+
+  return Object.assign(queueEvents, {
+    store,
+    push,
+    drain: (cb: any) => (queue.drain = cb),
+    empty: (cb: any) => (queue.empty = cb),
+    saturated: (cb: any) => (queue.saturated = cb),
+    error: (cb: any) => (queue.error = cb),
+    get: getJob,
+    cancel,
+    options: {
+      concurrency,
+      maxRetries,
+      maxTimeout,
+      retryDelay,
+      enableScheduledJob,
+    },
+  });
+}

package/api/src/libs/queue/store.ts

@@ -0,0 +1,47 @@
+import { Op } from 'sequelize';
+
+import { Job, TJob } from '../../store/models/job';
+import { CustomError } from '../util';
+
+export default function createQueueStore(queue: string) {
+  return {
+    async isCancelled(id: string): Promise<boolean> {
+      const job = await Job.findOne({ where: { queue, id } });
+      return !!job && !!job.cancelled;
+    },
+    getJob(id: string): Promise<TJob | null> {
+      return Job.findOne({ where: { queue, id } });
+    },
+    getJobs(): Promise<TJob[]> {
+      return Job.findAll({ where: { queue, delay: -1 }, order: [['created_at', 'ASC']] });
+    },
+    getScheduledJobs(): Promise<TJob[]> {
+      return Job.findAll({
+        where: { queue, delay: { [Op.not]: -1 }, will_run_at: { [Op.lte]: Date.now() } },
+        order: [['created_at', 'ASC']],
+      });
+    },
+    async updateJob(id: string, updates: Partial<TJob>): Promise<TJob> {
+      const job = await Job.findOne({ where: { queue, id } });
+      if (!job) {
+        throw new CustomError('JOB_NOT_FOUND', `Job ${id} does not exist`);
+      }
+
+      return job.update(updates);
+    },
+    async addJob(id: string, job: any, attrs: Partial<TJob> = {}): Promise<TJob> {
+      const exist = await Job.findOne({ where: { queue, id } });
+      if (exist) {
+        throw new CustomError('JOB_DUPLICATE', `Job ${queue}#${id} already exist`);
+      }
+
+      return Job.create({ id, job, queue, retry_count: 1, cancelled: false, ...attrs });
+    },
+    async deleteJob(id: string): Promise<boolean> {
+      const data = await Job.destroy({ where: { queue, id } });
+      return data > 0;
+    },
+  };
+}
+
+export type TQueueStore = ReturnType<typeof createQueueStore>;

package/api/src/libs/security.ts

@@ -0,0 +1,95 @@
+import { auth } from '@blocklet/sdk/lib/middlewares';
+import { verify } from '@blocklet/sdk/lib/util/verify-sign';
+import type { NextFunction, Request, Response } from 'express';
+import type { Model } from 'sequelize';
+
+import { Customer } from '../store/models/customer';
+
+export const ensureAdmin = auth({ roles: ['owner', 'admin'] });
+
+type PermissionSpec<T extends Model> = {
+  component?: boolean; // allow component calls
+  roles?: string[]; // allow current session user with one of the specified roles
+  record?: {
+    // allow record owner
+    model: T;
+    field: string;
+  };
+  mine?: boolean;
+};
+
+/**
+ * This middleware is used to authenticate request by session or component call.
+ * If a request is authenticated, it will set `req.user` to the session user.
+ * If a request is authenticated by component call, it will set `req.user` to the component user.
+ * If a request is authenticated by record owner, it will set `req.user` to the session user and set `req.doc` to the record.
+ */
+export function authenticate<T extends Model>({ component, roles, record, mine }: PermissionSpec<T>) {
+  return async (req: Request, res: Response, next: NextFunction) => {
+    // authenticate by component call
+    const sig = req.get('x-component-sig');
+    if (component && sig) {
+      const data = typeof req.body === 'undefined' ? {} : req.body;
+      const verified = verify(data, sig);
+      if (!verified) {
+        return res.status(401).json({ error: 'Invalid signature for component call' });
+      }
+
+      req.user = {
+        did: <string>req.get('x-component-did'),
+        role: 'owner',
+        provider: 'wallet',
+        fullName: <string>req.get('x-component-did'),
+        walletOS: '',
+        via: 'api',
+      };
+
+      return next();
+    }
+
+    if (req.headers['x-user-did']) {
+      req.user = {
+        did: <string>req.headers['x-user-did'],
+        role: <string>req.headers['x-user-role'],
+        provider: <string>req.headers['x-user-provider'],
+        fullName: decodeURIComponent(<string>req.headers['x-user-fullname']),
+        walletOS: <string>req.headers['x-user-wallet-os'],
+        via: 'dashboard',
+      };
+
+      // authenticate by session user
+      if (roles) {
+        if (roles.includes(req.user?.role)) {
+          return next();
+        }
+      }
+
+      if (mine) {
+        const customer = await Customer.findOne({ where: { did: req.user.did } });
+        if (customer) {
+          req.customer = customer;
+          req.query.customer_id = customer.id;
+          return next();
+        }
+      }
+
+      // authenticate by record owner
+      if (record) {
+        const { model, field = 'customer_id' } = record;
+        // @ts-ignore
+        const doc: T | null = await model.findByPk(req.params.id);
+        if (doc && doc[field as keyof T]) {
+          const customer = await Customer.findOne({ where: { did: req.user.did } });
+          req.doc = doc;
+          req.customer = customer;
+          if (customer && customer.id === doc[field as keyof T]) {
+            req.user.via = 'portal';
+            return next();
+          }
+        }
+      }
+    }
+
+    return res.status(401).json({ error: 'Not authorized to perform this action' });
+  };
+}

package/api/src/libs/session.ts

@@ -0,0 +1,164 @@
+import { env } from '@blocklet/sdk/lib/config';
+import { BN } from '@ocap/util';
+
+import type { Price, TPrice } from '../store/models/price';
+import type { Product } from '../store/models/product';
+import type { LineItem, PriceRecurring } from '../store/models/types';
+import dayjs from './dayjs';
+
+export type TLineItemExpanded = LineItem & { price: TPrice };
+
+export function getStatementDescriptor(items: any[]) {
+  for (const item of items) {
+    if (item.price?.product?.statement_descriptor) {
+      return item.price?.product?.statement_descriptor;
+    }
+  }
+
+  return env.appName;
+}
+
+export function getCheckoutMode(items: TLineItemExpanded[] = []) {
+  if (items.length === 0) {
+    return 'setup';
+  }
+
+  // all metered
+  if (items.every((x) => x.price.type === 'recurring' && x.price.recurring?.usage_type === 'metered')) {
+    return 'setup';
+  }
+
+  if (items.some((x) => x.price.type === 'recurring')) {
+    return 'subscription';
+  }
+
+  return 'payment';
+}
+
+// FIXME: apply coupon for discounts
+export function getCheckoutAmount(items: TLineItemExpanded[] = [], includeFreeTrial = false) {
+  const subtotal = items
+    .reduce((acc, x) => {
+      if (x.price.type === 'recurring') {
+        if (includeFreeTrial) {
+          return acc;
+        }
+        if (x.price.recurring?.usage_type === 'metered') {
+          return acc;
+        }
+      }
+      return acc.add(new BN(x.price.unit_amount).mul(new BN(x.quantity)));
+    }, new BN(0))
+    .toString();
+
+  const total = items
+    .reduce((acc, x) => {
+      if (x.price.type === 'recurring') {
+        if (includeFreeTrial) {
+          return acc;
+        }
+        if (x.price.recurring?.usage_type === 'metered') {
+          return acc;
+        }
+      }
+      return acc.add(new BN(x.price.unit_amount).mul(new BN(x.quantity)));
+    }, new BN(0))
+    .toString();
+
+  return { subtotal, total, discount: '0', shipping: '0', tax: '0' };
+}
+
+export function getRecurringPeriod(recurring: PriceRecurring) {
+  const { interval } = recurring;
+  const count = recurring.interval_count || 1;
+  const dayInMs = 24 * 60 * 60 * 1000;
+
+  switch (interval) {
+    case 'hour':
+      return 60 * 60 * 1000;
+    case 'day':
+      return count * dayInMs;
+    case 'week':
+      return count * 7 * dayInMs;
+    case 'month':
+      return count * 30 * dayInMs;
+    case 'year':
+      return count * 365 * dayInMs;
+    default:
+      return 0;
+  }
+}
+
+export function getSubscriptionCreateSetup(items: TLineItemExpanded[], trialInDays = 0) {
+  let setup = new BN(0);
+  let subscription = new BN(0);
+
+  items.forEach((x) => {
+    setup = setup.add(new BN(x.price.unit_amount).mul(new BN(x.quantity)));
+    if (x.price.type === 'recurring') {
+      if (trialInDays === 0) {
+        subscription = setup.add(new BN(x.price.unit_amount).mul(new BN(x.quantity)));
+      }
+    }
+  });
+
+  const recurring = items.find((x) => x.price.type === 'recurring')?.price.recurring as PriceRecurring;
+  const cycle = getRecurringPeriod(recurring);
+  const trial = trialInDays ? trialInDays * 24 * 60 * 60 * 1000 : 0;
+
+  return {
+    recurring,
+    cycle: {
+      duration: cycle,
+      anchor: trialInDays ? dayjs().add(trial, 'millisecond').unix() : dayjs().unix(),
+    },
+    trail: {
+      start: trialInDays ? dayjs().unix() : 0,
+      end: trialInDays ? dayjs().add(trial, 'millisecond').unix() : 0,
+    },
+    period: {
+      start: dayjs().unix(),
+      end: dayjs()
+        .add(trialInDays ? trial : cycle, 'millisecond')
+        .unix(),
+    },
+    amount: {
+      setup: setup.toString(),
+      subscription: subscription.toString(),
+    },
+  };
+}
+
+export function getSubscriptionCycleSetup(recurring: PriceRecurring, previousPeriodEnd: number) {
+  const cycle = getRecurringPeriod(recurring);
+
+  return {
+    recurring,
+    cycle,
+    period: {
+      start: previousPeriodEnd,
+      end: dayjs.unix(previousPeriodEnd).add(cycle, 'millisecond').unix(),
+    },
+  };
+}
+
+export function getSubscriptionCycleAmount(items: TLineItemExpanded[]) {
+  let amount = new BN(0);
+
+  items.forEach((x) => {
+    amount = amount.add(new BN(x.price.unit_amount).mul(new BN(x.quantity)));
+  });
+
+  return {
+    total: amount.toString(),
+  };
+}
+
+export function expandLineItems(items: any[], products: Product[], prices: Price[]) {
+  items.forEach((item) => {
+    item.price = prices.find((x) => x.id === item.price_id);
+    item.price.product = products.find((x) => x.id === item.price.product_id);
+  });
+
+  return items;
+}