@nocobase/plugin-license 2.0.0-alpha.8 → 2.0.0-beta.1

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

@@ -0,0 +1,16 @@
+/**
+ * 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';
+export declare function getClientDomain(ctx: any): string;
+export declare function isDomainMatch(currentDomain: string, keyData: KeyData): boolean;
+export declare function isEnvMatch(env: Env, keyData: KeyData): boolean;
+export declare function isDbMatch(env: any, keyData: any): boolean;
+export declare function isSysMatch(env: Env, keyData: KeyData): boolean;
+export declare function getEnvOnce(): any;

package/dist/server/utils/env.js

@@ -0,0 +1,125 @@
+/**
+ * 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 env_exports = {};
+__export(env_exports, {
+  getClientDomain: () => getClientDomain,
+  getEnvOnce: () => getEnvOnce,
+  isDbMatch: () => isDbMatch,
+  isDomainMatch: () => isDomainMatch,
+  isEnvMatch: () => isEnvMatch,
+  isSysMatch: () => isSysMatch
+});
+module.exports = __toCommonJS(env_exports);
+var import_license_kit = require("@nocobase/license-kit");
+var import_omit = __toESM(require("lodash/omit"));
+var import_isEqual = __toESM(require("lodash/isEqual"));
+function getClientDomain(ctx) {
+  var _a, _b, _c, _d;
+  if (!ctx) return "";
+  const referer = typeof ctx.get === "function" ? ctx.get("referer") : null;
+  if (referer) {
+    try {
+      return new URL(referer).origin;
+    } catch {
+      console.error("Invalid Referer URL:", referer);
+    }
+  }
+  const protocol = ((_a = ctx.headers) == null ? void 0 : _a["x-forwarded-proto"]) || ctx.protocol || ((_b = ctx.request) == null ? void 0 : _b.protocol) || "http";
+  const host = ((_c = ctx.headers) == null ? void 0 : _c["x-forwarded-host"]) || ctx.host || ((_d = ctx.request) == null ? void 0 : _d.host) || "";
+  return host ? `${protocol}://${host}` : "";
+}
+function matchSingleDomain(licenseDomain, currentDomain) {
+  let hostname = "";
+  let port = "";
+  try {
+    const url = new URL(currentDomain);
+    hostname = url.hostname;
+    port = url.port ? `:${url.port}` : "";
+  } catch {
+    return false;
+  }
+  const fullDomain = hostname + port;
+  if (!licenseDomain.includes("*")) {
+    return fullDomain === licenseDomain;
+  }
+  const base = licenseDomain.replace("*", "");
+  return fullDomain.endsWith(base);
+}
+function isDomainMatch(currentDomain, keyData) {
+  var _a;
+  if (!((_a = keyData == null ? void 0 : keyData.licenseKey) == null ? void 0 : _a.domain) || !currentDomain) return false;
+  const licenseDomains = keyData.licenseKey.domain.split(",").map((d) => d.trim()).filter(Boolean);
+  return licenseDomains.some((licenseDomain) => matchSingleDomain(licenseDomain, currentDomain));
+}
+function isEnvMatch(env, keyData) {
+  return isDbMatch(env, keyData) && isSysMatch(env, keyData);
+}
+function isDbMatch(env, keyData) {
+  var _a;
+  const a = env == null ? void 0 : env.db;
+  const b = (_a = keyData == null ? void 0 : keyData.instanceData) == null ? void 0 : _a.db;
+  if (!a || !b) return false;
+  if ((a == null ? void 0 : a.id) && (b == null ? void 0 : b.id)) return a.id === b.id;
+  return (0, import_isEqual.default)((0, import_omit.default)(a, ["id"]), (0, import_omit.default)(b, ["id"]));
+}
+function isSysMatch(env, keyData) {
+  const instance = keyData == null ? void 0 : keyData.instanceData;
+  if (!env || !instance) return false;
+  const normalize = (item) => {
+    if (!item) return null;
+    return {
+      sys: item.sys ?? null,
+      osVer: item.osVer ?? null
+    };
+  };
+  const a = normalize(env);
+  const b = normalize(instance);
+  return (0, import_isEqual.default)(a, b);
+}
+let envPromise;
+function getEnvOnce() {
+  return envPromise ?? (envPromise = (0, import_license_kit.getEnvAsync)());
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getClientDomain,
+  getEnvOnce,
+  isDbMatch,
+  isDomainMatch,
+  isEnvMatch,
+  isSysMatch
+});

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

@@ -0,0 +1,15 @@
+/**
+ * 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 * from './key';
+export * from './env';
+export * from './interface';
+export * from './license';
+export * from './instance';
+export * from './plugin';
+export * from './pkg';

package/dist/server/utils/index.js

@@ -0,0 +1,42 @@
+/**
+ * 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 __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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+module.exports = __toCommonJS(utils_exports);
+__reExport(utils_exports, require("./key"), module.exports);
+__reExport(utils_exports, require("./env"), module.exports);
+__reExport(utils_exports, require("./interface"), module.exports);
+__reExport(utils_exports, require("./license"), module.exports);
+__reExport(utils_exports, require("./instance"), module.exports);
+__reExport(utils_exports, require("./plugin"), module.exports);
+__reExport(utils_exports, require("./pkg"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./key"),
+  ...require("./env"),
+  ...require("./interface"),
+  ...require("./license"),
+  ...require("./instance"),
+  ...require("./plugin"),
+  ...require("./pkg")
+});

package/dist/server/{utils.d.ts → utils/instance.d.ts}

@@ -8,5 +8,4 @@
  */
 export declare function getInstanceId(): Promise<string>;
 export declare function createInstanceId(force?: boolean): Promise<unknown>;
-export declare function saveLicenseKey(licenseKey: string): Promise<void>;
 export declare function isLicenseKeyExists(): Promise<boolean>;

package/dist/server/{utils.js → utils/instance.js}

@@ -34,14 +34,13 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var utils_exports = {};
-__export(utils_exports, {
+var instance_exports = {};
+__export(instance_exports, {
   createInstanceId: () => createInstanceId,
   getInstanceId: () => getInstanceId,
-  isLicenseKeyExists: () => isLicenseKeyExists,
-  saveLicenseKey: () => saveLicenseKey
+  isLicenseKeyExists: () => isLicenseKeyExists
 });
-module.exports = __toCommonJS(utils_exports);
+module.exports = __toCommonJS(instance_exports);
 var import_fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
 var import_child_process = require("child_process");
@@ -63,11 +62,6 @@ async function createInstanceId(force = false) {
     });
   });
 }
-async function saveLicenseKey(licenseKey) {
-  const dir = import_path.default.resolve(process.cwd(), "storage/.license");
-  const filePath = import_path.default.resolve(dir, "license-key");
-  import_fs.default.writeFileSync(filePath, licenseKey);
-}
 async function isLicenseKeyExists() {
   const dir = import_path.default.resolve(process.cwd(), "storage/.license");
   const filePath = import_path.default.resolve(dir, "license-key");
@@ -77,6 +71,5 @@ async function isLicenseKeyExists() {
 0 && (module.exports = {
   createInstanceId,
   getInstanceId,
-  isLicenseKeyExists,
-  saveLicenseKey
+  isLicenseKeyExists
 });

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>;