updated the error handling

Author: naman-contentstack

src/generateTS/factory.ts

@@ -93,6 +93,13 @@ export default function (userOptions: TSGenOptions) {
   const skippedBlocks: Array<{ uid: string; path: string; reason: string }> =
     [];
 
+  // Collect numeric identifier errors instead of throwing immediately
+  const numericIdentifierErrors: Array<{
+    uid: string;
+    referenceTo?: string;
+    type: "content_type" | "global_field";
+  }> = [];
+
   const typeMap: TypeMap = {
     text: { func: type_text, track: true, flag: TypeFlags.BuiltinJS },
     number: { func: type_number, track: true, flag: TypeFlags.BuiltinJS },
@@ -153,13 +160,8 @@ 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)) {
-      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",
-      });
+      // Return a fallback name to continue processing
+      return `InvalidInterface_${uid}`;
     }
 
     return [options?.naming?.prefix, _.upperFirst(_.camelCase(uid))]
@@ -175,22 +177,35 @@ export default function (userOptions: TSGenOptions) {
     let interfaceName: string;
 
     const isGlobalField = contentType.data_type === "global_field";
-    const identifier = isGlobalField
-      ? (contentType.reference_to as string)
-      : contentType.uid;
-    if (isNumericIdentifier(identifier)) {
-      throwUIDValidationError({
+
+    // Check if the content type's own UID starts with a number
+    if (isNumericIdentifier(contentType.uid)) {
+      numericIdentifierErrors.push({
         uid: contentType.uid,
-        errorCode: isGlobalField
-          ? "INVALID_GLOBAL_FIELD_REFERENCE"
-          : "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",
-        ...(isGlobalField && { referenceTo: identifier }),
+        type: "content_type",
       });
+      // Return a fallback interface declaration to continue processing
+      interfaceName = `InvalidInterface_${contentType.uid}`;
+    } else if (
+      isGlobalField &&
+      contentType.reference_to &&
+      isNumericIdentifier(contentType.reference_to as string)
+    ) {
+      // For global fields, check if the referenced content type has a numeric identifier
+      // This is a global field error because it references an invalid content type
+      numericIdentifierErrors.push({
+        uid: contentType.uid, // The global field's UID
+        type: "global_field",
+        referenceTo: contentType.reference_to as string, // The referenced content type's UID
+      });
+      // Return a fallback interface declaration to continue processing
+      interfaceName = `InvalidInterface_${contentType.reference_to}`;
+    } else {
+      // No numeric identifier issues, generate normal interface name
+      interfaceName = name_type(
+        isGlobalField ? (contentType.reference_to as string) : contentType.uid
+      );
     }
-    interfaceName = name_type(identifier);
 
     const interface_declaration = ["export interface", interfaceName];
     if (systemFields && contentType.schema_type !== "global_field") {
@@ -585,6 +600,56 @@ export default function (userOptions: TSGenOptions) {
 
     const definition = visit_content_type(contentType);
 
+    // Check for numeric identifier errors and throw them immediately
+    if (numericIdentifierErrors.length > 0) {
+      // Group errors by type for better organization
+      const contentTypeErrors = numericIdentifierErrors.filter(
+        (err) => err.type === "content_type"
+      );
+      const globalFieldErrors = numericIdentifierErrors.filter(
+        (err) => err.type === "global_field"
+      );
+
+      // Build the detailed error message
+      let errorDetails = "";
+      errorDetails += `Type generation failed: Found ${numericIdentifierErrors.length} items with numeric identifiers that create invalid TypeScript interface names. Please use the --prefix flag to resolve this issue.\n\n`;
+
+      if (contentTypeErrors.length > 0) {
+        errorDetails += "Content Types & Global Fields with Numeric UIDs:\n";
+        errorDetails +=
+          "Note: Global Fields are Content Types, so they appear in this section if their own UID starts with a number.\n\n";
+
+        contentTypeErrors.forEach((error, index) => {
+          errorDetails += `${index + 1}. UID: "${error.uid}"\n`;
+          errorDetails += `   Reason: ${NUMERIC_IDENTIFIER_EXCLUSION_REASON}\n`;
+          errorDetails += `   Suggestion: Since UIDs cannot be changed, use the --prefix flag to add a valid prefix to all interface names (e.g., --prefix "ContentType")\n\n`;
+        });
+      }
+
+      if (globalFieldErrors.length > 0) {
+        errorDetails += "Global Fields Referencing Invalid Content Types:\n\n";
+
+        globalFieldErrors.forEach((error, index) => {
+          errorDetails += `${index + 1}. Global Field: "${error.uid}"\n`;
+          errorDetails += `   References: "${error.referenceTo || "Unknown"}"\n`;
+          errorDetails += `   Reason: ${NUMERIC_IDENTIFIER_EXCLUSION_REASON}\n`;
+          errorDetails += `   Suggestion: Since UIDs cannot be changed, use the --prefix flag to add a valid prefix to all interface names (e.g., --prefix "ContentType")\n\n`;
+        });
+      }
+
+      errorDetails += "To resolve these issues:\n";
+      errorDetails +=
+        "   • Use the --prefix flag to add a valid prefix to all interface names\n";
+      errorDetails += "   • Example: --prefix 'ContentType'\n";
+
+      // Throw a comprehensive error with all the details
+      throw {
+        type: "validation",
+        error_code: "VALIDATION_ERROR",
+        error_message: errorDetails,
+      };
+    }
+
     // Log summary table of skipped fields and blocks
     if (skippedFields.length > 0 || skippedBlocks.length > 0) {
       cliux.print("");

src/generateTS/index.ts

@@ -182,10 +182,19 @@ export const generateTSFromContentTypes = async ({
 
     return output;
   } catch (err: any) {
-    // Use common function to create detailed error information
-    const errorDetails = createErrorDetails(err, "generateTSFromContentTypes");
+    // Handle numeric identifier errors specially to preserve their detailed format
+    if (
+      err.type === "validation" &&
+      err.error_code === "VALIDATION_ERROR" &&
+      err.error_message &&
+      err.error_message.includes("numeric identifiers")
+    ) {
+      // Pass through the detailed error as-is
+      throw err;
+    }
 
-    // Don't log the error here - let the CLI handle the display
+    // Use common function to create detailed error information for other errors
+    const errorDetails = createErrorDetails(err, "generateTSFromContentTypes");
     throw errorDetails;
   }
 };

src/generateTS/shared/utils.ts

@@ -132,9 +132,6 @@ export function createErrorDetails(
     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 {
@@ -143,9 +140,6 @@ export function createErrorDetails(
     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: {},
     };
   }