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

package/dist/server/Plugin.d.ts

@@ -6,23 +6,15 @@
  * 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 '@nocobase/actions';
-import { HandlerType } from '@nocobase/resourcer';
 import { Plugin } from '@nocobase/server';
-import { Registry } from '@nocobase/utils';
-import { Provider } from '.';
-export interface Interceptor {
-    manual?: boolean;
-    expiresIn?: number;
-    getReceiver(ctx: any): string;
-    getCode?(ctx: any): string;
-    validate?(ctx: Context, receiver: string): boolean | Promise<boolean>;
-}
+import { VerificationManager } from './verification-manager';
+import { SMSOTPProviderManager } from './otp-verification/sms';
+import { Counter } from '@nocobase/cache';
 export default class PluginVerficationServer extends Plugin {
-    providers: Registry<typeof Provider>;
-    interceptors: Registry<Interceptor>;
-    intercept: HandlerType;
-    install(): Promise<void>;
+    verificationManager: VerificationManager;
+    smsOTPProviderManager: SMSOTPProviderManager;
+    smsOTPCounter: Counter;
+    afterAdd(): Promise<void>;
     load(): Promise<void>;
-    getDefault(): Promise<any>;
+    install(): Promise<void>;
 }

package/dist/server/Plugin.js

@@ -39,55 +39,81 @@ __export(Plugin_exports, {
   default: () => PluginVerficationServer
 });
 module.exports = __toCommonJS(Plugin_exports);
-var import_path = __toESM(require("path"));
-var import_database = require("@nocobase/database");
 var import_server = require("@nocobase/server");
 var import_utils = require("@nocobase/utils");
 var import__ = require(".");
-var import_actions2 = __toESM(require("./actions"));
-var import_constants = require("./constants");
-var import_providers = __toESM(require("./providers"));
+var import_constants = require("../constants");
+var import_verification_manager = require("./verification-manager");
+var import_sms = require("./otp-verification/sms");
+var import_constants2 = require("../constants");
+var import_verifiers = __toESM(require("./actions/verifiers"));
+var import_sms_aliyun = __toESM(require("./otp-verification/sms/providers/sms-aliyun"));
+var import_sms_tencent = __toESM(require("./otp-verification/sms/providers/sms-tencent"));
+var import_sms_otp_providers = __toESM(require("./otp-verification/sms/resource/sms-otp-providers"));
+var import_sms_otp = __toESM(require("./otp-verification/sms/resource/sms-otp"));
 class PluginVerficationServer extends import_server.Plugin {
-  providers = new import_utils.Registry();
-  interceptors = new import_utils.Registry();
-  intercept = async (context, next) => {
-    const { resourceName, actionName, values } = context.action.params;
-    const key = `${resourceName}:${actionName}`;
-    const interceptor = this.interceptors.get(key);
-    if (!interceptor) {
-      return context.throw(400);
-    }
-    const receiver = interceptor.getReceiver(context);
-    const content = interceptor.getCode ? interceptor.getCode(context) : values.code;
-    if (!receiver || !content) {
-      return context.throw(400);
-    }
-    const VerificationRepo = this.db.getRepository("verifications");
-    const item = await VerificationRepo.findOne({
-      filter: {
-        receiver,
-        type: key,
-        content,
-        expiresAt: {
-          [import_database.Op.gt]: /* @__PURE__ */ new Date()
+  verificationManager = new import_verification_manager.VerificationManager({ db: this.db });
+  smsOTPProviderManager = new import_sms.SMSOTPProviderManager();
+  smsOTPCounter;
+  async afterAdd() {
+    this.app.on("afterLoad", async () => {
+      this.smsOTPCounter = await this.app.cacheManager.createCounter(
+        {
+          name: "smsOTPCounter",
+          prefix: "sms-otp:attempts"
         },
-        status: import_constants.CODE_STATUS_UNUSED
+        this.app.lockManager
+      );
+    });
+  }
+  async load() {
+    this.app.dataSourceManager.use(this.verificationManager.middleware());
+    this.app.resourceManager.define(import_sms_otp_providers.default);
+    this.app.resourceManager.define(import_sms_otp.default);
+    Object.entries(import_verifiers.default).forEach(
+      ([action, handler]) => this.app.resourceManager.registerActionHandler(`verifiers:${action}`, handler)
+    );
+    this.app.acl.allow("verifiers", "listByUser", "loggedIn");
+    this.app.acl.allow("verifiers", "listForVerify", "loggedIn");
+    this.app.acl.allow("verifiers", "bind", "loggedIn");
+    this.app.acl.allow("verifiers", "unbind", "loggedIn");
+    this.app.acl.allow("smsOTP", "create", "loggedIn");
+    this.app.acl.allow("smsOTP", "publicCreate");
+    this.app.acl.registerSnippet({
+      name: `pm.${this.name}.verifiers`,
+      actions: ["verifiers:*", "smsOTPProviders:*"]
+    });
+    this.verificationManager.registerVerificationType(import_constants2.SMS_OTP_VERIFICATION_TYPE, {
+      title: (0, import_utils.tval)("SMS OTP", { ns: import__.namespace }),
+      description: (0, import_utils.tval)("Get one-time codes sent to your phone via SMS to complete authentication requests.", {
+        ns: import__.namespace
+      }),
+      bindingRequired: true,
+      verification: import_sms.SMSOTPVerification
+    });
+    this.verificationManager.addSceneRule(
+      (scene, verificationType) => ["auth-sms", "unbind-verifier"].includes(scene) && verificationType === import_constants2.SMS_OTP_VERIFICATION_TYPE
+    );
+    this.verificationManager.registerAction("verifiers:bind", {
+      manual: true,
+      getBoundInfoFromCtx: (ctx) => {
+        return ctx.action.params.values || {};
       }
     });
-    if (!item) {
-      return context.throw(400, {
-        code: "InvalidVerificationCode",
-        message: context.t("Verification code is invalid", { ns: import__.namespace })
-      });
-    }
-    try {
-      await next();
-    } finally {
-      await item.update({
-        status: import_constants.CODE_STATUS_USED
-      });
-    }
-  };
+    this.verificationManager.registerScene("unbind-verifier", {
+      actions: {
+        "verifiers:unbind": {}
+      }
+    });
+    this.smsOTPProviderManager.registerProvider(import_constants.PROVIDER_TYPE_SMS_ALIYUN, {
+      title: (0, import_utils.tval)("Aliyun SMS", { ns: import__.namespace }),
+      provider: import_sms_aliyun.default
+    });
+    this.smsOTPProviderManager.registerProvider(import_constants.PROVIDER_TYPE_SMS_TENCENT, {
+      title: (0, import_utils.tval)("Tencent SMS", { ns: import__.namespace }),
+      provider: import_sms_tencent.default
+    });
+  }
   async install() {
     const {
       DEFAULT_SMS_VERIFY_CODE_PROVIDER,
@@ -122,33 +148,4 @@ class PluginVerficationServer extends import_server.Plugin {
       });
     }
   }
-  async load() {
-    const { app, db, options } = this;
-    await this.importCollections(import_path.default.resolve(__dirname, "collections"));
-    await (0, import_providers.default)(this);
-    (0, import_actions2.default)(this);
-    const self = this;
-    app.resourceManager.use(async function verificationIntercept(context, next) {
-      const { resourceName, actionName, values } = context.action.params;
-      const key = `${resourceName}:${actionName}`;
-      const interceptor = self.interceptors.get(key);
-      if (!interceptor || interceptor.manual) {
-        return next();
-      }
-      return self.intercept(context, next);
-    });
-    app.acl.allow("verifications", "create", "public");
-    this.app.acl.registerSnippet({
-      name: `pm.${this.name}.providers`,
-      actions: ["verifications_providers:*"]
-    });
-  }
-  async getDefault() {
-    const providerRepo = this.db.getRepository("verifications_providers");
-    return providerRepo.findOne({
-      filter: {
-        default: true
-      }
-    });
-  }
 }

package/dist/server/actions/verifiers.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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, Next } from '@nocobase/actions';
+declare const _default: {
+    listTypes: (ctx: Context, next: Next) => Promise<void>;
+    listByScene: (ctx: Context, next: Next) => Promise<any>;
+    listByUser: (ctx: Context, next: Next) => Promise<void>;
+    listForVerify: (ctx: Context, next: Next) => Promise<any>;
+    bind: (ctx: Context, next: Next) => Promise<never>;
+    unbind: (ctx: Context, next: Next) => Promise<never>;
+};
+export default _default;

package/dist/server/actions/verifiers.js

@@ -0,0 +1,175 @@
+/**
+ * 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 verifiers_exports = {};
+__export(verifiers_exports, {
+  default: () => verifiers_default
+});
+module.exports = __toCommonJS(verifiers_exports);
+var import_package = __toESM(require("../../../package.json"));
+var verifiers_default = {
+  listTypes: async (ctx, next) => {
+    const plugin = ctx.app.pm.get("verification");
+    ctx.body = plugin.verificationManager.listTypes();
+    await next();
+  },
+  listByScene: async (ctx, next) => {
+    const { scene } = ctx.action.params || {};
+    const plugin = ctx.app.pm.get("verification");
+    const verificationTypes = plugin.verificationManager.getVerificationTypesByScene(scene);
+    if (!verificationTypes.length) {
+      ctx.body = { verifiers: [], availableTypes: [] };
+      return next();
+    }
+    const verifiers = await ctx.db.getRepository("verifiers").find({
+      filter: {
+        verificationType: verificationTypes.map((item) => item.type)
+      }
+    });
+    ctx.body = {
+      verifiers: (verifiers || []).map((item) => ({
+        name: item.name,
+        title: item.title
+      })),
+      availableTypes: verificationTypes.map((item) => ({
+        name: item.type,
+        title: item.title
+      }))
+    };
+    await next();
+  },
+  listByUser: async (ctx, next) => {
+    const plugin = ctx.app.pm.get("verification");
+    const verificationTypes = plugin.verificationManager.verificationTypes;
+    const bindingRequiredTypes = Array.from(verificationTypes.getEntities()).filter(([, options]) => options.bindingRequired).map(([type]) => type);
+    const verifiers = await ctx.db.getRepository("verifiers").find({
+      filter: {
+        verificationType: bindingRequiredTypes
+      }
+    });
+    const result = [];
+    for (const verifier of verifiers) {
+      try {
+        const verificationType = plugin.verificationManager.verificationTypes.get(verifier.verificationType);
+        const Verification = plugin.verificationManager.getVerification(verifier.verificationType);
+        const verification = new Verification({ ctx, verifier, options: verifier.options });
+        const boundInfo = await verification.getPublicBoundInfo(ctx.auth.user.id);
+        result.push({
+          ...verifier.dataValues,
+          title: verifier.title || verificationType.title,
+          description: verifier.description || verificationType.description,
+          boundInfo
+        });
+      } catch (error) {
+        ctx.log.error(error);
+      }
+    }
+    ctx.body = result;
+    await next();
+  },
+  listForVerify: async (ctx, next) => {
+    const { scene } = ctx.action.params || {};
+    const plugin = ctx.app.pm.get("verification");
+    const verificationTypes = plugin.verificationManager.getVerificationTypesByScene(scene);
+    if (!verificationTypes.length) {
+      ctx.body = [];
+      return next();
+    }
+    const verifiers = await ctx.db.getRepository("verifiers").find({
+      filter: {
+        verificationType: verificationTypes.map((item) => item.type)
+      }
+    });
+    if (!verifiers.length) {
+      ctx.body = [];
+      return next();
+    }
+    const result = [];
+    for (const verifier of verifiers) {
+      const verificationType = plugin.verificationManager.verificationTypes.get(verifier.verificationType);
+      const Verification = plugin.verificationManager.getVerification(verifier.verificationType);
+      const verification = new Verification({ ctx, verifier, options: verifier.options });
+      const publicBoundInfo = await verification.getPublicBoundInfo(ctx.auth.user.id);
+      if (!(publicBoundInfo == null ? void 0 : publicBoundInfo.bound)) {
+        continue;
+      }
+      result.push({
+        name: verifier.name,
+        title: verifier.title,
+        verificationType: verifier.verificationType,
+        verificationTypeTitle: verificationType == null ? void 0 : verificationType.title,
+        boundInfo: publicBoundInfo
+      });
+    }
+    ctx.body = result;
+    await next();
+  },
+  bind: async (ctx, next) => {
+    const { verifier: name } = ctx.action.params.values || {};
+    const user = ctx.auth.user;
+    const verificationPlugin = ctx.app.pm.get("verification");
+    const record = await verificationPlugin.verificationManager.getBoundRecord(user.id, name);
+    if (record) {
+      return ctx.throw(400, ctx.t("You have already bound this verifier", { ns: import_package.default.name }));
+    }
+    const verifier = await verificationPlugin.verificationManager.getVerifier(name);
+    if (!verifier) {
+      return ctx.throw(400, ctx.t("Invalid verifier"));
+    }
+    const Verification = verificationPlugin.verificationManager.getVerification(verifier.verificationType);
+    const verification = new Verification({ ctx, verifier, options: verifier.options });
+    const { uuid, meta } = await verification.bind(user.id);
+    await verifier.addUser(user.id, {
+      through: {
+        uuid,
+        meta
+      }
+    });
+    ctx.body = {};
+    await next();
+  },
+  unbind: async (ctx, next) => {
+    const { unbindVerifier: name } = ctx.action.params.values || {};
+    const user = ctx.auth.user;
+    const verificationPlugin = ctx.app.pm.get("verification");
+    const verifier = await verificationPlugin.verificationManager.getVerifier(name);
+    if (!verifier) {
+      return ctx.throw(400, ctx.t("Invalid verifier"));
+    }
+    await verifier.removeUser(user.id);
+    await next();
+  }
+};

package/dist/server/{actions/verifications.d.ts → collections/otp-records.d.ts}

@@ -6,5 +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.
  */
-import { Context, Next } from '@nocobase/actions';
-export declare function create(context: Context, next: Next): Promise<never>;
+declare const _default: import("@nocobase/database").CollectionOptions;
+export default _default;

package/dist/server/collections/otp-records.js

@@ -0,0 +1,75 @@
+/**
+ * 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 otp_records_exports = {};
+__export(otp_records_exports, {
+  default: () => otp_records_default
+});
+module.exports = __toCommonJS(otp_records_exports);
+var import_database = require("@nocobase/database");
+var otp_records_default = (0, import_database.defineCollection)({
+  dumpRules: {
+    group: "log"
+  },
+  migrationRules: ["schema-only", "skip"],
+  name: "otpRecords",
+  shared: true,
+  fields: [
+    {
+      type: "uuid",
+      name: "id",
+      primaryKey: true
+    },
+    {
+      type: "string",
+      name: "action"
+    },
+    {
+      type: "string",
+      name: "receiver"
+    },
+    {
+      type: "integer",
+      name: "status",
+      defaultValue: 0
+    },
+    {
+      type: "unixTimestamp",
+      name: "expiresAt",
+      accuracy: "millisecond"
+    },
+    {
+      type: "string",
+      name: "code"
+    },
+    {
+      type: "belongsTo",
+      name: "verifier",
+      target: "verifiers",
+      targetKey: "name"
+    }
+  ]
+});

package/dist/server/collections/users-verificators.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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.
+ */
+declare const _default: import("@nocobase/database").CollectionOptions;
+export default _default;

package/dist/server/collections/users-verificators.js

@@ -0,0 +1,58 @@
+/**
+ * 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 users_verificators_exports = {};
+__export(users_verificators_exports, {
+  default: () => users_verificators_default
+});
+module.exports = __toCommonJS(users_verificators_exports);
+var import_database = require("@nocobase/database");
+var users_verificators_default = (0, import_database.defineCollection)({
+  migrationRules: ["skip"],
+  name: "usersVerificators",
+  createdBy: true,
+  updatedBy: true,
+  logging: true,
+  fields: [
+    {
+      name: "uuid",
+      interface: "input",
+      type: "string",
+      allowNull: false,
+      uiSchema: {
+        type: "string",
+        title: '{{t("UUID")}}',
+        "x-component": "Input",
+        required: true
+      }
+    },
+    {
+      type: "json",
+      name: "meta",
+      defaultValue: {}
+    }
+  ]
+});

package/dist/server/collections/users-verifiers.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.
+ */
+/**
+ * Collection for user information of extended authentication methods,
+ * such as saml, oicd, oauth, sms, etc.
+ */
+declare const _default: import("@nocobase/database").CollectionOptions;
+export default _default;

package/dist/server/collections/users-verifiers.js

@@ -0,0 +1,58 @@
+/**
+ * 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 users_verifiers_exports = {};
+__export(users_verifiers_exports, {
+  default: () => users_verifiers_default
+});
+module.exports = __toCommonJS(users_verifiers_exports);
+var import_database = require("@nocobase/database");
+var users_verifiers_default = (0, import_database.defineCollection)({
+  migrationRules: ["schema-only", "overwrite", "skip"],
+  name: "usersVerifiers",
+  createdBy: true,
+  updatedBy: true,
+  logging: true,
+  fields: [
+    {
+      name: "uuid",
+      interface: "input",
+      type: "string",
+      allowNull: false,
+      uiSchema: {
+        type: "string",
+        title: '{{t("UUID")}}',
+        "x-component": "Input",
+        required: true
+      }
+    },
+    {
+      type: "json",
+      name: "meta",
+      defaultValue: {}
+    }
+  ]
+});

package/dist/server/collections/verificators.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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.
+ */
+declare const _default: import("@nocobase/database").CollectionOptions;
+export default _default;

package/dist/server/{actions/index.js → collections/verificators.js}

@@ -34,23 +34,14 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var actions_exports = {};
-__export(actions_exports, {
-  default: () => actions_default
+var verificators_exports = {};
+__export(verificators_exports, {
+  default: () => verificators_default
+});
+module.exports = __toCommonJS(verificators_exports);
+var import_database = require("@nocobase/database");
+var import_verificators = __toESM(require("../../collections/verificators"));
+var verificators_default = (0, import_database.defineCollection)({
+  migrationRules: ["skip"],
+  ...import_verificators.default
 });
-module.exports = __toCommonJS(actions_exports);
-var verifications = __toESM(require("./verifications"));
-function make(name, mod) {
-  return Object.keys(mod).reduce(
-    (result, key) => ({
-      ...result,
-      [`${name}:${key}`]: mod[key]
-    }),
-    {}
-  );
-}
-function actions_default({ app }) {
-  app.actions({
-    ...make("verifications", verifications)
-  });
-}

package/dist/server/collections/verifiers.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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.
+ */
+declare const _default: import("@nocobase/database").CollectionOptions;
+export default _default;