@mondart/nestjs-common-module 2.8.1 → 2.9.0

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecaptchaConfigRef = exports.ClassificationReason = exports.RecaptchaVerificationResult = exports.GoogleRecaptchaEnterpriseValidator = exports.GoogleRecaptchaValidator = exports.GoogleRecaptchaNetworkException = exports.GoogleRecaptchaException = exports.GoogleRecaptchaNetwork = exports.ErrorCode = exports.GoogleRecaptchaModule = exports.GoogleRecaptchaGuard = exports.RecaptchaResult = exports.SetRecaptchaOptions = exports.Recaptcha = void 0;
+var recaptcha_1 = require("./decorators/recaptcha");
+Object.defineProperty(exports, "Recaptcha", { enumerable: true, get: function () { return recaptcha_1.Recaptcha; } });
+var set_recaptcha_options_1 = require("./decorators/set-recaptcha-options");
+Object.defineProperty(exports, "SetRecaptchaOptions", { enumerable: true, get: function () { return set_recaptcha_options_1.SetRecaptchaOptions; } });
+var recaptcha_result_1 = require("./decorators/recaptcha-result");
+Object.defineProperty(exports, "RecaptchaResult", { enumerable: true, get: function () { return recaptcha_result_1.RecaptchaResult; } });
+var google_recaptcha_guard_1 = require("./guards/google-recaptcha.guard");
+Object.defineProperty(exports, "GoogleRecaptchaGuard", { enumerable: true, get: function () { return google_recaptcha_guard_1.GoogleRecaptchaGuard; } });
+var google_recaptcha_module_1 = require("./google-recaptcha.module");
+Object.defineProperty(exports, "GoogleRecaptchaModule", { enumerable: true, get: function () { return google_recaptcha_module_1.GoogleRecaptchaModule; } });
+var error_code_1 = require("./enums/error-code");
+Object.defineProperty(exports, "ErrorCode", { enumerable: true, get: function () { return error_code_1.ErrorCode; } });
+var google_recaptcha_network_1 = require("./enums/google-recaptcha-network");
+Object.defineProperty(exports, "GoogleRecaptchaNetwork", { enumerable: true, get: function () { return google_recaptcha_network_1.GoogleRecaptchaNetwork; } });
+var google_recaptcha_exception_1 = require("./exceptions/google-recaptcha.exception");
+Object.defineProperty(exports, "GoogleRecaptchaException", { enumerable: true, get: function () { return google_recaptcha_exception_1.GoogleRecaptchaException; } });
+var google_recaptcha_network_exception_1 = require("./exceptions/google-recaptcha-network.exception");
+Object.defineProperty(exports, "GoogleRecaptchaNetworkException", { enumerable: true, get: function () { return google_recaptcha_network_exception_1.GoogleRecaptchaNetworkException; } });
+var google_recaptcha_validator_1 = require("./services/validators/google-recaptcha.validator");
+Object.defineProperty(exports, "GoogleRecaptchaValidator", { enumerable: true, get: function () { return google_recaptcha_validator_1.GoogleRecaptchaValidator; } });
+var google_recaptcha_enterprise_validator_1 = require("./services/validators/google-recaptcha-enterprise.validator");
+Object.defineProperty(exports, "GoogleRecaptchaEnterpriseValidator", { enumerable: true, get: function () { return google_recaptcha_enterprise_validator_1.GoogleRecaptchaEnterpriseValidator; } });
+var recaptcha_verification_result_1 = require("./models/recaptcha-verification-result");
+Object.defineProperty(exports, "RecaptchaVerificationResult", { enumerable: true, get: function () { return recaptcha_verification_result_1.RecaptchaVerificationResult; } });
+var classification_reason_1 = require("./enums/classification-reason");
+Object.defineProperty(exports, "ClassificationReason", { enumerable: true, get: function () { return classification_reason_1.ClassificationReason; } });
+var recaptcha_config_ref_1 = require("./models/recaptcha-config-ref");
+Object.defineProperty(exports, "RecaptchaConfigRef", { enumerable: true, get: function () { return recaptcha_config_ref_1.RecaptchaConfigRef; } });

package/dist/lib/google-recaptcha/interfaces/google-recaptcha-enterprise-options.d.ts

@@ -0,0 +1,5 @@
+export interface GoogleRecaptchaEnterpriseOptions {
+    projectId: string;
+    siteKey: string;
+    apiKey: string;
+}

package/dist/lib/google-recaptcha/interfaces/google-recaptcha-enterprise-options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/google-recaptcha/interfaces/google-recaptcha-guard-options.d.ts

@@ -0,0 +1,7 @@
+import { RecaptchaRemoteIpProvider, RecaptchaResponseProvider, ScoreValidator, SkipIfValue } from '../types';
+export interface GoogleRecaptchaGuardOptions {
+    response: RecaptchaResponseProvider;
+    remoteIp?: RecaptchaRemoteIpProvider;
+    skipIf?: SkipIfValue;
+    score?: ScoreValidator;
+}

package/dist/lib/google-recaptcha/interfaces/google-recaptcha-guard-options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,21 @@
+import { GoogleRecaptchaGuardOptions } from './google-recaptcha-guard-options';
+import { GoogleRecaptchaValidatorOptions } from './google-recaptcha-validator-options';
+import { ModuleMetadata, Type } from '@nestjs/common/interfaces';
+import { Logger } from '@nestjs/common';
+import { Abstract } from '@nestjs/common/interfaces/abstract.interface';
+export interface GoogleRecaptchaModuleOptions extends GoogleRecaptchaValidatorOptions, GoogleRecaptchaGuardOptions {
+    disable?: boolean;
+    debug?: boolean;
+    logger?: Logger;
+    global?: boolean;
+}
+export interface GoogleRecaptchaOptionsFactory {
+    createGoogleRecaptchaOptions(): Promise<GoogleRecaptchaModuleOptions> | GoogleRecaptchaModuleOptions;
+}
+export interface GoogleRecaptchaModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    inject?: Array<string | symbol | Type | Abstract<any> | Function>;
+    useClass?: Type<GoogleRecaptchaOptionsFactory>;
+    useExisting?: Type<GoogleRecaptchaOptionsFactory>;
+    useFactory?: (...args: any[]) => Promise<Omit<GoogleRecaptchaModuleOptions, 'global'>> | Omit<GoogleRecaptchaModuleOptions, 'global'>;
+    global?: boolean;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/google-recaptcha/interfaces/google-recaptcha-validator-options.d.ts

@@ -0,0 +1,12 @@
+import { GoogleRecaptchaNetwork } from '../enums/google-recaptcha-network';
+import { ScoreValidator } from '../types';
+import { AxiosRequestConfig } from 'axios';
+import { GoogleRecaptchaEnterpriseOptions } from './google-recaptcha-enterprise-options';
+export interface GoogleRecaptchaValidatorOptions {
+    secretKey?: string;
+    actions?: string[];
+    score?: ScoreValidator;
+    network?: GoogleRecaptchaNetwork | string;
+    axiosConfig?: AxiosRequestConfig;
+    enterprise?: GoogleRecaptchaEnterpriseOptions;
+}

package/dist/lib/google-recaptcha/interfaces/google-recaptcha-validator-options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/google-recaptcha/interfaces/literal-object.d.ts

@@ -0,0 +1,3 @@
+export interface LiteralObject {
+    [key: string]: any;
+}

package/dist/lib/google-recaptcha/interfaces/literal-object.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/google-recaptcha/interfaces/verify-response-decorator-options.d.ts

@@ -0,0 +1,13 @@
+import { RecaptchaRemoteIpProvider, RecaptchaResponseProvider, ScoreValidator } from '../types';
+export interface VerifyResponseDecoratorOptions {
+    response?: RecaptchaResponseProvider;
+    remoteIp?: RecaptchaRemoteIpProvider;
+    score?: ScoreValidator;
+    action?: string;
+}
+export interface VerifyResponseOptions {
+    response: string;
+    remoteIp?: string;
+    score?: ScoreValidator;
+    action?: string;
+}

package/dist/lib/google-recaptcha/interfaces/verify-response-decorator-options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/google-recaptcha/interfaces/verify-response-enterprise.d.ts

@@ -0,0 +1,30 @@
+import { GoogleRecaptchaEnterpriseReason } from '../enums/google-recaptcha-enterprise-reason';
+import { ClassificationReason } from '../enums/classification-reason';
+export interface VerifyResponseEnterprise {
+    tokenProperties?: VerifyResponseEnterpriseTokenProperties;
+    riskAnalysis?: VerifyResponseEnterpriseRiskAnalysis;
+    event: VerifyTokenEnterpriseResponseEvent;
+    name: string;
+}
+export interface VerifyTokenEnterpriseEvent {
+    token: string;
+    siteKey: string;
+    expectedAction: string;
+    userIpAddress?: string;
+}
+export interface VerifyTokenEnterpriseResponseEvent extends VerifyTokenEnterpriseEvent {
+    userAgent: string;
+    userIpAddress: string;
+    hashedAccountId: string;
+}
+export interface VerifyResponseEnterpriseTokenProperties {
+    valid: boolean;
+    invalidReason?: GoogleRecaptchaEnterpriseReason;
+    hostname: string;
+    action: string;
+    createTime: string;
+}
+export interface VerifyResponseEnterpriseRiskAnalysis {
+    score: number;
+    reasons: ClassificationReason[];
+}

package/dist/lib/google-recaptcha/interfaces/verify-response-enterprise.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/google-recaptcha/interfaces/verify-response.d.ts

@@ -0,0 +1,11 @@
+import { ErrorCode } from '../enums/error-code';
+export interface VerifyResponseV2 {
+    success: boolean;
+    challenge_ts: string;
+    hostname: string;
+    errors: ErrorCode[];
+}
+export interface VerifyResponseV3 extends VerifyResponseV2 {
+    score: number;
+    action: string;
+}

package/dist/lib/google-recaptcha/interfaces/verify-response.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/google-recaptcha/models/recaptcha-config-ref.d.ts

@@ -0,0 +1,12 @@
+import { GoogleRecaptchaModuleOptions } from '../interfaces/google-recaptcha-module-options';
+import { GoogleRecaptchaEnterpriseOptions } from '../interfaces/google-recaptcha-enterprise-options';
+import { ScoreValidator, SkipIfValue } from '../types';
+export declare class RecaptchaConfigRef {
+    private readonly value;
+    get valueOf(): GoogleRecaptchaModuleOptions;
+    constructor(value: GoogleRecaptchaModuleOptions);
+    setSecretKey(secretKey: string): this;
+    setEnterpriseOptions(options: GoogleRecaptchaEnterpriseOptions): this;
+    setScore(score: ScoreValidator): this;
+    setSkipIf(skipIf: SkipIfValue): this;
+}

package/dist/lib/google-recaptcha/models/recaptcha-config-ref.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecaptchaConfigRef = void 0;
+class RecaptchaConfigRef {
+    get valueOf() {
+        return this.value;
+    }
+    constructor(value) {
+        this.value = value;
+    }
+    setSecretKey(secretKey) {
+        this.value.secretKey = secretKey;
+        this.value.enterprise = undefined;
+        return this;
+    }
+    setEnterpriseOptions(options) {
+        this.value.secretKey = undefined;
+        this.value.enterprise = options;
+        return this;
+    }
+    setScore(score) {
+        this.value.score = score;
+        return this;
+    }
+    setSkipIf(skipIf) {
+        this.value.skipIf = skipIf;
+        return this;
+    }
+}
+exports.RecaptchaConfigRef = RecaptchaConfigRef;

package/dist/lib/google-recaptcha/models/recaptcha-verification-result.d.ts

@@ -0,0 +1,26 @@
+import { ErrorCode } from '../enums/error-code';
+import { VerifyResponseEnterpriseRiskAnalysis } from '../interfaces/verify-response-enterprise';
+import { LiteralObject } from '../interfaces/literal-object';
+export interface RecaptchaVerificationResultOptions<Res> {
+    success: boolean;
+    nativeResponse: Res;
+    hostname: string;
+    action?: string;
+    score?: number;
+    remoteIp?: string;
+    errors: ErrorCode[];
+}
+export declare class RecaptchaVerificationResult<Res = LiteralObject> {
+    private readonly options;
+    readonly success: boolean;
+    readonly hostname: string;
+    readonly remoteIp: string | undefined;
+    readonly action: string | undefined;
+    readonly score: number | undefined;
+    readonly nativeResponse: Res;
+    readonly errors: ErrorCode[];
+    constructor(options: RecaptchaVerificationResultOptions<Res>);
+    toObject(): LiteralObject;
+    getResponse(): Res;
+    getEnterpriseRiskAnalytics(): VerifyResponseEnterpriseRiskAnalysis | null;
+}

package/dist/lib/google-recaptcha/models/recaptcha-verification-result.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecaptchaVerificationResult = void 0;
+class RecaptchaVerificationResult {
+    constructor(options) {
+        this.options = options;
+        this.success = options.success;
+        this.hostname = options.hostname;
+        this.action = options.action;
+        this.remoteIp = options.remoteIp;
+        this.score = options.score;
+        this.errors = options.errors;
+        this.nativeResponse = options.nativeResponse;
+    }
+    toObject() {
+        return {
+            success: this.success,
+            hostname: this.hostname,
+            action: this.action,
+            score: this.score,
+            remoteIp: this.remoteIp,
+            errors: this.errors,
+            nativeResponse: this.nativeResponse,
+        };
+    }
+    getResponse() {
+        return this.nativeResponse;
+    }
+    getEnterpriseRiskAnalytics() {
+        const res = this.getResponse();
+        return res['riskAnalysis'] || null;
+    }
+}
+exports.RecaptchaVerificationResult = RecaptchaVerificationResult;

package/dist/lib/google-recaptcha/provider.declarations.d.ts

@@ -0,0 +1,4 @@
+export declare const RECAPTCHA_OPTIONS: unique symbol;
+export declare const RECAPTCHA_VALIDATION_OPTIONS: unique symbol;
+export declare const RECAPTCHA_AXIOS_INSTANCE = "RECAPTCHA_AXIOS_INSTANCE";
+export declare const RECAPTCHA_LOGGER = "RECAPTCHA_LOGGER";

package/dist/lib/google-recaptcha/provider.declarations.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RECAPTCHA_LOGGER = exports.RECAPTCHA_AXIOS_INSTANCE = exports.RECAPTCHA_VALIDATION_OPTIONS = exports.RECAPTCHA_OPTIONS = void 0;
+exports.RECAPTCHA_OPTIONS = Symbol('RECAPTCHA_OPTIONS');
+exports.RECAPTCHA_VALIDATION_OPTIONS = Symbol('RECAPTCHA_VALIDATION_OPTIONS');
+exports.RECAPTCHA_AXIOS_INSTANCE = 'RECAPTCHA_AXIOS_INSTANCE';
+exports.RECAPTCHA_LOGGER = 'RECAPTCHA_LOGGER';

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

@@ -0,0 +1,5 @@
+import { GoogleRecaptchaEnterpriseReason } from '../enums/google-recaptcha-enterprise-reason';
+import { ErrorCode } from '../enums/error-code';
+export declare class EnterpriseReasonTransformer {
+    transform(errCode: GoogleRecaptchaEnterpriseReason): ErrorCode | null;
+}

package/dist/lib/google-recaptcha/services/enterprise-reason.transformer.js

@@ -0,0 +1,38 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnterpriseReasonTransformer = void 0;
+const common_1 = require("@nestjs/common");
+const google_recaptcha_enterprise_reason_1 = require("../enums/google-recaptcha-enterprise-reason");
+const error_code_1 = require("../enums/error-code");
+let EnterpriseReasonTransformer = class EnterpriseReasonTransformer {
+    transform(errCode) {
+        switch (errCode) {
+            case google_recaptcha_enterprise_reason_1.GoogleRecaptchaEnterpriseReason.BrowserError:
+                return error_code_1.ErrorCode.BrowserError;
+            case google_recaptcha_enterprise_reason_1.GoogleRecaptchaEnterpriseReason.SiteMismatch:
+                return error_code_1.ErrorCode.SiteMismatch;
+            case google_recaptcha_enterprise_reason_1.GoogleRecaptchaEnterpriseReason.Expired:
+            case google_recaptcha_enterprise_reason_1.GoogleRecaptchaEnterpriseReason.Dupe:
+                return error_code_1.ErrorCode.TimeoutOrDuplicate;
+            case google_recaptcha_enterprise_reason_1.GoogleRecaptchaEnterpriseReason.UnknownInvalidReason:
+            case google_recaptcha_enterprise_reason_1.GoogleRecaptchaEnterpriseReason.Malformed:
+                return error_code_1.ErrorCode.InvalidInputResponse;
+            case google_recaptcha_enterprise_reason_1.GoogleRecaptchaEnterpriseReason.Missing:
+                return error_code_1.ErrorCode.MissingInputResponse;
+            case google_recaptcha_enterprise_reason_1.GoogleRecaptchaEnterpriseReason.InvalidReasonUnspecified:
+                return null;
+            default:
+                return error_code_1.ErrorCode.UnknownError;
+        }
+    }
+};
+exports.EnterpriseReasonTransformer = EnterpriseReasonTransformer;
+exports.EnterpriseReasonTransformer = EnterpriseReasonTransformer = __decorate([
+    (0, common_1.Injectable)()
+], EnterpriseReasonTransformer);

package/dist/lib/google-recaptcha/services/recaptcha-request.resolver.d.ts

@@ -0,0 +1,4 @@
+import { ExecutionContext } from '@nestjs/common';
+export declare class RecaptchaRequestResolver {
+    resolve<T>(context: ExecutionContext): T;
+}

package/dist/lib/google-recaptcha/services/recaptcha-request.resolver.js

@@ -0,0 +1,32 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecaptchaRequestResolver = void 0;
+const common_1 = require("@nestjs/common");
+const load_module_1 = require("../helpers/load-module");
+let RecaptchaRequestResolver = class RecaptchaRequestResolver {
+    resolve(context) {
+        const contextType = context.getType();
+        switch (contextType) {
+            case 'http':
+                return context.switchToHttp().getRequest();
+            case 'graphql':
+                return (0, load_module_1.loadModule)('@nestjs/graphql', true)
+                    .GqlExecutionContext.create(context)
+                    .getContext().req?.socket?._httpMessage?.req;
+            case 'ws':
+                return context.switchToWs().getClient().handshake;
+            default:
+                throw new Error(`Unsupported request type '${contextType}'.`);
+        }
+    }
+};
+exports.RecaptchaRequestResolver = RecaptchaRequestResolver;
+exports.RecaptchaRequestResolver = RecaptchaRequestResolver = __decorate([
+    (0, common_1.Injectable)()
+], RecaptchaRequestResolver);

package/dist/lib/google-recaptcha/services/recaptcha-validator.resolver.d.ts

@@ -0,0 +1,11 @@
+import { AbstractGoogleRecaptchaValidator } from './validators/abstract-google-recaptcha-validator';
+import { GoogleRecaptchaValidator } from './validators/google-recaptcha.validator';
+import { GoogleRecaptchaEnterpriseValidator } from './validators/google-recaptcha-enterprise.validator';
+import { RecaptchaConfigRef } from '../models/recaptcha-config-ref';
+export declare class RecaptchaValidatorResolver {
+    private readonly configRef;
+    protected readonly googleRecaptchaValidator: GoogleRecaptchaValidator;
+    protected readonly googleRecaptchaEnterpriseValidator: GoogleRecaptchaEnterpriseValidator;
+    constructor(configRef: RecaptchaConfigRef, googleRecaptchaValidator: GoogleRecaptchaValidator, googleRecaptchaEnterpriseValidator: GoogleRecaptchaEnterpriseValidator);
+    resolve(): AbstractGoogleRecaptchaValidator<unknown>;
+}

package/dist/lib/google-recaptcha/services/recaptcha-validator.resolver.js

@@ -0,0 +1,40 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecaptchaValidatorResolver = void 0;
+const common_1 = require("@nestjs/common");
+const google_recaptcha_validator_1 = require("./validators/google-recaptcha.validator");
+const google_recaptcha_enterprise_validator_1 = require("./validators/google-recaptcha-enterprise.validator");
+const recaptcha_config_ref_1 = require("../models/recaptcha-config-ref");
+let RecaptchaValidatorResolver = class RecaptchaValidatorResolver {
+    constructor(configRef, googleRecaptchaValidator, googleRecaptchaEnterpriseValidator) {
+        this.configRef = configRef;
+        this.googleRecaptchaValidator = googleRecaptchaValidator;
+        this.googleRecaptchaEnterpriseValidator = googleRecaptchaEnterpriseValidator;
+    }
+    resolve() {
+        const configValue = this.configRef.valueOf;
+        if (configValue.secretKey) {
+            return this.googleRecaptchaValidator;
+        }
+        if (Object.keys(configValue.enterprise || {}).length) {
+            return this.googleRecaptchaEnterpriseValidator;
+        }
+        throw new Error('Cannot resolve google recaptcha validator');
+    }
+};
+exports.RecaptchaValidatorResolver = RecaptchaValidatorResolver;
+exports.RecaptchaValidatorResolver = RecaptchaValidatorResolver = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [recaptcha_config_ref_1.RecaptchaConfigRef,
+        google_recaptcha_validator_1.GoogleRecaptchaValidator,
+        google_recaptcha_enterprise_validator_1.GoogleRecaptchaEnterpriseValidator])
+], RecaptchaValidatorResolver);

package/dist/lib/google-recaptcha/services/validators/abstract-google-recaptcha-validator.d.ts

@@ -0,0 +1,11 @@
+import { VerifyResponseOptions } from '../../interfaces/verify-response-decorator-options';
+import { ScoreValidator } from '../../types';
+import { RecaptchaVerificationResult } from '../../models/recaptcha-verification-result';
+import { RecaptchaConfigRef } from '../../models/recaptcha-config-ref';
+export declare abstract class AbstractGoogleRecaptchaValidator<Res> {
+    protected readonly options: RecaptchaConfigRef;
+    protected constructor(options: RecaptchaConfigRef);
+    abstract validate(options: VerifyResponseOptions): Promise<RecaptchaVerificationResult<Res>>;
+    protected isValidAction(action: string, options?: VerifyResponseOptions): boolean;
+    protected isValidScore(score: number, validator?: ScoreValidator): boolean;
+}

package/dist/lib/google-recaptcha/services/validators/abstract-google-recaptcha-validator.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractGoogleRecaptchaValidator = void 0;
+class AbstractGoogleRecaptchaValidator {
+    constructor(options) {
+        this.options = options;
+    }
+    isValidAction(action, options) {
+        if (options.action) {
+            return options.action === action;
+        }
+        return this.options.valueOf.actions
+            ? this.options.valueOf.actions.includes(action)
+            : true;
+    }
+    isValidScore(score, validator) {
+        const finalValidator = validator || this.options.valueOf.score;
+        if (finalValidator) {
+            if (typeof finalValidator === 'function') {
+                return finalValidator(score);
+            }
+            return score >= finalValidator;
+        }
+        return true;
+    }
+}
+exports.AbstractGoogleRecaptchaValidator = AbstractGoogleRecaptchaValidator;

package/dist/lib/google-recaptcha/services/validators/google-recaptcha-enterprise.validator.d.ts

@@ -0,0 +1,17 @@
+import { Logger } from '@nestjs/common';
+import { VerifyResponseOptions } from '../../interfaces/verify-response-decorator-options';
+import { AbstractGoogleRecaptchaValidator } from './abstract-google-recaptcha-validator';
+import { RecaptchaVerificationResult } from '../../models/recaptcha-verification-result';
+import { VerifyResponseEnterprise } from '../../interfaces/verify-response-enterprise';
+import { EnterpriseReasonTransformer } from '../enterprise-reason.transformer';
+import { AxiosInstance } from 'axios';
+import { RecaptchaConfigRef } from '../../models/recaptcha-config-ref';
+export declare class GoogleRecaptchaEnterpriseValidator extends AbstractGoogleRecaptchaValidator<VerifyResponseEnterprise> {
+    private readonly axios;
+    private readonly logger;
+    private readonly enterpriseReasonTransformer;
+    private readonly headers;
+    constructor(axios: AxiosInstance, logger: Logger, configRef: RecaptchaConfigRef, enterpriseReasonTransformer: EnterpriseReasonTransformer);
+    validate(options: VerifyResponseOptions): Promise<RecaptchaVerificationResult<VerifyResponseEnterprise>>;
+    private verifyResponse;
+}

package/dist/lib/google-recaptcha/services/validators/google-recaptcha-enterprise.validator.js

@@ -0,0 +1,126 @@
+"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.GoogleRecaptchaEnterpriseValidator = void 0;
+const common_1 = require("@nestjs/common");
+const provider_declarations_1 = require("../../provider.declarations");
+const abstract_google_recaptcha_validator_1 = require("./abstract-google-recaptcha-validator");
+const recaptcha_verification_result_1 = require("../../models/recaptcha-verification-result");
+const error_code_1 = require("../../enums/error-code");
+const google_recaptcha_network_exception_1 = require("../../exceptions/google-recaptcha-network.exception");
+const google_recaptcha_context_1 = require("../../enums/google-recaptcha-context");
+const enterprise_reason_transformer_1 = require("../enterprise-reason.transformer");
+const get_error_info_1 = require("../../helpers/get-error-info");
+const recaptcha_config_ref_1 = require("../../models/recaptcha-config-ref");
+let GoogleRecaptchaEnterpriseValidator = class GoogleRecaptchaEnterpriseValidator extends abstract_google_recaptcha_validator_1.AbstractGoogleRecaptchaValidator {
+    constructor(axios, logger, configRef, enterpriseReasonTransformer) {
+        super(configRef);
+        this.axios = axios;
+        this.logger = logger;
+        this.enterpriseReasonTransformer = enterpriseReasonTransformer;
+        this.headers = { 'Content-Type': 'application/json' };
+    }
+    async validate(options) {
+        const [result, errorDetails] = await this.verifyResponse(options.response, options.action, options.remoteIp);
+        const errors = [];
+        let success = result?.tokenProperties?.valid || false;
+        if (!errorDetails) {
+            if (result.tokenProperties) {
+                if (result.tokenProperties.invalidReason) {
+                    const invalidReasonCode = this.enterpriseReasonTransformer.transform(result.tokenProperties.invalidReason);
+                    if (invalidReasonCode) {
+                        errors.push(invalidReasonCode);
+                    }
+                }
+                if (success &&
+                    !this.isValidAction(result.tokenProperties.action, options)) {
+                    success = false;
+                    errors.push(error_code_1.ErrorCode.ForbiddenAction);
+                }
+            }
+            if (result.riskAnalysis &&
+                !this.isValidScore(result.riskAnalysis.score, options.score)) {
+                success = false;
+                errors.push(error_code_1.ErrorCode.LowScore);
+            }
+        }
+        if (!success && !errors.length) {
+            errorDetails
+                ? errors.push(error_code_1.ErrorCode.UnknownError)
+                : errors.push(error_code_1.ErrorCode.InvalidInputResponse);
+        }
+        return new recaptcha_verification_result_1.RecaptchaVerificationResult({
+            success,
+            errors,
+            nativeResponse: result,
+            remoteIp: options.remoteIp,
+            score: result?.riskAnalysis?.score,
+            action: result?.tokenProperties?.action,
+            hostname: result?.tokenProperties?.hostname || '',
+        });
+    }
+    verifyResponse(response, expectedAction, remoteIp) {
+        const projectId = this.options.valueOf.enterprise.projectId;
+        const body = {
+            event: {
+                expectedAction,
+                siteKey: this.options.valueOf.enterprise.siteKey,
+                token: response,
+                userIpAddress: remoteIp,
+            },
+        };
+        const url = `https://recaptchaenterprise.googleapis.com/v1/projects/${projectId}/assessments`;
+        const config = {
+            headers: this.headers,
+            params: {
+                key: this.options.valueOf.enterprise.apiKey,
+            },
+        };
+        if (this.options.valueOf.debug) {
+            this.logger.debug({ body }, `${google_recaptcha_context_1.GoogleRecaptchaContext.GoogleRecaptchaEnterprise}.request`);
+        }
+        return this.axios
+            .post(url, body, config)
+            .then((res) => res.data)
+            .then((data) => {
+            if (this.options.valueOf.debug) {
+                this.logger.debug(data, `${google_recaptcha_context_1.GoogleRecaptchaContext.GoogleRecaptchaEnterprise}.response`);
+            }
+            return [data, null];
+        })
+            .catch((err) => {
+            if (this.options.valueOf.debug) {
+                this.logger.debug((0, get_error_info_1.getErrorInfo)(err), `${google_recaptcha_context_1.GoogleRecaptchaContext.GoogleRecaptchaEnterprise}.error`);
+            }
+            const networkErrorCode = err.isAxiosError && !err.response && err.code;
+            if (networkErrorCode) {
+                throw new google_recaptcha_network_exception_1.GoogleRecaptchaNetworkException(networkErrorCode);
+            }
+            const errData = {
+                status: err.response.status,
+                data: err.response.data,
+            };
+            return [null, errData];
+        });
+    }
+};
+exports.GoogleRecaptchaEnterpriseValidator = GoogleRecaptchaEnterpriseValidator;
+exports.GoogleRecaptchaEnterpriseValidator = GoogleRecaptchaEnterpriseValidator = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(provider_declarations_1.RECAPTCHA_AXIOS_INSTANCE)),
+    __param(1, (0, common_1.Inject)(provider_declarations_1.RECAPTCHA_LOGGER)),
+    __metadata("design:paramtypes", [Function, common_1.Logger,
+        recaptcha_config_ref_1.RecaptchaConfigRef,
+        enterprise_reason_transformer_1.EnterpriseReasonTransformer])
+], GoogleRecaptchaEnterpriseValidator);