@tachybase/module-auth 0.23.48 → 1.0.6

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

@@ -36,7 +36,6 @@ var users_authenticators_default = (0, import_database.defineCollection)({
       name: "id",
       type: "bigInt",
       autoIncrement: true,
-      primaryKey: true,
       allowNull: false
     },
     /**
@@ -87,6 +86,16 @@ var users_authenticators_default = (0, import_database.defineCollection)({
       type: "json",
       name: "meta",
       defaultValue: {}
+    },
+    {
+      type: "bigInt",
+      name: "userId",
+      primaryKey: true
+    },
+    {
+      type: "string",
+      name: "authenticator",
+      primaryKey: true
     }
   ]
 });

package/dist/server/locale/en-US.d.ts

@@ -5,5 +5,6 @@ declare const _default: {
     'Not a valid cellphone number, please re-enter': string;
     'The phone number has been registered, please login directly': string;
     'The phone number is not registered, please register first': string;
+    'The username, email or password is incorrect, please re-enter': string;
 };
 export default _default;

package/dist/server/locale/en-US.js

@@ -26,5 +26,6 @@ var en_US_default = {
   "The password is incorrect, please re-enter": "The password is incorrect, please re-enter",
   "Not a valid cellphone number, please re-enter": "Not a valid cellphone number, please re-enter",
   "The phone number has been registered, please login directly": "The phone number has been registered, please login directly",
-  "The phone number is not registered, please register first": "The phone number is not registered, please register first"
+  "The phone number is not registered, please register first": "The phone number is not registered, please register first",
+  "The username, email or password is incorrect, please re-enter": "The username, email or password is incorrect, please re-enter"
 };

package/dist/server/locale/zh-CN.d.ts

@@ -7,5 +7,6 @@ declare const _default: {
     'Please keep and enable at least one authenticator': string;
     'Please enter your username or email': string;
     'Please enter a valid username': string;
+    'The username, email or password is incorrect, please re-enter': string;
 };
 export default _default;

package/dist/server/locale/zh-CN.js

@@ -28,5 +28,6 @@ var zh_CN_default = {
   "The phone number is not registered, please register first": "\u624B\u673A\u53F7\u672A\u6CE8\u518C\uFF0C\u8BF7\u5148\u6CE8\u518C",
   "Please keep and enable at least one authenticator": "\u8BF7\u81F3\u5C11\u4FDD\u7559\u5E76\u542F\u7528\u4E00\u4E2A\u8BA4\u8BC1\u5668",
   "Please enter your username or email": "\u8BF7\u8F93\u5165\u7528\u6237\u540D\u6216\u90AE\u7BB1",
-  "Please enter a valid username": "\u8BF7\u8F93\u5165\u6709\u6548\u7684\u7528\u6237\u540D"
+  "Please enter a valid username": "\u8BF7\u8F93\u5165\u6709\u6548\u7684\u7528\u6237\u540D",
+  "The username, email or password is incorrect, please re-enter": "\u7528\u6237\u540D\u90AE\u7BB1\u6216\u8005\u5BC6\u7801\u6709\u8BEF,\u8BF7\u91CD\u65B0\u8F93\u5165"
 };

package/dist/server/migrations/20250318163707-create-token-policy.d.ts

@@ -0,0 +1,6 @@
+import { Migration } from '@tachybase/server';
+export default class extends Migration {
+    on: string;
+    appVersion: string;
+    up(): Promise<void>;
+}

package/dist/server/migrations/20250318163707-create-token-policy.js

@@ -0,0 +1,52 @@
+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 create_token_policy_exports = {};
+__export(create_token_policy_exports, {
+  default: () => create_token_policy_default
+});
+module.exports = __toCommonJS(create_token_policy_exports);
+var import_server = require("@tachybase/server");
+var import_constants = require("../../constants");
+class create_token_policy_default extends import_server.Migration {
+  constructor() {
+    super(...arguments);
+    this.on = "afterLoad";
+    // 'beforeLoad' or 'afterLoad'
+    this.appVersion = "<0.23.65";
+  }
+  async up() {
+    const tokenPolicyRepo = this.app.db.getRepository(import_constants.tokenPolicyCollectionName);
+    const tokenPolicy = await tokenPolicyRepo.findOne({ filterByTk: import_constants.tokenPolicyRecordKey });
+    if (tokenPolicy) {
+      this.app.authManager.tokenController.setConfig(tokenPolicy.config);
+    } else {
+      const config = {
+        tokenExpirationTime: "1d",
+        sessionExpirationTime: "7d",
+        expiredTokenRenewLimit: "1d"
+      };
+      await tokenPolicyRepo.create({
+        values: {
+          key: import_constants.tokenPolicyRecordKey,
+          config
+        }
+      });
+      this.app.authManager.tokenController.setConfig(config);
+    }
+  }
+}

package/dist/server/plugin.js

@@ -31,8 +31,8 @@ __export(plugin_exports, {
   default: () => plugin_default
 });
 module.exports = __toCommonJS(plugin_exports);
-var import_path = require("path");
 var import_server = require("@tachybase/server");
+var import_constants = require("../constants");
 var import_preset = require("../preset");
 var import_auth = __toESM(require("./actions/auth"));
 var import_authenticators = __toESM(require("./actions/authenticators"));
@@ -41,8 +41,29 @@ var import_locale = require("./locale");
 var import_authenticator = require("./model/authenticator");
 var import_storer = require("./storer");
 var import_token_blacklist = require("./token-blacklist");
+var import_token_controller = require("./token-controller");
 class PluginAuthServer extends import_server.Plugin {
   afterAdd() {
+    this.app.on("afterLoad", async () => {
+      if (this.app.authManager.tokenController) {
+        return;
+      }
+      const cache = await this.app.cacheManager.createCache({
+        name: "auth-token-controller",
+        prefix: "auth-token-controller"
+      });
+      const tokenController = new import_token_controller.TokenController({ cache, app: this.app, logger: this.app.log });
+      this.app.authManager.setTokenControlService(tokenController);
+      const tokenPolicyRepo = this.app.db.getRepository(import_constants.tokenPolicyCollectionName);
+      try {
+        const res = await tokenPolicyRepo.findOne({ filterByTk: import_constants.tokenPolicyRecordKey });
+        if (res) {
+          this.app.authManager.tokenController.setConfig(res.config);
+        }
+      } catch (error) {
+        this.app.logger.warn("access control config not exist, use default value");
+      }
+    });
   }
   async beforeLoad() {
     this.app.i18n.addResources("zh-CN", import_preset.namespace, import_locale.zhCN);
@@ -50,22 +71,16 @@ class PluginAuthServer extends import_server.Plugin {
     this.app.db.registerModels({ AuthModel: import_authenticator.AuthModel });
   }
   async load() {
-    await this.importCollections((0, import_path.resolve)(__dirname, "collections"));
-    this.db.addMigrations({
-      namespace: "auth",
-      directory: (0, import_path.resolve)(__dirname, "migrations"),
-      context: {
-        plugin: this
-      }
-    });
     this.cache = await this.app.cacheManager.createCache({
       name: "auth",
       prefix: "auth",
       store: "memory"
     });
     const storer = new import_storer.Storer({
+      app: this.app,
       db: this.db,
-      cache: this.cache
+      cache: this.cache,
+      authManager: this.app.authManager
     });
     this.app.authManager.setStorer(storer);
     if (!this.app.authManager.jwt.blacklist) {
@@ -73,7 +88,33 @@ class PluginAuthServer extends import_server.Plugin {
     }
     this.app.authManager.registerTypes(import_preset.presetAuthType, {
       auth: import_basic_auth.BasicAuth,
-      title: "Password"
+      title: "Password",
+      getPublicOptions: (options) => {
+        var _a;
+        const usersCollection = this.db.getCollection("users");
+        let signupForm = ((_a = options == null ? void 0 : options.public) == null ? void 0 : _a.signupForm) || [];
+        signupForm = signupForm.filter((item) => item.show);
+        if (!(signupForm.length && signupForm.some(
+          (item) => ["username", "email"].includes(item.field) && item.show && item.required
+        ))) {
+          signupForm.unshift({ field: "username", show: true, required: true });
+        }
+        signupForm = signupForm.filter((field) => field.show).map((item) => {
+          var _a2;
+          const field = usersCollection.getField(item.field);
+          return {
+            ...item,
+            uiSchema: {
+              ...(_a2 = field.options) == null ? void 0 : _a2.uiSchema,
+              required: item.required
+            }
+          };
+        });
+        return {
+          ...options == null ? void 0 : options.public,
+          signupForm
+        };
+      }
     });
     Object.entries(import_auth.default).forEach(
       ([action, handler]) => {
@@ -84,10 +125,9 @@ class PluginAuthServer extends import_server.Plugin {
     Object.entries(import_authenticators.default).forEach(
       ([action, handler]) => this.app.resourcer.registerAction(`authenticators:${action}`, handler)
     );
-    ["check", "signIn", "signUp"].forEach((action) => this.app.acl.allow("auth", action));
-    ["signOut", "changePassword"].forEach((action) => this.app.acl.allow("auth", action, "loggedIn"));
+    ["signIn", "signUp"].forEach((action) => this.app.acl.allow("auth", action));
+    ["check", "signOut", "changePassword"].forEach((action) => this.app.acl.allow("auth", action, "loggedIn"));
     this.app.acl.allow("authenticators", "publicList");
-    this.app.acl.allow("authenticators", "bindTypes", "loggedIn");
     this.app.acl.registerSnippet({
       name: `pm.${this.name}.authenticators`,
       actions: ["authenticators:*"]
@@ -100,24 +140,93 @@ class PluginAuthServer extends import_server.Plugin {
       const cache = this.app.cache;
       await cache.del(`auth:${user.id}`);
     });
+    this.app.on("cache:del:auth", async ({ userId }) => {
+      await this.cache.del(`auth:${userId}`);
+    });
+    this.app.on("ws:message:auth:token", async ({ clientId, payload }) => {
+      if (!payload || !payload.token || !payload.authenticator) {
+        this.app.emit(`ws:removeTag`, {
+          clientId,
+          tagKey: "userId"
+        });
+        return;
+      }
+      const auth = await this.app.authManager.get(payload.authenticator, {
+        getBearerToken: () => payload.token,
+        app: this.app,
+        db: this.app.db,
+        cache: this.app.cache,
+        logger: this.app.logger,
+        log: this.app.log,
+        throw: (...args) => {
+          throw new Error(...args);
+        },
+        t: this.app.i18n.t
+      });
+      let user;
+      try {
+        user = (await auth.checkToken()).user;
+      } catch (error) {
+        if (!user) {
+          this.app.logger.error(error);
+          this.app.emit(`ws:removeTag`, {
+            clientId,
+            tagKey: "userId"
+          });
+          return;
+        }
+      }
+      this.app.emit(`ws:setTag`, {
+        clientId,
+        tagKey: "userId",
+        tagValue: user.id
+      });
+      this.app.emit(`ws:authorized`, {
+        clientId,
+        userId: user.id
+      });
+    });
+    this.app.acl.registerSnippet({
+      name: `pm.security.token-policy`,
+      actions: [`${import_constants.tokenPolicyCollectionName}:*`]
+    });
+    this.app.db.on(`${import_constants.tokenPolicyCollectionName}.afterSave`, async (model) => {
+      var _a;
+      (_a = this.app.authManager.tokenController) == null ? void 0 : _a.setConfig(model.config);
+    });
   }
   async install(options) {
-    const repository = this.db.getRepository("authenticators");
-    const exist = await repository.findOne({ filter: { name: import_preset.presetAuthenticator } });
-    if (exist) {
+    const authRepository = this.db.getRepository("authenticators");
+    const exist = await authRepository.findOne({ filter: { name: import_preset.presetAuthenticator } });
+    if (!exist) {
+      await authRepository.create({
+        values: {
+          name: import_preset.presetAuthenticator,
+          authType: import_preset.presetAuthType,
+          description: "Sign in with username/email.",
+          enabled: true,
+          options: {
+            public: {
+              allowSignUp: true
+            }
+          }
+        }
+      });
+    }
+    const tokenPolicyRepo = this.app.db.getRepository(import_constants.tokenPolicyCollectionName);
+    const res = await tokenPolicyRepo.findOne({ filterByTk: import_constants.tokenPolicyRecordKey });
+    if (res) {
       return;
     }
-    await repository.create({
+    const config = {
+      tokenExpirationTime: "1d",
+      sessionExpirationTime: "7d",
+      expiredTokenRenewLimit: "1d"
+    };
+    await tokenPolicyRepo.create({
       values: {
-        name: import_preset.presetAuthenticator,
-        authType: import_preset.presetAuthType,
-        description: "Sign in with username/email.",
-        enabled: true,
-        options: {
-          public: {
-            allowSignUp: true
-          }
-        }
+        key: import_constants.tokenPolicyRecordKey,
+        config
       }
     });
   }

package/dist/server/storer.d.ts

@@ -1,15 +1,21 @@
-import { Storer as IStorer } from '@tachybase/auth';
+import { AuthManager, Storer as IStorer } from '@tachybase/auth';
 import { Cache } from '@tachybase/cache';
 import { Database } from '@tachybase/database';
+import { Application } from '@tachybase/server';
 import { AuthModel } from './model/authenticator';
 export declare class Storer implements IStorer {
     db: Database;
     cache: Cache;
+    app: Application;
+    authManager: AuthManager;
     key: string;
-    constructor({ db, cache }: {
+    constructor({ app, db, cache, authManager, }: {
+        app?: Application;
         db: Database;
         cache: Cache;
+        authManager: AuthManager;
     });
+    renderJsonTemplate(authenticator: any): any;
     getCache(): Promise<AuthModel[]>;
     setCache(authenticators: AuthModel[]): Promise<void>;
     get(name: string): Promise<AuthModel>;

package/dist/server/storer.js

@@ -21,21 +21,43 @@ __export(storer_exports, {
 });
 module.exports = __toCommonJS(storer_exports);
 class Storer {
-  constructor({ db, cache }) {
+  constructor({
+    app,
+    db,
+    cache,
+    authManager
+  }) {
     this.key = "authenticators";
+    this.app = app;
     this.db = db;
     this.cache = cache;
+    this.authManager = authManager;
     this.db.on("authenticators.afterSave", async (model) => {
       if (!model.enabled) {
         await this.cache.delValueInObject(this.key, model.name);
         return;
       }
-      await this.cache.setValueInObject(this.key, model.name, model);
+      await this.cache.setValueInObject(this.key, model.name, this.renderJsonTemplate(model));
     });
     this.db.on("authenticators.afterDestroy", async (model) => {
       await this.cache.delValueInObject(this.key, model.name);
     });
   }
+  renderJsonTemplate(authenticator) {
+    var _a, _b;
+    if (!authenticator) {
+      return authenticator;
+    }
+    const $env = (_a = this.app) == null ? void 0 : _a.environment;
+    if (!$env) {
+      return authenticator;
+    }
+    const config = this.authManager.getAuthConfig(authenticator.authType);
+    authenticator.dataValues.options = $env.renderJsonTemplate(authenticator.dataValues.options, {
+      omit: (_b = config == null ? void 0 : config.auth) == null ? void 0 : _b["optionsKeysNotAllowedInEnv"]
+    });
+    return authenticator;
+  }
   async getCache() {
     const authenticators = await this.cache.get(this.key);
     if (!authenticators) {
@@ -45,7 +67,7 @@ class Storer {
   }
   async setCache(authenticators) {
     const obj = authenticators.reduce((obj2, authenticator) => {
-      obj2[authenticator.name] = authenticator;
+      obj2[authenticator.name] = this.renderJsonTemplate(authenticator);
       return obj2;
     }, {});
     await this.cache.set(this.key, obj);
@@ -56,6 +78,7 @@ class Storer {
       const repo = this.db.getRepository("authenticators");
       authenticators = await repo.find({ filter: { enabled: true } });
       await this.setCache(authenticators);
+      authenticators = await this.getCache();
     }
     const authenticator = authenticators.find((authenticator2) => authenticator2.name === name);
     return authenticator || authenticators[0];

package/dist/server/token-controller.d.ts

@@ -0,0 +1,32 @@
+import { ITokenControlService, NumericTokenPolicyConfig, TokenInfo, TokenPolicyConfig } from '@tachybase/auth';
+import { Cache } from '@tachybase/cache';
+import Database from '@tachybase/database';
+import type { SystemLogger } from '@tachybase/logger';
+import Application from '@tachybase/server';
+type TokenControlService = ITokenControlService;
+export declare class TokenController implements TokenControlService {
+    cache: Cache;
+    app: Application;
+    db: Database;
+    logger: SystemLogger;
+    constructor({ cache, app, logger }: {
+        cache: Cache;
+        app: Application;
+        logger: SystemLogger;
+    });
+    setTokenInfo(id: string, value: TokenInfo): Promise<void>;
+    getConfig(): Promise<NumericTokenPolicyConfig>;
+    setConfig(config: TokenPolicyConfig): Promise<void>;
+    removeSessionExpiredTokens(userId: number): Promise<any>;
+    add({ userId }: {
+        userId: number;
+    }): Promise<{
+        jti: `${string}-${string}-${string}-${string}-${string}`;
+        issuedTime: number;
+        signInTime: number;
+        renewed: boolean;
+        userId: number;
+    }>;
+    renew: TokenControlService['renew'];
+}
+export {};

package/dist/server/token-controller.js

@@ -0,0 +1,139 @@
+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 token_controller_exports = {};
+__export(token_controller_exports, {
+  TokenController: () => TokenController
+});
+module.exports = __toCommonJS(token_controller_exports);
+var import_crypto = require("crypto");
+var import_auth = require("@tachybase/auth");
+var import_ms = __toESM(require("ms"));
+var import_constants = require("../constants");
+const JTICACHEKEY = "token-jti";
+class TokenController {
+  constructor({ cache, app, logger }) {
+    this.renew = async (jti) => {
+      const repo = this.app.db.getRepository(import_constants.issuedTokensCollectionName);
+      const model = this.app.db.getModel(import_constants.issuedTokensCollectionName);
+      const newId = (0, import_crypto.randomUUID)();
+      const issuedTime = Date.now();
+      const [count] = await model.update(
+        { jti: newId, issuedTime },
+        { where: { jti } }
+      );
+      if (count === 1) {
+        await this.cache.set(`jti-renewed-cahce:${jti}`, { jti: newId, issuedTime }, import_constants.RENEWED_JTI_CACHE_MS);
+        this.logger.info("jti renewed", { oldJti: jti, newJti: newId, issuedTime });
+        return { jti: newId, issuedTime };
+      } else {
+        const cachedJtiData = await this.cache.get(`jti-renewed-cahce:${jti}`);
+        if (cachedJtiData) {
+          return cachedJtiData;
+        }
+        this.logger.error("jti renew failed", {
+          module: "auth",
+          submodule: "token-controller",
+          method: "renew",
+          jti,
+          code: import_auth.AuthErrorCode.TOKEN_RENEW_FAILED
+        });
+        throw new import_auth.AuthError({
+          message: "Your session has expired. Please sign in again.",
+          code: import_auth.AuthErrorCode.TOKEN_RENEW_FAILED
+        });
+      }
+    };
+    this.cache = cache;
+    this.app = app;
+    this.logger = logger;
+  }
+  async setTokenInfo(id, value) {
+    const repo = this.app.db.getRepository(import_constants.issuedTokensCollectionName);
+    await repo.updateOrCreate({ filterKeys: ["id"], values: value });
+    return;
+  }
+  getConfig() {
+    return this.cache.wrap("config", async () => {
+      const repo = this.app.db.getRepository(import_constants.tokenPolicyCollectionName);
+      const configRecord = await repo.findOne({ filterByTk: import_constants.tokenPolicyRecordKey });
+      if (!configRecord) return null;
+      const config = configRecord.config;
+      return {
+        tokenExpirationTime: (0, import_ms.default)(config.tokenExpirationTime),
+        sessionExpirationTime: (0, import_ms.default)(config.sessionExpirationTime),
+        expiredTokenRenewLimit: (0, import_ms.default)(config.expiredTokenRenewLimit)
+      };
+    });
+  }
+  setConfig(config) {
+    return this.cache.set("config", {
+      tokenExpirationTime: (0, import_ms.default)(config.tokenExpirationTime),
+      sessionExpirationTime: (0, import_ms.default)(config.sessionExpirationTime),
+      expiredTokenRenewLimit: (0, import_ms.default)(config.expiredTokenRenewLimit)
+    });
+  }
+  async removeSessionExpiredTokens(userId) {
+    const config = await this.getConfig();
+    const issuedTokenRepo = this.app.db.getRepository(import_constants.issuedTokensCollectionName);
+    const currTS = Date.now();
+    return issuedTokenRepo.destroy({
+      filter: {
+        userId,
+        signInTime: {
+          $lt: currTS - config.sessionExpirationTime
+        }
+      }
+    });
+  }
+  async add({ userId }) {
+    const jti = (0, import_crypto.randomUUID)();
+    const currTS = Date.now();
+    const data = {
+      jti,
+      issuedTime: currTS,
+      signInTime: currTS,
+      renewed: false,
+      userId
+    };
+    await this.setTokenInfo(jti, data);
+    try {
+      if (process.env.DB_DIALECT === "sqlite") {
+        await this.removeSessionExpiredTokens(userId);
+      } else {
+        this.removeSessionExpiredTokens(userId);
+      }
+    } catch (err) {
+      this.logger.error(err, { module: "auth", submodule: "token-controller", method: "removeSessionExpiredTokens" });
+    }
+    return data;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TokenController
+});

package/dist/types.d.ts

@@ -0,0 +1 @@
+export type { TokenPolicyConfig as TokenPolicyConfig } from '@tachybase/auth';

package/dist/types.js

@@ -0,0 +1,15 @@
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@tachybase/module-auth",
   "displayName": "Authentication",
-  "version": "0.23.48",
+  "version": "1.0.6",
   "description": "User authentication management, including password, SMS, and support for Single Sign-On (SSO) protocols, with extensibility.",
   "keywords": [
-    "Authentication"
+    "Authentication",
+    "Security"
   ],
   "main": "./dist/server/index.js",
   "dependencies": {},
@@ -12,20 +13,23 @@
     "@ant-design/icons": "~5.3.7",
     "antd": "5.22.5",
     "cron": "^3.3.1",
+    "lodash": "^4.17.21",
+    "ms": "^2.1.3",
     "react": "^18.3.1",
     "react-i18next": "^15.2.0",
     "react-router-dom": "6.28.1",
-    "@tachybase/schema": "0.23.48"
+    "@tachybase/schema": "1.0.6"
   },
   "peerDependencies": {
-    "@tachybase/actions": "0.23.48",
-    "@tachybase/auth": "0.23.48",
-    "@tachybase/client": "0.23.48",
-    "@tachybase/cache": "0.23.48",
-    "@tachybase/database": "0.23.48",
-    "@tachybase/utils": "0.23.48",
-    "@tachybase/test": "0.23.48",
-    "@tachybase/server": "0.23.48"
+    "@tachybase/actions": "1.0.6",
+    "@tachybase/auth": "1.0.6",
+    "@tachybase/client": "1.0.6",
+    "@tachybase/server": "1.0.6",
+    "@tachybase/cache": "1.0.6",
+    "@tachybase/logger": "1.0.6",
+    "@tachybase/database": "1.0.6",
+    "@tachybase/test": "1.0.6",
+    "@tachybase/utils": "1.0.6"
   },
   "description.zh-CN": "用户认证管理，包括基础的密码认证、短信认证、SSO 协议的认证等，可扩展。",
   "displayName.zh-CN": "用户认证",