@gvrs/nestjs-hcaptcha 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
+
+## 0.1.0 (2024-01-28)
+
+
+### Features
+
+* initial commit ([9008bc3](https://github.com/alexgavrusev/nestjs-hcaptcha/commit/9008bc3386fc8dad738af6c5a96ed28424812f63))

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Aliaksandr Haurusiou
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,133 @@
+# @gvrs/nestjs-hcaptcha
+
+A NestJS module for adding hCaptcha validation
+
+## Installation
+
+```bash
+npm i @gvrs/nestjs-hcaptcha
+```
+
+## Usage
+
+First, provide the options in the root `AppModule`:
+
+```ts
+@Module({
+  imports: [
+    HcaptchaModule.forRoot({
+      secret: 'YOUR_HCAPTCHA_SECRET',
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+Afterward, import the `HcaptchaModule` in the module where you need to use captcha validation:
+
+```ts
+@Module({
+  imports: [HcaptchaModule],
+  controllers: [UsersController],
+})
+export class UsersModule {}
+```
+
+Finally, decorate the controller method with `@VerifyCaptcha()`:
+
+```ts
+@Controller('users')
+class UsersController {
+  @Post('register')
+  @VerifyCaptcha()
+  register() {}
+}
+```
+
+By default, the hCaptcha token will be extracted from the `h-captcha-response` request body field
+
+### Setting the sitekey you expect to see
+
+Provide the `sitekey` option in the root `HcaptchaModule`:
+
+```ts
+@Module({
+  imports: [
+    HcaptchaModule.forRoot({
+      secret: 'YOUR_HCAPTCHA_SECRET',
+      sitekey: 'YOUR_SITEKEY',
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+### Customizing the captcha data extraction
+
+If you want to customize the retrieval of the hCaptcha token and/or the user's IP address, provide an implementation of `getCaptchaData` in the root `HcaptchaModule`:
+
+```ts
+@Module({
+  imports: [
+    HcaptchaModule.forRoot({
+      secret: 'YOUR_HCAPTCHA_SECRET',
+      getCaptchaData: (ctx) => {
+        const request = ctx.switchToHttp().getRequest();
+
+        const token = request.body['token'];
+        const remoteip = request.headers['x-forwarded-for'];
+
+        return { token, remoteip };
+      },
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+### Customizing the error response
+
+By default, when the captcha is invalid, or cannot be validated, a 403 error will be sent to the client. To customize that response, use an [exception filter](https://docs.nestjs.com/exception-filters):
+
+```ts
+@Catch(HcaptchaException)
+class HcaptchaExceptionFilter implements ExceptionFilter {
+  catch(exception: HcaptchaException, host: ArgumentsHost) {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse();
+    const status = 400;
+
+    response.status(status).json({
+      statusCode: status,
+      message: 'Invalid captcha',
+    });
+  }
+}
+```
+
+### Imperative captcha verification
+
+If you don't want to, or cannot use the `@VerifyCaptha()` decorator or the `HcaptchaGuard`, you can verify the captcha by using the `HcaptchaService`:
+
+```ts
+@Controller('users')
+class UsersController {
+  constructor(private readonly hcaptchaService: HcaptchaService) {}
+
+  @Post('register')
+  async register(@Req() request: Request) {
+    try {
+      const token = request.body['h-captcha-response'];
+
+      // returns the hCaptcha JSON response, or throws a HcaptchaException
+      const verifyResponse = await this.hcaptchaService.verifyCaptcha(token);
+    } catch {
+      throw new BadRequestException();
+    }
+  }
+}
+```
+
+## License
+
+MIT © Aliaksandr Haurusiou.

package/index.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./src/index";

package/index.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./index.cjs.js').default;

package/index.cjs.js

@@ -0,0 +1,28 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var getCaptchaData = require('./lib/get-captcha-data/get-captcha-data.cjs.js');
+var hcaptcha_exception = require('./lib/hcaptcha.exception.cjs.js');
+var hcaptcha_guard = require('./lib/hcaptcha.guard.cjs.js');
+var hcaptcha_module = require('./lib/hcaptcha.module.cjs.js');
+var hcaptcha_service = require('./lib/hcaptcha.service.cjs.js');
+var verifyCaptcha_decorator = require('./lib/verify-captcha.decorator.cjs.js');
+
+
+
+exports.defaultGetCaptchaData = getCaptchaData.defaultGetCaptchaData;
+exports.HcaptchaException = hcaptcha_exception.HcaptchaException;
+Object.defineProperty(exports, 'HcaptchaGuard', {
+	enumerable: true,
+	get: function () { return hcaptcha_guard.HcaptchaGuard; }
+});
+Object.defineProperty(exports, 'HcaptchaModule', {
+	enumerable: true,
+	get: function () { return hcaptcha_module.HcaptchaModule; }
+});
+Object.defineProperty(exports, 'HcaptchaService', {
+	enumerable: true,
+	get: function () { return hcaptcha_service.HcaptchaService; }
+});
+exports.VerifyCaptcha = verifyCaptcha_decorator.VerifyCaptcha;

package/index.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './index.cjs.js';
+export { _default as default } from './index.cjs.default.js';

package/index.esm.js

@@ -0,0 +1,6 @@
+export { defaultGetCaptchaData } from './lib/get-captcha-data/get-captcha-data.esm.js';
+export { HcaptchaException } from './lib/hcaptcha.exception.esm.js';
+export { HcaptchaGuard } from './lib/hcaptcha.guard.esm.js';
+export { HcaptchaModule } from './lib/hcaptcha.module.esm.js';
+export { HcaptchaService } from './lib/hcaptcha.service.esm.js';
+export { VerifyCaptcha } from './lib/verify-captcha.decorator.esm.js';

package/lib/get-captcha-data/get-captcha-data.cjs.js

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var hcaptcha_exception = require('../hcaptcha.exception.cjs.js');
+
+const defaultGetCaptchaData = (context)=>{
+    const request = context.switchToHttp().getRequest();
+    const token = request.body['h-captcha-response'];
+    if (!token) {
+        throw new hcaptcha_exception.HcaptchaException(new Error('No hCaptcha token present in request body'));
+    }
+    return {
+        token
+    };
+};
+
+exports.defaultGetCaptchaData = defaultGetCaptchaData;

package/lib/get-captcha-data/get-captcha-data.esm.js

@@ -0,0 +1,14 @@
+import { HcaptchaException } from '../hcaptcha.exception.esm.js';
+
+const defaultGetCaptchaData = (context)=>{
+    const request = context.switchToHttp().getRequest();
+    const token = request.body['h-captcha-response'];
+    if (!token) {
+        throw new HcaptchaException(new Error('No hCaptcha token present in request body'));
+    }
+    return {
+        token
+    };
+};
+
+export { defaultGetCaptchaData };

package/lib/hcaptcha.exception.cjs.js

@@ -0,0 +1,15 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var common = require('@nestjs/common');
+
+class HcaptchaException extends common.ForbiddenException {
+    constructor(cause, message = 'Forbidden'){
+        super(message, {
+            cause
+        });
+    }
+}
+
+exports.HcaptchaException = HcaptchaException;

package/lib/hcaptcha.exception.esm.js

@@ -0,0 +1,11 @@
+import { ForbiddenException } from '@nestjs/common';
+
+class HcaptchaException extends ForbiddenException {
+    constructor(cause, message = 'Forbidden'){
+        super(message, {
+            cause
+        });
+    }
+}
+
+export { HcaptchaException };

package/lib/hcaptcha.guard.cjs.js

@@ -0,0 +1,33 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _ts_decorate = require('@swc/helpers/_/_ts_decorate');
+var _ts_metadata = require('@swc/helpers/_/_ts_metadata');
+var _ts_param = require('@swc/helpers/_/_ts_param');
+var common = require('@nestjs/common');
+var hcaptchaOptions_module = require('./options/hcaptcha-options.module.cjs.js');
+var hcaptcha_service = require('./hcaptcha.service.cjs.js');
+
+class HcaptchaGuard {
+    async canActivate(context) {
+        const { token, remoteip } = this.options.getCaptchaData(context);
+        await this.hcaptchaService.verifyCaptcha(token, remoteip);
+        return true;
+    }
+    constructor(options, hcaptchaService){
+        this.options = options;
+        this.hcaptchaService = hcaptchaService;
+    }
+}
+HcaptchaGuard = _ts_decorate._([
+    common.Injectable(),
+    _ts_param._(0, common.Inject(hcaptchaOptions_module.NORMALIZED_HCAPTCHA_OPTIONS)),
+    _ts_metadata._("design:type", Function),
+    _ts_metadata._("design:paramtypes", [
+        typeof NormalizedHcaptchaOptions === "undefined" ? Object : NormalizedHcaptchaOptions,
+        typeof hcaptcha_service.HcaptchaService === "undefined" ? Object : hcaptcha_service.HcaptchaService
+    ])
+], HcaptchaGuard);
+
+exports.HcaptchaGuard = HcaptchaGuard;

package/lib/hcaptcha.guard.esm.js

@@ -0,0 +1,29 @@
+import { _ } from '@swc/helpers/_/_ts_decorate';
+import { _ as _$2 } from '@swc/helpers/_/_ts_metadata';
+import { _ as _$1 } from '@swc/helpers/_/_ts_param';
+import { Injectable, Inject } from '@nestjs/common';
+import { HcaptchaService } from './hcaptcha.service.esm.js';
+import { NORMALIZED_HCAPTCHA_OPTIONS } from './options/hcaptcha-options.module.esm.js';
+
+class HcaptchaGuard {
+    async canActivate(context) {
+        const { token, remoteip } = this.options.getCaptchaData(context);
+        await this.hcaptchaService.verifyCaptcha(token, remoteip);
+        return true;
+    }
+    constructor(options, hcaptchaService){
+        this.options = options;
+        this.hcaptchaService = hcaptchaService;
+    }
+}
+HcaptchaGuard = _([
+    Injectable(),
+    _$1(0, Inject(NORMALIZED_HCAPTCHA_OPTIONS)),
+    _$2("design:type", Function),
+    _$2("design:paramtypes", [
+        typeof NormalizedHcaptchaOptions === "undefined" ? Object : NormalizedHcaptchaOptions,
+        typeof HcaptchaService === "undefined" ? Object : HcaptchaService
+    ])
+], HcaptchaGuard);
+
+export { HcaptchaGuard };

package/lib/hcaptcha.module.cjs.js

@@ -0,0 +1,39 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _ts_decorate = require('@swc/helpers/_/_ts_decorate');
+var common = require('@nestjs/common');
+var hcaptchaOptions_module = require('./options/hcaptcha-options.module.cjs.js');
+var hcaptcha_service = require('./hcaptcha.service.cjs.js');
+
+class HcaptchaModule {
+    static forRoot(options) {
+        return {
+            module: this,
+            imports: [
+                hcaptchaOptions_module.HcaptchaOptionsModule.forRoot(options)
+            ]
+        };
+    }
+    static forRootAsync(options) {
+        return {
+            module: this,
+            imports: [
+                hcaptchaOptions_module.HcaptchaOptionsModule.forRootAsync(options)
+            ]
+        };
+    }
+}
+HcaptchaModule = _ts_decorate._([
+    common.Module({
+        providers: [
+            hcaptcha_service.HcaptchaService
+        ],
+        exports: [
+            hcaptcha_service.HcaptchaService
+        ]
+    })
+], HcaptchaModule);
+
+exports.HcaptchaModule = HcaptchaModule;

package/lib/hcaptcha.module.esm.js

@@ -0,0 +1,35 @@
+import { _ } from '@swc/helpers/_/_ts_decorate';
+import { Module } from '@nestjs/common';
+import { HcaptchaService } from './hcaptcha.service.esm.js';
+import { HcaptchaOptionsModule } from './options/hcaptcha-options.module.esm.js';
+
+class HcaptchaModule {
+    static forRoot(options) {
+        return {
+            module: this,
+            imports: [
+                HcaptchaOptionsModule.forRoot(options)
+            ]
+        };
+    }
+    static forRootAsync(options) {
+        return {
+            module: this,
+            imports: [
+                HcaptchaOptionsModule.forRootAsync(options)
+            ]
+        };
+    }
+}
+HcaptchaModule = _([
+    Module({
+        providers: [
+            HcaptchaService
+        ],
+        exports: [
+            HcaptchaService
+        ]
+    })
+], HcaptchaModule);
+
+export { HcaptchaModule };

package/lib/hcaptcha.service.cjs.js

@@ -0,0 +1,40 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _ts_decorate = require('@swc/helpers/_/_ts_decorate');
+var _ts_metadata = require('@swc/helpers/_/_ts_metadata');
+var _ts_param = require('@swc/helpers/_/_ts_param');
+var common = require('@nestjs/common');
+var hcaptcha = require('hcaptcha');
+var hcaptchaOptions_module = require('./options/hcaptcha-options.module.cjs.js');
+var hcaptcha_exception = require('./hcaptcha.exception.cjs.js');
+
+class HcaptchaService {
+    async verifyCaptcha(token, remoteip) {
+        let verifyResponse;
+        try {
+            verifyResponse = await hcaptcha.verify(this.options.secret, token, remoteip, this.options.sitekey);
+        } catch (e) {
+            throw new hcaptcha_exception.HcaptchaException(e);
+        }
+        const { success } = verifyResponse;
+        if (!success) {
+            throw new hcaptcha_exception.HcaptchaException(verifyResponse);
+        }
+        return verifyResponse;
+    }
+    constructor(options){
+        this.options = options;
+    }
+}
+HcaptchaService = _ts_decorate._([
+    common.Injectable(),
+    _ts_param._(0, common.Inject(hcaptchaOptions_module.NORMALIZED_HCAPTCHA_OPTIONS)),
+    _ts_metadata._("design:type", Function),
+    _ts_metadata._("design:paramtypes", [
+        typeof NormalizedHcaptchaOptions === "undefined" ? Object : NormalizedHcaptchaOptions
+    ])
+], HcaptchaService);
+
+exports.HcaptchaService = HcaptchaService;

package/lib/hcaptcha.service.esm.js

@@ -0,0 +1,36 @@
+import { _ } from '@swc/helpers/_/_ts_decorate';
+import { _ as _$2 } from '@swc/helpers/_/_ts_metadata';
+import { _ as _$1 } from '@swc/helpers/_/_ts_param';
+import { Injectable, Inject } from '@nestjs/common';
+import { verify } from 'hcaptcha';
+import { HcaptchaException } from './hcaptcha.exception.esm.js';
+import { NORMALIZED_HCAPTCHA_OPTIONS } from './options/hcaptcha-options.module.esm.js';
+
+class HcaptchaService {
+    async verifyCaptcha(token, remoteip) {
+        let verifyResponse;
+        try {
+            verifyResponse = await verify(this.options.secret, token, remoteip, this.options.sitekey);
+        } catch (e) {
+            throw new HcaptchaException(e);
+        }
+        const { success } = verifyResponse;
+        if (!success) {
+            throw new HcaptchaException(verifyResponse);
+        }
+        return verifyResponse;
+    }
+    constructor(options){
+        this.options = options;
+    }
+}
+HcaptchaService = _([
+    Injectable(),
+    _$1(0, Inject(NORMALIZED_HCAPTCHA_OPTIONS)),
+    _$2("design:type", Function),
+    _$2("design:paramtypes", [
+        typeof NormalizedHcaptchaOptions === "undefined" ? Object : NormalizedHcaptchaOptions
+    ])
+], HcaptchaService);
+
+export { HcaptchaService };

package/lib/options/hcaptcha-options.module.cjs.js

@@ -0,0 +1,40 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _extends = require('@swc/helpers/_/_extends');
+var _ts_decorate = require('@swc/helpers/_/_ts_decorate');
+var common = require('@nestjs/common');
+var getCaptchaData = require('../get-captcha-data/get-captcha-data.cjs.js');
+
+const PROVIDED_HCAPTCHA_OPTIONS = Symbol('PROVIDED_HCAPTCHA_OPTIONS');
+const NORMALIZED_HCAPTCHA_OPTIONS = Symbol('NORMALIZED_HCAPTCHA_OPTIONS');
+const normalizeOptions = (options)=>_extends._({
+        getCaptchaData: getCaptchaData.defaultGetCaptchaData
+    }, options);
+const { ASYNC_OPTIONS_TYPE: ASYNC_HCAPTCHA_OPTIONS_TYPE, ConfigurableModuleClass } = new common.ConfigurableModuleBuilder({
+    optionsInjectionToken: PROVIDED_HCAPTCHA_OPTIONS
+}).setClassMethodName('forRoot').setExtras({}, (def)=>_extends._({}, def, {
+        global: true,
+        providers: [
+            ...def.providers,
+            {
+                provide: NORMALIZED_HCAPTCHA_OPTIONS,
+                useFactory: normalizeOptions,
+                inject: [
+                    PROVIDED_HCAPTCHA_OPTIONS
+                ]
+            }
+        ],
+        exports: [
+            NORMALIZED_HCAPTCHA_OPTIONS
+        ]
+    })).build();
+class HcaptchaOptionsModule extends ConfigurableModuleClass {
+}
+HcaptchaOptionsModule = _ts_decorate._([
+    common.Module({})
+], HcaptchaOptionsModule);
+
+exports.HcaptchaOptionsModule = HcaptchaOptionsModule;
+exports.NORMALIZED_HCAPTCHA_OPTIONS = NORMALIZED_HCAPTCHA_OPTIONS;

package/lib/options/hcaptcha-options.module.esm.js

@@ -0,0 +1,35 @@
+import { _ } from '@swc/helpers/_/_extends';
+import { _ as _$1 } from '@swc/helpers/_/_ts_decorate';
+import { ConfigurableModuleBuilder, Module } from '@nestjs/common';
+import { defaultGetCaptchaData } from '../get-captcha-data/get-captcha-data.esm.js';
+
+const PROVIDED_HCAPTCHA_OPTIONS = Symbol('PROVIDED_HCAPTCHA_OPTIONS');
+const NORMALIZED_HCAPTCHA_OPTIONS = Symbol('NORMALIZED_HCAPTCHA_OPTIONS');
+const normalizeOptions = (options)=>_({
+        getCaptchaData: defaultGetCaptchaData
+    }, options);
+const { ASYNC_OPTIONS_TYPE: ASYNC_HCAPTCHA_OPTIONS_TYPE, ConfigurableModuleClass } = new ConfigurableModuleBuilder({
+    optionsInjectionToken: PROVIDED_HCAPTCHA_OPTIONS
+}).setClassMethodName('forRoot').setExtras({}, (def)=>_({}, def, {
+        global: true,
+        providers: [
+            ...def.providers,
+            {
+                provide: NORMALIZED_HCAPTCHA_OPTIONS,
+                useFactory: normalizeOptions,
+                inject: [
+                    PROVIDED_HCAPTCHA_OPTIONS
+                ]
+            }
+        ],
+        exports: [
+            NORMALIZED_HCAPTCHA_OPTIONS
+        ]
+    })).build();
+class HcaptchaOptionsModule extends ConfigurableModuleClass {
+}
+HcaptchaOptionsModule = _$1([
+    Module({})
+], HcaptchaOptionsModule);
+
+export { HcaptchaOptionsModule, NORMALIZED_HCAPTCHA_OPTIONS };

package/lib/verify-captcha.decorator.cjs.js

@@ -0,0 +1,10 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var common = require('@nestjs/common');
+var hcaptcha_guard = require('./hcaptcha.guard.cjs.js');
+
+const VerifyCaptcha = ()=>common.applyDecorators(common.UseGuards(hcaptcha_guard.HcaptchaGuard));
+
+exports.VerifyCaptcha = VerifyCaptcha;

package/lib/verify-captcha.decorator.esm.js

@@ -0,0 +1,6 @@
+import { applyDecorators, UseGuards } from '@nestjs/common';
+import { HcaptchaGuard } from './hcaptcha.guard.esm.js';
+
+const VerifyCaptcha = ()=>applyDecorators(UseGuards(HcaptchaGuard));
+
+export { VerifyCaptcha };

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@gvrs/nestjs-hcaptcha",
+  "version": "0.1.0",
+  "license": "MIT",
+  "author": "Alex Gavrusev <alex@gavrusev.dev>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/alexgavrusev/nestjs-hcaptcha.git"
+  },
+  "homepage": "https://github.com/alexgavrusev/nestjs-hcaptcha#readme",
+  "bugs": {
+    "url": "https://github.com/alexgavrusev/nestjs-hcaptcha/issues"
+  },
+  "scripts": {
+    "prepare": "node -e \"if(require('fs').existsSync('.git')){/* proceed only if .git is found */ process.exit(1)}\" || is-ci || husky install"
+  },
+  "dependencies": {
+    "@swc/helpers": "~0.5.2"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^18.0.0",
+    "@commitlint/config-conventional": "^18.0.0",
+    "@gvrs-nx/ts-package": "0.3.0",
+    "@jscutlery/semver": "^4.1.0",
+    "@nestjs/common": "10.3.0",
+    "@nestjs/platform-express": "10.3.0",
+    "@nestjs/testing": "10.3.0",
+    "@nx/eslint": "17.2.8",
+    "@nx/eslint-plugin": "17.2.8",
+    "@nx/js": "17.2.8",
+    "@nx/rollup": "17.2.8",
+    "@nx/vite": "17.2.8",
+    "@nx/workspace": "17.2.8",
+    "@swc-node/register": "~1.6.7",
+    "@swc/cli": "~0.1.62",
+    "@swc/core": "~1.3.85",
+    "@types/express": "4.17.21",
+    "@types/node": "18.7.1",
+    "@types/supertest": "6.0.2",
+    "@typescript-eslint/eslint-plugin": "^6.9.1",
+    "@typescript-eslint/parser": "^6.9.1",
+    "@vitest/coverage-v8": "~0.34.6",
+    "@vitest/ui": "~0.34.6",
+    "eslint": "~8.48.0",
+    "eslint-config-prettier": "^9.0.0",
+    "hcaptcha": "0.1.1",
+    "husky": "^8.0.0",
+    "is-ci": "^3.0.0",
+    "nock": "13.5.0",
+    "nx": "17.2.8",
+    "prettier": "^2.6.2",
+    "supertest": "6.3.4",
+    "tslib": "^2.3.0",
+    "typescript": "~5.2.2",
+    "unplugin-swc": "1.4.4",
+    "verdaccio": "^5.0.4",
+    "vite": "^5.0.0",
+    "vitest": "1.2.1",
+    "vitest-mock-extended": "1.3.1"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^10.0.0",
+    "hcaptcha": "~0.1.1"
+  },
+  "sideEffects": false,
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "module": "./index.esm.js",
+      "import": "./index.cjs.mjs",
+      "default": "./index.cjs.js"
+    }
+  },
+  "module": "./index.esm.js",
+  "main": "./index.cjs.js"
+}

package/src/index.d.ts

@@ -0,0 +1 @@
+export * from './lib';

package/src/lib/get-captcha-data/get-captcha-data.d.ts

@@ -0,0 +1,7 @@
+import { ExecutionContext } from '@nestjs/common';
+export type CaptchaData = {
+    token: string;
+    remoteip?: string;
+};
+export type GetCaptchaData = (executionContext: ExecutionContext) => CaptchaData;
+export declare const defaultGetCaptchaData: GetCaptchaData;

package/src/lib/get-captcha-data/index.d.ts

@@ -0,0 +1 @@
+export * from './get-captcha-data';

package/src/lib/hcaptcha.exception.d.ts

@@ -0,0 +1,4 @@
+import { ForbiddenException } from '@nestjs/common';
+export declare class HcaptchaException extends ForbiddenException {
+    constructor(cause: unknown, message?: string);
+}

package/src/lib/hcaptcha.guard.d.ts

@@ -0,0 +1,9 @@
+import { CanActivate, ExecutionContext } from '@nestjs/common';
+import type { NormalizedHcaptchaOptions } from './options';
+import { HcaptchaService } from './hcaptcha.service';
+export declare class HcaptchaGuard implements CanActivate {
+    private readonly options;
+    private readonly hcaptchaService;
+    constructor(options: NormalizedHcaptchaOptions, hcaptchaService: HcaptchaService);
+    canActivate(context: ExecutionContext): Promise<boolean>;
+}

package/src/lib/hcaptcha.module.d.ts

@@ -0,0 +1,6 @@
+import { DynamicModule } from '@nestjs/common';
+import { HcaptchaOptions, AsyncHcaptchaOptions } from './options';
+export declare class HcaptchaModule {
+    static forRoot(options: HcaptchaOptions): DynamicModule;
+    static forRootAsync(options: AsyncHcaptchaOptions): DynamicModule;
+}

package/src/lib/hcaptcha.service.d.ts

@@ -0,0 +1,6 @@
+import type { NormalizedHcaptchaOptions } from './options';
+export declare class HcaptchaService {
+    private readonly options;
+    constructor(options: NormalizedHcaptchaOptions);
+    verifyCaptcha(token: string, remoteip?: string): Promise<globalThis.VerifyResponse>;
+}

package/src/lib/index.d.ts

@@ -0,0 +1,8 @@
+export * from './get-captcha-data';
+export type { HcaptchaOptions, AsyncHcaptchaOptions } from './options';
+export * from './hcaptcha.exception';
+export * from './hcaptcha.guard';
+export * from './hcaptcha.module';
+export * from './hcaptcha.service';
+export * from './verify-captcha.decorator';
+export * from './typings';

package/src/lib/options/hcaptcha-options.module.d.ts

@@ -0,0 +1,7 @@
+import { HcaptchaOptions } from './hcaptcha-options.types';
+declare const NORMALIZED_HCAPTCHA_OPTIONS: unique symbol;
+declare const ASYNC_HCAPTCHA_OPTIONS_TYPE: import("@nestjs/common").ConfigurableModuleAsyncOptions<HcaptchaOptions, "create"> & Partial<{}>, ConfigurableModuleClass: import("@nestjs/common").ConfigurableModuleCls<HcaptchaOptions, "forRoot", "create", {}>;
+export declare class HcaptchaOptionsModule extends ConfigurableModuleClass {
+}
+export type AsyncHcaptchaOptions = typeof ASYNC_HCAPTCHA_OPTIONS_TYPE;
+export { NORMALIZED_HCAPTCHA_OPTIONS };

package/src/lib/options/hcaptcha-options.types.d.ts

@@ -0,0 +1,7 @@
+import { GetCaptchaData } from '../get-captcha-data';
+export type HcaptchaOptions = {
+    secret: string;
+    sitekey?: string;
+    getCaptchaData?: GetCaptchaData;
+};
+export type NormalizedHcaptchaOptions = Required<Pick<HcaptchaOptions, 'getCaptchaData'>> & HcaptchaOptions;

package/src/lib/options/index.d.ts

@@ -0,0 +1,2 @@
+export * from './hcaptcha-options.module';
+export * from './hcaptcha-options.types';

package/src/lib/typings.d.ts

@@ -0,0 +1,2 @@
+import { verify } from 'hcaptcha';
+export type VerifyResponse = Awaited<ReturnType<typeof verify>>;

package/src/lib/verify-captcha.decorator.d.ts

@@ -0,0 +1 @@
+export declare const VerifyCaptcha: () => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;