vona-module-a-captcha 5.0.2 → 5.0.8

package/dist/.metadata/index.d.ts

@@ -1,9 +1,146 @@
+import type { TypeSymbolKeyFieldsMore } from 'vona-module-a-orm';
+import type { TypeEntityOptionsFields, TypeControllerOptionsActions } from 'vona-module-a-openapi';
+/** middleware: begin */
+export * from '../bean/middleware.captcha.ts';
+import type { IMiddlewareOptionsCaptcha } from '../bean/middleware.captcha.ts';
+import 'vona';
+declare module 'vona-module-a-aspect' {
+    interface IMiddlewareRecordLocal {
+        'a-captcha:captcha': IMiddlewareOptionsCaptcha;
+    }
+}
+declare module 'vona-module-a-captcha' {
+    interface MiddlewareCaptcha {
+    }
+    interface MiddlewareCaptcha {
+        get $beanFullName(): 'a-captcha.middleware.captcha';
+        get $onionName(): 'a-captcha:captcha';
+    }
+}
+/** middleware: end */
+/** bean: begin */
+export * from '../bean/bean.captcha.ts';
+import 'vona';
+declare module 'vona' {
+}
+declare module 'vona-module-a-captcha' {
+    interface BeanCaptcha {
+    }
+}
+/** bean: end */
+/** bean: begin */
+import type { BeanCaptcha } from '../bean/bean.captcha.ts';
+import 'vona';
+declare module 'vona' {
+    interface IBeanRecordGlobal {
+        'captcha': BeanCaptcha;
+    }
+}
+/** bean: end */
+/** cacheRedis: begin */
+export * from '../bean/cacheRedis.captcha.ts';
+import { type IDecoratorCacheRedisOptions } from 'vona-module-a-cache';
+declare module 'vona-module-a-cache' {
+    interface ICacheRedisRecord {
+        'a-captcha:captcha': IDecoratorCacheRedisOptions;
+    }
+}
+declare module 'vona-module-a-captcha' {
+    interface CacheRedisCaptcha {
+    }
+    interface CacheRedisCaptcha {
+        get $beanFullName(): 'a-captcha.cacheRedis.captcha';
+        get $onionName(): 'a-captcha:captcha';
+    }
+}
+/** cacheRedis: end */
+/** cacheRedis: begin */
+import type { CacheRedisCaptcha } from '../bean/cacheRedis.captcha.ts';
+export interface IModuleCacheRedis {
+    'captcha': CacheRedisCaptcha;
+}
+/** cacheRedis: end */
+/** dto: begin */
+export * from '../dto/captchaData.ts';
+export * from '../dto/captchaVerify.ts';
+import type { IDtoOptionsCaptchaData } from '../dto/captchaData.ts';
+import type { IDtoOptionsCaptchaVerify } from '../dto/captchaVerify.ts';
+import 'vona';
+declare module 'vona-module-a-web' {
+    interface IDtoRecord {
+        'a-captcha:captchaData': IDtoOptionsCaptchaData;
+        'a-captcha:captchaVerify': IDtoOptionsCaptchaVerify;
+    }
+}
+declare module 'vona-module-a-captcha' {
+}
+/** dto: end */
+/** dto: begin */
+import type { DtoCaptchaData } from '../dto/captchaData.ts';
+import type { DtoCaptchaVerify } from '../dto/captchaVerify.ts';
+declare module 'vona-module-a-captcha' {
+    interface IDtoOptionsCaptchaData {
+        fields?: TypeEntityOptionsFields<DtoCaptchaData, IDtoOptionsCaptchaData[TypeSymbolKeyFieldsMore]>;
+    }
+    interface IDtoOptionsCaptchaVerify {
+        fields?: TypeEntityOptionsFields<DtoCaptchaVerify, IDtoOptionsCaptchaVerify[TypeSymbolKeyFieldsMore]>;
+    }
+}
+/** dto: end */
+/** controller: begin */
+export * from '../controller/captcha.ts';
+import type { IControllerOptionsCaptcha } from '../controller/captcha.ts';
+import 'vona';
+declare module 'vona-module-a-web' {
+    interface IControllerRecord {
+        'a-captcha:captcha': IControllerOptionsCaptcha;
+    }
+}
+declare module 'vona-module-a-captcha' {
+    interface ControllerCaptcha {
+    }
+    interface ControllerCaptcha {
+        get $beanFullName(): 'a-captcha.controller.captcha';
+        get $onionName(): 'a-captcha:captcha';
+    }
+}
+/** controller: end */
+/** controller: begin */
+import '../controller/captcha.ts';
+declare module 'vona-module-a-captcha' {
+    interface IControllerOptionsCaptcha {
+        actions?: TypeControllerOptionsActions<ControllerCaptcha>;
+    }
+}
+declare module 'vona-module-a-web' {
+    interface IApiPathPostRecord {
+        '/captcha/create': undefined;
+        '/captcha/refresh': undefined;
+        '/captcha/verifyImmediate': undefined;
+    }
+}
+/** controller: end */
+/** config: begin */
+export * from '../config/config.ts';
+import type { config } from '../config/config.ts';
+export declare const locales: {
+    'en-us': {
+        CaptchaInvalid: string;
+    };
+    'zh-cn': {
+        CaptchaInvalid: string;
+    };
+};
+/** locale: end */
 /** scope: begin */
-import { BeanScopeBase, type BeanScopeUtil } from 'vona';
+import { BeanScopeBase, type BeanScopeUtil, type TypeModuleConfig, type TypeModuleLocales, type TypeLocaleBase } from 'vona';
 export declare class ScopeModuleACaptcha extends BeanScopeBase {
 }
 export interface ScopeModuleACaptcha {
     util: BeanScopeUtil;
+    config: TypeModuleConfig<typeof config>;
+    locale: TypeModuleLocales<(typeof locales)[TypeLocaleBase]>;
+    cacheRedis: IModuleCacheRedis;
 }
 import 'vona';
 declare module 'vona' {
@@ -13,5 +150,12 @@ declare module 'vona' {
     interface IBeanScopeContainer {
         captcha: ScopeModuleACaptcha;
     }
+    interface IBeanScopeConfig {
+        'a-captcha': ReturnType<typeof config>;
+    }
+    interface IBeanScopeLocale {
+        'a-captcha': (typeof locales)[TypeLocaleBase];
+    }
 }
+export declare function $locale<K extends keyof (typeof locales)[TypeLocaleBase]>(key: K): `a-captcha::${K}`;
 /** scope: end */

package/dist/bean/bean.captcha.d.ts

@@ -0,0 +1,20 @@
+import type { ICaptchaData, ICaptchaDataCache } from '../types/captcha.ts';
+import type { ICaptchaProviderRecord } from '../types/captchaProvider.ts';
+import type { ICaptchaSceneRecord } from '../types/captchaScene.ts';
+import { BeanBase } from 'vona';
+declare const SymbolProviders: unique symbol;
+export declare class BeanCaptcha extends BeanBase {
+    protected [SymbolProviders]: Record<keyof ICaptchaSceneRecord, ICaptchaProviderRecord>;
+    create(sceneName: keyof ICaptchaSceneRecord): Promise<ICaptchaData>;
+    refresh(id: string, sceneName: keyof ICaptchaSceneRecord): Promise<ICaptchaData>;
+    verify(id: string, token: unknown, sceneName: keyof ICaptchaSceneRecord): Promise<boolean>;
+    verifyImmediate(id: string, token: unknown): Promise<false | string>;
+    getCaptchaData(id: string): Promise<ICaptchaDataCache | null | undefined>;
+    updateCaptchaToken(id: string, token: unknown): Promise<undefined>;
+    private _getProviderInstance;
+    private _getProviderOptions;
+    private _resolveProvider;
+    private _getProviders;
+    private _prepareProviders;
+}
+export {};

package/dist/bean/cacheRedis.captcha.d.ts

@@ -0,0 +1,6 @@
+import type { ICaptchaDataCache } from '../types/captcha.ts';
+import { BeanCacheRedisBase } from 'vona-module-a-cache';
+export type TCacheRedisCaptchaKey = string;
+export type TCacheRedisCaptchaData = ICaptchaDataCache;
+export declare class CacheRedisCaptcha extends BeanCacheRedisBase<TCacheRedisCaptchaKey, TCacheRedisCaptchaData> {
+}

package/dist/bean/middleware.captcha.d.ts

@@ -0,0 +1,11 @@
+import type { Next } from 'vona';
+import type { IDecoratorMiddlewareOptions, IMiddlewareExecute } from 'vona-module-a-aspect';
+import type { ICaptchaSceneRecord } from '../types/captchaScene.ts';
+import { BeanBase } from 'vona';
+export interface IMiddlewareOptionsCaptcha extends IDecoratorMiddlewareOptions {
+    scene?: keyof ICaptchaSceneRecord;
+    bodyField?: string;
+}
+export declare class MiddlewareCaptcha extends BeanBase implements IMiddlewareExecute {
+    execute(options: IMiddlewareOptionsCaptcha, next: Next): Promise<any>;
+}

package/dist/config/config.d.ts

@@ -0,0 +1,10 @@
+import type { VonaApplication } from 'vona';
+export declare function config(app: VonaApplication): {
+    captchaProvider: {
+        ttl: number;
+        ttlSecondary: number;
+    };
+    captcha: {
+        showToken: boolean;
+    };
+};

package/dist/config/locale/en-us.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    CaptchaInvalid: string;
+};
+export default _default;

package/dist/config/locale/zh-cn.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    CaptchaInvalid: string;
+};
+export default _default;

package/dist/controller/captcha.d.ts

@@ -0,0 +1,9 @@
+import type { IDecoratorControllerOptions } from 'vona-module-a-web';
+import { BeanBase } from 'vona';
+export interface IControllerOptionsCaptcha extends IDecoratorControllerOptions {
+}
+export declare class ControllerCaptcha extends BeanBase {
+    create(scene: string): Promise<import("vona-module-a-captcha").ICaptchaData>;
+    refresh(id: string, scene: string): Promise<import("vona-module-a-captcha").ICaptchaData>;
+    verifyImmediate(id: string, token: unknown): Promise<string>;
+}

package/dist/dto/captchaData.d.ts

@@ -0,0 +1,9 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+export interface IDtoOptionsCaptchaData extends IDecoratorDtoOptions {
+}
+export declare class DtoCaptchaData {
+    id: string;
+    provider: string;
+    token: unknown;
+    payload: unknown;
+}

package/dist/dto/captchaVerify.d.ts

@@ -0,0 +1,7 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+export interface IDtoOptionsCaptchaVerify extends IDecoratorDtoOptions {
+}
+export declare class DtoCaptchaVerify {
+    id: string;
+    token: unknown;
+}

package/dist/index.js

@@ -1,15 +1,358 @@
-import { BeanInfo, BeanScopeBase, createBeanDecorator } from 'vona';
-import { Scope } from 'vona-module-a-bean';
+import { BeanInfo, BeanBase, uuidv4, beanFullNameFromOnionName, deepExtend, BeanScopeBase, createBeanDecorator } from 'vona';
+import { Middleware } from 'vona-module-a-aspect';
+import { getRandomInt } from '@cabloy/utils';
+import { Bean, Scope } from 'vona-module-a-bean';
+import { CacheRedis, BeanCacheRedisBase } from 'vona-module-a-cache';
+import { Api } from 'vona-module-a-openapi';
+import { Dto, Controller, Web, Arg } from 'vona-module-a-web';
+import { Passport } from 'vona-module-a-user';
+import z from 'zod';
+
+var _dec$6, _dec2$6, _class$6;
+let MiddlewareCaptcha = (_dec$6 = Middleware({
+  bodyField: 'captcha'
+}), _dec2$6 = BeanInfo({
+  module: "a-captcha"
+}), _dec$6(_class$6 = _dec2$6(_class$6 = class MiddlewareCaptcha extends BeanBase {
+  async execute(options, next) {
+    const sceneName = options.scene;
+    if (!sceneName) throw new Error('please specify the captcha scene name');
+    // captcha
+    const bodyField = options.bodyField;
+    const captcha = this.ctx.request.body[bodyField];
+    if (!captcha) throw new Error('not found captcha data');
+    const verified = await this.bean.captcha.verify(captcha.id, captcha.token, sceneName);
+    if (!verified) throw combineCaptchaError(bodyField, this.scope.locale.CaptchaInvalid());
+    // next
+    return next();
+  }
+}) || _class$6) || _class$6);
+function combineCaptchaError(bodyField, message) {
+  // error
+  const error = new Error();
+  error.code = 422;
+  error.message = [{
+    code: 'custom',
+    path: [bodyField],
+    message
+  }];
+  return error;
+}
+
+var _dec$5, _dec2$5, _class$5;
+const SymbolProviders = Symbol('SymbolProviders');
+let BeanCaptcha = (_dec$5 = Bean(), _dec2$5 = BeanInfo({
+  module: "a-captcha"
+}), _dec$5(_class$5 = _dec2$5(_class$5 = class BeanCaptcha extends BeanBase {
+  constructor(...args) {
+    super(...args);
+    this[SymbolProviders] = {};
+  }
+  async create(sceneName) {
+    // resolve provider
+    const provider = await this._resolveProvider(sceneName);
+    if (!provider) throw new Error(`not found captcha provider for scene: ${sceneName}`);
+    // create
+    const beanInstance = this._getProviderInstance(provider.name);
+    const captcha = await beanInstance.create(provider.options);
+    // data
+    const id = uuidv4();
+    const captchaData = {
+      scene: sceneName,
+      provider: provider.name,
+      token: captcha.token
+    };
+    // cache
+    await this.scope.cacheRedis.captcha.set(captchaData, id, {
+      ttl: provider.options.ttl ?? this.scope.config.captchaProvider.ttl
+    });
+    // result
+    const result = {
+      id,
+      provider: provider.name,
+      payload: captcha.payload
+    };
+    if (this.scope.config.captcha.showToken) {
+      result.token = captcha.token;
+    }
+    return result;
+  }
+  async refresh(id, sceneName) {
+    // delete cache
+    await this.scope.cacheRedis.captcha.del(id);
+    // create
+    return await this.create(sceneName);
+  }
+  async verify(id, token, sceneName) {
+    const captchaData = await this.getCaptchaData(id);
+    if (!captchaData) return false;
+    // scene
+    if (captchaData.scene !== sceneName) return false;
+    // tokenSecondary
+    const tokenSecondary = captchaData.token2;
+    if (tokenSecondary) {
+      // delete cache
+      this.ctx.commit(async () => {
+        await this.scope.cacheRedis.captcha.del(id);
+      });
+      return tokenSecondary === token;
+    }
+    // provider
+    const beanInstance = this._getProviderInstance(captchaData.provider);
+    const providerOptions = this._getProviderOptions(captchaData.scene, captchaData.provider);
+    // verify
+    const verified = await beanInstance.verify(captchaData.token, token, providerOptions);
+    if (!verified) {
+      // do not mutate cache
+      return false;
+    }
+    // delete cache
+    this.ctx.commit(async () => {
+      await this.scope.cacheRedis.captcha.del(id);
+    });
+    // ok
+    return true;
+  }
+  async verifyImmediate(id, token) {
+    let captchaData = await this.getCaptchaData(id);
+    if (!captchaData) return false;
+    // tokenSecondary
+    let tokenSecondary = captchaData.token2;
+    if (tokenSecondary) return tokenSecondary; // maybe called more times
+    // provider
+    const beanInstance = this._getProviderInstance(captchaData.provider);
+    const providerOptions = this._getProviderOptions(captchaData.scene, captchaData.provider);
+    // verify
+    const verified = await beanInstance.verify(captchaData.token, token, providerOptions);
+    if (!verified) {
+      // do not mutate cache
+      return false;
+    }
+    // tokenSecondary
+    tokenSecondary = uuidv4();
+    captchaData = {
+      ...captchaData,
+      token: undefined,
+      token2: tokenSecondary
+    };
+    // update cache
+    await this.scope.cacheRedis.captcha.set(captchaData, id, {
+      ttl: providerOptions.ttlSecondary ?? this.scope.config.captchaProvider.ttlSecondary
+    });
+    // ok
+    return tokenSecondary;
+  }
+  async getCaptchaData(id) {
+    return await this.scope.cacheRedis.captcha.get(id);
+  }
+  async updateCaptchaToken(id, token) {
+    let captchaData = await this.getCaptchaData(id);
+    if (!captchaData) return this.app.throw(403);
+    // provider
+    const providerOptions = this._getProviderOptions(captchaData.scene, captchaData.provider);
+    // update cache
+    captchaData = {
+      ...captchaData,
+      token
+    };
+    await this.scope.cacheRedis.captcha.set(captchaData, id, {
+      ttl: providerOptions.ttl ?? this.scope.config.captchaProvider.ttl
+    });
+  }
+  _getProviderInstance(providerName) {
+    const beanFullName = beanFullNameFromOnionName(providerName, 'captchaProvider');
+    return this.bean._getBean(beanFullName);
+  }
+  _getProviderOptions(sceneName, providerName) {
+    // providers
+    const providers = this._getProviders(sceneName);
+    return providers[providerName];
+  }
+  async _resolveProvider(sceneName) {
+    // providers
+    const providers = this._getProviders(sceneName);
+    if (Object.keys(providers).length === 0) return;
+    // resolver
+    const onionSlice = this.bean.onion.captchaScene.getOnionSlice(sceneName);
+    const onionOptions = onionSlice.beanOptions.options;
+    const resolver = onionOptions?.resolver ?? resolverDefault;
+    const providerName = await resolver(this.ctx, providers);
+    if (!providerName) return;
+    return {
+      name: providerName,
+      options: providers[providerName]
+    };
+  }
+  _getProviders(sceneName) {
+    if (!this[SymbolProviders][sceneName]) {
+      const onionSlice = this.bean.onion.captchaScene.getOnionSlice(sceneName);
+      if (!onionSlice) throw new Error(`not found captcha scene: ${sceneName}`);
+      const onionOptions = onionSlice.beanOptions.options;
+      this[SymbolProviders][sceneName] = this._prepareProviders(onionOptions?.providers);
+    }
+    return this[SymbolProviders][sceneName];
+  }
+  _prepareProviders(providers) {
+    if (!providers) return {};
+    const providersNew = {};
+    for (const _key in providers) {
+      const key = _key;
+      const providerOptions = providers[key];
+      if (providerOptions === false) continue;
+      const onionSlice = this.bean.onion.captchaProvider.getOnionSliceEnabled(true, key);
+      if (!onionSlice) continue;
+      providersNew[key] = deepExtend({}, onionSlice.beanOptions.options, providerOptions);
+    }
+    return providersNew;
+  }
+}) || _class$5) || _class$5);
+async function resolverDefault(_ctx, providers) {
+  const keys = Object.keys(providers);
+  const index = getRandomInt(keys.length, 0);
+  return keys[index];
+}
+
+var _dec$4, _dec2$4, _class$4;
+let CacheRedisCaptcha = (_dec$4 = CacheRedis(), _dec2$4 = BeanInfo({
+  module: "a-captcha"
+}), _dec$4(_class$4 = _dec2$4(_class$4 = class CacheRedisCaptcha extends BeanCacheRedisBase {}) || _class$4) || _class$4);
+
+function _applyDecoratedDescriptor(i, e, r, n, l) {
+  var a = {};
+  return Object.keys(n).forEach(function (i) {
+    a[i] = n[i];
+  }), a.enumerable = !!a.enumerable, a.configurable = !!a.configurable, ("value" in a || a.initializer) && (a.writable = true), a = r.slice().reverse().reduce(function (r, n) {
+    return n(i, e, r) || r;
+  }, a), l && void 0 !== a.initializer && (a.value = a.initializer ? a.initializer.call(l) : void 0, a.initializer = void 0), void 0 === a.initializer ? (Object.defineProperty(i, e, a), null) : a;
+}
+function _initializerDefineProperty(e, i, r, l) {
+  r && Object.defineProperty(e, i, {
+    enumerable: r.enumerable,
+    configurable: r.configurable,
+    writable: r.writable,
+    value: r.initializer ? r.initializer.call(l) : void 0
+  });
+}
+
+var _dec$3, _dec2$3, _dec3$2, _dec4$2, _dec5$2, _dec6$2, _dec7$1, _dec8$1, _dec9$1, _dec0$1, _class$3, _class2$2, _descriptor$1, _descriptor2$1, _descriptor3, _descriptor4;
+let DtoCaptchaData = (_dec$3 = Dto(), _dec2$3 = BeanInfo({
+  module: "a-captcha"
+}), _dec3$2 = Api.field(), _dec4$2 = Reflect.metadata("design:type", String), _dec5$2 = Api.field(), _dec6$2 = Reflect.metadata("design:type", String), _dec7$1 = Api.field(), _dec8$1 = Reflect.metadata("design:type", Object), _dec9$1 = Api.field(), _dec0$1 = Reflect.metadata("design:type", Object), _dec$3(_class$3 = _dec2$3(_class$3 = (_class2$2 = class DtoCaptchaData {
+  constructor() {
+    _initializerDefineProperty(this, "id", _descriptor$1, this);
+    _initializerDefineProperty(this, "provider", _descriptor2$1, this);
+    _initializerDefineProperty(this, "token", _descriptor3, this);
+    _initializerDefineProperty(this, "payload", _descriptor4, this);
+  }
+}, _descriptor$1 = _applyDecoratedDescriptor(_class2$2.prototype, "id", [_dec3$2, _dec4$2], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _descriptor2$1 = _applyDecoratedDescriptor(_class2$2.prototype, "provider", [_dec5$2, _dec6$2], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _descriptor3 = _applyDecoratedDescriptor(_class2$2.prototype, "token", [_dec7$1, _dec8$1], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _descriptor4 = _applyDecoratedDescriptor(_class2$2.prototype, "payload", [_dec9$1, _dec0$1], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _class2$2)) || _class$3) || _class$3);
+
+var _dec$2, _dec2$2, _dec3$1, _dec4$1, _dec5$1, _dec6$1, _class$2, _class2$1, _descriptor, _descriptor2;
+let DtoCaptchaVerify = (_dec$2 = Dto(), _dec2$2 = BeanInfo({
+  module: "a-captcha"
+}), _dec3$1 = Api.field(), _dec4$1 = Reflect.metadata("design:type", String), _dec5$1 = Api.field(), _dec6$1 = Reflect.metadata("design:type", Object), _dec$2(_class$2 = _dec2$2(_class$2 = (_class2$1 = class DtoCaptchaVerify {
+  constructor() {
+    _initializerDefineProperty(this, "id", _descriptor, this);
+    _initializerDefineProperty(this, "token", _descriptor2, this);
+  }
+}, _descriptor = _applyDecoratedDescriptor(_class2$1.prototype, "id", [_dec3$1, _dec4$1], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _descriptor2 = _applyDecoratedDescriptor(_class2$1.prototype, "token", [_dec5$1, _dec6$1], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _class2$1)) || _class$2) || _class$2);
+
+var _dec$1, _dec2$1, _dec3, _dec4, _dec5, _dec6, _dec7, _dec8, _dec9, _dec0, _dec1, _dec10, _dec11, _dec12, _dec13, _dec14, _dec15, _dec16, _dec17, _dec18, _dec19, _dec20, _class$1, _class2;
+let ControllerCaptcha = (_dec$1 = Controller('captcha'), _dec2$1 = BeanInfo({
+  module: "a-captcha"
+}), _dec3 = Web.post('create'), _dec4 = Api.body(DtoCaptchaData), _dec5 = Passport.public(), _dec6 = function (target, key) {
+  return Arg.body('scene')(target, key, 0);
+}, _dec7 = Reflect.metadata("design:type", Function), _dec8 = Reflect.metadata("design:paramtypes", [String]), _dec9 = Web.post('refresh'), _dec0 = Api.body(DtoCaptchaData), _dec1 = Passport.public(), _dec10 = function (target, key) {
+  return Arg.body('id')(target, key, 0);
+}, _dec11 = function (target, key) {
+  return Arg.body('scene')(target, key, 1);
+}, _dec12 = Reflect.metadata("design:type", Function), _dec13 = Reflect.metadata("design:paramtypes", [String, String]), _dec14 = Web.post('verifyImmediate'), _dec15 = Api.body(z.string()), _dec16 = Passport.public(), _dec17 = function (target, key) {
+  return Arg.body('id')(target, key, 0);
+}, _dec18 = function (target, key) {
+  return Arg.body('token')(target, key, 1);
+}, _dec19 = Reflect.metadata("design:type", Function), _dec20 = Reflect.metadata("design:paramtypes", [String, Object]), _dec$1(_class$1 = _dec2$1(_class$1 = (_class2 = class ControllerCaptcha extends BeanBase {
+  async create(scene) {
+    return await this.bean.captcha.create(scene);
+  }
+  async refresh(id, scene) {
+    return await this.bean.captcha.refresh(id, scene);
+  }
+  async verifyImmediate(id, token) {
+    const verified = await this.bean.captcha.verifyImmediate(id, token);
+    if (!verified) this.app.throw(403);
+    return verified;
+  }
+}, _applyDecoratedDescriptor(_class2.prototype, "create", [_dec3, _dec4, _dec5, _dec6, _dec7, _dec8], Object.getOwnPropertyDescriptor(_class2.prototype, "create"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "refresh", [_dec9, _dec0, _dec1, _dec10, _dec11, _dec12, _dec13], Object.getOwnPropertyDescriptor(_class2.prototype, "refresh"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "verifyImmediate", [_dec14, _dec15, _dec16, _dec17, _dec18, _dec19, _dec20], Object.getOwnPropertyDescriptor(_class2.prototype, "verifyImmediate"), _class2.prototype), _class2)) || _class$1) || _class$1);
+
+function config(app) {
+  const showToken = !app.meta.isProd;
+  return {
+    captchaProvider: {
+      ttl: 20 * 60 * 1000,
+      ttlSecondary: 20 * 60 * 1000
+    },
+    captcha: {
+      showToken
+    }
+  };
+}
+
+var locale_en_us = {
+  CaptchaInvalid: 'Captcha Invalid'
+};
+
+var locale_zh_cn = {
+  CaptchaInvalid: '验证码不正确'
+};
 
 var _dec, _dec2, _class;
+const locales = {
+  'en-us': locale_en_us,
+  'zh-cn': locale_zh_cn
+};
 let ScopeModuleACaptcha = (_dec = Scope(), _dec2 = BeanInfo({
   module: "a-captcha"
 }), _dec(_class = _dec2(_class = class ScopeModuleACaptcha extends BeanScopeBase {}) || _class) || _class);
-
+function $locale(key) {
+  return `a-captcha::${key}`;
+}
 /** scope: end */
 
 function CaptchaProvider(options) {
   return createBeanDecorator('captchaProvider', options);
 }
 
-export { CaptchaProvider, ScopeModuleACaptcha };
+function CaptchaScene(options) {
+  return createBeanDecorator('captchaScene', options);
+}
+
+export { $locale, BeanCaptcha, CacheRedisCaptcha, CaptchaProvider, CaptchaScene, ControllerCaptcha, DtoCaptchaData, DtoCaptchaVerify, MiddlewareCaptcha, ScopeModuleACaptcha, config, locales };

package/dist/lib/captchaScene.d.ts

@@ -0,0 +1,2 @@
+import type { IDecoratorCaptchaSceneOptions } from '../types/captchaScene.ts';
+export declare function CaptchaScene(options: IDecoratorCaptchaSceneOptions): ClassDecorator;

package/dist/lib/index.d.ts

@@ -1 +1,2 @@
 export * from './captchaProvider.ts';
+export * from './captchaScene.ts';

package/dist/types/captcha.d.ts

@@ -0,0 +1,14 @@
+import type { ICaptchaProviderRecord } from './captchaProvider.ts';
+import type { ICaptchaSceneRecord } from './captchaScene.ts';
+export interface ICaptchaDataCache {
+    scene: keyof ICaptchaSceneRecord;
+    provider: keyof ICaptchaProviderRecord;
+    token?: unknown;
+    token2?: string;
+}
+export interface ICaptchaData {
+    id: string;
+    provider: keyof ICaptchaProviderRecord;
+    token?: unknown;
+    payload: unknown;
+}

package/dist/types/captchaProvider.d.ts

@@ -2,7 +2,17 @@ import type { OmitNever } from 'vona';
 import type { ServiceOnion, TypeOnionOptionsEnableSimple } from 'vona-module-a-onion';
 export interface ICaptchaProviderRecord {
 }
+export interface ICaptchaProviderExecute<TOKEN = unknown, PAYLOAD = unknown> {
+    create(options: IDecoratorCaptchaProviderOptions): Promise<ICaptchaProviderData<TOKEN, PAYLOAD>>;
+    verify(token: TOKEN, tokenInput: TOKEN, options: IDecoratorCaptchaProviderOptions): Promise<boolean>;
+}
+export interface ICaptchaProviderData<TOKEN = unknown, PAYLOAD = unknown> {
+    token: TOKEN;
+    payload: PAYLOAD;
+}
 export interface IDecoratorCaptchaProviderOptions extends TypeOnionOptionsEnableSimple {
+    ttl?: number;
+    ttlSecondary?: number;
 }
 declare module 'vona-module-a-onion' {
     interface BeanOnion {

package/dist/types/captchaScene.d.ts

@@ -0,0 +1,30 @@
+import type { OmitNever, PowerPartial, VonaContext } from 'vona';
+import type { ServiceOnion, TypeUseOnionOmitOptionsEnable } from 'vona-module-a-onion';
+import type { ICaptchaProviderRecord } from './captchaProvider.ts';
+export interface ICaptchaSceneRecord {
+}
+export type ICaptchaSceneOptionsProviders = {
+    [K in keyof ICaptchaProviderRecord]?: PowerPartial<TypeUseOnionOmitOptionsEnable<ICaptchaProviderRecord[K]>> | boolean;
+};
+export interface ICaptchaSceneOptionsResolverResult<T extends keyof ICaptchaProviderRecord = keyof ICaptchaProviderRecord> {
+    name: T;
+    options: ICaptchaProviderRecord[T];
+}
+export type TypeCaptchaSceneOptionsResolver = (ctx: VonaContext, providers: ICaptchaProviderRecord) => Promise<keyof ICaptchaProviderRecord>;
+export interface IDecoratorCaptchaSceneOptions {
+    resolver?: TypeCaptchaSceneOptionsResolver;
+    providers: ICaptchaSceneOptionsProviders;
+}
+declare module 'vona-module-a-onion' {
+    interface BeanOnion {
+        captchaScene: ServiceOnion<IDecoratorCaptchaSceneOptions, keyof ICaptchaSceneRecord>;
+    }
+}
+declare module 'vona' {
+    interface ConfigOnions {
+        captchaScene: OmitNever<ICaptchaSceneRecord>;
+    }
+    interface IBeanSceneRecord {
+        captchaScene: never;
+    }
+}

package/dist/types/index.d.ts

@@ -1 +1,3 @@
+export * from './captcha.ts';
 export * from './captchaProvider.ts';
+export * from './captchaScene.ts';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vona-module-a-captcha",
   "type": "module",
-  "version": "5.0.2",
+  "version": "5.0.8",
   "title": "a-captcha",
   "vonaModule": {
     "dependencies": {},
@@ -10,6 +10,11 @@
         "optionsGlobalInterfaceName": "IDecoratorCaptchaProviderOptions",
         "optionsGlobalInterfaceFrom": "vona-module-a-captcha",
         "boilerplate": "cli/captchaProvider/boilerplate"
+      },
+      "captchaScene": {
+        "optionsGlobalInterfaceName": "IDecoratorCaptchaSceneOptions",
+        "optionsGlobalInterfaceFrom": "vona-module-a-captcha",
+        "boilerplate": "cli/captchaScene/boilerplate"
       }
     }
   },