added common functions for error handling

naman-contentstack · naman-contentstack · commit edc644d190ae · 2025-08-12T19:09:27.000+05:30
diff --git a/src/generateTS/factory.ts b/src/generateTS/factory.ts
@@ -8,6 +8,7 @@ import {
   isNumericIdentifier,
   NUMERIC_IDENTIFIER_EXCLUSION_REASON,
   checkNumericIdentifierExclusion,
+  throwUIDValidationError,
 } from "./shared/utils";
 
 export type TSGenOptions = {
@@ -152,19 +153,13 @@ export default function (userOptions: TSGenOptions) {
   function name_type(uid: string) {
     // Check if the UID starts with a number, which would create invalid TypeScript
     if (isNumericIdentifier(uid)) {
-      const error = {
-        type: "validation",
-        error_code: "INVALID_INTERFACE_NAME",
-        error_message: `Content type UID "${uid}" starts with a number, which creates invalid TypeScript interface names. TypeScript interface names cannot start with numbers.`,
-        details: {
-          uid,
-          reason: NUMERIC_IDENTIFIER_EXCLUSION_REASON,
-          suggestion: `Since UIDs cannot be changed, use the --prefix flag to add a valid prefix to all interface names (e.g., --prefix "ContentType")`,
-        },
+      throwUIDValidationError({
+        uid,
+        errorCode: "INVALID_INTERFACE_NAME",
+        reason: NUMERIC_IDENTIFIER_EXCLUSION_REASON,
+        suggestion: `Since UIDs cannot be changed, use the --prefix flag to add a valid prefix to all interface names (e.g., --prefix "ContentType")`,
         context: "generateTSFromContentTypes",
-        timestamp: new Date().toISOString(),
-      };
-      throw error;
+      });
     }
 
     return [options?.naming?.prefix, _.upperFirst(_.camelCase(uid))]
@@ -182,37 +177,25 @@ export default function (userOptions: TSGenOptions) {
     if (contentType.data_type === "global_field") {
       const referenceTo = contentType.reference_to as string;
       if (isNumericIdentifier(referenceTo)) {
-        const error = {
-          type: "validation",
-          error_code: "INVALID_GLOBAL_FIELD_REFERENCE",
-          error_message: `Global field "${contentType.uid}" references content type "${referenceTo}" which starts with a number, creating invalid TypeScript interface names.`,
-          details: {
-            uid: contentType.uid,
-            reference_to: referenceTo,
-            reason: NUMERIC_IDENTIFIER_EXCLUSION_REASON,
-            suggestion: `Since UIDs cannot be changed, use the --prefix flag to add a valid prefix to all interface names (e.g., --prefix "ContentType")`,
-          },
+        throwUIDValidationError({
+          uid: contentType.uid,
+          errorCode: "INVALID_GLOBAL_FIELD_REFERENCE",
+          reason: NUMERIC_IDENTIFIER_EXCLUSION_REASON,
+          suggestion: `Since UIDs cannot be changed, use the --prefix flag to add a valid prefix to all interface names (e.g., --prefix "ContentType")`,
           context: "generateTSFromContentTypes",
-          timestamp: new Date().toISOString(),
-        };
-        throw error;
+          referenceTo,
+        });
       }
       interfaceName = name_type(referenceTo);
     } else {
       if (isNumericIdentifier(contentType.uid)) {
-        const error = {
-          type: "validation",
-          error_code: "INVALID_CONTENT_TYPE_UID",
-          error_message: `Content type UID "${contentType.uid}" starts with a number, which creates invalid TypeScript interface names.`,
-          details: {
-            uid: contentType.uid,
-            reason: NUMERIC_IDENTIFIER_EXCLUSION_REASON,
-            suggestion: `Since UIDs cannot be changed, use the --prefix flag to add a valid prefix to all interface names (e.g., --prefix "ContentType")`,
-          },
+        throwUIDValidationError({
+          uid: contentType.uid,
+          errorCode: "INVALID_CONTENT_TYPE_UID",
+          reason: NUMERIC_IDENTIFIER_EXCLUSION_REASON,
+          suggestion: `Since UIDs cannot be changed, use the --prefix flag to add a valid prefix to all interface names (e.g., --prefix "ContentType")`,
           context: "generateTSFromContentTypes",
-          timestamp: new Date().toISOString(),
-        };
-        throw error;
+        });
       }
       interfaceName = name_type(contentType.uid);
     }
diff --git a/src/generateTS/index.ts b/src/generateTS/index.ts
@@ -11,6 +11,7 @@ import { defaultInterfaces } from "./stack/builtins";
 import { format } from "../format/index";
 import { ContentType } from "../types/schema";
 import { cliux } from "@contentstack/cli-utilities";
+import { createErrorDetails } from "./shared/utils";
 
 export const generateTS = async ({
   token,
@@ -27,11 +28,14 @@ export const generateTS = async ({
 }: GenerateTS) => {
   try {
     if (!token || !tokenType || !apiKey || !environment || !region) {
-      throw {
-        type: "validation",
-        error_message:
-          "Please provide all the required params (token, tokenType, apiKey, environment, region)",
-      };
+      throw createErrorDetails(
+        {
+          type: "validation",
+          error_message:
+            "Please provide all the required params (token, tokenType, apiKey, environment, region)",
+        },
+        "generateTS"
+      );
     }
 
     if (tokenType === TOKEN_TYPE.DELIVERY) {
@@ -61,11 +65,14 @@ export const generateTS = async ({
           "Please create Content Models to generate type definitions",
           { color: "yellow" }
         );
-        throw {
-          type: "validation",
-          error_message:
-            "There are no Content Types in the Stack, please create Content Models to generate type definitions",
-        };
+        throw createErrorDetails(
+          {
+            type: "validation",
+            error_message:
+              "There are no Content Types in the Stack, please create Content Models to generate type definitions",
+          },
+          "generateTS"
+        );
       }
 
       let schemas: ContentType[] = [];
@@ -94,9 +101,10 @@ export const generateTS = async ({
   } catch (error: any) {
     if (error.type === "validation") {
       // Handle validation errors with proper error codes
+      const errorDetails = createErrorDetails(error, "generateTS");
       throw {
-        error_message: error.error_message,
-        error_code: error.error_code || "VALIDATION_ERROR",
+        error_message: errorDetails.error_message,
+        error_code: errorDetails.error_code,
       };
     } else {
       const errorObj = JSON.parse(error.message.replace("Error: ", ""));
@@ -185,31 +193,8 @@ export const generateTSFromContentTypes = async ({
 
     return output;
   } catch (err: any) {
-    // Enhanced error logging with more context
-    let errorDetails;
-
-    if (err.type === "validation") {
-      // Handle validation errors with proper error codes
-      errorDetails = {
-        error_message: err.error_message || "Validation error occurred", // Keep for backwards compatibility
-        error_code: err.error_code || "VALIDATION_ERROR", // New property
-        context: "generateTSFromContentTypes",
-        timestamp: new Date().toISOString(),
-        error_type: "ValidationError",
-        details: err.details || {},
-      };
-    } else {
-      // Handle other types of errors
-      const errorMessage = err.message || "Unknown error occurred";
-      errorDetails = {
-        error_message: `Type generation failed: ${errorMessage}`, // Keep for backwards compatibility
-        error_code: "TYPE_GENERATION_FAILED", // New property
-        context: "generateTSFromContentTypes",
-        timestamp: new Date().toISOString(),
-        error_type: err.constructor.name,
-        details: {},
-      };
-    }
+    // Use common error details creation function
+    const errorDetails = createErrorDetails(err, "generateTSFromContentTypes");
 
     // Don't log the error here - let the CLI handle the display
     throw errorDetails;
diff --git a/src/generateTS/shared/utils.ts b/src/generateTS/shared/utils.ts
@@ -57,3 +57,83 @@ export function checkNumericIdentifierExclusion(
   }
   return { shouldExclude: false };
 }
+
+/**
+ * Throws a UID validation error with standardized structure
+ * @param params - Object containing error parameters
+ * @param params.uid - The UID that caused the validation error
+ * @param params.errorCode - The error code for the validation error
+ * @param params.reason - The reason for the validation error
+ * @param params.suggestion - The suggestion to resolve the issue
+ * @param params.context - The context where the error occurred
+ * @param params.referenceTo - Optional reference UID for global field errors
+ * @throws A validation error object
+ */
+export function throwUIDValidationError({
+  uid,
+  errorCode,
+  reason,
+  suggestion,
+  context,
+  referenceTo,
+}: {
+  uid: string;
+  errorCode: string;
+  reason: string;
+  suggestion: string;
+  context: string;
+  referenceTo?: string;
+}): never {
+  const errorMessage =
+    errorCode === "INVALID_GLOBAL_FIELD_REFERENCE"
+      ? `Global field "${uid}" references content type "${referenceTo}" which starts with a number, creating invalid TypeScript interface names.`
+      : `Content type UID "${uid}" starts with a number, which creates invalid TypeScript interface names.`;
+
+  throw {
+    type: "validation",
+    error_code: errorCode,
+    error_message: errorMessage,
+    details: {
+      uid,
+      ...(referenceTo ? { reference_to: referenceTo } : {}),
+      reason,
+      suggestion,
+    },
+    context,
+    timestamp: new Date().toISOString(),
+  };
+}
+
+/**
+ * Creates standardized error details for different types of errors
+ * @param err - The error object to process
+ * @param context - The context where the error occurred
+ * @returns Standardized error details object
+ */
+export function createErrorDetails(
+  err: any,
+  context: string = "generateTSFromContentTypes"
+) {
+  if (err.type === "validation") {
+    // Handle validation errors with proper error codes
+    return {
+      error_message: err.error_message || "Validation error occurred", // Keep for backwards compatibility
+      error_code: err.error_code || "VALIDATION_ERROR", // New property
+      context,
+      timestamp: new Date().toISOString(),
+      error_type: "ValidationError",
+      details: err.details || {},
+    };
+  } else {
+    // Handle other types of errors
+    const errorMessage = err.message || "Unknown error occurred";
+    return {
+      error_message: `Type generation failed: ${errorMessage}`, // Keep for backwards compatibility
+      error_code: "TYPE_GENERATION_FAILED", // New property
+      context,
+      timestamp: new Date().toISOString(),
+      error_type: err.constructor.name,
+      details: {},
+    };
+  }
+}
diff --git a/src/graphqlTS/index.ts b/src/graphqlTS/index.ts
@@ -3,6 +3,7 @@ import { GraphQLBase } from "../types";
 import { introspectionQuery } from "./queries";
 import axios from "axios";
 import { cliux } from "@contentstack/cli-utilities";
+import { createErrorDetails } from "../generateTS/shared/utils";
 
 type RegionUrlMap = {
   [prop: string]: string;
@@ -36,11 +37,14 @@ export async function graphqlTS({
       cliux.print("Required: token, apiKey, environment, region", {
         color: "yellow",
       });
-      throw {
-        type: "validation",
-        error_message:
-          "Please provide all the required params (token, apiKey, environment, region)",
-      };
+      throw createErrorDetails(
+        {
+          type: "validation",
+          error_message:
+            "Please provide all the required params (token, apiKey, environment, region)",
+        },
+        "graphqlTS"
+      );
     }
     let config = {
       method: "post",
@@ -73,10 +77,13 @@ export async function graphqlTS({
         { color: "yellow" }
       );
       cliux.print("Or provide a custom host", { color: "yellow" });
-      throw {
-        type: "validation",
-        error_message: `GraphQL content delivery api unavailable for '${region}' region and no custom host provided`,
-      };
+      throw createErrorDetails(
+        {
+          type: "validation",
+          error_message: `GraphQL content delivery api unavailable for '${region}' region and no custom host provided`,
+        },
+        "graphqlTS"
+      );
     }
 
     const result = await axios.request(config);
@@ -90,7 +97,8 @@ export async function graphqlTS({
     return schema;
   } catch (error: any) {
     if (error.type === "validation") {
-      throw { error_message: error.error_message };
+      const errorDetails = createErrorDetails(error, "graphqlTS");
+      throw { error_message: errorDetails.error_message };
     }
 
     if (error.message && !error.response) {
