@adobe/spacecat-shared-utils 1.33.3 → 1.35.0

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [@adobe/spacecat-shared-utils-v1.35.0](https://github.com/adobe/spacecat-shared/compare/@adobe/spacecat-shared-utils-v1.34.0...@adobe/spacecat-shared-utils-v1.35.0) (2025-03-06)
+
+
+### Features
+
+* tracing fetch timeout ([#657](https://github.com/adobe/spacecat-shared/issues/657)) ([67335e3](https://github.com/adobe/spacecat-shared/commit/67335e32b7cceeb500ca58dc05518876589a108a))
+
+# [@adobe/spacecat-shared-utils-v1.34.0](https://github.com/adobe/spacecat-shared/compare/@adobe/spacecat-shared-utils-v1.33.3...@adobe/spacecat-shared-utils-v1.34.0) (2025-03-05)
+
+
+### Features
+
+* Brand client ([#640](https://github.com/adobe/spacecat-shared/issues/640)) ([8d82f45](https://github.com/adobe/spacecat-shared/commit/8d82f45349ea9be2b1359fe5ebebf5a350f52666))
+
 # [@adobe/spacecat-shared-utils-v1.33.3](https://github.com/adobe/spacecat-shared/compare/@adobe/spacecat-shared-utils-v1.33.2...@adobe/spacecat-shared-utils-v1.33.3) (2025-03-04)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/spacecat-shared-utils",
-  "version": "1.33.3",
+  "version": "1.35.0",
   "description": "Shared modules of the Spacecat Services - utils",
   "type": "module",
   "engines": {

package/src/functions.js

@@ -15,6 +15,7 @@ import { validate as uuidValidate } from 'uuid';
 // Precompile regular expressions
 const REGEX_ISO_DATE = /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z/;
 const REGEX_TIME_OFFSET_DATE = /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}(Z|[+-]\d{2}:\d{2})/;
+const IMS_ORG_ID_REGEX = /[a-z0-9]{24}@AdobeOrg/i;
 
 /**
  * Determines if the given parameter is an array.
@@ -251,6 +252,15 @@ function dateAfterDays(days, dateString) {
   return currentDate;
 }
 
+/**
+ * Validates whether the given string is a valid IMS Org ID.
+ * @param {string} imsOrgId - The string to validate.
+ * @returns {boolean} True if the given string is a valid IMS Org ID, false otherwise.
+ */
+function isValidIMSOrgId(imsOrgId) {
+  return IMS_ORG_ID_REGEX.test(imsOrgId);
+}
+
 export {
   arrayEquals,
   dateAfterDays,
@@ -269,5 +279,6 @@ export {
   isValidDate,
   isValidUrl,
   isValidUUID,
+  isValidIMSOrgId,
   toBoolean,
 };

package/src/index.d.ts

@@ -45,6 +45,8 @@ export function isValidUrl(urlString: string): boolean;
 
 export function isValidUUID(uuid: string): boolean;
 
+export function isValidIMSOrgId(imsOrgId: string): boolean;
+
 export function dateAfterDays(days: number, dateString: string): Date;
 
 export function deepEqual(a: unknown, b: unknown): boolean;

package/src/index.js

@@ -28,6 +28,7 @@ export {
   isValidDate,
   isValidUrl,
   isValidUUID,
+  isValidIMSOrgId,
   toBoolean,
 } from './functions.js';
 

package/src/tracing-fetch.js

@@ -9,7 +9,7 @@
  * OF ANY KIND, either express or implied. See the License for the specific language
  * governing permissions and limitations under the License.
  */
-import { Request } from '@adobe/fetch';
+import { Request, timeoutSignal, AbortError } from '@adobe/fetch';
 import AWSXRay from 'aws-xray-sdk';
 
 import { fetch as adobeFetch } from './adobe-fetch.js';
@@ -107,17 +107,60 @@ const handleSubSegmentError = (subSegment, request, error) => {
   subSegment.close(error);
 };
 
+/**
+ * Creates a timeout error with a consistent format
+ * @param {number} timeout - The timeout value in milliseconds
+ * @returns {Error} A formatted timeout error
+ */
+const createTimeoutError = (timeout) => {
+  const timeoutError = new Error(`Request timeout after ${timeout}ms`);
+  timeoutError.code = 'ETIMEOUT';
+  return timeoutError;
+};
+
+/**
+ * Performs a fetch request with timeout handling
+ * @param {string|Request} resource - The resource to fetch
+ * @param {Object} options - Options for the fetch call
+ * @param {Object} signal - The timeout signal
+ * @returns {Promise<Response>} The fetch response
+ */
+const fetchWithTimeout = async (resource, options, signal) => {
+  try {
+    const fetchOptions = { ...options, signal };
+    return await adobeFetch(resource, fetchOptions);
+  } catch (error) {
+    if (error instanceof AbortError) {
+      // Extract timeout from signal (implementation detail, but necessary)
+      // eslint-disable-next-line no-underscore-dangle
+      const timeout = signal._ms || 10000;
+      throw createTimeoutError(timeout);
+    }
+    throw error;
+  } finally {
+    signal.clear(); // Clean up the signal
+  }
+};
+
 /**
  * Performs a fetch request and adds AWS X-Ray tracing, including request/response tracking.
  * @param {string} url - The URL for the request.
- * @param {Object} options - Options to be passed to the fetch call.
+ * @param {Object} [options] - Optional options to be passed to the fetch call.
+ * @param {number} [options.timeout=10000] - Timeout in milliseconds (defaults to 10 seconds).
  * @returns {Promise<Response>} The response from the fetch request.
  */
 export async function tracingFetch(url, options) {
   const parentSegment = AWSXRay.getSegment();
 
-  options = isObject(options) ? options : {};
-  options.headers = isObject(options.headers) ? options.headers : new Headers();
+  options = isObject(options) ? { ...options } : {};
+  options.headers = isObject(options.headers) ? options.headers : { };
+
+  // Set default timeout of 10 seconds if not specified
+  const timeout = options.timeout || 10000;
+  delete options.timeout; // Remove from options as we'll handle it separately
+
+  // Create a timeout signal
+  const signal = timeoutSignal(timeout);
 
   // find user-agent header in headers case insensitively
   let hasUserAgent = false;
@@ -131,10 +174,12 @@ export async function tracingFetch(url, options) {
     options.headers['User-Agent'] = SPACECAT_USER_AGENT;
   }
 
+  // If no parent segment, perform fetch without tracing
   if (!parentSegment) {
-    return adobeFetch(url, options);
+    return fetchWithTimeout(url, options, signal);
   }
 
+  // With parent segment, create subsegment and add tracing
   const request = new Request(url, options);
   const { hostname } = new URL(request.url);
   const subSegment = createSubsegment(parentSegment, hostname);
@@ -145,21 +190,22 @@ export async function tracingFetch(url, options) {
     setTraceHeaders(request, parentSegment, subSegment);
   }
 
-  const capturedAdobeFetch = async () => {
-    let response = null;
-    try {
-      response = await adobeFetch(request);
-    } catch (e) {
-      handleSubSegmentError(subSegment, request, e);
-      throw e;
-    }
+  subSegment.addAnnotation('timeout_ms', timeout);
 
-    setSubSegmentFlagsByStatusCode(subSegment, response.status);
+  try {
+    // Create a new request with the signal
+    const requestWithSignal = new Request(request, { signal });
+
+    // Use the same fetchWithTimeout function but catch errors to handle subsegment
+    const response = await fetchWithTimeout(requestWithSignal, { }, signal);
 
+    setSubSegmentFlagsByStatusCode(subSegment, response.status);
     addFetchRequestDataToSegment(subSegment, request, response);
     subSegment.close();
-    return response;
-  };
 
-  return capturedAdobeFetch();
+    return response;
+  } catch (error) {
+    handleSubSegmentError(subSegment, request, error);
+    throw error;
+  }
 }