@blocklet/launcher-util 2.2.3 → 2.2.5

package/es/constant.js

@@ -0,0 +1,169 @@
+const INSTANCE_STATUS = Object.freeze({
+  error: 0,
+  waiting: 5,
+  pending: 10,
+  starting: 20,
+  running: 30,
+  restarting: 40,
+  stopping: 50,
+  stopped: 60,
+  terminated: 70,
+  expired: 80,
+  underMaintenance: 90
+});
+const PLAN_STATUS = Object.freeze({
+  draft: 10,
+  published: 20,
+  dropped: 30
+  // 已下架
+});
+const LAUNCH_STATUS = Object.freeze({
+  created: 0,
+  selected: 10,
+  connected: 20,
+  paid: 30,
+  allocated: 40,
+  installed: 50,
+  expired: 60,
+  terminated: 70,
+  timeout: 80,
+  transferred: 90
+});
+const LAUNCH_ACTIVITY_TYPE = Object.freeze({
+  created: "created",
+  selected: "selected",
+  connected: "connected",
+  paid: "paid",
+  allocated: "allocated",
+  installed: "installed",
+  timeout: "timeout",
+  expired: "expired",
+  terminated: "terminated",
+  transferred: "transferred"
+});
+const SERVER_ACTIVITY_TYPE = Object.freeze({
+  purchase: "purchase",
+  launch: "launch",
+  createFailed: "createFailed",
+  created: "created",
+  start: "start",
+  started: "started",
+  startFailed: "startFailed",
+  stop: "stop",
+  stopped: "stopped",
+  stopFailed: "stopFailed",
+  restart: "restart",
+  restarted: "restarted",
+  restartFailed: "restartFailed",
+  expired: "expired",
+  terminate: "terminate",
+  terminated: "terminated",
+  terminateFailed: "terminateFailed",
+  renewaled: "renewaled",
+  transferred: "transferred",
+  replacement: "replacement"
+});
+const SERVERLESS_INSTANCE_STATUS = {
+  launching: 10,
+  running: 20,
+  expired: 30,
+  terminated: 40
+};
+const toMap = (staus) => Object.keys(staus).reduce((acc, cur) => {
+  acc[staus[cur]] = cur;
+  return acc;
+}, {});
+const fromStatus = (map) => (status) => map[status];
+const statusInstanceMap = toMap(INSTANCE_STATUS);
+const planStatusMap = toMap(PLAN_STATUS);
+const fromInstanceStatus = fromStatus(statusInstanceMap);
+const fromPlanStatus = fromStatus(planStatusMap);
+const NFT_TYPE_SERVERLESS = "BlockletServerServerlessNFT";
+const BLOCKLET_SERVER_OWNERSHIP_NFT = "BlockletServerOwnershipNFT";
+const TIME_LOCALE = {
+  en: {
+    h: "hour",
+    hs: "hours",
+    d: " day",
+    ds: " days",
+    m: " month",
+    ms: " months",
+    y: " year",
+    ys: " years"
+  },
+  zh: {
+    h: "小时",
+    hs: "小时",
+    d: "天",
+    ds: "天",
+    m: "个月",
+    ms: "个月",
+    y: "年",
+    ys: "年"
+  }
+};
+const APP_TYPE = Object.freeze({
+  serverless: "serverless",
+  dedicated: "dedicated"
+});
+const SKU_STATUS = Object.freeze({
+  DISABLED: 0,
+  ENABLED: 1
+});
+const PAYMENT_STATUS = Object.freeze({
+  unpaid: 10,
+  paid: 20,
+  done: 30,
+  expired: 40,
+  canceled: 60,
+  failed: 70
+});
+const PAYMENT_TYPES = {
+  purchase: "purchase",
+  renewal: "renewal",
+  autoRenewal: "auto-renewal"
+};
+const PAYMENT_METHODS = Object.freeze({
+  crypto: "crypto",
+  stripe: "stripe",
+  fiat: "fiat"
+  // TODO: 区分支付货币和支付方式
+});
+const DID_DOMAIN_SUFFIX = "did.abtnet.io";
+const REDEEM_NFT_ID = "redeem";
+const INSTANCE_MAX_NAME_LENGTH = 30;
+const INSTANCE_MAX_DESC_LENGTH = 50;
+const LAUNCH_TYPE = {
+  instant: "instant",
+  redeem: "redeem"
+};
+const CURRENCY_TYPE = {
+  fiat: "fiat",
+  crypto: "crypto"
+};
+const SERVERLESS_RETAIN_DAYS = 30;
+export {
+  APP_TYPE,
+  BLOCKLET_SERVER_OWNERSHIP_NFT,
+  CURRENCY_TYPE,
+  DID_DOMAIN_SUFFIX,
+  INSTANCE_MAX_DESC_LENGTH,
+  INSTANCE_MAX_NAME_LENGTH,
+  INSTANCE_STATUS,
+  LAUNCH_ACTIVITY_TYPE,
+  LAUNCH_STATUS,
+  LAUNCH_TYPE,
+  NFT_TYPE_SERVERLESS,
+  PAYMENT_METHODS,
+  PAYMENT_STATUS,
+  PAYMENT_TYPES,
+  PLAN_STATUS,
+  REDEEM_NFT_ID,
+  SERVERLESS_INSTANCE_STATUS,
+  SERVERLESS_RETAIN_DAYS,
+  SERVER_ACTIVITY_TYPE,
+  SKU_STATUS,
+  TIME_LOCALE,
+  fromInstanceStatus,
+  fromPlanStatus
+};

package/es/format-error.js

@@ -0,0 +1,25 @@
+const formatError = (err) => {
+  var _a;
+  if (!err) {
+    return err;
+  }
+  const { details, errors, response } = err;
+  if (Array.isArray(errors)) {
+    return errors.map((x) => x.message).join("\n");
+  }
+  if (Array.isArray(details)) {
+    const formatted = details.map((e) => {
+      const errorMessage = e.message.replace(/["]/g, "'");
+      const errorPath = e.path.join(".");
+      return `${errorPath}: ${errorMessage}`;
+    });
+    return `Validate failed: ${formatted.join(";")}`;
+  }
+  if (response) {
+    return ((_a = response.data) == null ? void 0 : _a.error) || `Request failed: ${response.status} ${response.statusText}: ${JSON.stringify(response.data)}`;
+  }
+  return err.message || err;
+};
+export {
+  formatError as default
+};

package/es/get-asset.js

@@ -0,0 +1,45 @@
+import joinUrl from "url-join";
+import axios from "axios";
+import get from "lodash.get";
+const getAsset = async (chainHost, address) => {
+  const url = joinUrl(new URL(chainHost).origin, "/api/gql/");
+  const result = await axios.post(
+    url,
+    JSON.stringify({
+      query: `{
+        getAssetState(address: "${address}") {
+          state {
+            address
+            data {
+              typeUrl
+              value
+            }
+            display {
+              type
+              content
+            }
+            issuer
+            owner
+            parent
+            tags
+          }
+        }
+      }`
+    }),
+    {
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      },
+      timeout: 60 * 1e3
+    }
+  );
+  const state = get(result, "data.data.getAssetState.state");
+  if (state && state.data.typeUrl === "json") {
+    state.data.value = JSON.parse(state.data.value);
+  }
+  return state;
+};
+export {
+  getAsset as default
+};

package/es/locale/en.js

@@ -0,0 +1,43 @@
+import flat from "flat";
+import { SERVERLESS_INSTANCE_STATUS, INSTANCE_STATUS, PAYMENT_METHODS, CURRENCY_TYPE } from "../constant";
+const en = flat({
+  common: {
+    app: "App",
+    billing: "Billing",
+    duration: "Duration",
+    spaceName: "Space Name"
+  },
+  serverlessInstance: {
+    appStatus: {
+      [SERVERLESS_INSTANCE_STATUS.launching]: "Launching",
+      [SERVERLESS_INSTANCE_STATUS.running]: "Running",
+      [SERVERLESS_INSTANCE_STATUS.expired]: "Expired",
+      [SERVERLESS_INSTANCE_STATUS.terminated]: "Terminated"
+    }
+  },
+  dedicatedInstance: {
+    appStatus: {
+      [INSTANCE_STATUS.unknown]: "Unknown",
+      [INSTANCE_STATUS.pending]: "Pending",
+      [INSTANCE_STATUS.starting]: "Starting",
+      [INSTANCE_STATUS.running]: "Running",
+      [INSTANCE_STATUS.restarting]: "Restarting",
+      [INSTANCE_STATUS.stopping]: "Stopping",
+      [INSTANCE_STATUS.stopped]: "Stopped",
+      [INSTANCE_STATUS.terminated]: "Terminated",
+      [INSTANCE_STATUS.expired]: "Expired",
+      [INSTANCE_STATUS.error]: "Error",
+      [INSTANCE_STATUS.waiting]: "Waiting",
+      [INSTANCE_STATUS.underMaintenance]: "Under-Maintenance"
+    }
+  },
+  paymentMethod: {
+    [PAYMENT_METHODS.crypto]: "Crypto",
+    [PAYMENT_METHODS.stripe]: "Credit",
+    [CURRENCY_TYPE.fiat]: "Credit",
+    [CURRENCY_TYPE.crypto]: "Crypto"
+  }
+});
+export {
+  en as default
+};

package/es/locale/index.js

@@ -0,0 +1,17 @@
+const index = (locales) => {
+  const replace = (template, data) => (template || "").replace(
+    /{(\w*)}/g,
+    (_, key) => Object.prototype.hasOwnProperty.call(data || {}, key) ? data[key] : ""
+  );
+  const translate = (key, locale, params) => {
+    if (!locales[locale]) {
+      locale = "en";
+    }
+    return replace(locales[locale][key], params) || key;
+  };
+  const createTranslateFunc = (locale) => (key, params) => translate(key, locale || "en", params);
+  return { translate, createTranslateFunc };
+};
+export {
+  index as default
+};

package/es/locale/zh.js

@@ -0,0 +1,45 @@
+import flat from "flat";
+import { SERVERLESS_INSTANCE_STATUS, INSTANCE_STATUS, PAYMENT_METHODS, CURRENCY_TYPE } from "../constant";
+const zh = flat({
+  common: {
+    app: "应用",
+    billing: "账单",
+    duration: "时长",
+    spaceName: "应用空间"
+  },
+  serverlessInstance: {
+    appStatus: {
+      [SERVERLESS_INSTANCE_STATUS.launching]: "启动中",
+      [SERVERLESS_INSTANCE_STATUS.running]: "运行中",
+      [SERVERLESS_INSTANCE_STATUS.expired]: "已过期",
+      [SERVERLESS_INSTANCE_STATUS.terminated]: "已终止"
+    }
+  },
+  dedicatedInstance: {
+    appStatus: {
+      [INSTANCE_STATUS.unknown]: "未知",
+      [INSTANCE_STATUS.pending]: "待处理",
+      [INSTANCE_STATUS.starting]: "启动中",
+      [INSTANCE_STATUS.running]: "运行中",
+      [INSTANCE_STATUS.restarting]: "重启中",
+      [INSTANCE_STATUS.stopping]: "停止中",
+      [INSTANCE_STATUS.stopped]: "已停止",
+      [INSTANCE_STATUS.terminated]: "已终止",
+      [INSTANCE_STATUS.expired]: "已过期",
+      [INSTANCE_STATUS.error]: "错误",
+      [INSTANCE_STATUS.waiting]: "等待中",
+      [INSTANCE_STATUS.underMaintenance]: "维护中"
+    }
+  },
+  paymentMethod: {
+    [PAYMENT_METHODS.crypto]: "加密货币",
+    [PAYMENT_METHODS.stripe]: "信用卡",
+    [CURRENCY_TYPE.fiat]: "信用卡",
+    // TODO: 统一管理支付方式和货币类型
+    [CURRENCY_TYPE.crypto]: "加密货币"
+    // TODO: 统一管理支付方式和货币类型
+  }
+});
+export {
+  zh as default
+};

package/es/middleware.js

@@ -0,0 +1,66 @@
+import pick from "lodash.pick";
+import { getSort } from "./util";
+const MAX_PAGING_SIZE = 100;
+const DEFAULT_PAGING_SIZE = MAX_PAGING_SIZE;
+const DEFAULT_PAGE = 1;
+const pagination = (req, res, next) => {
+  const paging = {
+    page: DEFAULT_PAGE,
+    size: DEFAULT_PAGING_SIZE
+  };
+  req.paging = paging;
+  if (!Number.isNaN(Number(req.query.page))) {
+    paging.page = Number(req.query.page);
+  }
+  if (!Number.isNaN(Number(req.query.size))) {
+    const size = Number(req.query.size);
+    paging.size = size <= MAX_PAGING_SIZE ? size : MAX_PAGING_SIZE;
+  }
+  paging.sort = getSort(req.query.sortby, req.query.sortdir);
+  next();
+};
+const validate = (schema, option = {}) => (req, res, next) => {
+  const { error, value } = schema.validate(req.body, {
+    errors: { language: req.query.locale || "en" },
+    ...option
+  });
+  if (error) {
+    res.status(400).json({ error: error.message });
+    return;
+  }
+  req.data = value;
+  next();
+};
+const createAuditMiddleware = ({ baseURL, writer, formatterMap }) => (req, res, next) => {
+  if (["PUT", "POST", "PATCH", "DELETE"].includes(req.method)) {
+    const originalResponse = res.end.bind(res);
+    const wrappedResponse = (...args) => {
+      if (res.statusCode >= 200 && res.statusCode < 300) {
+        const key = `${req.baseUrl}${req.route.path}`.replace(baseURL, req.method.toLowerCase());
+        const formater = formatterMap[key];
+        if (formater) {
+          const data = {
+            user: { ...pick(req.user, ["did", "role", "fullName"]) },
+            id: formater.id,
+            resource: formater.resource,
+            payload: formater.format({ req, res }),
+            ip: req.get("x-Real-ip", ""),
+            ua: req.get("user-agent", "")
+          };
+          writer(data);
+        }
+      }
+      return originalResponse(...args);
+    };
+    res.end = wrappedResponse;
+  }
+  next();
+};
+export {
+  DEFAULT_PAGE,
+  DEFAULT_PAGING_SIZE,
+  MAX_PAGING_SIZE,
+  createAuditMiddleware,
+  pagination,
+  validate
+};

package/es/notification/index.js

@@ -0,0 +1,29 @@
+import BlockletNotification from "@blocklet/sdk/service/notification";
+class Notification {
+  constructor({ logger, auth }) {
+    this.auth = auth;
+    this.logger = logger || { info: console.info, error: console.error };
+  }
+  async sendNotification({ to, title, message, actions, attachments = [], assetAddress }) {
+    try {
+      const payload = { title, body: message, actions: actions || [], attachments: [...attachments] };
+      if (typeof assetAddress !== "undefined") {
+        payload.attachments.push({
+          type: "asset",
+          data: {
+            chainHost: this.auth.chainHost,
+            did: assetAddress
+          }
+        });
+      }
+      await BlockletNotification.sendToUser(to, payload);
+      this.logger.info("text message was sent", { to, payload: JSON.stringify(payload, null, 2) });
+    } catch (error) {
+      this.logger.error("send text message failed", { error, to, message, actions, attachments });
+      throw error;
+    }
+  }
+}
+export {
+  Notification as default
+};

package/es/permission.js

@@ -0,0 +1,5 @@
+const ADMIN_ROLES = ["owner", "admin"];
+const canAccessAdmin = (role) => ADMIN_ROLES.includes(role);
+export {
+  canAccessAdmin
+};

package/es/util.js

@@ -0,0 +1,132 @@
+import "moment-timezone";
+import "moment/locale/zh-cn";
+import moment from "moment";
+import joinURL from "url-join";
+import get from "lodash.get";
+import { TIME_LOCALE, LAUNCH_STATUS } from "./constant";
+const formatPeriod = (duration) => {
+  const value = Number(duration.slice(0, duration.length - 1));
+  const unit = duration[duration.length - 1];
+  return { value, unit };
+};
+const prettyDurationUnit = ({ value, unit }, locale) => {
+  if (!Object.keys(TIME_LOCALE).includes(locale)) {
+    locale = "en";
+  }
+  const localeKey = value > 1 ? `${unit}s` : unit;
+  return TIME_LOCALE[locale][localeKey.toLowerCase()];
+};
+const prettyDuration = (duration, locale) => {
+  if (!duration) {
+    return "";
+  }
+  const { value, unit } = duration;
+  return `${value}${prettyDurationUnit({ value, unit }, locale)}`;
+};
+const formatDatetime = (time, locale = "en-us", timezone = Intl.DateTimeFormat().resolvedOptions().timeZone) => {
+  if (!time) {
+    return "";
+  }
+  locale = locale || "en-us";
+  if (locale === "zh") {
+    locale = "zh-cn";
+  }
+  try {
+    return moment(time).locale(locale).tz(timezone).format("LLL zz");
+  } catch (error) {
+    console.error(`formate date time "${time}" error`, error);
+    return "";
+  }
+};
+const formatUtcDatetime = (time, locale = "en-us") => formatDatetime(time, locale, "UTC");
+const sortArrayByDate = (array, asc = true, field = void 0) => (array || []).sort((x, y) => {
+  let v1 = x;
+  let v2 = y;
+  if (typeof field !== "undefined") {
+    v1 = v1[field];
+    v2 = v2[field];
+  }
+  if (v1 === v2) {
+    return 0;
+  }
+  const directionResult = asc ? 1 : -1;
+  if (moment(v1).diff(moment(v2)) > 0) {
+    return directionResult;
+  }
+  return -1 * directionResult;
+});
+const getSort = (sortby, sortdir) => {
+  if (sortby && sortby !== "undefined") {
+    return { [sortby]: sortdir };
+  }
+  return { createdAt: -1 };
+};
+const getExplorerUrl = ({ address, type = "txs", chainHost }) => {
+  return `https://explorer.abtnetwork.io/explorer/${type}/${address}?host=${chainHost}`;
+};
+const getBlockletDisplayName = (blocklet) => get(blocklet, "title") || get(blocklet, "name") || "";
+const getBlockletAdminURL = (appURL) => joinURL(appURL, "/.well-known/service/admin/overview");
+const isDateExpired = (expirationDate) => !!expirationDate && new Date(expirationDate).getTime() <= Date.now();
+const getContinueLaunchURL = ({ baseURL, launch }) => {
+  const urlObject = new URL(baseURL);
+  if (launch.status < LAUNCH_STATUS.paid) {
+    urlObject.searchParams.set("sessionId", launch._id);
+    urlObject.searchParams.set("blocklet_meta_url", launch.blockletMetaUrl);
+    return urlObject.href;
+  }
+  if (launch.status >= LAUNCH_STATUS.paid && launch.status < LAUNCH_STATUS.installed) {
+    urlObject.pathname = joinURL(urlObject.pathname, `/launch/${launch.nftDid}`);
+    urlObject.searchParams.set("sessionId", launch._id);
+    urlObject.searchParams.set("blocklet_meta_url", launch.blockletMetaUrl);
+    urlObject.searchParams.set("launchType", launch.type);
+    if (launch.from) {
+      urlObject.searchParams.set("from", launch.from);
+    }
+    return urlObject.href;
+  }
+  return "";
+};
+const getBlockletMetaUrlFromQuery = (query) => {
+  const url = (query.get("blocklet_meta_url") || query.get("meta_url") || "").trim();
+  return decodeURIComponent(url);
+};
+const getRegistryUrlFromBlockletMetaUrl = (blockletMetaUrl) => {
+  try {
+    return blockletMetaUrl ? new URL(blockletMetaUrl).origin : "";
+  } catch (error) {
+    console.error("get registry url from blocklet meta url error:", error);
+    return "";
+  }
+};
+const formatRegistryLogoPath = (did, asset) => {
+  if (asset.startsWith("/assets")) {
+    return asset;
+  }
+  return `/assets/${did}/${asset}`;
+};
+const getBlockletLogoUrl = ({ did, baseUrl, logoPath }) => {
+  if (logoPath && logoPath.startsWith("http")) {
+    return logoPath;
+  }
+  if (baseUrl.startsWith("http") && logoPath) {
+    return joinURL(baseUrl, formatRegistryLogoPath(did, logoPath));
+  }
+  return "";
+};
+export {
+  formatDatetime,
+  formatPeriod,
+  formatUtcDatetime,
+  getBlockletAdminURL,
+  getBlockletDisplayName,
+  getBlockletLogoUrl,
+  getBlockletMetaUrlFromQuery,
+  getContinueLaunchURL,
+  getExplorerUrl,
+  getRegistryUrlFromBlockletMetaUrl,
+  getSort,
+  isDateExpired,
+  prettyDuration,
+  prettyDurationUnit,
+  sortArrayByDate
+};

package/es/validator.js

@@ -0,0 +1,10 @@
+const create = (schema) => (data, locale) => {
+  const { error, value } = schema.validate(data, { errors: { language: locale || "en" } });
+  if (error) {
+    throw new Error(error.message);
+  }
+  return value;
+};
+export {
+  create
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blocklet/launcher-util",
-  "version": "2.2.3",
+  "version": "2.2.5",
   "description": "Common constants",
   "keywords": [
     "constant"
@@ -11,6 +11,7 @@
   "main": "lib/util.js",
   "files": [
     "lib",
+    "es",
     "LICENSE",
     "package.json",
     "README.md"
@@ -50,5 +51,5 @@
     "vite": "^4.4.9",
     "vite-plugin-build": "^0.10.0"
   },
-  "gitHead": "1acf4153e622cc49e553eff6366b3516c1aa6b7a"
+  "gitHead": "fab4f0dd5e6475b7e96104219aec4da5262df3ef"
 }