payment-kit 1.21.8 → 1.21.9

package/api/src/libs/vendor-util/adapters/didnames-adapter.ts

@@ -18,6 +18,44 @@ import {
 } from './types';
 import { formatVendorUrl } from './util';
 
+const DOMAIN_CONFLICT_ERROR_CODE = 'ERROR_DOMAIN_NOT_AVAILABLE';
+
+export const parseDomainLength = (len: number | string | undefined, defaultValue: number) => {
+  try {
+    if (len === undefined) {
+      return defaultValue;
+    }
+
+    if (typeof len === 'number') {
+      return len;
+    }
+
+    return parseInt(len, 10) || defaultValue;
+  } catch (error) {
+    logger.error('failed to parse domain length', {
+      error,
+      len,
+      defaultValue,
+    });
+
+    return defaultValue;
+  }
+};
+
+export const generateRandomSubdomain = (totalLength: number = 8): string => {
+  // Generate timestamp-based string for uniqueness
+  const timestamp = Date.now();
+  const timeStr = timestamp.toString(36);
+  let result = timeStr.slice(-Math.min(timeStr.length, totalLength));
+
+  // Pad with random chars if needed
+  while (result.length < totalLength) {
+    result = Math.floor(Math.random() * 36).toString(36) + result;
+  }
+
+  return result.slice(0, totalLength);
+};
+
 export class DidnamesAdapter implements VendorAdapter {
   private vendorConfig: VendorConfig | null = null;
   private vendorKey: string;
@@ -33,53 +71,128 @@ export class DidnamesAdapter implements VendorAdapter {
   }
 
   /**
-   * Generate random subdomain for documentation site
-   * Format: [prefix][separator][timestamp-suffix] or pure timestamp
-   * Configurable length, prefix, separator with timestamp-based uniqueness
+   * Submit domain order with retry logic for domain conflicts
    */
-  private generateRandomSubdomain(
-    options: {
-      totalLength?: number; // Total subdomain length (default: 9)
-      prefix?: string; // Prefix (default: 'doc')
-      usePrefix?: boolean; // Whether to use prefix (default: true)
-      separator?: string; // Separator between prefix and suffix (default: '-')
-    } = {}
-  ): string {
-    const { totalLength = 8, prefix = 'doc', usePrefix = true, separator = '-' } = options;
-
-    if (usePrefix) {
-      // With prefix: 'doc' + separator + timestamp suffix
-      const prefixWithSeparatorLength = prefix.length + separator.length;
-      const suffixLength = totalLength - prefixWithSeparatorLength;
-      if (suffixLength <= 0) {
-        throw new Error(
-          `Total length (${totalLength}) must be greater than prefix + separator length (${prefixWithSeparatorLength})`
-        );
-      }
+  private async submitDomainOrderWithRetry(
+    orderData: any,
+    url: string,
+    rootDomain: string,
+    totalLength: number,
+    maxRetries: number = 5
+  ): Promise<{ response: Response; subdomain: string; domain: string; bindDomainCap: any }> {
+    let lastError: Error | null = null;
+
+    // eslint-disable-next-line no-await-in-loop
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      const subdomain = generateRandomSubdomain(totalLength);
+      const domain = `${subdomain}.${rootDomain}`;
 
-      const timestamp = Date.now();
-      const timeStr = timestamp.toString(36);
-      let suffix = timeStr.slice(-suffixLength);
+      logger.info(`Domain generation attempt ${attempt}/${maxRetries}`, {
+        subdomain,
+        domain,
+        checkoutSessionId: orderData.checkoutSessionId,
+      });
 
-      // Pad with random chars if timestamp is shorter than needed
-      while (suffix.length < suffixLength) {
-        suffix = Math.floor(Math.random() * 36).toString(36) + suffix;
-      }
+      // Generate bindDomainCap for this domain
+      const bindDomainCap = this.generateBindCap({
+        domain,
+        checkoutSessionId: orderData.checkoutSessionId,
+      });
 
-      return `${prefix}${separator}${suffix}`;
-    }
+      // Update order data with current domain info
+      const updatedOrderData = {
+        ...orderData,
+        deliveryParams: {
+          ...orderData.deliveryParams,
+          customParams: {
+            ...orderData.deliveryParams.customParams,
+            subdomain,
+            rootDomain,
+            domain,
+            bindDomainCap,
+          },
+        },
+      };
 
-    // Pure timestamp-based without prefix
-    const timestamp = Date.now();
-    const timeStr = timestamp.toString(36);
-    let result = timeStr.slice(-totalLength);
+      try {
+        const { headers, body } = VendorAuth.signRequestWithHeaders(updatedOrderData);
+
+        // eslint-disable-next-line no-await-in-loop
+        const response = await fetch(url, {
+          method: 'POST',
+          headers,
+          body,
+        });
+
+        if (response.ok) {
+          logger.info('domain registration successful', {
+            subdomain,
+            domain,
+            attempt,
+            checkoutSessionId: orderData.checkoutSessionId,
+          });
+          return { response, subdomain, domain, bindDomainCap };
+        }
+
+        // Handle error response
+        // eslint-disable-next-line no-await-in-loop
+        const errorBody = await response.text();
+        let errorData;
+
+        try {
+          errorData = JSON.parse(errorBody);
+        } catch {
+          errorData = { message: errorBody };
+        }
+
+        if (errorData.code === DOMAIN_CONFLICT_ERROR_CODE && attempt < maxRetries) {
+          logger.warn('domain not available, retrying with new domain', {
+            subdomain,
+            domain,
+            attempt,
+            remainingAttempts: maxRetries - attempt,
+            checkoutSessionId: orderData.checkoutSessionId,
+          });
+          // eslint-disable-next-line no-continue
+          continue; // Try again with new domain
+        }
+
+        const errorMsg =
+          errorData.code === DOMAIN_CONFLICT_ERROR_CODE
+            ? `failed to find available domain after ${maxRetries} attempts`
+            : `did names API error: ${response.status} ${response.statusText} - ${errorData.message || errorBody}`;
+
+        logger.error('did names API error', {
+          url,
+          status: response.status,
+          statusText: response.statusText,
+          body: errorBody,
+          subdomain,
+          attempt,
+          isDomainConflict: errorData.code === DOMAIN_CONFLICT_ERROR_CODE,
+        });
 
-    // Pad with random chars if needed
-    while (result.length < totalLength) {
-      result = Math.floor(Math.random() * 36).toString(36) + result;
+        throw new Error(errorMsg);
+      } catch (error: any) {
+        lastError = error;
+
+        // If it's a network error and not max retries, continue
+        if (attempt < maxRetries && !error.message.includes('did names API error')) {
+          logger.warn('network error during domain registration, retrying', {
+            error: error.message,
+            attempt,
+            remainingAttempts: maxRetries - attempt,
+            checkoutSessionId: orderData.checkoutSessionId,
+          });
+          // eslint-disable-next-line no-continue
+          continue;
+        }
+
+        throw error;
+      }
     }
 
-    return result;
+    throw lastError || new Error('Unknown error occurred during domain registration');
   }
 
   /**
@@ -132,57 +245,33 @@ export class DidnamesAdapter implements VendorAdapter {
 
       logger.info('didnames vendor rootDomain', { rootDomain });
 
-      const subdomain = this.generateRandomSubdomain({ totalLength: 8 });
-      const domain = `${subdomain}.${rootDomain}`;
-
-      const { checkoutSessionId } = params;
-      const bindDomainCap = this.generateBindCap({
-        domain,
-        checkoutSessionId,
-      });
-
-      params.deliveryParams.customParams = {
-        ...params.deliveryParams.customParams,
-        years: 1,
-        whoisPrivacy: true,
-        subdomain,
-        rootDomain,
-        domain,
-        checkoutSessionId,
-        bindDomainCap,
-      };
+      const totalLength = parseDomainLength(vendorConfig.metadata?.subDomainLength, 8);
 
-      const orderData = {
+      // Prepare base order data
+      const baseOrderData = {
         checkoutSessionId: params.checkoutSessionId,
         description: params.description,
         userInfo: params.userInfo,
-        deliveryParams: params.deliveryParams,
+        deliveryParams: {
+          ...params.deliveryParams,
+          customParams: {
+            ...params.deliveryParams.customParams,
+            years: 1,
+            whoisPrivacy: true,
+            checkoutSessionId: params.checkoutSessionId,
+          },
+        },
       };
 
       const url = formatVendorUrl(vendorConfig, '/api/vendor/deliveries');
-      logger.info('submitting domain delivery to DID Names', {
-        subdomain,
-        url,
-      });
-
-      const { headers, body } = VendorAuth.signRequestWithHeaders(orderData);
-
-      const response = await fetch(url, {
-        method: 'POST',
-        headers,
-        body,
-      });
 
-      if (!response.ok) {
-        const errorBody = await response.text();
-        logger.error('DID Names API error', {
-          url,
-          status: response.status,
-          statusText: response.statusText,
-          body: errorBody,
-        });
-        throw new Error(`DID Names API error: ${response.status} ${response.statusText}`);
-      }
+      // Use the retry wrapper to submit order with domain conflict handling
+      const { response, subdomain, domain, bindDomainCap } = await this.submitDomainOrderWithRetry(
+        baseOrderData,
+        url,
+        rootDomain,
+        totalLength
+      );
 
       const didNamesResult = await response.json();
 

package/blocklet.yml

@@ -14,7 +14,7 @@ repository:
   type: git
   url: git+https://github.com/blocklet/payment-kit.git
 specVersion: 1.2.8
-version: 1.21.8
+version: 1.21.9
 logo: logo.png
 files:
   - dist

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "payment-kit",
-  "version": "1.21.8",
+  "version": "1.21.9",
   "scripts": {
     "dev": "blocklet dev --open",
     "lint": "tsc --noEmit && eslint src api/src --ext .mjs,.js,.jsx,.ts,.tsx",
@@ -56,9 +56,9 @@
     "@blocklet/error": "^0.2.5",
     "@blocklet/js-sdk": "^1.16.52",
     "@blocklet/logger": "^1.16.52",
-    "@blocklet/payment-broker-client": "1.21.8",
-    "@blocklet/payment-react": "1.21.8",
-    "@blocklet/payment-vendor": "1.21.8",
+    "@blocklet/payment-broker-client": "1.21.9",
+    "@blocklet/payment-react": "1.21.9",
+    "@blocklet/payment-vendor": "1.21.9",
     "@blocklet/sdk": "^1.16.52",
     "@blocklet/ui-react": "^3.1.46",
     "@blocklet/uploader": "^0.2.13",
@@ -128,7 +128,7 @@
   "devDependencies": {
     "@abtnode/types": "^1.16.52",
     "@arcblock/eslint-config-ts": "^0.3.3",
-    "@blocklet/payment-types": "1.21.8",
+    "@blocklet/payment-types": "1.21.9",
     "@types/cookie-parser": "^1.4.9",
     "@types/cors": "^2.8.19",
     "@types/debug": "^4.1.12",
@@ -175,5 +175,5 @@
       "parser": "typescript"
     }
   },
-  "gitHead": "d97f6b353583b95b2e0ec49ea66ab45426658532"
+  "gitHead": "dd41fc0eab97528eeb2f696e73073518ef360043"
 }