@mondart/nestjs-common-module 2.8.0 → 2.9.0

package/dist/lib/google-recaptcha/decorators/recaptcha-result.d.ts

@@ -0,0 +1 @@
+export declare const RecaptchaResult: (...dataOrPipes: any[]) => ParameterDecorator;

package/dist/lib/google-recaptcha/decorators/recaptcha-result.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecaptchaResult = void 0;
+const common_1 = require("@nestjs/common");
+const load_module_1 = require("../helpers/load-module");
+exports.RecaptchaResult = (0, common_1.createParamDecorator)((data, context) => {
+    switch (context.getType()) {
+        case 'http':
+            return context.switchToHttp().getRequest().recaptchaValidationResult;
+        case 'graphql':
+            return (0, load_module_1.loadModule)('@nestjs/graphql', true)
+                .GqlExecutionContext.create(context)
+                .getContext().req?.connection?._httpMessage?.req
+                ?.recaptchaValidationResult;
+    }
+});

package/dist/lib/google-recaptcha/decorators/recaptcha.d.ts

@@ -0,0 +1,2 @@
+import { VerifyResponseDecoratorOptions } from '../interfaces/verify-response-decorator-options';
+export declare function Recaptcha(options?: VerifyResponseDecoratorOptions): MethodDecorator & ClassDecorator;

package/dist/lib/google-recaptcha/decorators/recaptcha.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Recaptcha = Recaptcha;
+const common_1 = require("@nestjs/common");
+const google_recaptcha_guard_1 = require("../guards/google-recaptcha.guard");
+const set_recaptcha_options_1 = require("./set-recaptcha-options");
+function Recaptcha(options) {
+    return (0, common_1.applyDecorators)((0, set_recaptcha_options_1.SetRecaptchaOptions)(options), (0, common_1.UseGuards)(google_recaptcha_guard_1.GoogleRecaptchaGuard));
+}

package/dist/lib/google-recaptcha/decorators/set-recaptcha-options.d.ts

@@ -0,0 +1,2 @@
+import { VerifyResponseDecoratorOptions } from '../interfaces/verify-response-decorator-options';
+export declare function SetRecaptchaOptions(options?: VerifyResponseDecoratorOptions): MethodDecorator & ClassDecorator;

package/dist/lib/google-recaptcha/decorators/set-recaptcha-options.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetRecaptchaOptions = SetRecaptchaOptions;
+const common_1 = require("@nestjs/common");
+const provider_declarations_1 = require("../provider.declarations");
+function SetRecaptchaOptions(options) {
+    return (0, common_1.SetMetadata)(provider_declarations_1.RECAPTCHA_VALIDATION_OPTIONS, options);
+}

package/dist/lib/google-recaptcha/enums/classification-reason.d.ts

@@ -0,0 +1,8 @@
+export declare enum ClassificationReason {
+    CLASSIFICATION_REASON_UNSPECIFIED = "CLASSIFICATION_REASON_UNSPECIFIED",
+    AUTOMATION = "AUTOMATION",
+    UNEXPECTED_ENVIRONMENT = "UNEXPECTED_ENVIRONMENT",
+    TOO_MUCH_TRAFFIC = "TOO_MUCH_TRAFFIC",
+    UNEXPECTED_USAGE_PATTERNS = "UNEXPECTED_USAGE_PATTERNS",
+    LOW_CONFIDENCE_SCORE = "LOW_CONFIDENCE_SCORE"
+}

package/dist/lib/google-recaptcha/enums/classification-reason.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClassificationReason = void 0;
+var ClassificationReason;
+(function (ClassificationReason) {
+    ClassificationReason["CLASSIFICATION_REASON_UNSPECIFIED"] = "CLASSIFICATION_REASON_UNSPECIFIED";
+    ClassificationReason["AUTOMATION"] = "AUTOMATION";
+    ClassificationReason["UNEXPECTED_ENVIRONMENT"] = "UNEXPECTED_ENVIRONMENT";
+    ClassificationReason["TOO_MUCH_TRAFFIC"] = "TOO_MUCH_TRAFFIC";
+    ClassificationReason["UNEXPECTED_USAGE_PATTERNS"] = "UNEXPECTED_USAGE_PATTERNS";
+    ClassificationReason["LOW_CONFIDENCE_SCORE"] = "LOW_CONFIDENCE_SCORE";
+})(ClassificationReason || (exports.ClassificationReason = ClassificationReason = {}));

package/dist/lib/google-recaptcha/enums/error-code.d.ts

@@ -0,0 +1,16 @@
+export declare enum ErrorCode {
+    MissingInputSecret = "missing-input-secret",
+    InvalidInputSecret = "invalid-input-secret",
+    MissingInputResponse = "missing-input-response",
+    InvalidInputResponse = "invalid-input-response",
+    BadRequest = "bad-request",
+    TimeoutOrDuplicate = "timeout-or-duplicate",
+    UnknownError = "unknown-error",
+    ForbiddenAction = "forbidden-action",
+    LowScore = "low-score",
+    InvalidKeys = "invalid-keys",
+    IncorrectCaptchaSol = "incorrect-captcha-sol",
+    NetworkError = "network-error",
+    SiteMismatch = "site-mismatch",
+    BrowserError = "browser-error"
+}

package/dist/lib/google-recaptcha/enums/error-code.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorCode = void 0;
+var ErrorCode;
+(function (ErrorCode) {
+    ErrorCode["MissingInputSecret"] = "missing-input-secret";
+    ErrorCode["InvalidInputSecret"] = "invalid-input-secret";
+    ErrorCode["MissingInputResponse"] = "missing-input-response";
+    ErrorCode["InvalidInputResponse"] = "invalid-input-response";
+    ErrorCode["BadRequest"] = "bad-request";
+    ErrorCode["TimeoutOrDuplicate"] = "timeout-or-duplicate";
+    ErrorCode["UnknownError"] = "unknown-error";
+    ErrorCode["ForbiddenAction"] = "forbidden-action";
+    ErrorCode["LowScore"] = "low-score";
+    ErrorCode["InvalidKeys"] = "invalid-keys";
+    ErrorCode["IncorrectCaptchaSol"] = "incorrect-captcha-sol";
+    ErrorCode["NetworkError"] = "network-error";
+    ErrorCode["SiteMismatch"] = "site-mismatch";
+    ErrorCode["BrowserError"] = "browser-error";
+})(ErrorCode || (exports.ErrorCode = ErrorCode = {}));

package/dist/lib/google-recaptcha/enums/google-recaptcha-context.d.ts

@@ -0,0 +1,4 @@
+export declare enum GoogleRecaptchaContext {
+    GoogleRecaptcha = "GoogleRecaptcha",
+    GoogleRecaptchaEnterprise = "GoogleRecaptchaEnterprise"
+}

package/dist/lib/google-recaptcha/enums/google-recaptcha-context.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleRecaptchaContext = void 0;
+var GoogleRecaptchaContext;
+(function (GoogleRecaptchaContext) {
+    GoogleRecaptchaContext["GoogleRecaptcha"] = "GoogleRecaptcha";
+    GoogleRecaptchaContext["GoogleRecaptchaEnterprise"] = "GoogleRecaptchaEnterprise";
+})(GoogleRecaptchaContext || (exports.GoogleRecaptchaContext = GoogleRecaptchaContext = {}));

package/dist/lib/google-recaptcha/enums/google-recaptcha-enterprise-reason.d.ts

@@ -0,0 +1,10 @@
+export declare enum GoogleRecaptchaEnterpriseReason {
+    InvalidReasonUnspecified = "INVALID_REASON_UNSPECIFIED",
+    UnknownInvalidReason = "UNKNOWN_INVALID_REASON",
+    Malformed = "MALFORMED",
+    Expired = "EXPIRED",
+    Dupe = "DUPE",
+    SiteMismatch = "SITE_MISMATCH",
+    Missing = "MISSING",
+    BrowserError = "BROWSER_ERROR"
+}

package/dist/lib/google-recaptcha/enums/google-recaptcha-enterprise-reason.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleRecaptchaEnterpriseReason = void 0;
+var GoogleRecaptchaEnterpriseReason;
+(function (GoogleRecaptchaEnterpriseReason) {
+    GoogleRecaptchaEnterpriseReason["InvalidReasonUnspecified"] = "INVALID_REASON_UNSPECIFIED";
+    GoogleRecaptchaEnterpriseReason["UnknownInvalidReason"] = "UNKNOWN_INVALID_REASON";
+    GoogleRecaptchaEnterpriseReason["Malformed"] = "MALFORMED";
+    GoogleRecaptchaEnterpriseReason["Expired"] = "EXPIRED";
+    GoogleRecaptchaEnterpriseReason["Dupe"] = "DUPE";
+    GoogleRecaptchaEnterpriseReason["SiteMismatch"] = "SITE_MISMATCH";
+    GoogleRecaptchaEnterpriseReason["Missing"] = "MISSING";
+    GoogleRecaptchaEnterpriseReason["BrowserError"] = "BROWSER_ERROR";
+})(GoogleRecaptchaEnterpriseReason || (exports.GoogleRecaptchaEnterpriseReason = GoogleRecaptchaEnterpriseReason = {}));

package/dist/lib/google-recaptcha/enums/google-recaptcha-network.d.ts

@@ -0,0 +1,4 @@
+export declare enum GoogleRecaptchaNetwork {
+    Google = "https://www.google.com/recaptcha/api/siteverify",
+    Recaptcha = "https://recaptcha.net/recaptcha/api/siteverify"
+}

package/dist/lib/google-recaptcha/enums/google-recaptcha-network.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleRecaptchaNetwork = void 0;
+var GoogleRecaptchaNetwork;
+(function (GoogleRecaptchaNetwork) {
+    GoogleRecaptchaNetwork["Google"] = "https://www.google.com/recaptcha/api/siteverify";
+    GoogleRecaptchaNetwork["Recaptcha"] = "https://recaptcha.net/recaptcha/api/siteverify";
+})(GoogleRecaptchaNetwork || (exports.GoogleRecaptchaNetwork = GoogleRecaptchaNetwork = {}));

package/dist/lib/google-recaptcha/exceptions/google-recaptcha-network.exception.d.ts

@@ -0,0 +1,5 @@
+import { GoogleRecaptchaException } from './google-recaptcha.exception';
+export declare class GoogleRecaptchaNetworkException extends GoogleRecaptchaException {
+    readonly networkErrorCode?: string;
+    constructor(networkErrorCode?: string);
+}

package/dist/lib/google-recaptcha/exceptions/google-recaptcha-network.exception.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleRecaptchaNetworkException = void 0;
+const google_recaptcha_exception_1 = require("./google-recaptcha.exception");
+const error_code_1 = require("../enums/error-code");
+class GoogleRecaptchaNetworkException extends google_recaptcha_exception_1.GoogleRecaptchaException {
+    constructor(networkErrorCode) {
+        super([error_code_1.ErrorCode.NetworkError], networkErrorCode
+            ? `Network error '${networkErrorCode}'.`
+            : 'Unknown network error.');
+        this.networkErrorCode = networkErrorCode;
+    }
+}
+exports.GoogleRecaptchaNetworkException = GoogleRecaptchaNetworkException;

package/dist/lib/google-recaptcha/exceptions/google-recaptcha.exception.d.ts

@@ -0,0 +1,8 @@
+import { HttpException } from '@nestjs/common';
+import { ErrorCode } from '../enums/error-code';
+export declare class GoogleRecaptchaException extends HttpException {
+    readonly errorCodes: ErrorCode[];
+    constructor(errorCodes: ErrorCode[], errorMessage?: string);
+    private static getErrorMessage;
+    private static getErrorStatus;
+}

package/dist/lib/google-recaptcha/exceptions/google-recaptcha.exception.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleRecaptchaException = void 0;
+const common_1 = require("@nestjs/common");
+const error_code_1 = require("../enums/error-code");
+class GoogleRecaptchaException extends common_1.HttpException {
+    constructor(errorCodes, errorMessage) {
+        super(errorMessage || GoogleRecaptchaException.getErrorMessage(errorCodes[0]), GoogleRecaptchaException.getErrorStatus(errorCodes[0]));
+        this.errorCodes = errorCodes;
+    }
+    static getErrorMessage(errorCode) {
+        switch (errorCode) {
+            case error_code_1.ErrorCode.InvalidInputResponse:
+                return 'The response parameter is invalid or malformed.';
+            case error_code_1.ErrorCode.MissingInputResponse:
+                return 'The response parameter is missing.';
+            case error_code_1.ErrorCode.TimeoutOrDuplicate:
+                return 'The response is no longer valid: either is too old or has been used previously.';
+            case error_code_1.ErrorCode.InvalidInputSecret:
+            case error_code_1.ErrorCode.MissingInputSecret:
+                return 'Invalid module configuration. Please check public-secret keys.';
+            case error_code_1.ErrorCode.InvalidKeys:
+                return 'Recaptcha token was signed by invalid api key.';
+            case error_code_1.ErrorCode.LowScore:
+                return 'Low recaptcha score.';
+            case error_code_1.ErrorCode.ForbiddenAction:
+                return 'Forbidden recaptcha action.';
+            case error_code_1.ErrorCode.SiteMismatch:
+                return 'The user verification token did not match the provided site key.';
+            case error_code_1.ErrorCode.BrowserError:
+                return 'Retriable error (such as network failure) occurred on the browser.';
+            case error_code_1.ErrorCode.IncorrectCaptchaSol:
+                return 'incorrect-google-recaptcha-sol';
+            case error_code_1.ErrorCode.UnknownError:
+            case error_code_1.ErrorCode.BadRequest:
+            default:
+                return 'Unexpected error.';
+        }
+    }
+    static getErrorStatus(errorCode) {
+        return errorCode === error_code_1.ErrorCode.InvalidInputResponse ||
+            errorCode === error_code_1.ErrorCode.MissingInputResponse ||
+            errorCode === error_code_1.ErrorCode.TimeoutOrDuplicate ||
+            errorCode === error_code_1.ErrorCode.ForbiddenAction ||
+            errorCode === error_code_1.ErrorCode.SiteMismatch ||
+            errorCode === error_code_1.ErrorCode.BrowserError ||
+            errorCode === error_code_1.ErrorCode.IncorrectCaptchaSol ||
+            errorCode === error_code_1.ErrorCode.LowScore ||
+            errorCode === error_code_1.ErrorCode.InvalidKeys
+            ? common_1.HttpStatus.BAD_REQUEST
+            : common_1.HttpStatus.INTERNAL_SERVER_ERROR;
+    }
+}
+exports.GoogleRecaptchaException = GoogleRecaptchaException;

package/dist/lib/google-recaptcha/google-recaptcha.module.d.ts

@@ -0,0 +1,12 @@
+import { DynamicModule } from '@nestjs/common';
+import { GoogleRecaptchaModuleAsyncOptions, GoogleRecaptchaModuleOptions } from './interfaces/google-recaptcha-module-options';
+export declare class GoogleRecaptchaModule {
+    private static axiosDefaultConfig;
+    static forRoot(options: GoogleRecaptchaModuleOptions): DynamicModule;
+    static forRootAsync(options: GoogleRecaptchaModuleAsyncOptions): DynamicModule;
+    private static transformAxiosConfig;
+    private static createAsyncProviders;
+    private static createAsyncOptionsProvider;
+    private static validateOptions;
+    private static isGoogleRecaptchaFactory;
+}

package/dist/lib/google-recaptcha/google-recaptcha.module.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleRecaptchaModule = void 0;
+const common_1 = require("@nestjs/common");
+const google_recaptcha_guard_1 = require("./guards/google-recaptcha.guard");
+const google_recaptcha_validator_1 = require("./services/validators/google-recaptcha.validator");
+const google_recaptcha_enterprise_validator_1 = require("./services/validators/google-recaptcha-enterprise.validator");
+const provider_declarations_1 = require("./provider.declarations");
+const recaptcha_request_resolver_1 = require("./services/recaptcha-request.resolver");
+const core_1 = require("@nestjs/core");
+const axios_1 = require("axios");
+const https_1 = require("https");
+const recaptcha_validator_resolver_1 = require("./services/recaptcha-validator.resolver");
+const enterprise_reason_transformer_1 = require("./services/enterprise-reason.transformer");
+const xor_1 = require("./helpers/xor");
+const recaptcha_config_ref_1 = require("./models/recaptcha-config-ref");
+class GoogleRecaptchaModule {
+    static forRoot(options) {
+        const providers = [
+            core_1.Reflector,
+            google_recaptcha_guard_1.GoogleRecaptchaGuard,
+            google_recaptcha_validator_1.GoogleRecaptchaValidator,
+            google_recaptcha_enterprise_validator_1.GoogleRecaptchaEnterpriseValidator,
+            recaptcha_request_resolver_1.RecaptchaRequestResolver,
+            recaptcha_validator_resolver_1.RecaptchaValidatorResolver,
+            enterprise_reason_transformer_1.EnterpriseReasonTransformer,
+            {
+                provide: provider_declarations_1.RECAPTCHA_OPTIONS,
+                useValue: options,
+            },
+            {
+                provide: provider_declarations_1.RECAPTCHA_LOGGER,
+                useFactory: () => options.logger || new common_1.Logger(),
+            },
+            {
+                provide: recaptcha_config_ref_1.RecaptchaConfigRef,
+                useFactory: () => new recaptcha_config_ref_1.RecaptchaConfigRef(options),
+            },
+        ];
+        this.validateOptions(options);
+        const internalProviders = [
+            {
+                provide: provider_declarations_1.RECAPTCHA_AXIOS_INSTANCE,
+                useFactory: () => axios_1.default.create(this.transformAxiosConfig({
+                    ...this.axiosDefaultConfig,
+                    ...options.axiosConfig,
+                    headers: null,
+                })),
+            },
+        ];
+        return {
+            global: options.global != null ? options.global : true,
+            module: GoogleRecaptchaModule,
+            providers: providers.concat(internalProviders),
+            exports: providers,
+        };
+    }
+    static forRootAsync(options) {
+        const providers = [
+            core_1.Reflector,
+            {
+                provide: provider_declarations_1.RECAPTCHA_LOGGER,
+                useFactory: (options) => options.logger || new common_1.Logger(),
+                inject: [provider_declarations_1.RECAPTCHA_OPTIONS],
+            },
+            {
+                provide: recaptcha_config_ref_1.RecaptchaConfigRef,
+                useFactory: (opts) => new recaptcha_config_ref_1.RecaptchaConfigRef(opts),
+                inject: [provider_declarations_1.RECAPTCHA_OPTIONS],
+            },
+            google_recaptcha_guard_1.GoogleRecaptchaGuard,
+            google_recaptcha_validator_1.GoogleRecaptchaValidator,
+            google_recaptcha_enterprise_validator_1.GoogleRecaptchaEnterpriseValidator,
+            recaptcha_request_resolver_1.RecaptchaRequestResolver,
+            recaptcha_validator_resolver_1.RecaptchaValidatorResolver,
+            enterprise_reason_transformer_1.EnterpriseReasonTransformer,
+            ...this.createAsyncProviders(options),
+        ];
+        const internalProviders = [
+            {
+                provide: provider_declarations_1.RECAPTCHA_AXIOS_INSTANCE,
+                useFactory: (options) => {
+                    this.validateOptions(options);
+                    const transformedAxiosConfig = this.transformAxiosConfig({
+                        ...this.axiosDefaultConfig,
+                        ...options.axiosConfig,
+                        headers: null,
+                    });
+                    return axios_1.default.create(transformedAxiosConfig);
+                },
+                inject: [provider_declarations_1.RECAPTCHA_OPTIONS],
+            },
+        ];
+        return {
+            global: options.global != null ? options.global : true,
+            module: GoogleRecaptchaModule,
+            imports: options.imports,
+            providers: providers.concat(internalProviders),
+            exports: providers,
+        };
+    }
+    static transformAxiosConfig(axiosConfig) {
+        const config = { ...axiosConfig };
+        delete config.baseURL;
+        delete config.url;
+        delete config.responseType;
+        delete config.method;
+        delete config.transformRequest;
+        delete config.transformResponse;
+        delete config.paramsSerializer;
+        delete config.validateStatus;
+        delete config.data;
+        delete config.adapter;
+        return config;
+    }
+    static createAsyncProviders(options) {
+        const providers = [this.createAsyncOptionsProvider(options)];
+        if (options.useClass) {
+            providers.push({
+                provide: options.useClass,
+                useClass: options.useClass,
+            });
+        }
+        return providers;
+    }
+    static createAsyncOptionsProvider(options) {
+        if (options.useFactory) {
+            return {
+                provide: provider_declarations_1.RECAPTCHA_OPTIONS,
+                useFactory: options.useFactory,
+                inject: options.inject,
+            };
+        }
+        return {
+            provide: provider_declarations_1.RECAPTCHA_OPTIONS,
+            useFactory: async (optionsFactory) => {
+                if (!this.isGoogleRecaptchaFactory(optionsFactory)) {
+                    throw new Error("Factory must be implement 'GoogleRecaptchaOptionsFactory' interface.");
+                }
+                return optionsFactory.createGoogleRecaptchaOptions();
+            },
+            inject: [options.useExisting || options.useClass],
+        };
+    }
+    static validateOptions(options) {
+        const hasEnterpriseOptions = !!Object.keys(options.enterprise || {}).length;
+        if (!(0, xor_1.xor)(options.disable, !(0, xor_1.xor)(options.secretKey, hasEnterpriseOptions))) {
+            throw new Error('Google recaptcha options must be contains "secretKey" xor "enterprise".');
+        }
+    }
+    static isGoogleRecaptchaFactory(object) {
+        return (!!object && typeof object.createGoogleRecaptchaOptions === 'function');
+    }
+}
+exports.GoogleRecaptchaModule = GoogleRecaptchaModule;
+GoogleRecaptchaModule.axiosDefaultConfig = {
+    timeout: 60_000,
+    httpsAgent: new https_1.Agent({ keepAlive: true }),
+};

package/dist/lib/google-recaptcha/guards/google-recaptcha.guard.d.ts

@@ -0,0 +1,15 @@
+import { CanActivate, ExecutionContext, Logger } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { RecaptchaRequestResolver } from '../services/recaptcha-request.resolver';
+import { RecaptchaValidatorResolver } from '../services/recaptcha-validator.resolver';
+import { RecaptchaConfigRef } from '../models/recaptcha-config-ref';
+export declare class GoogleRecaptchaGuard implements CanActivate {
+    private readonly reflector;
+    private readonly requestResolver;
+    private readonly validatorResolver;
+    private readonly logger;
+    private readonly configRef;
+    constructor(reflector: Reflector, requestResolver: RecaptchaRequestResolver, validatorResolver: RecaptchaValidatorResolver, logger: Logger, configRef: RecaptchaConfigRef);
+    canActivate(context: ExecutionContext): Promise<true | never>;
+    private resolveLogContext;
+}

package/dist/lib/google-recaptcha/guards/google-recaptcha.guard.js

@@ -0,0 +1,89 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleRecaptchaGuard = void 0;
+const common_1 = require("@nestjs/common");
+const provider_declarations_1 = require("../provider.declarations");
+const google_recaptcha_exception_1 = require("../exceptions/google-recaptcha.exception");
+const core_1 = require("@nestjs/core");
+const recaptcha_request_resolver_1 = require("../services/recaptcha-request.resolver");
+const recaptcha_validator_resolver_1 = require("../services/recaptcha-validator.resolver");
+const google_recaptcha_context_1 = require("../enums/google-recaptcha-context");
+const google_recaptcha_enterprise_validator_1 = require("../services/validators/google-recaptcha-enterprise.validator");
+const recaptcha_config_ref_1 = require("../models/recaptcha-config-ref");
+let GoogleRecaptchaGuard = class GoogleRecaptchaGuard {
+    constructor(reflector, requestResolver, validatorResolver, logger, configRef) {
+        this.reflector = reflector;
+        this.requestResolver = requestResolver;
+        this.validatorResolver = validatorResolver;
+        this.logger = logger;
+        this.configRef = configRef;
+    }
+    async canActivate(context) {
+        const isDisabled = this.configRef.valueOf.disable;
+        if (isDisabled) {
+            return true;
+        }
+        const request = this.requestResolver.resolve(context);
+        const skipIfValue = this.configRef.valueOf.skipIf;
+        const skip = typeof skipIfValue === 'function'
+            ? await skipIfValue(request)
+            : !!skipIfValue;
+        if (skip) {
+            return true;
+        }
+        const options = this.reflector.get(provider_declarations_1.RECAPTCHA_VALIDATION_OPTIONS, context.getHandler());
+        const [response, remoteIp] = await Promise.all([
+            options?.response
+                ? await options.response(request)
+                : await this.configRef.valueOf.response(request),
+            options?.remoteIp
+                ? await options.remoteIp(request)
+                : (await this.configRef.valueOf.remoteIp) &&
+                    this.configRef.valueOf.remoteIp(request),
+        ]);
+        const score = options?.score || this.configRef.valueOf.score;
+        const action = options?.action;
+        const validator = this.validatorResolver.resolve();
+        request.recaptchaValidationResult = await validator.validate({
+            response,
+            remoteIp,
+            score,
+            action,
+        });
+        if (this.configRef.valueOf.debug) {
+            const loggerCtx = this.resolveLogContext(validator);
+            this.logger.debug(request.recaptchaValidationResult.toObject(), `${loggerCtx}.result`);
+        }
+        if (request.recaptchaValidationResult.success) {
+            return true;
+        }
+        throw new google_recaptcha_exception_1.GoogleRecaptchaException(request.recaptchaValidationResult.errors);
+    }
+    resolveLogContext(validator) {
+        return validator instanceof google_recaptcha_enterprise_validator_1.GoogleRecaptchaEnterpriseValidator
+            ? google_recaptcha_context_1.GoogleRecaptchaContext.GoogleRecaptchaEnterprise
+            : google_recaptcha_context_1.GoogleRecaptchaContext.GoogleRecaptcha;
+    }
+};
+exports.GoogleRecaptchaGuard = GoogleRecaptchaGuard;
+exports.GoogleRecaptchaGuard = GoogleRecaptchaGuard = __decorate([
+    (0, common_1.Injectable)(),
+    __param(3, (0, common_1.Inject)(provider_declarations_1.RECAPTCHA_LOGGER)),
+    __metadata("design:paramtypes", [core_1.Reflector,
+        recaptcha_request_resolver_1.RecaptchaRequestResolver,
+        recaptcha_validator_resolver_1.RecaptchaValidatorResolver,
+        common_1.Logger,
+        recaptcha_config_ref_1.RecaptchaConfigRef])
+], GoogleRecaptchaGuard);

package/dist/lib/google-recaptcha/helpers/get-error-info.d.ts

@@ -0,0 +1,4 @@
+import * as axios from 'axios';
+import { LiteralObject } from '../interfaces/literal-object';
+export declare function isAxiosError<T = LiteralObject>(error: Error | axios.AxiosError<T>): error is axios.AxiosError<T>;
+export declare function getErrorInfo(error: Error): string | LiteralObject;

package/dist/lib/google-recaptcha/helpers/get-error-info.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAxiosError = isAxiosError;
+exports.getErrorInfo = getErrorInfo;
+function isAxiosError(error) {
+    return error.isAxiosError;
+}
+function getErrorInfo(error) {
+    if (isAxiosError(error)) {
+        return error.response?.data || error.code || 'Unknown axios error';
+    }
+    return { error: error.name, message: error.message, stack: error.stack };
+}

package/dist/lib/google-recaptcha/helpers/load-module.d.ts

@@ -0,0 +1,2 @@
+import { LiteralObject } from '../interfaces/literal-object';
+export declare function loadModule(moduleName: string, logError?: boolean): LiteralObject;

package/dist/lib/google-recaptcha/helpers/load-module.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadModule = loadModule;
+const common_1 = require("@nestjs/common");
+function loadModule(moduleName, logError = false) {
+    try {
+        return require(moduleName);
+    }
+    catch (e) {
+        if (logError) {
+            common_1.Logger.error(`Module '${moduleName}' not found. \nPotential solution npm i  ${moduleName}`);
+        }
+        throw e;
+    }
+}

package/dist/lib/google-recaptcha/helpers/xor.d.ts

@@ -0,0 +1 @@
+export declare function xor(a: any, b: any): boolean;

package/dist/lib/google-recaptcha/helpers/xor.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xor = xor;
+function xor(a, b) {
+    return !!a !== !!b;
+}

package/dist/lib/google-recaptcha/index.d.ts

@@ -0,0 +1,15 @@
+export { Recaptcha } from './decorators/recaptcha';
+export { SetRecaptchaOptions } from './decorators/set-recaptcha-options';
+export { RecaptchaResult } from './decorators/recaptcha-result';
+export { GoogleRecaptchaGuard } from './guards/google-recaptcha.guard';
+export { GoogleRecaptchaModule } from './google-recaptcha.module';
+export { GoogleRecaptchaModuleOptions } from './interfaces/google-recaptcha-module-options';
+export { ErrorCode } from './enums/error-code';
+export { GoogleRecaptchaNetwork } from './enums/google-recaptcha-network';
+export { GoogleRecaptchaException } from './exceptions/google-recaptcha.exception';
+export { GoogleRecaptchaNetworkException } from './exceptions/google-recaptcha-network.exception';
+export { GoogleRecaptchaValidator } from './services/validators/google-recaptcha.validator';
+export { GoogleRecaptchaEnterpriseValidator } from './services/validators/google-recaptcha-enterprise.validator';
+export { RecaptchaVerificationResult } from './models/recaptcha-verification-result';
+export { ClassificationReason } from './enums/classification-reason';
+export { RecaptchaConfigRef } from './models/recaptcha-config-ref';