@nocobase/plugin-license 2.0.0-alpha.51 → 2.0.0-alpha.53

package/dist/server/utils/interface.d.ts

@@ -0,0 +1,56 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+export interface KeyData {
+    upgradeExpirationDate: string;
+    licenseKey: {
+        id: string;
+        licensee: string;
+        desc: string;
+        type: string;
+        domain: string;
+        licenseStatus: string;
+    };
+    plugins: Array<{
+        displayName: string;
+        packageName: string;
+        updateExpirationDate?: string;
+    }>;
+    instanceData: {
+        timestamp: string;
+        sys: string;
+        osVer: string;
+        kVer: string;
+        hostname: string;
+        mac: string;
+        db: {
+            type: string;
+            name: string;
+            oid: number;
+            ver: string;
+            id?: string;
+        };
+        container: {
+            name: string;
+            id: string;
+        };
+    };
+    service: {
+        domain: string;
+        [key: string]: any;
+    };
+    accessKeyId: string;
+    accessKeySecret: string;
+    timestamp: number;
+}
+export declare const enum LICENSE_ERROR {
+    KEY_FORMAT_ERROR = "KEY_FORMAT_ERROR",
+    KEY_NOT_FOUND = "KEY_NOT_FOUND",
+    KEY_READ_ERROR = "KEY_READ_ERROR"
+}
+export declare const CACHE_KEY = "license-key";

package/dist/server/utils/interface.js

@@ -0,0 +1,44 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var interface_exports = {};
+__export(interface_exports, {
+  CACHE_KEY: () => CACHE_KEY,
+  LICENSE_ERROR: () => LICENSE_ERROR
+});
+module.exports = __toCommonJS(interface_exports);
+var LICENSE_ERROR = /* @__PURE__ */ ((LICENSE_ERROR2) => {
+  LICENSE_ERROR2["KEY_FORMAT_ERROR"] = "KEY_FORMAT_ERROR";
+  LICENSE_ERROR2["KEY_NOT_FOUND"] = "KEY_NOT_FOUND";
+  LICENSE_ERROR2["KEY_READ_ERROR"] = "KEY_READ_ERROR";
+  return LICENSE_ERROR2;
+})(LICENSE_ERROR || {});
+const CACHE_KEY = "license-key";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CACHE_KEY,
+  LICENSE_ERROR
+});

package/dist/server/utils/key.d.ts

@@ -0,0 +1,24 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { Context } from 'koa';
+import { KeyData } from './interface';
+export declare function request({ url, method, body, headers, timeout, }: {
+    url: string;
+    method?: string;
+    body?: Record<string, any>;
+    headers?: any;
+    timeout?: number;
+}, ctx?: Context): Promise<any>;
+export declare function saveLicenseKey(licenseKey: string, ctx?: any): Promise<void>;
+export declare function getLocalKeyData(): Promise<any>;
+export declare function getKey(ctx?: Context): Promise<string>;
+export declare function getLicenseStatus(keyData: KeyData): Promise<'active' | 'invalid'>;
+export declare function parseKey(key: string): KeyData;
+export declare function getKeyInfo(ctx?: Context): Promise<KeyData>;
+export declare function isDateExpired(upgradeExpirationDate: string): boolean;

package/dist/server/utils/key.js

@@ -0,0 +1,211 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var key_exports = {};
+__export(key_exports, {
+  getKey: () => getKey,
+  getKeyInfo: () => getKeyInfo,
+  getLicenseStatus: () => getLicenseStatus,
+  getLocalKeyData: () => getLocalKeyData,
+  isDateExpired: () => isDateExpired,
+  parseKey: () => parseKey,
+  request: () => request,
+  saveLicenseKey: () => saveLicenseKey
+});
+module.exports = __toCommonJS(key_exports);
+var import_license_kit = require("@nocobase/license-kit");
+var import_path = __toESM(require("path"));
+var import_fs = __toESM(require("fs"));
+var import_interface2 = require("./interface");
+var import_axios = __toESM(require("axios"));
+var import_logger = require("@nocobase/logger");
+async function request({
+  url,
+  method = "GET",
+  body,
+  headers,
+  timeout = 5e3
+}, ctx) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const xHeaders = {
+    "Content-Type": "application/json",
+    "X-Hostname": new URL(url).hostname,
+    "X-Timezone": (_b = (_a = ctx == null ? void 0 : ctx.request) == null ? void 0 : _a.headers) == null ? void 0 : _b["x-timezone"],
+    "X-Locale": (_d = (_c = ctx == null ? void 0 : ctx.request) == null ? void 0 : _c.headers) == null ? void 0 : _d["x-locale"],
+    "X-Role": (_f = (_e = ctx == null ? void 0 : ctx.request) == null ? void 0 : _e.headers) == null ? void 0 : _f["x-role"],
+    "X-Authenticator": (_h = (_g = ctx == null ? void 0 : ctx.request) == null ? void 0 : _g.headers) == null ? void 0 : _h["x-authenticator"]
+  };
+  try {
+    const res = await (0, import_axios.default)({
+      url,
+      method,
+      timeout,
+      headers: {
+        ...xHeaders,
+        ...headers
+      },
+      data: body || {}
+    });
+    return res.data;
+  } catch (err) {
+    if (err.code === "ECONNABORTED") {
+      throw new Error(`Request timeout after ${timeout}ms`);
+    }
+    throw err;
+  }
+}
+async function saveLicenseKey(licenseKey, ctx) {
+  const dir = import_path.default.resolve(process.cwd(), "storage/.license");
+  const filePath = import_path.default.resolve(dir, "license-key");
+  await import_fs.default.promises.writeFile(filePath, licenseKey);
+  if (ctx && ctx.cache) {
+    await ctx.cache.set("license-key", licenseKey);
+  }
+}
+async function getLocalKeyData() {
+  const keyFile = import_path.default.resolve(process.cwd(), "storage/.license/license-key");
+  try {
+    const key = (await import_fs.default.promises.readFile(keyFile, "utf8")).trim();
+    return JSON.parse((0, import_license_kit.keyDecrypt)(key));
+  } catch (e) {
+    return null;
+  }
+}
+async function getKey(ctx) {
+  var _a, _b;
+  let key;
+  const keyFile = import_path.default.resolve(process.cwd(), "storage/.license/license-key");
+  if (ctx == null ? void 0 : ctx.cache) {
+    try {
+      key = await ctx.cache.get(import_interface2.CACHE_KEY);
+    } catch (e) {
+      import_logger.logger.warn("Failed to get license key from cache", e);
+    }
+  }
+  if (!key) {
+    try {
+      key = (await import_fs.default.promises.readFile(keyFile, "utf8")).trim();
+    } catch (e) {
+      import_logger.logger.error("Failed to read license key file", e);
+      throw new Error("notfound");
+    }
+  }
+  if (!key) {
+    import_logger.logger.error("License key not found");
+    throw new Error("notfound");
+  }
+  let keyData;
+  try {
+    keyData = JSON.parse((0, import_license_kit.keyDecrypt)(key));
+  } catch (e) {
+    import_logger.logger.error("Failed to parse license key");
+    throw new Error("invalid");
+  }
+  try {
+    const { data } = await request({
+      url: `${(_a = keyData == null ? void 0 : keyData.service) == null ? void 0 : _a.domain}/api/license_keys:getKey`,
+      method: "POST",
+      body: {
+        access_key_id: keyData == null ? void 0 : keyData.accessKeyId,
+        access_key_secret: keyData == null ? void 0 : keyData.accessKeySecret
+      },
+      headers: ((_b = keyData == null ? void 0 : keyData.service) == null ? void 0 : _b.headers) || {}
+    });
+    const { key: remoteKey } = data || {};
+    if (remoteKey && typeof remoteKey === "string") {
+      await saveLicenseKey(remoteKey, ctx);
+      return remoteKey;
+    }
+  } catch (e) {
+    return key;
+  }
+  return key;
+}
+async function getLicenseStatus(keyData) {
+  var _a, _b, _c;
+  if (!keyData) {
+    return "invalid";
+  }
+  if (((_a = keyData == null ? void 0 : keyData.licenseKey) == null ? void 0 : _a.licenseStatus) === "invalid") {
+    return "invalid";
+  }
+  try {
+    const { data } = await request({
+      url: `${(_b = keyData == null ? void 0 : keyData.service) == null ? void 0 : _b.domain}/api/license_keys:getKeyStatus`,
+      method: "POST",
+      body: {
+        access_key_id: keyData == null ? void 0 : keyData.accessKeyId,
+        access_key_secret: keyData == null ? void 0 : keyData.accessKeySecret
+      },
+      headers: ((_c = keyData == null ? void 0 : keyData.service) == null ? void 0 : _c.headers) || {}
+    });
+    if ((data == null ? void 0 : data.status) === "active") {
+      return "active";
+    } else {
+      return "invalid";
+    }
+  } catch (e) {
+    return "active";
+  }
+}
+function parseKey(key) {
+  try {
+    return JSON.parse((0, import_license_kit.keyDecrypt)(key));
+  } catch (e) {
+    throw new Error("invalid");
+  }
+}
+async function getKeyInfo(ctx) {
+  const key = await getKey(ctx);
+  return parseKey(key);
+}
+function isDateExpired(upgradeExpirationDate) {
+  if (!upgradeExpirationDate) {
+    return true;
+  }
+  return /* @__PURE__ */ new Date() > new Date(upgradeExpirationDate);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getKey,
+  getKeyInfo,
+  getLicenseStatus,
+  getLocalKeyData,
+  isDateExpired,
+  parseKey,
+  request,
+  saveLicenseKey
+});

package/dist/server/utils/license.d.ts

@@ -0,0 +1,34 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { Env } from '@nocobase/license-kit';
+import { KeyData } from './interface';
+import { PluginData } from './plugin';
+export interface LicenseValidateResult {
+    current: {
+        env: Env;
+        domain: string;
+    };
+    dbMatch: boolean;
+    sysMatch: boolean;
+    envMatch: boolean;
+    domainMatch: boolean;
+    isExpired: boolean;
+    isServiceConnection: boolean;
+    isPkgLogin: boolean;
+    keyData: KeyData;
+    pkgUrl: string;
+    licenseStatus: 'active' | 'invalid';
+    pluginsLicensed: boolean;
+    plugins: PluginData[];
+    keyStatus?: 'invalid' | 'notfound';
+}
+export declare function getLicenseValidate({ key, ctx }: {
+    key?: string;
+    ctx?: any;
+}): Promise<LicenseValidateResult>;

package/dist/server/utils/license.js

@@ -0,0 +1,80 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var license_exports = {};
+__export(license_exports, {
+  getLicenseValidate: () => getLicenseValidate
+});
+module.exports = __toCommonJS(license_exports);
+var import_key = require("./key");
+var import_env = require("./env");
+var import_pkg = require("./pkg");
+var import_plugin = require("./plugin");
+async function getLicenseValidate({ key, ctx }) {
+  var _a;
+  const currentDomain = (0, import_env.getClientDomain)(ctx);
+  const currentEnv = await (0, import_env.getEnvOnce)();
+  let keyStatus;
+  let keyData;
+  try {
+    const keyStr = key || await (0, import_key.getKey)(ctx);
+    keyData = (0, import_key.parseKey)(keyStr);
+  } catch (e) {
+    keyStatus = e == null ? void 0 : e.message;
+  }
+  const domainMatch = (0, import_env.isDomainMatch)(currentDomain, keyData);
+  const dbMatch = (0, import_env.isDbMatch)(currentEnv, keyData);
+  const sysMatch = (0, import_env.isSysMatch)(currentEnv, keyData);
+  const envMatch = dbMatch && sysMatch;
+  const isExpired = (0, import_key.isDateExpired)(keyData == null ? void 0 : keyData.upgradeExpirationDate);
+  const plugins = await (0, import_plugin.getPlugins)({ keyData, ctx });
+  const pluginsLicensed = (0, import_plugin.getPluginsLicenseStatus)({ plugins });
+  const isPkgLogin = await (0, import_pkg.testPkgLogin)(keyData);
+  const isServiceConnection = await (0, import_pkg.testServiceConnection)(keyData);
+  return {
+    current: {
+      env: currentEnv,
+      domain: currentDomain ? new URL(currentDomain).host : ""
+    },
+    keyData,
+    dbMatch,
+    sysMatch,
+    envMatch,
+    domainMatch,
+    isExpired,
+    isPkgLogin,
+    isServiceConnection,
+    pkgUrl: (0, import_pkg.getNocoBasePkgUrl)(),
+    plugins,
+    pluginsLicensed,
+    keyStatus,
+    licenseStatus: (_a = keyData == null ? void 0 : keyData.licenseKey) == null ? void 0 : _a.licenseStatus
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getLicenseValidate
+});

package/dist/server/utils/pkg.d.ts

@@ -0,0 +1,13 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { KeyData } from './interface';
+export declare function getNocoBasePkgUrl(): string;
+export declare function testPkgConnection(): Promise<any>;
+export declare function testPkgLogin(keyData: KeyData | Record<string, any>): Promise<boolean>;
+export declare function testServiceConnection(keyData: KeyData): Promise<any>;

package/dist/server/utils/pkg.js

@@ -0,0 +1,115 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pkg_exports = {};
+__export(pkg_exports, {
+  getNocoBasePkgUrl: () => getNocoBasePkgUrl,
+  testPkgConnection: () => testPkgConnection,
+  testPkgLogin: () => testPkgLogin,
+  testServiceConnection: () => testServiceConnection
+});
+module.exports = __toCommonJS(pkg_exports);
+var http = __toESM(require("http"));
+var https = __toESM(require("https"));
+var import_axios = __toESM(require("axios"));
+function getNocoBasePkgUrl() {
+  var _a;
+  return ((_a = process.env) == null ? void 0 : _a.NOCOBASE_PKG_URL) || "https://pkg.nocobase.com/";
+}
+async function testDomain(url) {
+  return new Promise((resolve) => {
+    const client = url.startsWith("https") ? https : http;
+    const req = client.get(url, (res) => {
+      resolve({
+        reachable: true,
+        statusCode: res.statusCode
+      });
+      req.end();
+    });
+    req.on("error", (err) => {
+      resolve({
+        reachable: false,
+        error: err.message
+      });
+    });
+    req.setTimeout(5e3, () => {
+      req.destroy();
+      resolve({
+        reachable: false,
+        error: "Timeout"
+      });
+    });
+  });
+}
+async function testPkgConnection() {
+  const res = await testDomain(getNocoBasePkgUrl());
+  return res.reachable;
+}
+async function testPkgLogin(keyData) {
+  try {
+    const NOCOBASE_PKG_URL = getNocoBasePkgUrl();
+    const { accessKeyId, accessKeySecret } = keyData || {};
+    if (!accessKeyId || !accessKeySecret) {
+      return false;
+    }
+    const credentials = { username: accessKeyId, password: accessKeySecret };
+    const res1 = await import_axios.default.post(`${NOCOBASE_PKG_URL}-/verdaccio/sec/login`, credentials, {
+      responseType: "json"
+    });
+    const token = res1.data.token;
+    if (!token) {
+      return false;
+    }
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+async function testServiceConnection(keyData) {
+  var _a, _b;
+  if (!((_a = keyData == null ? void 0 : keyData.service) == null ? void 0 : _a.domain)) {
+    return false;
+  }
+  const res = await testDomain((_b = keyData == null ? void 0 : keyData.service) == null ? void 0 : _b.domain);
+  return res.reachable;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getNocoBasePkgUrl,
+  testPkgConnection,
+  testPkgLogin,
+  testServiceConnection
+});

package/dist/server/utils/plugin.d.ts

@@ -0,0 +1,24 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { KeyData } from './interface';
+export interface PluginData {
+    name: string;
+    packageName: string;
+    status: string;
+    expirationDate: string;
+    enabled: boolean;
+    installed: boolean;
+}
+export declare function getPlugins({ keyData, ctx }: {
+    keyData: KeyData;
+    ctx: any;
+}): Promise<PluginData[]>;
+export declare function getPluginsLicenseStatus({ plugins }: {
+    plugins: PluginData[];
+}): boolean;