@karibulab/wsdl2tsx 0.7.0 → 0.8.1

package/README.md

@@ -11,7 +11,7 @@ npm install -g @karibulab/wsdl2tsx
 O usar directamente con `npx`:
 
 ```bash
-npx @karibulab/wsdl2tsx <wsdl-url> <directorio-salida>
+npx @karibulab/wsdl2tsx <wsdl-url> <directorio-salida> [--operation=<nombre>]
 ```
 
 ## Uso
@@ -19,27 +19,42 @@ npx @karibulab/wsdl2tsx <wsdl-url> <directorio-salida>
 ### Desde línea de comandos
 
 ```bash
-wsdl2tsx <ruta-wsdl> <directorio-salida>
+wsdl2tsx <ruta-wsdl> <directorio-salida> [--operation=<nombre>]
 ```
 
-**Ejemplo:**
+**Ejemplos:**
 
 ```bash
+# Generar todas las operaciones
 wsdl2tsx http://ejemplo.com/servicio?wsdl ./output
 ```
 
+```bash
+# Generar solo una operación específica
+wsdl2tsx http://ejemplo.com/servicio?wsdl ./output --operation=ConsultaCodigoPlan
+```
+
+```bash
+# Con flag corto
+wsdl2tsx http://ejemplo.com/servicio?wsdl ./output -o ConsultaCodigoPlan
+```
+
 ### Parámetros
 
 - `<ruta-wsdl>`: URL o ruta local al archivo WSDL
 - `<directorio-salida>`: Directorio donde se generarán los archivos TSX
+- `--operation=<nombre>` o `-o <nombre>` (opcional): Especifica el nombre de la operación a generar. Si no se especifica, se generan todas las operaciones con input definido. El nombre debe coincidir exactamente con el nombre de la operación en el WSDL (no es case-sensitive).
 
 ## Características
 
 - ✅ Genera componentes TypeScript/TSX tipados desde WSDL
+- ✅ **Soporta múltiples operaciones**: Genera un archivo TSX por cada operación del WSDL
+- ✅ **Filtrado por operación**: Permite generar solo una operación específica con `--operation` o `-o`
 - ✅ Respeta `elementFormDefault` para manejo correcto de namespaces
 - ✅ Genera interfaces TypeScript para todos los tipos complejos
 - ✅ Soporta múltiples schemas y namespaces
 - ✅ Maneja imports y referencias entre schemas
+- ✅ Omite automáticamente operaciones sin input (notificaciones, solo-output)
 - ✅ Genera código compatible con el runtime `@karibulab/wsdl2tsx-runtime`
 
 ## Ejemplo de salida
@@ -85,9 +100,15 @@ npm run build:cli
 
 # Ejecutar localmente
 cd packages/cli
-node dist/cli.js <wsdl-url> <output-dir>
+node dist/cli.js <wsdl-url> <output-dir> [--operation=<nombre>]
 ```
 
+### Notas sobre operaciones
+
+- **Operaciones sin input**: Las operaciones que no tienen un nodo `input` definido (como notificaciones o operaciones solo-output) se omiten automáticamente con una advertencia.
+- **Múltiples operaciones**: Por defecto, el CLI procesa todas las operaciones válidas y genera un archivo por cada una.
+- **Filtrado**: Usa `--operation` o `-o` para generar solo una operación específica, útil cuando trabajas con WSDL grandes.
+
 ## Licencia
 
 ISC

package/dist/cli.js

@@ -22478,9 +22478,14 @@ var getPortTypeNode = (node) => {
   const portTypeField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?portType/));
   return node[portTypeField];
 };
-var getOperationNode = (node) => {
+var getOperationNodes = (node) => {
   const operationField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?operation/));
-  return node[operationField];
+  if (!operationField) return [];
+  const operationValue = node[operationField];
+  return Array.isArray(operationValue) ? operationValue : operationValue ? [operationValue] : [];
+};
+var getOperationName = (operationNode) => {
+  return operationNode.name || "UnknownOperation";
 };
 var getInputNode = (node) => {
   const inputField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?input/));
@@ -22490,21 +22495,14 @@ var getPartNode = (node) => {
   const partField = Object.keys(node).find((objectField) => objectField.match(/([a-zA-z0-9]*:)?part/));
   return node[partField];
 };
-var getRequestTypeFromDefinitions = (definitionsNode, schemaObject) => {
-  const portTypeNode = getPortTypeNode(definitionsNode);
-  if (!portTypeNode) {
-    throw new Error("No se encontr\xF3 el nodo portType en las definiciones del WSDL");
-  }
-  const operationNode = getOperationNode(portTypeNode);
-  if (!operationNode) {
-    throw new Error("No se encontr\xF3 el nodo operation en el portType");
-  }
+var getRequestTypeFromOperation = (operationNode, definitionsNode, schemaObject) => {
+  const operationName = getOperationName(operationNode);
   const inputNode = getInputNode(operationNode);
   if (!inputNode) {
-    throw new Error("No se encontr\xF3 el nodo input en la operaci\xF3n");
+    return null;
   }
   if (!inputNode.message) {
-    throw new Error("El nodo input no tiene el atributo message definido");
+    throw new Error(`El nodo input de la operaci\xF3n '${operationName}' no tiene el atributo message definido`);
   }
   const messageNode = getMessageNode(definitionsNode);
   if (!messageNode || messageNode.length === 0) {
@@ -22516,10 +22514,10 @@ var getRequestTypeFromDefinitions = (definitionsNode, schemaObject) => {
   }
   const partNode = getPartNode(inputMessageNode);
   if (!partNode) {
-    throw new Error("No se encontr\xF3 el nodo part en el mensaje de entrada");
+    throw new Error(`No se encontr\xF3 el nodo part en el mensaje de entrada de la operaci\xF3n '${operationName}'`);
   }
   if (!partNode.element) {
-    throw new Error("El nodo part no tiene el atributo element definido");
+    throw new Error(`El nodo part de la operaci\xF3n '${operationName}' no tiene el atributo element definido`);
   }
   const definitionsNamespaces = getNamespacesFromNode(definitionsNode);
   let elementName = partNode.element;
@@ -22538,10 +22536,10 @@ var getRequestTypeFromDefinitions = (definitionsNode, schemaObject) => {
   if (!requestType) {
     const availableTypes = Object.keys(schemaObject).filter((k) => k !== "$namespace").join(", ");
     throw new Error(
-      `No se encontr\xF3 el tipo de solicitud '${partNode.element}' (resuelto: '${resolvedElementName}') en el schema. Tipos disponibles: ${availableTypes || "ninguno"}`
+      `No se encontr\xF3 el tipo de solicitud '${partNode.element}' (resuelto: '${resolvedElementName}') para la operaci\xF3n '${operationName}'. Tipos disponibles: ${availableTypes || "ninguno"}`
     );
   }
-  return requestType;
+  return { operationName, requestType };
 };
 var getNamespacesFromNode = (node) => {
   const namespaces = /* @__PURE__ */ new Map();
@@ -23329,7 +23327,7 @@ function compileTemplate(templateData) {
   }
   return compiledTemplate(templateData);
 }
-async function generateTsxFromWsdl(wsdlPath, outDir) {
+async function generateTsxFromWsdl(wsdlPath, outDir, operationName) {
   const wsdlRoot = await loadXml(wsdlPath);
   const definitionsNode = getDefinitionsNode(wsdlRoot);
   if (!definitionsNode) {
@@ -23411,101 +23409,188 @@ Schema [${i}] (targetNamespace: ${schemaNode.targetNamespace || "no definido"}):
     }
     throw new Error(errorMsg);
   }
-  const requestType = getRequestTypeFromDefinitions(definitionsNode, schemaObject);
-  if (!requestType) {
-    throw new Error("No se pudo determinar el tipo de solicitud desde las definiciones del WSDL");
-  }
-  const requestTypeObject = schemaObject[requestType];
-  if (!requestTypeObject) {
-    throw new Error(`No se encontr\xF3 el objeto de tipo ${requestType} en el schema`);
-  }
-  if (!requestTypeObject["$namespace"] && schemaObject["$namespace"]) {
-    requestTypeObject["$namespace"] = schemaObject["$namespace"];
-  }
-  if (!requestTypeObject["$namespace"]) {
-    throw new Error(`El tipo ${requestType} no tiene namespace definido`);
-  }
-  if (Object.keys(allComplexTypes).length > 0) {
-  }
-  const allTypesForInterfaces = { ...requestTypeObject };
-  const findReferencedTypes = (obj, found = /* @__PURE__ */ new Set(), depth = 0) => {
-    const indent = "  ".repeat(depth);
-    for (const [key, value] of Object.entries(obj)) {
-      if (key === "$namespace" || key === "$base") continue;
-      if (typeof value === "object" && value !== null && "type" in value) {
-        const typeValue = value.type;
-        if (typeof typeValue === "string") {
-          const matchingType = Object.keys(allComplexTypes).find(
-            (k) => k === typeValue || k.endsWith(":" + typeValue.split(":").pop()) || k.split(":").pop() === typeValue.split(":").pop()
-          );
-          if (matchingType && !found.has(matchingType)) {
-            found.add(matchingType);
-            if (allComplexTypes[matchingType]) {
-              findReferencedTypes(allComplexTypes[matchingType], found, depth + 1);
+  const portTypeNode = getPortTypeNode(definitionsNode);
+  if (!portTypeNode) {
+    throw new Error("No se encontr\xF3 el nodo portType en las definiciones del WSDL");
+  }
+  const operationNodes = getOperationNodes(portTypeNode);
+  if (operationNodes.length === 0) {
+    throw new Error("No se encontraron operaciones en el portType");
+  }
+  const operationsToProcess = operationName ? operationNodes.filter((op) => {
+    const opName = getOperationName(op);
+    return opName === operationName || opName.toLowerCase() === operationName.toLowerCase();
+  }) : operationNodes;
+  if (operationName && operationsToProcess.length === 0) {
+    const availableOps = operationNodes.map((op) => getOperationName(op)).join(", ");
+    throw new Error(
+      `No se encontr\xF3 la operaci\xF3n '${operationName}'. Operaciones disponibles: ${availableOps || "ninguna"}`
+    );
+  }
+  const processOperation = (operationNode) => {
+    const operationInfo = getRequestTypeFromOperation(operationNode, definitionsNode, schemaObject);
+    if (!operationInfo) {
+      const opName2 = getOperationName(operationNode);
+      console.warn(`\u26A0\uFE0F  Operaci\xF3n '${opName2}' no tiene input, se omite`);
+      return;
+    }
+    const { operationName: opName, requestType } = operationInfo;
+    const requestTypeObject = schemaObject[requestType];
+    if (!requestTypeObject) {
+      throw new Error(`No se encontr\xF3 el objeto de tipo ${requestType} en el schema para la operaci\xF3n '${opName}'`);
+    }
+    if (!requestTypeObject["$namespace"] && schemaObject["$namespace"]) {
+      requestTypeObject["$namespace"] = schemaObject["$namespace"];
+    }
+    if (!requestTypeObject["$namespace"]) {
+      throw new Error(`El tipo ${requestType} no tiene namespace definido para la operaci\xF3n '${opName}'`);
+    }
+    const allTypesForInterfaces = { ...requestTypeObject };
+    const findReferencedTypes = (obj, found = /* @__PURE__ */ new Set(), depth = 0) => {
+      for (const [key, value] of Object.entries(obj)) {
+        if (key === "$namespace" || key === "$base") continue;
+        if (typeof value === "object" && value !== null && "type" in value) {
+          const typeValue = value.type;
+          if (typeof typeValue === "string") {
+            const matchingType = Object.keys(allComplexTypes).find(
+              (k) => k === typeValue || k.endsWith(":" + typeValue.split(":").pop()) || k.split(":").pop() === typeValue.split(":").pop()
+            );
+            if (matchingType && !found.has(matchingType)) {
+              found.add(matchingType);
+              if (allComplexTypes[matchingType]) {
+                findReferencedTypes(allComplexTypes[matchingType], found, depth + 1);
+              }
+            } else if (matchingType && found.has(matchingType)) {
             }
-          } else if (matchingType && found.has(matchingType)) {
+          } else if (typeof typeValue === "object" && typeValue !== null) {
+            findReferencedTypes(typeValue, found, depth + 1);
           }
-        } else if (typeof typeValue === "object" && typeValue !== null) {
-          findReferencedTypes(typeValue, found, depth + 1);
         }
       }
-    }
-    return found;
+      return found;
+    };
+    const referencedTypeNames = findReferencedTypes(requestTypeObject);
+    for (const typeName of referencedTypeNames) {
+      if (!allTypesForInterfaces[typeName] && allComplexTypes[typeName]) {
+        allTypesForInterfaces[typeName] = allComplexTypes[typeName];
+      }
+    }
+    for (const [typeName, typeDef] of Object.entries(allComplexTypes)) {
+      if (!allTypesForInterfaces[typeName]) {
+        allTypesForInterfaces[typeName] = typeDef;
+      }
+    }
+    const namespaceMappings = extractAllNamespaceMappings(requestType, requestTypeObject);
+    const namespacesTagsMapping = namespaceMappings.tagsMapping;
+    const namespacesPrefixMapping = namespaceMappings.prefixesMapping;
+    const namespacesTypeMapping = namespaceMappings.typesMapping;
+    const baseNamespacePrefix = namespacesTypeMapping[requestType].prefix;
+    const templateData = prepareTemplateData(
+      requestType,
+      requestTypeObject,
+      // Usar requestTypeObject original para propsInterface
+      namespacesTagsMapping,
+      namespacesPrefixMapping,
+      namespacesTypeMapping,
+      soapNamespaceURI,
+      baseNamespacePrefix,
+      allTypesForInterfaces
+      // Pasar allTypesForInterfaces como parámetro adicional para interfaces
+    );
+    const generatedCode = compileTemplate(templateData);
+    const typeNameForFile = opName;
+    if (!import_fs2.default.existsSync(outDir)) {
+      import_fs2.default.mkdirSync(outDir, { recursive: true });
+    }
+    const outputPath = import_path2.default.join(outDir, `${typeNameForFile}.tsx`);
+    import_fs2.default.writeFileSync(outputPath, generatedCode);
+    console.log(`\u2705 Archivo ${typeNameForFile}.tsx generado correctamente en ${outDir}`);
   };
-  const referencedTypeNames = findReferencedTypes(requestTypeObject);
-  if (referencedTypeNames.size > 0) {
-  }
-  for (const typeName of referencedTypeNames) {
-    if (!allTypesForInterfaces[typeName] && allComplexTypes[typeName]) {
-      allTypesForInterfaces[typeName] = allComplexTypes[typeName];
-    }
-  }
-  for (const [typeName, typeDef] of Object.entries(allComplexTypes)) {
-    if (!allTypesForInterfaces[typeName]) {
-      allTypesForInterfaces[typeName] = typeDef;
-    }
-  }
-  const namespaceMappings = extractAllNamespaceMappings(requestType, requestTypeObject);
-  const namespacesTagsMapping = namespaceMappings.tagsMapping;
-  const namespacesPrefixMapping = namespaceMappings.prefixesMapping;
-  const namespacesTypeMapping = namespaceMappings.typesMapping;
-  const baseNamespacePrefix = namespacesTypeMapping[requestType].prefix;
-  const templateData = prepareTemplateData(
-    requestType,
-    requestTypeObject,
-    // Usar requestTypeObject original para propsInterface
-    namespacesTagsMapping,
-    namespacesPrefixMapping,
-    namespacesTypeMapping,
-    soapNamespaceURI,
-    baseNamespacePrefix,
-    allTypesForInterfaces
-    // Pasar allTypesForInterfaces como parámetro adicional para interfaces
-  );
-  if (templateData.interfaces.length > 0) {
+  let generatedCount = 0;
+  for (const operationNode of operationsToProcess) {
+    try {
+      processOperation(operationNode);
+      generatedCount++;
+    } catch (error) {
+      const opName = getOperationName(operationNode);
+      console.error(`\u274C Error al procesar operaci\xF3n '${opName}':`, error.message);
+      if (operationName) {
+        throw error;
+      }
+    }
   }
-  const generatedCode = compileTemplate(templateData);
-  const typeNameForFile = requestType.includes(":") ? requestType.split(":").pop() : requestType;
-  if (!import_fs2.default.existsSync(outDir)) {
-    import_fs2.default.mkdirSync(outDir, { recursive: true });
+  if (generatedCount === 0) {
+    throw new Error("No se gener\xF3 ning\xFAn archivo. Verifica que las operaciones tengan input definido.");
   }
-  const outputPath = import_path2.default.join(outDir, `${typeNameForFile}.tsx`);
-  import_fs2.default.writeFileSync(outputPath, generatedCode);
-  console.log(`Archivo ${typeNameForFile}.tsx generado correctamente en ${outDir}`);
+  console.log(`
+\u2728 Proceso completado: ${generatedCount} archivo(s) generado(s)`);
 }
 
 // src/cli.ts
 console.log("wsdl2tsx CLI - Generador de c\xF3digo TSX desde WSDL");
-var WSDL_PATH = process.argv[2];
-var OUT_DIR = process.argv[3];
-if (!WSDL_PATH || !OUT_DIR) {
-  console.error("Uso: tsx cli/generate-tsx.ts <ruta-wsdl> <directorio-salida>");
-  process.exit(1);
+function parseArgs() {
+  const args = process.argv.slice(2);
+  let wsdlPath;
+  let outDir;
+  let operationName;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--operation" || arg === "-o") {
+      if (i + 1 < args.length && !args[i + 1].startsWith("-")) {
+        const value = args[i + 1];
+        if (!value || value.trim() === "") {
+          throw new Error(`El flag ${arg} requiere un valor no vac\xEDo`);
+        }
+        operationName = value;
+        i++;
+      } else {
+        throw new Error(`El flag ${arg} requiere un valor`);
+      }
+    } else if (arg.startsWith("--operation=")) {
+      const value = arg.split("=")[1];
+      if (!value || value.trim() === "") {
+        throw new Error("El flag --operation requiere un valor no vac\xEDo");
+      }
+      operationName = value;
+    } else if (arg.startsWith("-o=")) {
+      const value = arg.split("=")[1];
+      if (!value || value.trim() === "") {
+        throw new Error("El flag -o requiere un valor no vac\xEDo");
+      }
+      operationName = value;
+    } else if (!wsdlPath) {
+      wsdlPath = arg;
+    } else if (!outDir) {
+      outDir = arg;
+    } else {
+      if (!operationName) {
+        operationName = arg;
+      }
+    }
+  }
+  return { wsdlPath, outDir, operationName };
 }
-generateTsxFromWsdl(WSDL_PATH, OUT_DIR).catch((error) => {
-  console.error("Error al generar TSX:", error);
+try {
+  const { wsdlPath, outDir, operationName } = parseArgs();
+  if (!wsdlPath || !outDir) {
+    console.error("Uso: wsdl2tsx <ruta-wsdl> <directorio-salida> [--operation=<nombre>]");
+    console.error("  --operation, -o: Especifica el nombre de la operaci\xF3n a generar");
+    console.error("  Si no se especifica --operation, se generan todas las operaciones");
+    console.error("");
+    console.error("Ejemplos:");
+    console.error("  wsdl2tsx wsdl.xml output/");
+    console.error("  wsdl2tsx wsdl.xml output/ --operation=Add");
+    console.error("  wsdl2tsx wsdl.xml output/ -o Add");
+    process.exit(1);
+  }
+  generateTsxFromWsdl(wsdlPath, outDir, operationName).catch((error) => {
+    console.error("Error al generar TSX:", error);
+    process.exit(1);
+  });
+} catch (error) {
+  console.error("Error al parsear argumentos:", error.message);
   process.exit(1);
-});
+}
 /*! Bundled license information:
 
 mime-db/index.js:

package/package.json

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