@karibulab/wsdl2tsx 0.22.0 → 0.23.0

package/dist/cli.js

@@ -17215,7 +17215,7 @@ var init_processors = __esm({
 });
 
 // src/wsdl/complex-type-helpers.ts
-async function processImports(wsdlFile, node, currentNamespaces, object) {
+async function processImports(wsdlFile, node, currentNamespaces, object, processedSchemas = /* @__PURE__ */ new Set()) {
   const importNode = getImportNode(node);
   if (importNode === void 0) {
     return;
@@ -17227,13 +17227,19 @@ async function processImports(wsdlFile, node, currentNamespaces, object) {
       debugContext("processImports", `Import sin schemaLocation, omitiendo`);
       return;
     }
+    const schemaId = item.schemaLocation;
+    if (processedSchemas.has(schemaId)) {
+      debugContext("processImports", `Schema ya procesado, omitiendo: ${schemaId}`);
+      return;
+    }
     debugContext("processImports", `Cargando XSD importado desde: ${item.schemaLocation}`);
     try {
       const importedXsd = await loadXsd(wsdlFile, item.schemaLocation);
       const schemaNode = getSchemaNode(importedXsd);
       if (schemaNode) {
+        processedSchemas.add(schemaId);
         const { complexTypesFromSchema: complexTypesFromSchema2 } = await Promise.resolve().then(() => (init_complex_types(), complex_types_exports));
-        const importedComplexTypes = await complexTypesFromSchema2(wsdlFile, schemaNode, currentNamespaces);
+        const importedComplexTypes = await complexTypesFromSchema2(wsdlFile, schemaNode, currentNamespaces, processedSchemas);
         const importedCount = Object.keys(importedComplexTypes).length;
         debugContext("processImports", `\u2713 XSD importado exitosamente: ${importedCount} tipo(s) complejo(s) encontrado(s)`);
         Object.assign(object, importedComplexTypes);
@@ -17312,13 +17318,13 @@ var init_complex_types = __esm({
     init_node_extractors();
     init_processors();
     init_complex_type_helpers();
-    complexTypesFromSchema = async (wsdlFile, node, namespaces) => {
+    complexTypesFromSchema = async (wsdlFile, node, namespaces, processedSchemas = /* @__PURE__ */ new Set()) => {
       const targetNamespace = node.targetNamespace;
       const isQualified = node.elementFormDefault === "qualified";
       const schemaNamespaces = namespaces ?? getNamespacesFromNode(node);
       const currentNamespaces = schemaNamespaces;
       let object = {};
-      await processImports(wsdlFile, node, currentNamespaces, object);
+      await processImports(wsdlFile, node, currentNamespaces, object, processedSchemas);
       processComplexTypeNodes(node, targetNamespace, currentNamespaces, object, isQualified);
       processElementNodes(node, targetNamespace, currentNamespaces, object, isQualified);
       return object;
@@ -23534,7 +23540,12 @@ init_node_extractors();
 // src/generator/schema-processing.ts
 init_node_extractors();
 init_loader();
-async function processSchemaAndImports(schemaNode, wsdlPath, allNamespaces, allComplexTypes, schemaObject) {
+async function processSchemaAndImports(schemaNode, wsdlPath, allNamespaces, allComplexTypes, schemaObject, processedSchemas = /* @__PURE__ */ new Set(), schemaLocation) {
+  const schemaId = schemaLocation || schemaNode.targetNamespace || "default";
+  if (processedSchemas.has(schemaId)) {
+    return;
+  }
+  processedSchemas.add(schemaId);
   const schemaObj = schemaToObject(schemaNode, allNamespaces, allComplexTypes);
   for (const [key, value] of Object.entries(schemaObj)) {
     if (key !== "$namespace" || !schemaObject["$namespace"]) {
@@ -23553,7 +23564,7 @@ async function processSchemaAndImports(schemaNode, wsdlPath, allNamespaces, allC
           const importedXsd = await loadXsd(wsdlPath, item.schemaLocation);
           const importedSchemaNode = getSchemaNode(importedXsd);
           if (importedSchemaNode) {
-            await processSchemaAndImports(importedSchemaNode, wsdlPath, allNamespaces, allComplexTypes, schemaObject);
+            await processSchemaAndImports(importedSchemaNode, wsdlPath, allNamespaces, allComplexTypes, schemaObject, processedSchemas, item.schemaLocation);
           }
         } catch (error2) {
           const { warn: warn2 } = await Promise.resolve().then(() => (init_logger(), logger_exports));
@@ -24070,6 +24081,7 @@ function resolveNestedType(nestedTypeValue, schemaObject, allComplexTypes) {
 }
 
 // src/codegen/xml-generator/xml-property.ts
+init_logger();
 function generateXmlPropertyCode(namespacesTypeMapping, baseNamespacePrefix, key, elementObject, parentKey = null, propertyPath = "", parentIsQualified = true, prefixesMapping, schemaObject, allComplexTypes, tagUsageCollector) {
   const namespacePrefix = getNamespacePrefix(
     namespacesTypeMapping,
@@ -24092,7 +24104,9 @@ function generateXmlPropertyCode(namespacesTypeMapping, baseNamespacePrefix, key
   }
   const isArray2 = typeof elementObject === "object" && elementObject !== null && "maxOccurs" in elementObject && elementObject.maxOccurs !== void 0 && elementObject.maxOccurs !== "1" && elementObject.maxOccurs !== DEFAULT_OCCURS;
   const currentPropertyPath = propertyPath ? propertyPath.endsWith(`.${tagCamelCase}`) || propertyPath === tagCamelCase ? propertyPath : `${propertyPath}.${tagCamelCase}` : tagCamelCase;
-  if (typeof elementObject === "object" && elementObject !== null && typeof elementObject.type === "string" && (schemaObject || allComplexTypes)) {
+  const isXsdSimpleType = typeof elementObject === "object" && elementObject !== null && typeof elementObject.type === "string" && (elementObject.type.startsWith("xsd:") || elementObject.type === "string" || elementObject.type === "int" || elementObject.type === "boolean" || elementObject.type === "date" || elementObject.type === "dateTime");
+  debugContext("generateXmlPropertyCode", `Procesando propiedad "${key}" (tagLocalName: "${tagLocalName}"), elementObject.type: ${typeof elementObject === "object" && elementObject !== null ? typeof elementObject.type : "N/A"}, isXsdSimpleType: ${isXsdSimpleType}`);
+  if (typeof elementObject === "object" && elementObject !== null && typeof elementObject.type === "string" && (schemaObject || allComplexTypes) && !isXsdSimpleType) {
     const referencedType = elementObject.type;
     const referencedElement = resolveReferencedType(referencedType, schemaObject, allComplexTypes);
     if (referencedElement && typeof referencedElement === "object") {
@@ -24233,6 +24247,13 @@ function generateXmlPropertyCode(namespacesTypeMapping, baseNamespacePrefix, key
     ${wrapperCloseTag}`;
       }
     }
+    if (typeof elementObject.type === "string") {
+      return `${openTag}{props.${currentPropertyPath}}${closeTag}`;
+    }
+  }
+  if (typeof elementObject === "object" && elementObject !== null && typeof elementObject.type === "string") {
+    debugContext("generateXmlPropertyCode", `Generando tag para tipo simple "${elementObject.type}" con propertyPath "${currentPropertyPath}"`);
+    return `${openTag}{props.${currentPropertyPath}}${closeTag}`;
   }
   if (typeof elementObject === "object" && elementObject !== null && typeof elementObject.type === "object") {
     const keys = getFilteredKeys(elementObject.type);
@@ -24334,10 +24355,27 @@ function generateXmlBodyCode(baseNamespacePrefix, namespacesTypeMapping, baseTyp
   }
   const properties = keys.map((key) => {
     const element = baseTypeObject[key];
+    debugContext("generateXmlBodyCode", `Procesando propiedad "${key}", typeof element: ${typeof element}, element: ${typeof element === "object" && element !== null ? JSON.stringify(Object.keys(element)).substring(0, 100) : element}`);
+    if (typeof element === "string") {
+      const keyLocalName = extractLocalName(key);
+      const keyCamelCase = toCamelCase2(keyLocalName);
+      const propertyPath = propsInterfaceName ? `${propsInterfaceName}.${keyCamelCase}` : keyCamelCase;
+      const namespacePrefix = getNamespacePrefix(
+        namespacesTypeMapping,
+        baseNamespacePrefix,
+        key,
+        null,
+        { $qualified: true },
+        prefixesMapping
+      );
+      debugContext("generateXmlBodyCode", `Generando tag para tipo simple string "${element}" con propertyPath "${propertyPath}"`);
+      return `<${namespacePrefix}.${keyLocalName}>{props.${propertyPath}}</${namespacePrefix}.${keyLocalName}>`;
+    }
     if (typeof element === "object" && element !== null) {
       const keyLocalName = extractLocalName(key);
       const keyCamelCase = toCamelCase2(keyLocalName);
       const propertyPath = propsInterfaceName ? `${propsInterfaceName}.${keyCamelCase}` : keyCamelCase;
+      debugContext("generateXmlBodyCode", `Llamando a generateXmlPropertyCode para "${key}" con propertyPath "${propertyPath}"`);
       return generateXmlPropertyCode(
         namespacesTypeMapping,
         baseNamespacePrefix,
@@ -24353,6 +24391,7 @@ function generateXmlBodyCode(baseNamespacePrefix, namespacesTypeMapping, baseTyp
         tagUsageCollector
       );
     }
+    debugContext("generateXmlBodyCode", `\u26A0 Propiedad "${key}" no es un objeto ni string, omitiendo`);
     return "";
   }).filter(Boolean).join("\n");
   if (tagUsageCollector) {
@@ -24766,7 +24805,7 @@ function extractNestedComplexTypes(typeObject, namespaceKey, xmlSchemaUri, visit
 
 // src/codegen/data-preparer/props-interface.ts
 init_logger();
-function preparePropsInterfaceData(typeName, typeObject, allTypesForInterfaces, schemaObject, allComplexTypes) {
+function preparePropsInterfaceData(typeName, typeObject, allTypesForInterfaces, schemaObject, allComplexTypes, visitedTypes = /* @__PURE__ */ new Set()) {
   const keys = getFilteredKeys(typeObject);
   const localNames = keys.map((key) => extractLocalName(key));
   debugContext("preparePropsInterfaceData", `Procesando tipo "${typeName}" con ${keys.length} propiedades: ${keys.join(", ")}`);
@@ -24931,22 +24970,38 @@ function preparePropsInterfaceData(typeName, typeObject, allTypesForInterfaces,
               debugContext("preparePropsInterfaceData", `  Propiedades del tipo anidado (nombres locales): ${nestedLocalNames.join(" -> ")}`);
               if (hasOnlyTypeProperty || !hasTypeAndOtherProperties && refKeys.length === 0) {
                 debugContext("preparePropsInterfaceData", `Expandiendo contenido del tipo anidado (wrapper sin otras propiedades)`);
+                if (visitedTypes.has(nestedTypeValue)) {
+                  debugContext("preparePropsInterfaceData", `\u26A0 Tipo anidado "${nestedTypeValue}" ya fue procesado, evitando recursi\xF3n infinita`);
+                  return {
+                    properties: [],
+                    interfaces: []
+                  };
+                }
+                visitedTypes.add(nestedTypeValue);
                 const cleanedNestedElement = { ...nestedReferencedElement };
                 Object.keys(cleanedNestedElement).forEach((key) => {
                   if (key.startsWith("_")) {
                     delete cleanedNestedElement[key];
                   }
                 });
-                return preparePropsInterfaceData(typeName, cleanedNestedElement, allTypesForInterfaces, schemaObject, allComplexTypes);
+                return preparePropsInterfaceData(nestedTypeValue, cleanedNestedElement, allTypesForInterfaces, schemaObject, allComplexTypes, visitedTypes);
               } else {
                 debugContext("preparePropsInterfaceData", `Combinando propiedades del wrapper con el tipo anidado`);
+                if (visitedTypes.has(nestedTypeValue)) {
+                  debugContext("preparePropsInterfaceData", `\u26A0 Tipo anidado "${nestedTypeValue}" ya fue procesado, evitando recursi\xF3n infinita`);
+                  return {
+                    properties: [],
+                    interfaces: []
+                  };
+                }
+                visitedTypes.add(nestedTypeValue);
                 const cleanedNestedElement = { ...nestedReferencedElement };
                 Object.keys(cleanedNestedElement).forEach((key) => {
                   if (key.startsWith("_")) {
                     delete cleanedNestedElement[key];
                   }
                 });
-                return preparePropsInterfaceData(typeName, cleanedNestedElement, allTypesForInterfaces, schemaObject, allComplexTypes);
+                return preparePropsInterfaceData(nestedTypeValue, cleanedNestedElement, allTypesForInterfaces, schemaObject, allComplexTypes, visitedTypes);
               }
             }
           }
@@ -24957,7 +25012,16 @@ function preparePropsInterfaceData(typeName, typeObject, allTypesForInterfaces,
             }
           });
           debugContext("preparePropsInterfaceData", `Expandiendo tipo referenciado directamente (sin type anidado)`);
-          return preparePropsInterfaceData(typeName, cleanedReferencedElement, allTypesForInterfaces, schemaObject, allComplexTypes);
+          const referencedTypeId = typeValue || typeName;
+          if (visitedTypes.has(referencedTypeId)) {
+            debugContext("preparePropsInterfaceData", `\u26A0 Tipo referenciado "${referencedTypeId}" ya fue procesado, evitando recursi\xF3n infinita`);
+            return {
+              properties: [],
+              interfaces: []
+            };
+          }
+          visitedTypes.add(referencedTypeId);
+          return preparePropsInterfaceData(referencedTypeId, cleanedReferencedElement, allTypesForInterfaces, schemaObject, allComplexTypes, visitedTypes);
         }
       }
       if (typeof typeValue === "object" && typeValue !== null) {
@@ -24969,7 +25033,15 @@ function preparePropsInterfaceData(typeName, typeObject, allTypesForInterfaces,
         });
         const typeKeys = getFilteredKeys(cleanedTypeValue);
         if (typeKeys.length > 0) {
-          return preparePropsInterfaceData(typeName, cleanedTypeValue, allTypesForInterfaces, schemaObject, allComplexTypes);
+          if (visitedTypes.has(typeName)) {
+            debugContext("preparePropsInterfaceData", `\u26A0 Tipo "${typeName}" ya fue procesado, evitando recursi\xF3n infinita`);
+            return {
+              properties: [],
+              interfaces: []
+            };
+          }
+          visitedTypes.add(typeName);
+          return preparePropsInterfaceData(typeName, cleanedTypeValue, allTypesForInterfaces, schemaObject, allComplexTypes, visitedTypes);
         }
       }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@karibulab/wsdl2tsx",
-  "version": "0.22.0",
+  "version": "0.23.0",
   "description": "Generador de código TSX desde archivos WSDL",
   "main": "dist/index.js",
   "bin": "./dist/cli.js",
@@ -13,7 +13,7 @@
     "start": "node dist/cli.js"
   },
   "dependencies": {
-    "@karibulab/wsdl2tsx-runtime": "0.22.0",
+    "@karibulab/wsdl2tsx-runtime": "0.23.0",
     "axios": "^1.7.9",
     "fast-xml-parser": "5.3.3",
     "handlebars": "4.7.8"