@adobe-commerce/recaptcha 1.1.0-alpha-202603171457 → 1.1.0-beta.0

package/CHANGELOG.md

@@ -0,0 +1,17 @@
+# @adobe-commerce/recaptcha
+
+## 1.1.0-beta.0
+
+### Minor Changes
+
+- d054150: ### Summary
+
+  - Replaces the `recaptchaV3Config` GraphQL query with `recaptchaFormConfig`, which supports both reCAPTCHA v3 and Enterprise
+  - Queries all form types in a single request using GraphQL aliases and normalizes the per-form response into the existing config shape
+  - Loads `enterprise.js` or `api.js` based on the detected `re_captcha_type` from the backend
+  - Uses `grecaptcha.enterprise.*` namespace for token generation and badge rendering when Enterprise is configured
+  - Skips forms with empty `website_key` (enabled but not usable)
+  - Warns and disables reCAPTCHA entirely if mixed types (v3 + Enterprise) are detected across forms
+  - Adds `[ReCaptcha]`-prefixed debug logging throughout the lifecycle (gated behind `enableLogger`)
+  - Renames all `V3`-suffixed types to generic names (`ReCaptchaModel`, `ReCaptchaResponse`, etc.)
+  - Updates README with Enterprise support documentation

package/README.md

@@ -2,54 +2,105 @@
 
 ## Purpose
 
-This functionality is designed to prevent CAPTCHAs. It provides methods for detecting and bypassing CAPTCHAs, improving user experience and automating interactions with web services.
-`
+This module integrates Google reCAPTCHA into Adobe Commerce storefronts. It supports both **reCAPTCHA v3** and **reCAPTCHA Enterprise**, providing methods for configuring, initializing, and verifying reCAPTCHA on protected forms.
 
-## Methods
+The module queries the `recaptchaFormConfig` GraphQL endpoint to fetch per-form configuration, automatically detecting which reCAPTCHA type (v3 or Enterprise) is configured and loading the appropriate script.
 
-### Private Methods
+## Installation
 
-Private methods are used within the class and are not accessible externally.
+```bash
+npm i @adobe-commerce/recaptcha
+```
 
-- `_updateBadgePosition(currentForm, config);`
-  - Responsible for changing the widget's position if it needs to be placed inline.
-- `_addRecaptchaScript();`
-  - Adds a script to the page.
-- `_fetchStoreConfig();`
-  - Requests configuration from the backend.
-- `_loadConfig();`
-  - Responsible for loading the config from Session Storage.
+## Quick Start
 
-### Public Methods
+```typescript
+import { setEndpoint, setConfig, initReCaptcha, verifyReCaptcha, enableLogger } from '@adobe-commerce/recaptcha';
 
-    `import {setEndpoint, setConfig, initReCaptcha, verifyReCaptcha } from "@adobe-commerce/recaptcha"`
+// 1. Set the backend GraphQL endpoint
+setEndpoint('https://your-store.com/graphql');
 
-Public methods are available for use when interacting with the functionality.
+// 2. Fetch and store reCAPTCHA configuration
+await setConfig([{ badgeId: 'generateCustomerToken' }]);
 
-- `setEndpoint(url : string);`
-  - It sets the URL from which the reCAPTCHA settings will be fetched.
-- `setConfig(configList : [{ badgeId: 'badgeId'}]);`
-  - Initializes the configuration, accepting a URL and a set of parameters. The set of parameters is necessary for customizing form settings. Init on top lvl application.
-- `initReCaptcha();`
-  - Initializes reCAPTCHA and adds a script to the website.
-- `verifyReCaptcha();`
-  - If the method is present, it returns a token.
+// 3. Initialize reCAPTCHA (loads script, renders badges)
+initReCaptcha();
 
-## Installation
+// 4. Get a token when submitting a protected form
+const token = await verifyReCaptcha();
+```
+
+## Public Methods
+
+### `setEndpoint(url: string)`
+
+Sets the GraphQL endpoint URL used to fetch reCAPTCHA configuration.
+
+### `setConfig(configList: PropsFormTypes[])`
+
+Fetches reCAPTCHA configuration from the backend via `recaptchaFormConfig` and stores it in session storage.
+
+- Queries all known form types and determines which are enabled
+- Normalizes the response into a unified config shape
+- Detects the reCAPTCHA type (v3 or Enterprise) from the `re_captcha_type` field
+- Skips forms with empty `website_key`
+- Warns and disables reCAPTCHA if mixed types (both v3 and Enterprise) are detected across forms
+
+```typescript
+await setConfig([
+  { badgeId: 'generateCustomerToken' },
+  { badgeId: 'contactUs' },
+]);
+```
+
+### `initReCaptcha(lazyLoadTimeout?: number)`
+
+Initializes reCAPTCHA by loading the appropriate Google script and rendering badges.
+
+- Loads `enterprise.js` for Enterprise or `api.js` for v3
+- For inline badge position, renders invisible widgets into DOM elements matching each form's `badgeId`
+- Default lazy load timeout: 3000ms
+
+### `verifyReCaptcha(): Promise<string | undefined>`
+
+Generates and returns a reCAPTCHA token for form submission.
+
+- Uses `grecaptcha.enterprise.execute()` for Enterprise or `grecaptcha.execute()` for v3
+- Returns `undefined` if reCAPTCHA is not enabled or not configured
+
+### `enableLogger(enabled: boolean)`
 
-To install this functionality, follow these steps:
+Enables or disables debug logging. When enabled, logs are prefixed with `[ReCaptcha]` and include:
 
-1.  npm i: `@adobe-commerce/recaptcha`
+- Config fetch and normalization details
+- Which reCAPTCHA type is detected and which forms are enabled
+- Script loading URLs
+- Badge rendering activity
+- Token generation attempts
+- Warnings for skipped forms (missing keys) or mixed type configurations
 
-2.  [ setEndpoint ] - Use this function at the top level to pass the backend URL.
+## Supported Form Types
 
-3.  [ setConfig ] - Also use this function at the top level to pass your custom configurations if you plan to use your custom form.
+The module queries these form types from the backend:
 
-4.  [ initReCaptcha ] - Call the function on the page where Dropins is integrated, or immediately after setEndpoint or setConfig. Adds a script to the website.
+| Form Type | Badge ID |
+|---|---|
+| `PLACE_ORDER` | `placeOrder` |
+| `CONTACT` | `contactUs` |
+| `CUSTOMER_LOGIN` | `generateCustomerToken` |
+| `CUSTOMER_FORGOT_PASSWORD` | `requestPasswordResetEmail` |
+| `CUSTOMER_CREATE` | `createCustomerV2` |
+| `CUSTOMER_EDIT` | `updateCustomerV2` |
+| `NEWSLETTER` | `subscribeEmailToNewsletter` |
+| `PRODUCT_REVIEW` | `createProductReview` |
+| `SENDFRIEND` | `SENDFRIEND` |
+| `BRAINTREE` | `BRAINTREE` |
 
-5. [ verifyReCaptcha ] This function serves as an example in either the API method or your form submission handler. It returns a token, which can then be initialized in the headers upon receipt.
+## Mixed Type Configuration
 
+If the Commerce Admin has some forms configured with reCAPTCHA v3 and others with Enterprise, the module will:
 
-## Summary
+1. Log a warning with instructions to update the Commerce Admin configuration
+2. Disable reCAPTCHA entirely (returns no config, no script loaded)
 
-This functionality provides methods for preventing and solving CAPTCHAs, enhancing automation and interaction with websites. Using it will help simplify processes related to CAPTCHA.
+All forms must use the same reCAPTCHA type. Configure this in the Commerce Admin under **Stores > Configuration > Security > Google reCAPTCHA Storefront**.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe-commerce/recaptcha",
-  "version": "1.1.0-alpha-202603171457",
+  "version": "1.1.0-beta.0",
   "license": "SEE LICENSE IN LICENSE.md",
   "description": "Module allows to efficiently verify that users are humans, not bots or spammers",
   "engines": {

package/src/configs/message.config.ts

@@ -13,5 +13,8 @@ export const recaptchaMessage = {
   failedGetStorageConfig: 'Configuration could not be loaded.',
   failedExecutionRecaptcha: 'Recaptcha execution failed',
   failedInitializing: 'An error occurred while initializing ReCaptcha:',
-  failedEnterpriseDetection: 'Failed to detect reCAPTCHA type, defaulting to V3',
+  mixedTypesWarning:
+    'Multiple reCAPTCHA types detected across forms (both v3 and Enterprise). ' +
+    'This configuration is not supported — all forms must use the same reCAPTCHA type. ' +
+    'Please update your configuration in Commerce Admin '
 };

package/src/graphql/recaptchaConfig.graphql.ts

@@ -6,32 +6,29 @@
  * file in accordance with the terms of the Adobe license agreement 
  * accompanying it. 
  *******************************************************************/
-
-export const RECAPTCHA_CONFIGURATION_V3 = `query {
-  recaptchaV3Config {
-    is_enabled
-    website_key
-    minimum_score
-    badge_position
-    language_code
-    failure_message
-    forms
-    theme
-  } 
-}`;
-
-export const RECAPTCHA_FORM_CONFIGURATION = `query {
-  recaptchaFormConfig(formType: PLACE_ORDER) {
+const RECAPTCHA_FORM_CONFIG_FIELDS = `
     is_enabled
     configurations {
-      re_captcha_type
       website_key
-      theme
       badge_position
       language_code
       minimum_score
+      re_captcha_type
       technical_failure_message
       validation_failure_message
-    }
-  }
-}`;
+      theme
+    }`;
+
+export const buildRecaptchaFormConfigQuery = (
+  formTypes: string[]
+): string => {
+  const queries = formTypes
+    .map(
+      (formType) =>
+        `  ${formType}: recaptchaFormConfig(formType: ${formType}) {${RECAPTCHA_FORM_CONFIG_FIELDS}
+  }`
+    )
+    .join('\n');
+
+  return `query {\n${queries}\n}`;
+};

package/src/index.ts

@@ -8,11 +8,16 @@
  *******************************************************************/
 
 import {
-  ReCaptchaV3Response,
+  ReCaptchaResponse,
   PropsFormTypes,
-  ReCaptchaV3Model,
+  ReCaptchaModel,
+  ReCaptchaFormConfigResult,
 } from './types/recaptcha.types';
-import { recaptchaMessage, recaptchaBadgeSelector } from './configs';
+import {
+  recaptchaMessage,
+  recaptchaBadgeSelector,
+  typeDefaultForm,
+} from './configs';
 import {
   extendConfig,
   setConfigStorage,
@@ -24,33 +29,126 @@ import {
   getRecaptchaToken,
   verifyReCaptchaLoad,
 } from './services/recaptcha.service';
-import {
-  RECAPTCHA_CONFIGURATION_V3,
-  RECAPTCHA_FORM_CONFIGURATION,
-} from './graphql/recaptchaConfig.graphql';
+import { buildRecaptchaFormConfigQuery } from './graphql/recaptchaConfig.graphql';
 
 import { FetchGraphQL } from '@adobe-commerce/fetch-graphql';
 
 export const recaptchaFetchApi = new FetchGraphQL().getMethods();
 
+const RECAPTCHA_V3_SCRIPT_URL = 'https://www.google.com/recaptcha/api.js';
+const RECAPTCHA_ENTERPRISE_SCRIPT_URL = 'https://www.google.com/recaptcha/enterprise.js';
+
+const LOG_PREFIX = '[ReCaptcha]';
+
 export class RecaptchaModule {
   _enableReCAPTCHA: boolean = false;
-  _recaptchaBackendEndpoint: string =
-    recaptchaFetchApi.getConfig()?.endpoint || '';
-  _recaptchaScriptUrl: string = 'https://www.google.com/recaptcha/api.js';
-  _recaptchaEnterpriseScriptUrl: string =
-    'https://www.google.com/recaptcha/enterprise.js';
+  _recaptchaBackendEndpoint: string = recaptchaFetchApi.getConfig()?.endpoint || '';
+  _recaptchaScriptUrl: string = RECAPTCHA_V3_SCRIPT_URL;
   _configStorageKey: string = 'recaptchaConfig';
   _logger: boolean = false;
 
+  _log(...args: any[]) {
+    this._logger && console.log(LOG_PREFIX, ...args);
+  }
+
+  _normalizeFormConfigResponse(
+    response: any,
+    formTypes: string[]
+  ): ReCaptchaResponse | undefined {
+    const data = response?.data;
+    if (!data) return undefined;
+
+    const enabledForms: string[] = [];
+    let globalConfig: ReCaptchaFormConfigResult | null = null;
+    const detectedTypes = new Set<string>();
+
+    for (const formType of formTypes) {
+      const formData = data[formType];
+
+      if (!formData?.is_enabled) continue;
+
+      // configurations may be an array or a single object
+      const config = Array.isArray(formData.configurations)
+        ? formData.configurations[0]
+        : formData.configurations;
+
+      if (!config) continue;
+
+      // Track all reCAPTCHA types across enabled forms, regardless of website_key
+      if (config.re_captcha_type) {
+        detectedTypes.add(config.re_captcha_type);
+      }
+
+      // Skip forms with empty website_key — enabled but not usable
+      if (!config.website_key) {
+        this._log(
+          `Skipping ${formType}: enabled but missing website_key`
+        );
+        continue;
+      }
+
+      enabledForms.push(formType);
+
+      if (!globalConfig) {
+        globalConfig = config;
+      }
+    }
+
+    // Abort if mixed reCAPTCHA types detected across enabled forms
+    if (detectedTypes.size > 1) {
+      console.warn(
+        LOG_PREFIX,
+        recaptchaMessage.mixedTypesWarning,
+        `\nDetected: ${[...detectedTypes].join(', ')}`
+      );
+      return undefined;
+    }
+
+    if (!globalConfig || enabledForms.length === 0) {
+      this._log('No enabled forms found in recaptchaFormConfig response');
+      return undefined;
+    }
+
+    // Map ReCaptchaConfiguration fields to the existing recaptchaConfig shape
+    const isEnterprise =
+      globalConfig.re_captcha_type === 'RECAPTCHA_ENTERPRISE';
+
+    this._log(
+      `Using reCAPTCHA ${isEnterprise ? 'Enterprise' : 'v3'}`,
+      `| Enabled forms: ${enabledForms.join(', ')}`
+    );
+
+    return {
+      data: {
+        recaptchaConfig: {
+          is_enabled: true,
+          website_key: globalConfig.website_key,
+          badge_position: globalConfig.badge_position,
+          language_code: globalConfig.language_code,
+          minimum_score: globalConfig.minimum_score,
+          failure_message: globalConfig.validation_failure_message,
+          theme: globalConfig.theme,
+          forms: enabledForms,
+          recaptcha_type: isEnterprise ? 'enterprise' : 'v3',
+        },
+      },
+    };
+  }
+
   async _updateBadgePosition(
     badgeId: string,
-    config: ReCaptchaV3Model
+    config: ReCaptchaModel
   ): Promise<void | null> {
     if (!config) return;
 
     if (config?.badgePosition === 'inline') {
-      await verifyReCaptchaLoad(badgeId, config, this._logger);
+      this._log(`Rendering inline badge for: ${badgeId}`);
+      await verifyReCaptchaLoad(
+        badgeId,
+        config,
+        this._logger,
+        config.recaptchaType === 'enterprise'
+      );
     } else {
       const isBadgeLoaded = await checkRecaptchaBadge();
 
@@ -83,102 +181,53 @@ export class RecaptchaModule {
       const isBadgeGlobal = config.badgePosition === 'inline';
       const languageCode = config.languageCode;
 
-      if (!webApiKey) return;
+      if (!webApiKey) {
+        this._log('No website key found, skipping script injection');
+        return;
+      }
 
-      // Enterprise uses a different script; V3 uses the standard api.js
-      const scriptBaseUrl =
-        config.reCaptchaType === 'RECAPTCHA_ENTERPRISE'
-          ? this._recaptchaEnterpriseScriptUrl
+      const scriptUrl =
+        config.recaptchaType === 'enterprise'
+          ? RECAPTCHA_ENTERPRISE_SCRIPT_URL
           : this._recaptchaScriptUrl;
 
       const script = document.createElement('script');
       script.setAttribute('id', 'recaptchaId');
       script.defer = true;
       script.src = isBadgeGlobal
-        ? `${scriptBaseUrl}?render=${webApiKey}&badge=none&hl=${languageCode}`
-        : `${scriptBaseUrl}?render=${webApiKey}&badge=${config.badgePosition}&hl=${languageCode}`;
+        ? `${scriptUrl}?render=${webApiKey}&badge=none&hl=${languageCode}`
+        : `${scriptUrl}?render=${webApiKey}&badge=${config.badgePosition}&hl=${languageCode}`;
 
+      this._log(`Loading script: ${script.src}`);
       document.head.appendChild(script);
     }
   }
 
-  async _fetchStoreConfig(): Promise<ReCaptchaV3Response | undefined> {
+  async _fetchStoreConfig(): Promise<ReCaptchaResponse | undefined> {
     try {
-      const response = await recaptchaFetchApi.fetchGraphQl(
-        RECAPTCHA_CONFIGURATION_V3,
-        {
-          method: 'GET',
-          cache: 'force-cache',
-        }
-      );
-
-      if (response?.errors?.length) {
-        this._logger && console.error(response.errors[0].message);
+      const formTypes = Object.keys(typeDefaultForm);
+      const query = buildRecaptchaFormConfigQuery(formTypes);
 
-        return;
-      }
+      this._log(`Fetching config for forms: ${formTypes.join(', ')}`);
 
-      return response;
-    } catch (error) {
-      this._logger && console.error(`${recaptchaMessage.failedFetch}:`, error);
-    }
-  }
-
-  /**
-   * Fetches config from recaptchaFormConfig (new API). Used when backend
-   * is configured with reCAPTCHA Enterprise. Normalizes the nested
-   * response to match recaptchaV3Config shape for downstream pipeline.
-   * Returns undefined if query fails (older backend) or config is invalid.
-   */
-  async _fetchFormConfig(): Promise<ReCaptchaV3Response | undefined> {
-    try {
-      const response = await recaptchaFetchApi.fetchGraphQl(
-        RECAPTCHA_FORM_CONFIGURATION,
-        {
-          method: 'GET',
-          cache: 'force-cache',
-        }
-      );
+      const response = await recaptchaFetchApi.fetchGraphQl(query, {
+        method: 'GET',
+        cache: 'force-cache',
+      });
 
       if (response?.errors?.length) {
         this._logger && console.error(response.errors[0].message);
-        return;
-      }
 
-      const formConfig = response?.data?.recaptchaFormConfig;
-      if (!formConfig?.is_enabled || !formConfig?.configurations?.length) {
         return;
       }
 
-      const config = formConfig.configurations[0];
-
-      // Normalize to recaptchaV3Config shape so convertKeysToCamelCase
-      // and extendConfig work unchanged
-      return {
-        data: {
-          recaptchaV3Config: {
-            is_enabled: formConfig.is_enabled,
-            website_key: config.website_key,
-            minimum_score: config.minimum_score,
-            badge_position: config.badge_position,
-            language_code: config.language_code,
-            failure_message:
-              config.technical_failure_message ||
-              config.validation_failure_message,
-            theme: config.theme,
-            re_captcha_type: config.re_captcha_type,
-            forms: [],
-          },
-        },
-      };
+      return this._normalizeFormConfigResponse(response, formTypes);
     } catch (error) {
-      this._logger &&
-        console.error(recaptchaMessage.failedEnterpriseDetection, error);
-      return;
+      this._logger && console.error(`${recaptchaMessage.failedFetch}:`, error);
     }
   }
 
-  async _loadConfig(): Promise<ReCaptchaV3Model | null> {
+  async _loadConfig(): Promise<ReCaptchaModel | null> {
     const config = await getConfigStorage(this._configStorageKey);
 
     if (!config) {
@@ -201,28 +250,27 @@ export class RecaptchaModule {
 
   async setConfig(configList: PropsFormTypes[]) {
     try {
-      // Try new API first. Use it only for Enterprise; V3 or
-      // failure falls back to old API (preserves forms list, backward compat).
-      const formConfig = await this._fetchFormConfig();
-      const isEnterprise =
-        formConfig?.data?.recaptchaV3Config?.re_captcha_type ===
-        'RECAPTCHA_ENTERPRISE';
-      const config = isEnterprise
-        ? formConfig
-        : await this._fetchStoreConfig();
-
-      if (!config?.data?.recaptchaV3Config) {
+      const config = await this._fetchStoreConfig();
+
+      if (!config?.data?.recaptchaConfig) {
+        this._log('No reCAPTCHA config returned, clearing storage');
         sessionStorage.removeItem(this._configStorageKey);
         return;
       }
 
-      const transformConfig: ReCaptchaV3Model = convertKeysToCamelCase(
-        config?.data?.recaptchaV3Config
+      const transformConfig: ReCaptchaModel = convertKeysToCamelCase(
+        config?.data?.recaptchaConfig
       );
 
       const extendedRecaptchaConfig = extendConfig(transformConfig, configList);
 
       if (extendedRecaptchaConfig) {
+        this._log('Config stored:', {
+          type: extendedRecaptchaConfig.recaptchaType ?? 'v3',
+          enabled: extendedRecaptchaConfig.isEnabled,
+          badge: extendedRecaptchaConfig.badgePosition,
+          forms: extendedRecaptchaConfig.forms,
+        });
         setConfigStorage(
           this._configStorageKey,
           extendedRecaptchaConfig,
@@ -245,9 +293,14 @@ export class RecaptchaModule {
           const config = await this._loadConfig();
 
           if (!config?.forms || !config.isEnabled) {
+            this._log('reCAPTCHA disabled or no forms configured, skipping init');
             return;
           }
 
+          this._log(
+            `Initializing reCAPTCHA (type: ${config.recaptchaType ?? 'v3'}, badge: ${config.badgePosition})`
+          );
+
           await this._addRecaptchaScript();
 
           if (config.badgePosition === 'inline') {
@@ -272,13 +325,22 @@ export class RecaptchaModule {
       const config = await this._loadConfig();
 
       if (!config?.forms || !config.websiteKey || !config.isEnabled) {
+        this._log('verifyReCaptcha skipped: reCAPTCHA not enabled or missing config');
         return undefined;
       }
 
-      // Enterprise calls grecaptcha.enterprise.execute(); V3 calls grecaptcha.execute()
-      const isEnterprise =
-        config.reCaptchaType === 'RECAPTCHA_ENTERPRISE';
-      return await getRecaptchaToken(config.websiteKey, isEnterprise);
+      this._log(
+        `Requesting token (type: ${config.recaptchaType ?? 'v3'})`
+      );
+
+      const token = await getRecaptchaToken(
+        config.websiteKey,
+        config.recaptchaType === 'enterprise'
+      );
+
+      this._log('Token obtained successfully');
+
+      return token;
     } catch (error) {
       this._logger && console.error(error);
     }

package/src/lib/_extendConfig.ts

@@ -7,13 +7,13 @@
  * accompanying it. 
  *******************************************************************/
 
-import { ReCaptchaV3Model } from '../types/recaptcha.types';
+import { ReCaptchaModel } from '../types/recaptcha.types';
 import { typeDefaultForm } from '../configs/typeForms.config';
 
 export const extendConfig = (
-  config: ReCaptchaV3Model,
+  config: ReCaptchaModel,
   modifyParams: any[]
-): ReCaptchaV3Model | undefined => {
+): ReCaptchaModel | undefined => {
   if (config && config.forms) {
     const modifyForm = config.forms.concat(modifyParams).map((el) => {
       if (typeof el !== 'string') return { ...el, enabledBadgePlace: false };

package/src/lib/_storageConfig.ts

@@ -8,13 +8,13 @@
  *******************************************************************/
 
 import { recaptchaMessage } from '../configs';
-import { ReCaptchaV3Model } from '../types/recaptcha.types';
+import { ReCaptchaModel } from '../types/recaptcha.types';
 
 const getConfigStorage = async (
   storageKey: string,
   retries = 1,
   delay = 1000
-): Promise<ReCaptchaV3Model | null> => {
+): Promise<ReCaptchaModel | null> => {
   const storedConfig = sessionStorage.getItem(storageKey);
 
   if (storedConfig !== null) {
@@ -30,7 +30,7 @@ const getConfigStorage = async (
 
 const setConfigStorage = (
   storageKey: string,
-  config: ReCaptchaV3Model,
+  config: ReCaptchaModel,
   logger: boolean
 ) => {
   if (!storageKey || !config.websiteKey) return null;

package/src/services/recaptcha.service.ts

@@ -10,15 +10,10 @@
 import { recaptchaMessage } from '../configs';
 import {
   MutationObserverInit,
-  ReCaptchaV3Model,
+  ReCaptchaModel,
 } from '../types/recaptcha.types';
 const { failedExecutionRecaptcha } = recaptchaMessage;
 
-/**
- * Retrieves a reCAPTCHA token.
- * @param websiteKey - The reCAPTCHA site key
- * @param isEnterprise - If true, uses grecaptcha.enterprise.execute() for Enterprise
- */
 export const getRecaptchaToken = async (
   websiteKey: string,
   isEnterprise = false
@@ -27,19 +22,14 @@ export const getRecaptchaToken = async (
     return Promise.reject(failedExecutionRecaptcha);
   }
 
-  if (isEnterprise && !window.grecaptcha.enterprise) {
-    return Promise.reject(failedExecutionRecaptcha);
-  }
-
   try {
-    // Enterprise uses grecaptcha.enterprise.execute() vs grecaptcha.execute() for V3
-    const executor = isEnterprise
-      ? window.grecaptcha.enterprise
-      : window.grecaptcha;
-
-    const token = await executor.execute(websiteKey, {
-      action: 'click',
-    });
+    const token = isEnterprise
+      ? await window.grecaptcha.enterprise.execute(websiteKey, {
+          action: 'click',
+        })
+      : await window.grecaptcha.execute(websiteKey, {
+          action: 'click',
+        });
 
     return token;
   } catch (error) {
@@ -47,15 +37,10 @@ export const getRecaptchaToken = async (
   }
 };
 
-export const waitForReCaptcha = (isEnterprise = false) => {
+export const waitForReCaptcha = () => {
   return new Promise((resolve) => {
     const observer = new MutationObserver((_, obs) => {
-      // Enterprise script populates grecaptcha.enterprise; V3 populates grecaptcha directly
-      const isReady = isEnterprise
-        ? window.grecaptcha?.enterprise
-        : window.grecaptcha;
-
-      if (isReady) {
+      if (window.grecaptcha) {
         obs.disconnect();
         resolve(true);
       }
@@ -73,21 +58,17 @@ export const waitForReCaptcha = (isEnterprise = false) => {
 
 export const verifyReCaptchaLoad = async (
   badgeId: string,
-  config: ReCaptchaV3Model,
-  logger: boolean
+  config: ReCaptchaModel,
+  logger: boolean,
+  isEnterprise = false
 ): Promise<void> => {
-  const isEnterprise = config.reCaptchaType === 'RECAPTCHA_ENTERPRISE';
-
   if (!window.grecaptcha) {
-    await waitForReCaptcha(isEnterprise);
+    await waitForReCaptcha();
   }
 
-  // Select the correct API namespace: Enterprise uses grecaptcha.enterprise for ready()/render()
-  const recaptchaApi = isEnterprise
-    ? grecaptcha.enterprise
-    : grecaptcha;
+  const api = isEnterprise ? grecaptcha.enterprise : grecaptcha;
 
-  return recaptchaApi.ready(() => {
+  return api.ready(() => {
     const badgeContainers = document.querySelectorAll(`#${badgeId}`);
 
     if (!badgeContainers.length) return;
@@ -101,7 +82,7 @@ export const verifyReCaptchaLoad = async (
     badgeContainers.forEach((element) => {
       if (element.innerHTML === '') {
         try {
-          recaptchaApi.render(element.id, {
+          api.render(element.id, {
             sitekey: config.websiteKey as string,
             badge: config.badgePosition,
             size: 'invisible',

package/src/tests/setup.ts

@@ -0,0 +1,5 @@
+// Suppress console.log and console.warn output during tests to keep shell clean.
+// Using direct override instead of jest.spyOn so restoreAllMocks() won't undo it.
+const noop = () => {};
+console.log = noop;
+console.warn = noop;

package/src/types/recaptcha.types.ts

@@ -7,20 +7,17 @@
  * accompanying it. 
  *******************************************************************/
 
-export type ReCaptchaType = 'RECAPTCHA_V3' | 'RECAPTCHA_ENTERPRISE';
-
-export interface ReCaptchaV3InitProps {
+export interface ReCaptchaInitProps {
   is_enabled?: boolean;
   website_key?: string;
   minimum_score?: number;
   badge_position?: string;
   language_code?: string;
   failure_message?: string;
-  re_captcha_type?: string;
   theme: string;
 }
 
-export interface ReCaptchaV3Props extends ReCaptchaV3InitProps {
+export interface ReCaptchaProps extends ReCaptchaInitProps {
   forms?: string[];
 }
 
@@ -29,46 +26,41 @@ export interface PropsFormTypes {
   enabledBadgePlace?: boolean;
 }
 
-export interface ReCaptchaV3ModifyProps extends ReCaptchaV3InitProps {
+export interface ReCaptchaModifyProps extends ReCaptchaInitProps {
   forms?: PropsFormTypes[];
 }
 
-export interface ReCaptchaV3Response {
+export interface ReCaptchaResponse {
   data?: {
-    recaptchaV3Config?: ReCaptchaV3Props | ReCaptchaV3ModifyProps;
+    recaptchaConfig?: ReCaptchaProps | ReCaptchaModifyProps;
+    [key: string]: ReCaptchaFormConfigResult | ReCaptchaProps | ReCaptchaModifyProps | undefined;
   };
   errors?: { message: string }[];
 }
 
-export interface ReCaptchaV3Model {
+export type ReCaptchaType = 'v3' | 'enterprise';
+
+export interface ReCaptchaModel {
   isEnabled?: boolean;
   websiteKey?: string;
   minimumScore?: number;
   badgePosition?: string;
   languageCode?: string;
   failureMessage?: string;
-  reCaptchaType?: ReCaptchaType;
   theme?: string;
   forms?: PropsFormTypes[] | string[];
+  recaptchaType?: ReCaptchaType;
 }
 
-export interface ReCaptchaFormConfigResponse {
-  data?: {
-    recaptchaFormConfig?: {
-      is_enabled?: boolean;
-      configurations?: {
-        re_captcha_type?: string;
-        website_key?: string;
-        theme?: string;
-        badge_position?: string;
-        language_code?: string;
-        minimum_score?: number;
-        technical_failure_message?: string;
-        validation_failure_message?: string;
-      }[];
-    };
-  };
-  errors?: { message: string }[];
+export interface ReCaptchaFormConfigResult {
+  website_key?: string;
+  badge_position?: string;
+  language_code?: string;
+  minimum_score?: number;
+  re_captcha_type?: string;
+  technical_failure_message?: string;
+  validation_failure_message?: string;
+  theme?: string;
 }
 
 export interface MutationObserverInit {