@karibulab/wsdl2tsx 0.23.0 → 0.24.0

package/dist/cli.js

@@ -24357,6 +24357,163 @@ function generateXmlBodyCode(baseNamespacePrefix, namespacesTypeMapping, baseTyp
     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 isXsdSimpleType = element.startsWith("xsd:") || element === "string" || element === "int" || element === "boolean" || element === "date" || element === "dateTime";
+      if (!isXsdSimpleType && element.includes(":") && (schemaObject || allComplexTypes)) {
+        const referencedElement = resolveReferencedType(element, schemaObject, allComplexTypes);
+        debugContext("generateXmlBodyCode", `Intentando resolver referencia "${element}", resultado: ${referencedElement ? typeof referencedElement === "object" ? `objeto con ${Object.keys(referencedElement).length} propiedades: ${Object.keys(referencedElement).join(", ")}` : typeof referencedElement : "null"}`);
+        if (referencedElement && typeof referencedElement === "object") {
+          if ("type" in referencedElement && typeof referencedElement.type === "string" && !referencedElement.type.startsWith("xsd:")) {
+            if (referencedElement.type !== element) {
+              const nestedReferencedElement = resolveReferencedType(referencedElement.type, schemaObject, allComplexTypes);
+              if (nestedReferencedElement && typeof nestedReferencedElement === "object") {
+                let finalNestedElement = nestedReferencedElement;
+                if ("type" in nestedReferencedElement && typeof nestedReferencedElement.type === "object" && nestedReferencedElement.type !== null) {
+                  finalNestedElement = nestedReferencedElement.type;
+                  debugContext("generateXmlBodyCode", `Usando complexType inline del tipo anidado "${referencedElement.type}"`);
+                }
+                const nestedKeys = getFilteredKeys(finalNestedElement);
+                debugContext("generateXmlBodyCode", `Expandiendo tipo anidado "${referencedElement.type}" con ${nestedKeys.length} propiedades: ${nestedKeys.join(", ")}`);
+                const keyLocalName3 = extractLocalName(key);
+                const keyCamelCase3 = toCamelCase2(keyLocalName3);
+                const propertyPath3 = propsInterfaceName ? `${propsInterfaceName}.${keyCamelCase3}` : keyCamelCase3;
+                const nestedProperties = nestedKeys.map((nestedKey) => {
+                  const nestedElement = finalNestedElement[nestedKey];
+                  if (typeof nestedElement === "object" && nestedElement !== null) {
+                    const nestedKeyLocalName = extractLocalName(nestedKey);
+                    const nestedKeyCamelCase = toCamelCase2(nestedKeyLocalName);
+                    const nestedPropertyPath = `${propertyPath3}.${nestedKeyCamelCase}`;
+                    return generateXmlPropertyCode(
+                      namespacesTypeMapping,
+                      baseNamespacePrefix,
+                      nestedKey,
+                      nestedElement,
+                      key,
+                      nestedPropertyPath,
+                      true,
+                      prefixesMapping,
+                      schemaObject,
+                      allComplexTypes,
+                      tagUsageCollector
+                    );
+                  } else if (typeof nestedElement === "string") {
+                    const nestedKeyLocalName = extractLocalName(nestedKey);
+                    const nestedKeyCamelCase = toCamelCase2(nestedKeyLocalName);
+                    const nestedPropertyPath = `${propertyPath3}.${nestedKeyCamelCase}`;
+                    const nestedNamespacePrefix = getNamespacePrefix(
+                      namespacesTypeMapping,
+                      baseNamespacePrefix,
+                      nestedKey,
+                      key,
+                      { $qualified: true },
+                      prefixesMapping
+                    );
+                    return `<${nestedNamespacePrefix}.${nestedKeyLocalName}>{props.${nestedPropertyPath}}</${nestedNamespacePrefix}.${nestedKeyLocalName}>`;
+                  }
+                  return "";
+                }).filter(Boolean).join("\n");
+                const namespacePrefix2 = getNamespacePrefix(
+                  namespacesTypeMapping,
+                  baseNamespacePrefix,
+                  key,
+                  null,
+                  referencedElement,
+                  prefixesMapping
+                );
+                const isQualified = shouldHavePrefix(referencedElement);
+                const wrapperOpenTag = isQualified ? `<${namespacePrefix2}.${keyLocalName3}>` : `<${keyLocalName3}>`;
+                const wrapperCloseTag = isQualified ? `</${namespacePrefix2}.${keyLocalName3}>` : `</${keyLocalName3}>`;
+                return `${wrapperOpenTag}
+    ${nestedProperties}
+${wrapperCloseTag}`;
+              }
+            } else {
+              debugContext("generateXmlBodyCode", `\u26A0 Referencia circular detectada: "${element}" -> "${referencedElement.type}", buscando complexType directamente`);
+              const typeLocalName = element.split(":").pop() || element;
+              if (allComplexTypes) {
+                const complexTypeKey = Object.keys(allComplexTypes).find((k) => {
+                  const kLocalName = k.split(":").pop() || k;
+                  return kLocalName === typeLocalName;
+                });
+                if (complexTypeKey) {
+                  const complexType = allComplexTypes[complexTypeKey];
+                  if (complexType && typeof complexType === "object") {
+                    let finalComplexType = complexType;
+                    if ("type" in complexType && typeof complexType.type === "object" && complexType.type !== null) {
+                      finalComplexType = complexType.type;
+                    }
+                    const complexKeys = getFilteredKeys(finalComplexType);
+                    debugContext("generateXmlBodyCode", `Usando complexType "${complexTypeKey}" con ${complexKeys.length} propiedades: ${complexKeys.join(", ")}`);
+                    const keyLocalName3 = extractLocalName(key);
+                    const keyCamelCase3 = toCamelCase2(keyLocalName3);
+                    const propertyPath3 = propsInterfaceName ? `${propsInterfaceName}.${keyCamelCase3}` : keyCamelCase3;
+                    const complexProperties = complexKeys.map((complexKey) => {
+                      const complexElement = finalComplexType[complexKey];
+                      if (typeof complexElement === "object" && complexElement !== null) {
+                        const complexKeyLocalName = extractLocalName(complexKey);
+                        const complexKeyCamelCase = toCamelCase2(complexKeyLocalName);
+                        const complexPropertyPath = propsInterfaceName ? `${propsInterfaceName}.${complexKeyCamelCase}` : complexKeyCamelCase;
+                        return generateXmlPropertyCode(
+                          namespacesTypeMapping,
+                          baseNamespacePrefix,
+                          complexKey,
+                          complexElement,
+                          null,
+                          // parentKey es null porque estamos en el nivel raíz
+                          complexPropertyPath,
+                          true,
+                          prefixesMapping,
+                          schemaObject,
+                          allComplexTypes,
+                          tagUsageCollector
+                        );
+                      } else if (typeof complexElement === "string") {
+                        const complexKeyLocalName = extractLocalName(complexKey);
+                        const complexKeyCamelCase = toCamelCase2(complexKeyLocalName);
+                        const complexPropertyPath = propsInterfaceName ? `${propsInterfaceName}.${complexKeyCamelCase}` : complexKeyCamelCase;
+                        const complexNamespacePrefix = getNamespacePrefix(
+                          namespacesTypeMapping,
+                          baseNamespacePrefix,
+                          complexKey,
+                          null,
+                          // parentKey es null porque estamos en el nivel raíz
+                          { $qualified: true },
+                          prefixesMapping
+                        );
+                        return `<${complexNamespacePrefix}.${complexKeyLocalName}>{props.${complexPropertyPath}}</${complexNamespacePrefix}.${complexKeyLocalName}>`;
+                      }
+                      return "";
+                    }).filter(Boolean).join("\n");
+                    return complexProperties;
+                  }
+                }
+              }
+            }
+          }
+          debugContext("generateXmlBodyCode", `Resolviendo referencia "${element}" a tipo complejo con propiedades: ${Object.keys(referencedElement).filter((k) => !k.startsWith("$")).join(", ")}`);
+          const keyLocalName2 = extractLocalName(key);
+          const keyCamelCase2 = toCamelCase2(keyLocalName2);
+          const propertyPath2 = propsInterfaceName ? `${propsInterfaceName}.${keyCamelCase2}` : keyCamelCase2;
+          const elementAsObject = {
+            type: element,
+            $qualified: true
+          };
+          return generateXmlPropertyCode(
+            namespacesTypeMapping,
+            baseNamespacePrefix,
+            key,
+            elementAsObject,
+            null,
+            propertyPath2,
+            true,
+            prefixesMapping,
+            schemaObject,
+            allComplexTypes,
+            tagUsageCollector
+          );
+        } else {
+          debugContext("generateXmlBodyCode", `No se pudo resolver la referencia "${element}", tratando como tipo simple`);
+        }
+      }
       const keyLocalName = extractLocalName(key);
       const keyCamelCase = toCamelCase2(keyLocalName);
       const propertyPath = propsInterfaceName ? `${propsInterfaceName}.${keyCamelCase}` : keyCamelCase;
@@ -24814,6 +24971,43 @@ function preparePropsInterfaceData(typeName, typeObject, allTypesForInterfaces,
     const singleKey = keys[0];
     const element = typeObject[singleKey];
     debugContext("preparePropsInterfaceData", `Procesando propiedad \xFAnica "${singleKey}" (tipo: ${typeof element})`);
+    if (typeof element === "string" && element.includes(":") && !element.startsWith("xsd:") && (schemaObject || allComplexTypes)) {
+      const typeLocalName = typeName.split(":").pop() || typeName;
+      const elementLocalName = element.split(":").pop() || element;
+      if (elementLocalName === typeLocalName && allComplexTypes) {
+        debugContext("preparePropsInterfaceData", `\u26A0 Propiedad \xFAnica "${singleKey}" es string que parece referencia circular "${element}", buscando complexType directamente`);
+        const complexTypeKey = Object.keys(allComplexTypes).find((k) => {
+          const kLocalName = k.split(":").pop() || k;
+          return kLocalName === typeLocalName;
+        });
+        if (complexTypeKey) {
+          const complexType = allComplexTypes[complexTypeKey];
+          if (complexType && typeof complexType === "object") {
+            let finalComplexType = complexType;
+            if ("type" in complexType && typeof complexType.type === "object" && complexType.type !== null) {
+              finalComplexType = complexType.type;
+            }
+            const complexKeys = getFilteredKeys(finalComplexType);
+            debugContext("preparePropsInterfaceData", `Usando complexType "${complexTypeKey}" con ${complexKeys.length} propiedades: ${complexKeys.join(", ")}`);
+            const cleanedComplexType = { ...finalComplexType };
+            Object.keys(cleanedComplexType).forEach((key) => {
+              if (key.startsWith("_")) {
+                delete cleanedComplexType[key];
+              }
+            });
+            if (visitedTypes.has(complexTypeKey)) {
+              debugContext("preparePropsInterfaceData", `\u26A0 ComplexType "${complexTypeKey}" ya fue procesado, evitando recursi\xF3n infinita`);
+              return {
+                properties: [],
+                interfaces: []
+              };
+            }
+            visitedTypes.add(complexTypeKey);
+            return preparePropsInterfaceData(complexTypeKey, cleanedComplexType, allTypesForInterfaces, schemaObject, allComplexTypes, visitedTypes);
+          }
+        }
+      }
+    }
     if (typeof element === "object" && element !== null && "type" in element) {
       const typeValue = element.type;
       debugContext("preparePropsInterfaceData", `Tipo de propiedad: ${typeof typeValue === "string" ? `referencia "${typeValue}"` : `objeto complejo`}`);
@@ -24968,6 +25162,44 @@ function preparePropsInterfaceData(typeName, typeObject, allTypesForInterfaces,
               const nestedLocalNames = nestedKeys.map((k) => extractLocalName(k));
               debugContext("preparePropsInterfaceData", `Tipo anidado resuelto tiene ${nestedKeys.length} propiedades: ${nestedKeys.join(", ")}`);
               debugContext("preparePropsInterfaceData", `  Propiedades del tipo anidado (nombres locales): ${nestedLocalNames.join(" -> ")}`);
+              const typeLocalName2 = typeName.split(":").pop() || typeName;
+              const nestedTypeLocalName = nestedTypeValue.split(":").pop() || nestedTypeValue;
+              const isCircularNestedReference = nestedTypeLocalName === typeLocalName2;
+              if (isCircularNestedReference) {
+                debugContext("preparePropsInterfaceData", `\u26A0 Referencia circular detectada en tipo anidado: "${typeName}" (local: "${typeLocalName2}") -> "${nestedTypeValue}" (local: "${nestedTypeLocalName}"), buscando complexType directamente`);
+                if (allComplexTypes) {
+                  const complexTypeKey = Object.keys(allComplexTypes).find((k) => {
+                    const kLocalName = k.split(":").pop() || k;
+                    return kLocalName === typeLocalName2;
+                  });
+                  if (complexTypeKey) {
+                    const complexType = allComplexTypes[complexTypeKey];
+                    if (complexType && typeof complexType === "object") {
+                      let finalComplexType = complexType;
+                      if ("type" in complexType && typeof complexType.type === "object" && complexType.type !== null) {
+                        finalComplexType = complexType.type;
+                      }
+                      const complexKeys = getFilteredKeys(finalComplexType);
+                      debugContext("preparePropsInterfaceData", `Usando complexType "${complexTypeKey}" con ${complexKeys.length} propiedades: ${complexKeys.join(", ")}`);
+                      const cleanedComplexType = { ...finalComplexType };
+                      Object.keys(cleanedComplexType).forEach((key) => {
+                        if (key.startsWith("_")) {
+                          delete cleanedComplexType[key];
+                        }
+                      });
+                      if (visitedTypes.has(complexTypeKey)) {
+                        debugContext("preparePropsInterfaceData", `\u26A0 ComplexType "${complexTypeKey}" ya fue procesado, evitando recursi\xF3n infinita`);
+                        return {
+                          properties: [],
+                          interfaces: []
+                        };
+                      }
+                      visitedTypes.add(complexTypeKey);
+                      return preparePropsInterfaceData(complexTypeKey, cleanedComplexType, allTypesForInterfaces, schemaObject, allComplexTypes, visitedTypes);
+                    }
+                  }
+                }
+              }
               if (hasOnlyTypeProperty || !hasTypeAndOtherProperties && refKeys.length === 0) {
                 debugContext("preparePropsInterfaceData", `Expandiendo contenido del tipo anidado (wrapper sin otras propiedades)`);
                 if (visitedTypes.has(nestedTypeValue)) {
@@ -25013,6 +25245,44 @@ function preparePropsInterfaceData(typeName, typeObject, allTypesForInterfaces,
           });
           debugContext("preparePropsInterfaceData", `Expandiendo tipo referenciado directamente (sin type anidado)`);
           const referencedTypeId = typeValue || typeName;
+          const typeLocalName = typeName.split(":").pop() || typeName;
+          const referencedTypeLocalName = typeValue ? typeValue.split(":").pop() || typeValue : null;
+          const isCircularReference = referencedTypeLocalName === typeLocalName && "type" in cleanedReferencedElement && typeof cleanedReferencedElement.type === "string" && (cleanedReferencedElement.type === typeValue || cleanedReferencedElement.type.split(":").pop() === typeLocalName);
+          if (isCircularReference) {
+            debugContext("preparePropsInterfaceData", `\u26A0 Referencia circular detectada: "${typeName}" (local: "${typeLocalName}") -> "${typeValue}" (local: "${referencedTypeLocalName}"), buscando complexType directamente`);
+            if (allComplexTypes) {
+              const complexTypeKey = Object.keys(allComplexTypes).find((k) => {
+                const kLocalName = k.split(":").pop() || k;
+                return kLocalName === typeLocalName;
+              });
+              if (complexTypeKey) {
+                const complexType = allComplexTypes[complexTypeKey];
+                if (complexType && typeof complexType === "object") {
+                  let finalComplexType = complexType;
+                  if ("type" in complexType && typeof complexType.type === "object" && complexType.type !== null) {
+                    finalComplexType = complexType.type;
+                  }
+                  const complexKeys = getFilteredKeys(finalComplexType);
+                  debugContext("preparePropsInterfaceData", `Usando complexType "${complexTypeKey}" con ${complexKeys.length} propiedades: ${complexKeys.join(", ")}`);
+                  const cleanedComplexType = { ...finalComplexType };
+                  Object.keys(cleanedComplexType).forEach((key) => {
+                    if (key.startsWith("_")) {
+                      delete cleanedComplexType[key];
+                    }
+                  });
+                  if (visitedTypes.has(complexTypeKey)) {
+                    debugContext("preparePropsInterfaceData", `\u26A0 ComplexType "${complexTypeKey}" ya fue procesado, evitando recursi\xF3n infinita`);
+                    return {
+                      properties: [],
+                      interfaces: []
+                    };
+                  }
+                  visitedTypes.add(complexTypeKey);
+                  return preparePropsInterfaceData(complexTypeKey, cleanedComplexType, allTypesForInterfaces, schemaObject, allComplexTypes, visitedTypes);
+                }
+              }
+            }
+          }
           if (visitedTypes.has(referencedTypeId)) {
             debugContext("preparePropsInterfaceData", `\u26A0 Tipo referenciado "${referencedTypeId}" ya fue procesado, evitando recursi\xF3n infinita`);
             return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@karibulab/wsdl2tsx",
-  "version": "0.23.0",
+  "version": "0.24.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.23.0",
+    "@karibulab/wsdl2tsx-runtime": "0.24.0",
     "axios": "^1.7.9",
     "fast-xml-parser": "5.3.3",
     "handlebars": "4.7.8"