@nocobase/plugin-verification 1.7.0-beta.8 → 1.8.0-beta.1

package/dist/server/{providers/index.js → collections/verifiers.js}

@@ -34,19 +34,14 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var providers_exports = {};
-__export(providers_exports, {
-  default: () => providers_default
+var verifiers_exports = {};
+__export(verifiers_exports, {
+  default: () => verifiers_default
+});
+module.exports = __toCommonJS(verifiers_exports);
+var import_database = require("@nocobase/database");
+var import_verifiers = __toESM(require("../../collections/verifiers"));
+var verifiers_default = (0, import_database.defineCollection)({
+  migrationRules: ["overwrite", "skip"],
+  ...import_verifiers.default
 });
-module.exports = __toCommonJS(providers_exports);
-var import_constants = require("../constants");
-var import_sms_aliyun = __toESM(require("./sms-aliyun"));
-var import_sms_tencent = __toESM(require("./sms-tencent"));
-async function providers_default(plugin, more = {}) {
-  const { providers } = plugin;
-  providers.register(import_constants.PROVIDER_TYPE_SMS_ALIYUN, import_sms_aliyun.default);
-  providers.register(import_constants.PROVIDER_TYPE_SMS_TENCENT, import_sms_tencent.default);
-  for (const [name, provider] of Object.entries({ ...more })) {
-    providers.register(name, provider);
-  }
-}

package/dist/server/constants.d.ts

@@ -6,7 +6,5 @@
  * 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 declare const PROVIDER_TYPE_SMS_ALIYUN = "sms-aliyun";
-export declare const PROVIDER_TYPE_SMS_TENCENT = "sms-tencent";
 export declare const CODE_STATUS_UNUSED = 0;
 export declare const CODE_STATUS_USED = 1;

package/dist/server/constants.js

@@ -27,19 +27,13 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var constants_exports = {};
 __export(constants_exports, {
   CODE_STATUS_UNUSED: () => CODE_STATUS_UNUSED,
-  CODE_STATUS_USED: () => CODE_STATUS_USED,
-  PROVIDER_TYPE_SMS_ALIYUN: () => PROVIDER_TYPE_SMS_ALIYUN,
-  PROVIDER_TYPE_SMS_TENCENT: () => PROVIDER_TYPE_SMS_TENCENT
+  CODE_STATUS_USED: () => CODE_STATUS_USED
 });
 module.exports = __toCommonJS(constants_exports);
-const PROVIDER_TYPE_SMS_ALIYUN = "sms-aliyun";
-const PROVIDER_TYPE_SMS_TENCENT = "sms-tencent";
 const CODE_STATUS_UNUSED = 0;
 const CODE_STATUS_USED = 1;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CODE_STATUS_UNUSED,
-  CODE_STATUS_USED,
-  PROVIDER_TYPE_SMS_ALIYUN,
-  PROVIDER_TYPE_SMS_TENCENT
+  CODE_STATUS_USED
 });

package/dist/server/index.d.ts

@@ -6,7 +6,10 @@
  * 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 { Interceptor, default } from './Plugin';
+export { default } from './Plugin';
 export * from './constants';
-export { Provider } from './providers/Provider';
+export { SMSOTPVerification } from './otp-verification/sms';
+export { Verification } from './verification';
+export { VerificationManager } from './verification-manager';
+export { SMSProvider } from './otp-verification/sms/providers';
 export declare const namespace: string;

package/dist/server/index.js

@@ -37,8 +37,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var server_exports = {};
 __export(server_exports, {
-  Interceptor: () => import_Plugin.Interceptor,
-  Provider: () => import_Provider.Provider,
+  SMSOTPVerification: () => import_sms.SMSOTPVerification,
+  SMSProvider: () => import_providers.SMSProvider,
+  Verification: () => import_verification.Verification,
+  VerificationManager: () => import_verification_manager.VerificationManager,
   default: () => import_Plugin.default,
   namespace: () => namespace
 });
@@ -46,12 +48,17 @@ module.exports = __toCommonJS(server_exports);
 var import_package = require("../../package.json");
 var import_Plugin = __toESM(require("./Plugin"));
 __reExport(server_exports, require("./constants"), module.exports);
-var import_Provider = require("./providers/Provider");
+var import_sms = require("./otp-verification/sms");
+var import_verification = require("./verification");
+var import_verification_manager = require("./verification-manager");
+var import_providers = require("./otp-verification/sms/providers");
 const namespace = import_package.name;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  Interceptor,
-  Provider,
+  SMSOTPVerification,
+  SMSProvider,
+  Verification,
+  VerificationManager,
   namespace,
   ...require("./constants")
 });

package/dist/server/migrations/20250111192640-providers2verificators.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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 { Migration } from '@nocobase/server';
+export default class extends Migration {
+    on: string;
+    appVersion: string;
+    up(): Promise<void>;
+}

package/dist/server/migrations/20250111192640-providers2verificators.js

@@ -0,0 +1,97 @@
+/**
+ * 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 providers2verificators_exports = {};
+__export(providers2verificators_exports, {
+  default: () => providers2verificators_default
+});
+module.exports = __toCommonJS(providers2verificators_exports);
+var import_server = require("@nocobase/server");
+var import_utils = require("@nocobase/utils");
+var import_constants = require("../../constants");
+class providers2verificators_default extends import_server.Migration {
+  on = "afterLoad";
+  // 'beforeLoad' or 'afterLoad'
+  appVersion = "<1.7.0";
+  async up() {
+    const verificatorsRepo = this.db.getRepository("verificators");
+    if (await verificatorsRepo.count()) {
+      return;
+    }
+    const repo = this.db.getRepository("verifications_providers");
+    if (!repo) {
+      return;
+    }
+    const providers = await this.db.getRepository("verifications_providers").find();
+    if (!providers.length) {
+      return;
+    }
+    const verificators = [];
+    let defaultVerificator;
+    providers.forEach((provider) => {
+      const verificator = {
+        name: `v_${(0, import_utils.uid)()}`,
+        title: provider.title,
+        verificationType: import_constants.SMS_OTP_VERIFICATION_TYPE,
+        options: {
+          provider: provider.type,
+          settings: provider.options
+        }
+      };
+      verificators.push(verificator);
+      if (provider.default) {
+        defaultVerificator = verificator;
+      }
+    });
+    if (!defaultVerificator) {
+      defaultVerificator = verificators[0];
+    }
+    const smsAuth = await this.db.getRepository("authenticators").find({
+      filter: {
+        authType: "SMS"
+      }
+    });
+    await this.db.sequelize.transaction(async (transaction) => {
+      var _a;
+      const verificatorModel = this.db.getModel("verificators");
+      await verificatorModel.bulkCreate(verificators, { transaction });
+      for (const item of smsAuth) {
+        await item.update(
+          {
+            options: {
+              ...item.options,
+              public: {
+                ...(_a = item.options) == null ? void 0 : _a.public,
+                verificator: defaultVerificator == null ? void 0 : defaultVerificator.name
+              }
+            }
+          },
+          { transaction }
+        );
+      }
+    });
+  }
+}

package/dist/server/migrations/20250507220644-fix-verifier-typo.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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 { Migration } from '@nocobase/server';
+export default class extends Migration {
+    on: string;
+    appVersion: string;
+    up(): Promise<void>;
+}

package/dist/server/migrations/20250507220644-fix-verifier-typo.js

@@ -0,0 +1,86 @@
+/**
+ * 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 fix_verifier_typo_exports = {};
+__export(fix_verifier_typo_exports, {
+  default: () => fix_verifier_typo_default
+});
+module.exports = __toCommonJS(fix_verifier_typo_exports);
+var import_server = require("@nocobase/server");
+class fix_verifier_typo_default extends import_server.Migration {
+  on = "afterLoad";
+  // 'beforeLoad' or 'afterLoad'
+  appVersion = "<1.7.0";
+  async up() {
+    const oldRepo = await this.db.getRepository("verificators");
+    const newRepo = await this.db.getRepository("verifiers");
+    const oldThroughRepo = await this.db.getRepository("usersVerificators");
+    const newThroughRepo = await this.db.getRepository("usersVerifiers");
+    await this.db.sequelize.transaction(async (transaction) => {
+      if (await newRepo.count({ transaction })) {
+        return;
+      }
+      const oldRecords = await oldRepo.find({ transaction });
+      if (!oldRecords.length) {
+        return;
+      }
+      const newRecords = oldRecords.map((record) => ({
+        createdAt: record.createdAt,
+        updatedAt: record.updatedAt,
+        name: record.name,
+        title: record.title,
+        verificationType: record.verificationType,
+        description: record.description,
+        options: record.options
+      }));
+      const model = await this.db.getModel("verifiers");
+      await model.bulkCreate(newRecords, {
+        transaction
+      });
+      if (await newThroughRepo.count({ transaction })) {
+        return;
+      }
+      const oldThroughRecords = await oldThroughRepo.find({ transaction });
+      if (!oldThroughRecords.length) {
+        return;
+      }
+      const newThroughRecords = oldThroughRecords.map((record) => ({
+        createdAt: record.createdAt,
+        updatedAt: record.updatedAt,
+        userId: record.userId,
+        uuid: record.uuid,
+        meta: record.meta,
+        verifier: record.verificator,
+        createdById: record.createdById,
+        updatedById: record.updatedById
+      }));
+      const throughModel = await this.db.getModel("usersVerifiers");
+      await throughModel.bulkCreate(newThroughRecords, {
+        transaction
+      });
+    });
+  }
+}

package/dist/server/otp-verification/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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 { Verification } from '../verification';
+export declare class OTPVerification extends Verification {
+    expiresIn: number;
+    maxVerifyAttempts: number;
+    verify({ resource, action, boundInfo, verifyParams }: {
+        resource: any;
+        action: any;
+        boundInfo: any;
+        verifyParams: any;
+    }): Promise<any>;
+    bind(userId: number, resource?: string, action?: string): Promise<{
+        uuid: string;
+        meta?: any;
+    }>;
+    onActionComplete({ verifyResult }: {
+        verifyResult: any;
+    }): Promise<void>;
+}

package/dist/server/otp-verification/index.js

@@ -0,0 +1,152 @@
+/**
+ * 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 otp_verification_exports = {};
+__export(otp_verification_exports, {
+  OTPVerification: () => OTPVerification
+});
+module.exports = __toCommonJS(otp_verification_exports);
+var import_verification = require("../verification");
+var import_constants = require("../constants");
+var import_package = __toESM(require("../../../package.json"));
+var import_dayjs = __toESM(require("dayjs"));
+class OTPVerification extends import_verification.Verification {
+  expiresIn = 120;
+  maxVerifyAttempts = 5;
+  async verify({ resource, action, boundInfo, verifyParams }) {
+    const { uuid: receiver } = boundInfo;
+    const code = verifyParams.code;
+    if (!code) {
+      return this.ctx.throw(400, "Verification code is invalid");
+    }
+    const plugin = this.ctx.app.pm.get("verification");
+    const counter = plugin.smsOTPCounter;
+    const key = `${resource}:${action}:${receiver}`;
+    let attempts = 0;
+    try {
+      attempts = await counter.get(key);
+    } catch (e) {
+      this.ctx.logger.error(e.message, {
+        module: "verification",
+        submodule: "sms-otp",
+        method: "verify",
+        receiver,
+        action: `${resource}:${action}`
+      });
+      this.ctx.throw(500, "Internal Server Error");
+    }
+    if (attempts > this.maxVerifyAttempts) {
+      this.ctx.throw(
+        429,
+        this.ctx.t("Too many failed attempts. Please request a new verification code.", { ns: import_package.default.name })
+      );
+    }
+    const repo = this.ctx.db.getRepository("otpRecords");
+    const item = await repo.findOne({
+      filter: {
+        receiver,
+        action: `${resource}:${action}`,
+        code,
+        expiresAt: {
+          $dateAfter: /* @__PURE__ */ new Date()
+        },
+        status: import_constants.CODE_STATUS_UNUSED,
+        verifierName: this.verifier.name
+      }
+    });
+    if (!item) {
+      let attempts2 = 0;
+      try {
+        let ttl = this.expiresIn * 1e3;
+        const record = await repo.findOne({
+          filter: {
+            action: `${resource}:${action}`,
+            receiver,
+            status: import_constants.CODE_STATUS_UNUSED,
+            expiresAt: {
+              $dateAfter: /* @__PURE__ */ new Date()
+            }
+          }
+        });
+        if (record) {
+          ttl = (0, import_dayjs.default)(record.get("expiresAt")).diff((0, import_dayjs.default)());
+        }
+        attempts2 = await counter.incr(key, ttl);
+      } catch (e) {
+        this.ctx.logger.error(e.message, {
+          module: "verification",
+          submodule: "totp-authenticator",
+          method: "verify",
+          receiver,
+          action: `${resource}:${action}`
+        });
+        this.ctx.throw(500, "Internal Server Error");
+      }
+      if (attempts2 > this.maxVerifyAttempts) {
+        this.ctx.throw(
+          429,
+          this.ctx.t("Too many failed attempts. Please request a new verification code", { ns: import_package.default.name })
+        );
+      }
+      return this.ctx.throw(400, {
+        code: "InvalidVerificationCode",
+        message: this.ctx.t("Verification code is invalid", { ns: import_package.default.name })
+      });
+    }
+    await counter.reset(key);
+    return { codeInfo: item };
+  }
+  async bind(userId, resource, action) {
+    const { uuid, code } = this.ctx.action.params.values || {};
+    await this.verify({
+      resource: resource || "verifiers",
+      action: action || "bind",
+      boundInfo: { uuid },
+      verifyParams: { code }
+    });
+    return { uuid };
+  }
+  async onActionComplete({ verifyResult }) {
+    const { codeInfo } = verifyResult;
+    await codeInfo.update({
+      status: import_constants.CODE_STATUS_USED
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OTPVerification
+});

package/dist/server/otp-verification/sms/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 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 { Registry } from '@nocobase/utils';
+import { OTPVerification } from '..';
+import { SMSProvider } from './providers';
+type SMSProviderOptions = {
+    title: string;
+    provider: typeof SMSProvider;
+};
+export declare class SMSOTPProviderManager {
+    providers: Registry<SMSProviderOptions>;
+    registerProvider(type: string, options: SMSProviderOptions): void;
+    listProviders(): {
+        name: string;
+        title: string;
+    }[];
+}
+export declare class SMSOTPVerification extends OTPVerification {
+    getProvider(): Promise<SMSProvider>;
+    getPublicBoundInfo(userId: number): Promise<{
+        bound: boolean;
+        publicInfo?: undefined;
+    } | {
+        bound: boolean;
+        publicInfo: string;
+    }>;
+    validateBoundInfo({ uuid: phone }: {
+        uuid: any;
+    }): Promise<boolean>;
+}
+export {};

package/dist/server/otp-verification/sms/index.js

@@ -0,0 +1,87 @@
+/**
+ * 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 sms_exports = {};
+__export(sms_exports, {
+  SMSOTPProviderManager: () => SMSOTPProviderManager,
+  SMSOTPVerification: () => SMSOTPVerification
+});
+module.exports = __toCommonJS(sms_exports);
+var import_utils = require("@nocobase/utils");
+var import__ = require("..");
+class SMSOTPProviderManager {
+  providers = new import_utils.Registry();
+  registerProvider(type, options) {
+    this.providers.register(type, options);
+  }
+  listProviders() {
+    return Array.from(this.providers.getEntities()).map(([providerType, options]) => ({
+      name: providerType,
+      title: options.title
+    }));
+  }
+}
+class SMSOTPVerification extends import__.OTPVerification {
+  async getProvider() {
+    const { provider: providerType, settings } = this.options;
+    if (!providerType) {
+      return null;
+    }
+    const plugin = this.ctx.app.pm.get("verification");
+    const providerOptions = plugin.smsOTPProviderManager.providers.get(providerType);
+    if (!providerOptions) {
+      return null;
+    }
+    const Provider = providerOptions.provider;
+    if (!Provider) {
+      return null;
+    }
+    const options = this.ctx.app.environment.renderJsonTemplate(settings);
+    return new Provider(options);
+  }
+  async getPublicBoundInfo(userId) {
+    const boundInfo = await this.getBoundInfo(userId);
+    if (!boundInfo) {
+      return { bound: false };
+    }
+    const { uuid: phone } = boundInfo;
+    return {
+      bound: true,
+      publicInfo: "*".repeat(phone.length - 4) + phone.slice(-4)
+    };
+  }
+  async validateBoundInfo({ uuid: phone }) {
+    if (!phone) {
+      throw new Error(this.ctx.t("Not a valid cellphone number, please re-enter"));
+    }
+    return true;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SMSOTPProviderManager,
+  SMSOTPVerification
+});

package/dist/server/{providers/Provider.d.ts → otp-verification/sms/providers/index.d.ts}

@@ -6,11 +6,9 @@
  * 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 Plugin from '../Plugin';
-export declare class Provider {
-    protected plugin: Plugin;
+export declare class SMSProvider {
     protected options: any;
-    constructor(plugin: Plugin, options: any);
+    constructor(options: any);
     send(receiver: string, data: {
         [key: string]: any;
     }): Promise<any>;

package/dist/server/{providers/Provider.js → otp-verification/sms/providers/index.js}

@@ -24,21 +24,19 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var Provider_exports = {};
-__export(Provider_exports, {
-  Provider: () => Provider
+var providers_exports = {};
+__export(providers_exports, {
+  SMSProvider: () => SMSProvider
 });
-module.exports = __toCommonJS(Provider_exports);
-class Provider {
-  constructor(plugin, options) {
-    this.plugin = plugin;
-    this.options = plugin.app.environment.renderJsonTemplate(options);
+module.exports = __toCommonJS(providers_exports);
+class SMSProvider {
+  constructor(options) {
+    this.options = options;
   }
-  options;
   async send(receiver, data) {
   }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  Provider
+  SMSProvider
 });