@techspokes/typescript-wsdl-client 0.3.0 → 0.4.2

package/dist/emit/clientEmitter.js

@@ -1,24 +1,7 @@
+// noinspection UnreachableCodeJS,JSUnusedLocalSymbols
 import fs from "node:fs";
-import { pascal } from "../util/xml.js";
-export function emitClient(outFile, compiled, opts) {
-    const ext = opts.importExt ?? ".js";
-    const lines = [];
-    lines.push(`import { createSoapClient, toSoapArgs, fromSoapResult } from "./runtime${ext}";`);
-    lines.push(`import { ATTR_SPEC, CHILD_TYPE, PROP_META } from "./meta${ext}";`);
-    lines.push(`import type * as T from "./types${ext}";`);
-    lines.push("");
-    // Derive class name: prefer explicit override, else WSDL service name, else base filename, else default
-    const overrideName = (opts.clientName || "").trim();
-    const svcName = compiled.serviceName && pascal(compiled.serviceName);
-    const fileBase = (() => {
-        const uri = compiled.wsdlUri || "";
-        // extract last path segment and strip extension for both URL and file path
-        const seg = uri.split(/[\\/]/).pop() || "";
-        const noExt = seg.replace(/\.[^.]+$/, "");
-        return noExt ? pascal(noExt) : "";
-    })();
-    const className = overrideName || ((svcName || fileBase) ? `${svcName || fileBase}SoapClient` : "GeneratedSoapClient");
-    // Helpers for emitting safe method names
+import { pascal, deriveClientName, pascalToSnakeCase } from "../util/tools.js";
+export function emitClient(outFile, compiled) {
     const isValidIdent = (name) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name);
     const reserved = new Set([
         "break", "case", "catch", "class", "const", "continue", "debugger", "default", "delete",
@@ -27,42 +10,344 @@ export function emitClient(outFile, compiled, opts) {
         "true", "try", "typeof", "var", "void", "while", "with", "as", "implements", "interface",
         "let", "package", "private", "protected", "public", "static", "yield", "constructor"
     ]);
-    lines.push(`export class ${className} {`);
-    lines.push(`  constructor(private source: string | any, private attributesKey: string = "${opts.attributesKey || "$attributes"}") {}`);
-    lines.push(`  async _client() {`);
-    lines.push(`    if (typeof this.source === 'string') return createSoapClient({ wsdlUrl: this.source });`);
-    lines.push(`    return this.source;`);
-    lines.push(`  }`);
+    const ext = compiled.options.imports ?? "bare";
+    const suffix = ("bare" === ext) ? "" : `.${ext}`;
+    const methods = [];
+    // get the class name for the client
+    const clientName = deriveClientName(compiled);
+    const clientConstant = pascalToSnakeCase(clientName).toUpperCase();
+    // Build the dynamic methods for the client class
     for (const op of compiled.operations) {
-        const m = op.name;
+        const m = isValidIdent(op.name) && !reserved.has(op.name)
+            ? op.name
+            : `[${JSON.stringify(op.name)}]`;
         const inTypeName = op.inputElement ? pascal(op.inputElement.local) : undefined;
         const outTypeName = op.outputElement ? pascal(op.outputElement.local) : undefined;
         const inTs = inTypeName ? `T.${inTypeName}` : `any`;
         const outTs = outTypeName ? `T.${outTypeName}` : `any`;
-        const inMetaKey = inTypeName ?? m;
-        const outMetaKey = outTypeName ?? m;
         const secHints = Array.isArray(op.security) && op.security.length ? op.security : [];
-        const methodHeader = (isValidIdent(m) && !reserved.has(m))
-            ? `  async ${m}(args: ${inTs}): Promise<${outTs}> {`
-            : `  async [${JSON.stringify(m)}](args: ${inTs}): Promise<${outTs}> {`;
-        const clientCall = (isValidIdent(m) && !reserved.has(m))
-            ? `c.${m}`
-            : `c[${JSON.stringify(m)}]`;
-        lines.push(`  /** SOAPAction: ${op.soapAction}${secHints.length ? `\n   * Security (WSDL policy hint): ${secHints.join(", ")}` : ""} */`);
-        lines.push(methodHeader);
-        lines.push(`    const c: any = await this._client();`);
-        if (secHints.length) {
-            lines.push(`    if (!c || !c.security) { console.warn("[wsdl-client] Operation '${m}' may require security: ${secHints.join(", ")}. Configure client.setSecurity(...) or pass { security } to createSoapClient()."); }`);
+        const secHintsStr = secHints.length ? `\n   *\n   * Security (WSDL policy hint): ${secHints.join(", ")}` : "";
+        const methodTemplate = `
+
+  /**
+   * Calls the ${m} operation of the ${clientName}.${secHintsStr}
+   *
+   * @param args - The request arguments for the ${m} operation.
+   * @returns A promise resolving to the operation response containing data, headers, response raw XML, and request raw XML.
+   */
+  async ${m}<HeadersType = Record<string, unknown>>(
+    args: ${inTs}
+  ): Promise<${clientName}Response<${outTs}, HeadersType>> {
+    return this.call<${inTs}, ${outTs}, HeadersType>(
+      args,
+      ${JSON.stringify(m)},
+      ${JSON.stringify(m)}
+    );
+  }`;
+        methods.push(methodTemplate);
+    }
+    const methodsBody = methods.join("\n");
+    // noinspection JSFileReferences,JSUnresolvedReference,CommaExpressionJS,JSDuplicatedDeclaration,ReservedWordAsName,JSCommentMatchesSignature,JSValidateTypes,JSIgnoredPromiseFromCall,BadExpressionStatementJS,ES6UnusedImports,JSUnnecessarySemicolon
+    const classTemplate = `// noinspection JSAnnotator
+
+/**
+ * Generated ${clientName} client class.
+ * This class wraps the node-soap client and provides strongly-typed methods for each operation.
+ */
+import * as soap from "soap";
+import type * as T from "./types${suffix}";
+import type {${clientName}DataTypes} from "./utils${suffix}";
+import {${clientConstant}_DATA_TYPES} from "./utils${suffix}";
+
+/**
+ * Represents the response structure for ${clientName} operations.
+ * Contains the response object, SOAP headers object, and raw response/request XML.
+ *
+ * @typeParam ResponseType - The type of the response data.
+ * @typeParam HeadersType - The type of the headers (default: Record<string, unknown>).
+ */
+export type ${clientName}Response<ResponseType, HeadersType = Record<string, unknown>> = {
+  response: ResponseType;
+  headers: HeadersType;
+  responseRaw: string;
+  requestRaw: string;
+}
+
+/**
+ * @class ${clientName}
+ *
+ * Represents a SOAP client wrapper around the ${clientName} service.
+ * Provides async methods for each operation defined in the WSDL.
+ * Handles serialization/deserialization of request/response data
+ * according to the WSDL-defined data types.
+ * Supports security settings (hints) and custom attribute handling.
+ *
+ * @property source - The WSDL URL or local file path to use.
+ * @property options - Optional SOAP client configuration options.
+ * @property security - Optional SOAP security settings to apply.
+ * @property attributesKeyIn - Key name for input attribute bags (default: "$attributes").
+ * @property attributesKeyOut - Key name for output attribute bags (default: "attributes").
+ * @property client - The underlying node-soap client instance.
+ * @property dataTypes - Metadata for data types used in serialization/deserialization.
+ * @property dataTypes.Attributes - Maps type names to lists of property names that should be treated as XML attributes.
+ * @property dataTypes.ChildrenTypes - Maps type names to their child element types for recursive processing.
+ *
+ *
+ * @note Have fun with the generated client! If TechSpokes made your day (or a week),
+ *      please consider supporting this project: https://github.com/TechSpokes/typescript-wsdl-client?tab=readme-ov-file#readme
+ *      Thanks for using it!
+ *
+ *      Cheers,
+ *      Serge Liatko, TechSpokes, https://www.techspokes.com | https://www.techspokes.store
+ *      https://www.linkedin.com/in/sergeliatko/ | https://www.linkedin.com/company/techspokes/
+ *
+ * @license MIT
+ */
+export class ${clientName} {
+  protected source: string;
+  protected options?: soap.IOptions;
+  protected security?: soap.ISecurity;
+  protected attributesKeyIn: string;
+  protected attributesKeyOut: string;
+  protected client?: soap.Client;
+  protected dataTypes: ${clientName}DataTypes = ${clientConstant}_DATA_TYPES;
+
+  /**
+   * Creates a new ${clientName} instance.
+   *
+   * @param options - Configuration options for the service.
+   * @param options.source - The WSDL URL or local file path to use.
+   * @param [options.options] - Optional SOAP client configuration options.
+   * @param [options.security] - Optional SOAP security settings to apply.
+   * @param [options.attributesKeyIn] - Key name for input attribute bags (default: "$attributes").
+   * @param [options.attributesKeyOut] - Key name for output attribute bags (default: "attributes").
+   */
+  constructor(options: {
+    source: string,
+    options?: soap.IOptions,
+    security?: soap.ISecurity,
+    attributesKeyIn?: string,
+    attributesKeyOut?: string
+  }) {
+    this.source = options.source;
+    this.attributesKeyIn = options.attributesKeyIn ?? "$attributes";
+    this.attributesKeyOut = options.attributesKeyOut ?? "attributes";
+    if (options.options) {
+      this.options = options.options;
+    }
+    if (options.security) {
+      this.security = options.security;
+    }
+  }
+
+  /**
+   * Lazily initializes and returns the underlying SOAP client.
+   * If the client is not yet created or its WSDL is missing, a new client is instantiated.
+   *
+   * @returns The initialized SOAP client instance.
+   * @throws Error if the WSDL source is invalid or client creation fails.
+   */
+  async soapClient(): Promise<soap.Client> {
+    // If client is not initialized or has no WSDL source, create a new one
+    if (!this.client || !this.client.wsdl) {
+      // Note: source can be a URL or a local WSDL file path
+      if (!this.source) {
+        throw new Error("WSDL source must be a non-empty string URL or file path.");
+      }
+      try {
+        // Create the SOAP client using the provided source and options
+        this.client = await soap.createClientAsync(this.source, this.options || {});
+        if (this.security) {
+          this.client.setSecurity(this.security);
+        }
+      } catch (e) {
+        throw new Error("Error creating SOAP client: " + (e instanceof Error ? e.message : String(e)));
+      }
+    }
+    return this.client;
+  }
+${methodsBody}
+
+  /**
+   * Calls a specified SOAP operation with the provided arguments and response type.
+   *
+   * @param args - The request arguments/payload for the operation.
+   * @param operation - The name of the SOAP operation to invoke.
+   * @param responseType - The metadata type name for response deserialization.
+   * @returns A promise resolving to the operation response containing data, headers, and raw XML.
+   * @throws Error if the specified operation is not found on the SOAP client.
+   */
+  protected async call<RequestType, ResponseType, HeadersType>(
+    args: RequestType,
+    operation: string,
+    responseType: string
+  ): Promise<${clientName}Response<ResponseType, HeadersType>> {
+    const client = await this.soapClient();
+    if (!client[operation] || typeof client[operation] !== "function") {
+      throw new Error("Operation not found on SOAP client: " + operation);
+    }
+    // Convert TypeScript object to the format expected by node-soap
+    const soapArgs = this.toSoapArgs(args, responseType);
+    return new Promise((resolve, reject) => {
+      client[operation](soapArgs, (err: any, result: any, rawResponse: string, soapHeader: any, rawRequest: string) => {
+        if (err) {
+          reject(err);
+        } else {
+          // Convert the SOAP response back to TypeScript object
+          const response = this.fromSoapResult(result, responseType);
+          resolve({
+            response,
+            headers: soapHeader || {},
+            responseRaw: rawResponse,
+            requestRaw: rawRequest
+          });
         }
-        lines.push(`    const meta = { ATTR_SPEC, CHILD_TYPE, PROP_META } as const;`);
-        lines.push(`    const soapArgs = toSoapArgs(args as any, ${JSON.stringify(inMetaKey)}, meta, this.attributesKey);`);
-        lines.push(`    return new Promise((resolve, reject) => {`);
-        lines.push(`      ${clientCall}(soapArgs, (err: any, result: any) => {`);
-        lines.push(`        if (err) reject(err); else resolve(fromSoapResult(result, ${JSON.stringify(outMetaKey)}, meta, this.attributesKey));`);
-        lines.push(`      });`);
-        lines.push(`    });`);
-        lines.push(`  }`);
-    }
-    lines.push(`}`);
-    fs.writeFileSync(outFile, lines.join("\n"), "utf8");
+      });
+    });
+  }
+
+  /**
+   * Converts TypeScript objects to the format expected by node-soap for SOAP requests.
+   * Handles the conversion of object properties to XML attributes and elements based on metadata.
+   *
+   * @param value - The value to convert (object, array, or primitive)
+   * @param typeName - Optional type name for metadata lookup
+   * @returns Converted value ready for SOAP serialization
+   */
+  protected toSoapArgs(value: any, typeName?: string): any {
+    // Pass through null/undefined unchanged
+    if (value == null) {
+      return value;
+    }
+    // Pass through primitives (string, number, boolean) unchanged
+    if (typeof value !== "object") {
+      return value;
+    }
+    // Recursively process array elements with same type context
+    if (Array.isArray(value)) {
+      return value.map(v => this.toSoapArgs(v, typeName));
+    }
+
+    /**
+     * Normalizes values to strings for XML attribute serialization.
+     * Handles null, boolean, number, and other types appropriately.
+     */
+    const normalize = (v: unknown): string => {
+      if (v == null) return "";
+      if (typeof v === "boolean") return v ? "true" : "false";
+      if (typeof v === "number") return Number.isFinite(v) ? String(v) : "";
+      return String(v);
+    };
+
+    // Get metadata for this specific type to know which props are attributes
+    const attributesList = (typeName && this.dataTypes?.Attributes?.[typeName]) || [];
+    const childrenTypes = (typeName && this.dataTypes?.ChildrenTypes?.[typeName]) || {};
+
+    const out: any = {};
+    const attributesBag: Record<string, any> = {};
+
+    // Preserve text content for mixed XML elements (text + child elements)
+    if ("$value" in value) {
+      out.$value = (value as any).$value;
+    }
+
+    // Extract pre-existing attributes from input object's attribute bag
+    const inAttrNode = (value as any)[this.attributesKeyIn] ?? (value as any)["attributes"];
+    if (inAttrNode && typeof inAttrNode === "object") {
+      // Normalize all attribute values to strings for XML serialization
+      for (const [ak, av] of Object.entries(inAttrNode)) {
+        attributesBag[ak] = normalize(av);
+      }
+    }
+
+    // Categorize each property as either XML attribute or child element
+    for (const [k, v] of Object.entries<any>(value)) {
+      // Skip special properties that are handled separately above
+      if (k === "$value" || k === this.attributesKeyIn || k === "attributes") {
+        continue;
+      }
+
+      // Check metadata to see if this property should be an XML attribute
+      if (attributesList.includes(k)) {
+        attributesBag[k] = normalize(v);
+        continue;
+      }
+
+      // Everything else becomes a child element, recursively processed
+      const childType = (childrenTypes as any)[k] as string | undefined;
+      out[k] = Array.isArray(v)
+        ? v.map(node => this.toSoapArgs(node, childType))
+        : this.toSoapArgs(v, childType);
+    }
+
+    // Only add attributes bag if we actually have attributes to serialize
+    if (Object.keys(attributesBag).length) {
+      out[this.attributesKeyOut] = attributesBag; // renders as XML attributes
+    }
+
+    return out;
+  }
+
+  /**
+   * Converts SOAP response nodes into application DTOs based on metadata mapping.
+   *
+   * @param node - The raw SOAP response node.
+   * @param typeName - Optional metadata key to guide deserialization.
+   * @returns The deserialized object matching your DTO shape.
+   */
+  protected fromSoapResult(node: any, typeName?: string): any {
+    // Pass through null/undefined unchanged
+    if (node == null) {
+      return node;
+    }
+    // Pass through primitives unchanged
+    if (typeof node !== "object") {
+      return node;
+    }
+    // Recursively process array elements
+    if (Array.isArray(node)) {
+      return node.map(n => this.fromSoapResult(n, typeName));
+    }
+
+    // Get child type mapping for recursive processing with correct types
+    const childrenTypes = (typeName && this.dataTypes?.ChildrenTypes?.[typeName]) || {};
+    const result: any = {};
+
+    // Preserve text content for mixed XML elements
+    if ("$value" in node) {
+      result.$value = (node as any).$value;
+    }
+
+    // Extract attributes from various node-soap attribute containers
+    // Different SOAP parsers may use "attributes", "$", or custom keys
+    const inAttrNode = (node as any)[this.attributesKeyOut] || (node as any)["attributes"] || (node as any)["$"];
+    if (inAttrNode && typeof inAttrNode === "object") {
+      // Promote all attributes to top-level properties for easier TS access
+      Object.assign(result, inAttrNode);
+    }
+
+    // Process remaining properties as child elements
+    for (const [k, v] of Object.entries<any>(node)) {
+      // Skip all possible attribute containers and special properties
+      if (k === this.attributesKeyOut || k === "attributes" || k === "$" || k === "$value") {
+        continue;
+      }
+      // Recursively convert child elements with their specific type info
+      const childType = (childrenTypes as any)[k] as string | undefined;
+      result[k] = Array.isArray(v)
+        ? v.map(node => this.fromSoapResult(node, childType))
+        : this.fromSoapResult(v, childType);
+    }
+
+    return result;
+  }
+}
+`;
+    try {
+        fs.writeFileSync(outFile, classTemplate.replace(`// noinspection JSAnnotator\n\n`, ''), "utf8");
+        console.log(`Client class written to ${outFile}`);
+    }
+    catch (e) {
+        console.log(`Failed to write catalog to ${outFile}`);
+    }
 }

package/dist/emit/typesEmitter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typesEmitter.d.ts","sourceRoot":"","sources":["../../src/emit/typesEmitter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,eAAe,EAAe,MAAM,+BAA+B,CAAC;AAEjF;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,eAAe,QA2InE"}
+{"version":3,"file":"typesEmitter.d.ts","sourceRoot":"","sources":["../../src/emit/typesEmitter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,eAAe,EAAe,MAAM,+BAA+B,CAAC;AAEjF;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,eAAe,QAgJnE"}

package/dist/emit/typesEmitter.js

@@ -135,5 +135,11 @@ export function emitTypes(outFile, compiled) {
         lines.push("}");
         lines.push("");
     }
-    fs.writeFileSync(outFile, lines.join("\n"), "utf8");
+    try {
+        fs.writeFileSync(outFile, lines.join("\n"), "utf8");
+        console.log(`Types written to ${outFile}`);
+    }
+    catch (e) {
+        console.error(`Failed to write types to ${outFile}:`, e);
+    }
 }

package/dist/emit/utilsEmitter.d.ts

@@ -0,0 +1,3 @@
+import type { CompiledCatalog } from "../compiler/schemaCompiler.js";
+export declare function emitUtils(outFile: string, compiled: CompiledCatalog): void;
+//# sourceMappingURL=utilsEmitter.d.ts.map

package/dist/emit/utilsEmitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utilsEmitter.d.ts","sourceRoot":"","sources":["../../src/emit/utilsEmitter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,+BAA+B,CAAC;AAGnE,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,eAAe,QAiCnE"}

package/dist/emit/utilsEmitter.js

@@ -0,0 +1,33 @@
+import fs from "node:fs";
+import { deriveClientName, pascalToSnakeCase } from "../util/tools.js";
+export function emitUtils(outFile, compiled) {
+    const clientName = deriveClientName(compiled);
+    const clientConstant = pascalToSnakeCase(clientName).toUpperCase();
+    const { attrSpec, childType } = compiled.meta;
+    if (!attrSpec || !childType) {
+        throw new Error("Metadata not found in compiled catalog. Ensure schemaCompiler runs before metaEmitter.");
+    }
+    if (typeof attrSpec !== "object" || typeof childType !== "object") {
+        throw new Error("Invalid metadata structure. Expected objects for Attributes and ChildrenTypes.");
+    }
+    const metas = JSON.stringify({ Attributes: attrSpec, ChildrenTypes: childType }, null, 2);
+    const dataTypes = `/**
+ * ${clientName} WSDL data types for proper serialization/deserialization.
+ * Used to distinguish between XML attributes and elements during conversion.
+ */
+export interface ${clientName}DataTypes {
+  /** Maps type names to lists of property names that should be treated as XML attributes */
+  Attributes: Record<string, readonly string[]>;
+  /** Maps type names to their child element types for recursive processing */
+  ChildrenTypes: Record<string, Readonly<Record<string, string>>>;
+}
+
+export const ${clientConstant}_DATA_TYPES: ${clientName}DataTypes = ${metas} as const;\n`;
+    try {
+        fs.writeFileSync(outFile, dataTypes, "utf8");
+        console.log(`Utils written to ${outFile}`);
+    }
+    catch (e) {
+        console.error(`Failed to write utils to ${outFile}:`, e);
+    }
+}

package/dist/index.d.ts

@@ -4,8 +4,4 @@ export declare function compileWsdlToProject(input: {
     outDir: string;
     options?: CompilerOptions;
 }): Promise<void>;
-export { compileCatalog } from "./compiler/schemaCompiler.js";
-export type { PrimitiveOptions } from "./xsd/primitives.js";
-export { xsdToTsPrimitive } from "./xsd/primitives.js";
-export type { CompilerOptions } from "./config.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAcnD,wBAAsB,oBAAoB,CACtC,KAAK,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,eAAe,CAAA;CAAE,iBA6CrE;AAGD,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,YAAY,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACvD,YAAY,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,aAAa,CAAC;AAUjD,wBAAsB,oBAAoB,CACxC,KAAK,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,eAAe,CAAA;CAAE,iBAsDnE"}

package/dist/index.js

@@ -1,57 +1,60 @@
-import { defaultOptions } from "./config.js";
+import fs from "node:fs";
+import path from "node:path";
 import { loadWsdl } from "./loader/wsdlLoader.js";
 import { compileCatalog } from "./compiler/schemaCompiler.js";
 import { emitTypes } from "./emit/typesEmitter.js";
-import { emitMeta } from "./emit/metaEmitter.js";
-import { emitOperations } from "./emit/opsEmitter.js";
+import { emitUtils } from "./emit/utilsEmitter.js";
+import { emitCatalog } from "./emit/catalogEmitter.js";
 import { emitClient } from "./emit/clientEmitter.js";
-import { emitRuntime } from "./emit/runtimeEmitter.js";
-import fs from "node:fs";
-import path from "node:path";
-// Entry point for programmatic API: compile a WSDL into a set of TypeScript files in a project layout
+import { TYPESCRIPT_WSDL_CLIENT_DEFAULT_COMPLIER_OPTIONS } from "./config.js";
 // noinspection JSUnusedGlobalSymbols
 export async function compileWsdlToProject(input) {
-    // Merge defaults with user overrides
-    const baseOptions = { ...defaultOptions, ...(input.options || {}) };
-    // Backward compatibility: legacy flags map to the new primitive preferences if not set
-    const normalizedPrimitive = { ...(baseOptions.primitive || {}) };
-    if (baseOptions.dateAs && normalizedPrimitive.dateAs == null) {
-        // dateAs legacy: choose Date or string based on flag
-        normalizedPrimitive.dateAs = baseOptions.dateAs === "date" ? "Date" : "string";
-    }
-    if (baseOptions.intAs && (normalizedPrimitive.int64As == null || normalizedPrimitive.bigIntegerAs == null)) {
-        // intAs legacy: apply to both 64-bit and big integer types
-        const as = baseOptions.intAs;
-        if (normalizedPrimitive.int64As == null)
-            normalizedPrimitive.int64As = as;
-        if (normalizedPrimitive.bigIntegerAs == null)
-            normalizedPrimitive.bigIntegerAs = as;
-    }
-    // Final merged options including computed primitive mappings
-    const finalOptions = { ...baseOptions, primitive: normalizedPrimitive };
-    // Load WSDL definitions and schema catalog (remote or local file)
+    // Merge defaults with overrides, always set wsdl+out
+    const finalOptions = {
+        ...TYPESCRIPT_WSDL_CLIENT_DEFAULT_COMPLIER_OPTIONS,
+        ...(input.options || {}),
+        wsdl: input.wsdl,
+        out: input.outDir,
+    };
+    // Load & compile
     const wsdlCatalog = await loadWsdl(input.wsdl);
     console.log(`Loaded WSDL: ${wsdlCatalog.wsdlUri}`);
-    // Compile schemas and operations into intermediate data structures
-    const compiledCatalog = compileCatalog(wsdlCatalog, finalOptions);
+    if (wsdlCatalog.schemas.length === 0) {
+        throw new Error(`No schemas found in WSDL: ${input.wsdl}`);
+    }
     console.log(`Schemas discovered: ${wsdlCatalog.schemas.length}`);
-    console.log(`Compiled types: ${compiledCatalog.types.length}`);
-    console.log(`Operations: ${compiledCatalog.operations.length}`);
-    // Prepare output directory for generated files
-    fs.mkdirSync(input.outDir, { recursive: true });
-    // Define target paths
+    const compiled = compileCatalog(wsdlCatalog, finalOptions);
+    console.log(`Compiled WSDL: ${wsdlCatalog.wsdlUri}`);
+    // check if we have any types and operations
+    if (compiled.types.length === 0) {
+        throw new Error(`No types compiled from WSDL: ${input.wsdl}`);
+    }
+    else {
+        console.log(`Types discovered: ${compiled.types.length}`);
+    }
+    if (compiled.operations.length === 0) {
+        throw new Error(`No operations compiled from WSDL: ${input.wsdl}`);
+    }
+    else {
+        console.log(`Operations discovered: ${compiled.operations.length}`);
+    }
+    // Emit artifacts
     const typesFile = path.join(input.outDir, "types.ts");
     const metaFile = path.join(input.outDir, "meta.ts");
-    const opsFile = path.join(input.outDir, "operations.json");
+    const catalogFile = path.join(input.outDir, "catalog.json");
     const clientFile = path.join(input.outDir, "client.ts");
-    const runtimeFile = path.join(input.outDir, "runtime.ts");
-    // Emit code artifacts: types, metadata, operations listing, client harness, runtime helpers
-    emitTypes(typesFile, compiledCatalog);
-    emitMeta(metaFile, compiledCatalog, finalOptions);
-    emitOperations(opsFile, compiledCatalog);
-    emitClient(clientFile, compiledCatalog, finalOptions);
-    emitRuntime(runtimeFile);
+    // Prepare output dir
+    try {
+        fs.mkdirSync(input.outDir, { recursive: true });
+    }
+    catch (e) {
+        throw new Error(`Failed to create output directory '${input.outDir}': ${e instanceof Error ? e.message : String(e)}`);
+    }
+    // Emit files
+    emitClient(clientFile, compiled);
+    emitTypes(typesFile, compiled);
+    emitUtils(metaFile, compiled);
+    if (compiled.options.catalog) {
+        emitCatalog(catalogFile, compiled);
+    }
 }
-// Re-export public API for library consumers
-export { compileCatalog } from "./compiler/schemaCompiler.js";
-export { xsdToTsPrimitive } from "./xsd/primitives.js";

package/dist/loader/wsdlLoader.js

@@ -2,7 +2,7 @@ import { XMLParser } from "fast-xml-parser";
 import { fetchText } from "./fetch.js";
 import path from "node:path";
 // noinspection ES6UnusedImports
-import { getChildrenWithLocalName, normalizeArray } from "../util/xml.js";
+import { getChildrenWithLocalName, normalizeArray } from "../util/tools.js";
 const parser = new XMLParser({ ignoreAttributes: false, attributeNamePrefix: "@_" });
 export async function loadWsdl(wsdlUrlOrPath) {
     const { uri: wsdlUri, text } = await fetchText(wsdlUrlOrPath);

package/dist/util/{xml.d.ts → tools.d.ts}

@@ -1,3 +1,4 @@
+import type { CompiledCatalog } from "../compiler/schemaCompiler.js";
 /** Normalize a possibly-single value into an array. */
 export declare function normalizeArray<T>(x: T | T[] | undefined | null): T[];
 /** Collect direct children whose LOCAL name matches (prefix-agnostic). */
@@ -10,4 +11,10 @@ export declare function resolveQName(qname: string, defaultNS: string, prefixes:
     ns: string;
     local: string;
 };
-//# sourceMappingURL=xml.d.ts.map
+/** Derive a SOAP client class name from CompilerOptions and compiled catalog. */
+export declare function deriveClientName(compiled: CompiledCatalog): string;
+/** Explode a PascalCase string into its constituent segments. */
+export declare function explodePascal(s: string): string[];
+/** Convert a PascalCase string to snake_case (lowercase + underscores). */
+export declare function pascalToSnakeCase(s: string): string;
+//# sourceMappingURL=tools.d.ts.map

package/dist/util/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../src/util/tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAErE,uDAAuD;AACvD,wBAAgB,cAAc,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,SAAS,GAAG,IAAI,GAAG,CAAC,EAAE,CAGpE;AAED,0EAA0E;AAC1E,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,GAAG,GAAG,EAAE,CASxE;AAED,gFAAgF;AAChF,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,GAAG,GAAG,GAAG,SAAS,CAK/E;AAED,6DAA6D;AAC7D,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CA6BxC;AAED,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC/B;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAS/B;AAED,iFAAiF;AACjF,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,eAAe,GACxB,MAAM,CAWR;AAED,iEAAiE;AACjE,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAMjD;AAED,2EAA2E;AAC3E,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAInD"}

package/dist/util/{xml.js → tools.js}

@@ -66,3 +66,30 @@ export function resolveQName(qname, defaultNS, prefixes) {
     }
     return { ns: defaultNS, local: qname };
 }
+/** Derive a SOAP client class name from CompilerOptions and compiled catalog. */
+export function deriveClientName(compiled) {
+    const overrideName = (compiled.options.clientName || "").trim();
+    const svcName = compiled.serviceName ? pascal(compiled.serviceName) : "";
+    const fileBase = (() => {
+        const uri = compiled.wsdlUri || "";
+        const seg = uri.split(/[\\/]/).pop() || "";
+        const noExt = seg.replace(/\.[^.]+$/, "");
+        return noExt ? pascal(noExt) : "";
+    })();
+    return overrideName
+        || ((svcName || fileBase) ? `${svcName || fileBase}` : "GeneratedSOAPClient");
+}
+/** Explode a PascalCase string into its constituent segments. */
+export function explodePascal(s) {
+    // insert underscores between camel‐transitions
+    const withUnderscores = String(s)
+        .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+        .replace(/([A-Z])([A-Z][a-z])/g, '$1_$2');
+    return withUnderscores.split('_').filter(Boolean);
+}
+/** Convert a PascalCase string to snake_case (lowercase + underscores). */
+export function pascalToSnakeCase(s) {
+    return explodePascal(s)
+        .map(seg => seg.toLowerCase())
+        .join('_');
+}