npm - @techspokes/typescript-wsdl-client - Versions diffs - 0.1.9 → 0.2.2 - Mend

@techspokes/typescript-wsdl-client 0.1.9 → 0.2.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (15) hide show

package/README.md +59 -9
package/dist/cli.js +9 -0
package/dist/compiler/schemaCompiler.d.ts +13 -0
package/dist/compiler/schemaCompiler.d.ts.map +1 -1
package/dist/compiler/schemaCompiler.js +264 -80
package/dist/config.d.ts +29 -2
package/dist/config.d.ts.map +1 -1
package/dist/config.js +3 -0
package/dist/emit/clientEmitter.d.ts.map +1 -1
package/dist/emit/clientEmitter.js +27 -5
package/dist/emit/runtimeEmitter.d.ts.map +1 -1
package/dist/emit/runtimeEmitter.js +3 -6
package/dist/index.d.ts.map +1 -1
package/dist/index.js +40 -29
package/package.json +2 -2

package/README.md CHANGED Viewed

@@ -23,7 +23,7 @@ Reads WSDL/XSD (with imports) and emits a small, typed client you can compile in
 * Deterministic metadata (`ATTR_SPEC`, `PROP_META`) for clean JSON ⇄ SOAP mapping
 * ESM **and** CommonJS friendly output
-Vendor: **[TechSpokes](https://www.techspokes.com)** · Contact: **[contact@techspokes.com](mailto:contact@techspokes.com)**
+Vendor: **[TechSpokes](https://www.techspokes.com)** · Contact: **[contact page](https://www.techspokes.com/contact/)**
 Maintainer: **Serge Liatko** ([@sergeliatko](https://github.com/sergeliatko)) · GitHub org: [@techspokes](https://github.com/techspokes)
 ---
@@ -33,7 +33,7 @@ Maintainer: **Serge Liatko** ([@sergeliatko](https://github.com/sergeliatko)) ·
 Install the generator (dev-time) in your project:
 ```bash
-npm i -D typescript-wsdl-client
+npm i -D @techspokes/typescript-wsdl-client
 # your app will use node-soap at runtime:
 npm i soap
 ```
@@ -49,17 +49,28 @@ Use the generated client:
 ```ts
 // ESM / NodeNext app
 import { createSoapClient } from "./generated/my/runtime.js";
-import { GeneratedSoapClient } from "./generated/my/client.js";
+// class name defaults to <ServiceName>SoapClient (from WSDL), e.g., MyServiceSoapClient
+import { MyServiceSoapClient } from "./generated/my/client.js";
-const soap = await createSoapClient({ wsdlUrl: "https://example.com/MyService?wsdl" });
-const client = new GeneratedSoapClient(soap, "$attributes"); // attributes key optional
+// optional: pass security straight into createSoapClient (node-soap security instance)
+import soap from "soap";
+const security = new soap.WSSecurity("user", "pass");
+const soapClient = await createSoapClient({
+  wsdlUrl: "https://example.com/MyService?wsdl",
+  security, // or configure after creation: (await createSoapClient(...)).setSecurity(security)
+});
+const client = new MyServiceSoapClient(soapClient, "$attributes"); // attributes key optional
+// Example: To set literal text content for an XML element, use the reserved `$value` key.
+// Other keys in the object represent XML attributes (e.g. `MyAttribute`) and child elements (e.g. `MyElement`).
+// This lets you build mixed-content XML: `$value` for text, attribute keys for XML attributes, and element keys for nested elements.
 const rs = await client.MyOperation({
   MyOperationRQ: {
     MyAttribute: "passed as attribute",
     MyElement: "passed as child element",
-    // ...other fields
-    // attributes appear as top-level props; child elements as nested objects
+    $value: "passed text content here",
   }
 });
@@ -70,12 +81,42 @@ console.log(rs);
 ---
+## Security and WS-Policy hints
+- node-soap leaves security up to you. Create a security instance (e.g., `new soap.BasicAuthSecurity(...)`, `new soap.WSSecurity(...)`, `new soap.ClientSSLSecurity(...)`) and set it on the client via `client.setSecurity(...)`.
+- The runtime factory `createSoapClient({ wsdlUrl, endpoint?, wsdlOptions?, security? })` accepts an optional `security` and will call `client.setSecurity(security)` for you.
+- The generated client includes minimal WS-Policy hints if your WSDL embeds inline `wsp:Policy` under `wsdl:binding` or `wsdl:binding/wsdl:operation`.
+  - Hints are surfaced in method JSDoc as “Security (WSDL policy hint): …” and in `operations.json`/`operations.ts` as a `security: string[]` field (e.g., `usernameToken`, `https`, `x509`, `messageSecurity`).
+  - These hints are best-effort and not authoritative (no `wsp:PolicyReference` dereferencing yet). They’re intended to nudge you to configure the right security.
+  - At runtime, if an operation has hints and your client has no `security` configured, a console warning is emitted.
+---
 ## CLI
 ```
 wsdl-tsc --wsdl <path-or-url> --out <dir> [options]
 ```
+### Local development
+By default, `npx wsdl-tsc` invokes the published npm version. To run the CLI from your local source (with your latest changes), use one of these approaches:
+```bash
+# Directly via tsx (requires tsx in devDependencies)
+npx tsx src/cli.ts --wsdl <path-or-url> --out <dir> [options]
+# Via npm script
+git clone ... then:
+npm install
+git checkout <branch>
+npm run dev -- --wsdl <path-or-url> --out <dir> [options]
+# Using npm link to symlink your working copy
+npm link
+wsdl-tsc --wsdl <path-or-url> --out <dir> [options]
+```
 **Required**
 * `--wsdl` — WSDL path or URL
@@ -88,11 +129,19 @@ wsdl-tsc --wsdl <path-or-url> --out <dir> [options]
 | `--imports`         | string    | js, ts, bare                   | js           | Intra-generated import specifiers: '.js', '.ts', or bare         |
 | `--ops-ts`          | boolean   | true, false                    | true         | Emit `operations.ts` instead of JSON                             |
 | `--attributes-key`  | string    | any                            | $attributes  | Key used by runtime marshaller for XML attributes                |
+| `--client-name`     | string    | any                            | —            | Override the exported client class name (exact)                  |
 | `--int64-as`        | string    | string, number, bigint         | string       | How to map xs:long/xs:unsignedLong                               |
 | `--bigint-as`       | string    | string, number                 | string       | How to map xs:integer family (positive/nonNegative/etc.)         |
 | `--decimal-as`      | string    | string, number                 | string       | How to map xs:decimal (money/precision)                          |
 | `--date-as`         | string    | string, Date                   | string       | How to map date/time/duration types                              |
+### Client naming
+- By default, the generated client class is named after the WSDL service: `<ServiceName>SoapClient`.
+- If the service name can’t be determined, we fall back to the WSDL filename: `<WsdlFileBaseName>SoapClient`.
+- If neither is available, we fall back to `GeneratedSoapClient`.
+- You can override the name entirely with `--client-name MyCustomClient` (the exact export name will be used).
 **Primitive mapping (safe defaults)**
 Defaults are **string-first** to avoid precision & timezone surprises:
@@ -176,8 +225,8 @@ TypeScript will compile to `require("./runtime")` cleanly.
 ## Programmatic API (optional)
 ```ts
-import { compileCatalog, xsdToTsPrimitive, type CompilerOptions } from "typescript-wsdl-client";
-import { loadWsdlCatalog } from "typescript-wsdl-client/internal-or-your-loader"; // if you expose it
+import { compileCatalog, xsdToTsPrimitive, type CompilerOptions } from "@techspokes/typescript-wsdl-client";
+import { loadWsdlCatalog } from "@techspokes/typescript-wsdl-client/internal-or-your-loader"; // if you expose it
 const catalog = await loadWsdlCatalog("./spec/wsdl/MyService.wsdl");
 const compiled = compileCatalog(catalog, {
@@ -218,6 +267,7 @@ npx tsc --noEmit --module NodeNext --moduleResolution NodeNext --target ES2022 .
 * **“Cannot find './runtime.js'”** — Your app must be `module: "NodeNext"` when using `--imports js`.
   Use `--imports bare` for CommonJS apps.
 * **“node-soap not found”** — Install it in your **app**: `npm i soap`.
+* **“Security required?”** — If your generated client warns or JSDoc shows a security hint, configure node-soap security: `client.setSecurity(new soap.WSSecurity(...))` or pass `security` to `createSoapClient`.
 ---

package/dist/cli.js CHANGED Viewed

@@ -37,6 +37,10 @@ const argv = await yargs(hideBin(process.argv))
     type: "string",
     default: "$attributes",
     desc: "Key used by runtime marshaller for XML attributes",
+})
+    .option("client-name", {
+    type: "string",
+    desc: "Override the generated client class name (exact export name)",
 })
     // Primitive mapping knobs (safe defaults)
     .option("int64-as", {
@@ -78,6 +82,10 @@ const compiled = compileCatalog(catalog, {
         dateAs: argv["date-as"],
     },
 });
+// Report counts of types and operations for user visibility
+console.log(`Schemas discovered: ${catalog.schemas.length}`);
+console.log(`Compiled types: ${compiled.types.length}`);
+console.log(`Operations: ${compiled.operations.length}`);
 // Emit files
 const importExt = argv.imports === "js" ? ".js" : argv.imports === "ts" ? ".ts" : "";
 emitTypes(path.join(outDir, "types.ts"), compiled);
@@ -90,5 +98,6 @@ emitClient(path.join(outDir, "client.ts"), compiled, {
     // @ts-ignore runtime-only options for emitter
     importExt,
     attributesKey: String(argv["attributes-key"]),
+    clientName: argv["client-name"],
 });
 console.log(`✅ Generated TypeScript client in ${outDir}`);

package/dist/compiler/schemaCompiler.d.ts CHANGED Viewed

@@ -43,8 +43,21 @@ export type CompiledCatalog = {
         soapAction: string;
         inputElement?: QName;
         outputElement?: QName;
+        security?: string[];
     }>;
     wsdlTargetNS: string;
+    serviceName?: string;
+    wsdlUri: string;
 };
+/**
+ * Compile a WSDL catalog into an internal representation (CompiledCatalog).
+ * Steps:
+ * 1. Collect and index complexType, simpleType, and element definitions across all schemas.
+ * 2. Recursively compile each named type to a TS interface or alias, handling inheritance,
+ *    inline definitions, and XSD primitives.
+ * 3. Build metadata maps for runtime marshalling (attributes, children, nillable, occurrence).
+ * 4. Extract WSDL operations: pick the appropriate SOAP binding (v1.1 or v1.2), resolve its
+ *    portType reference, then enumerate operations and their soapAction URIs.
+ */
 export declare function compileCatalog(cat: WsdlCatalog, _opts: CompilerOptions): CompiledCatalog;
 //# sourceMappingURL=schemaCompiler.d.ts.map

package/dist/compiler/schemaCompiler.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"schemaCompiler.d.ts","sourceRoot":"","sources":["../../src/compiler/schemaCompiler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAU3D,MAAM,MAAM,KAAK,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAElD,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,KAAK,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;QACf,GAAG,CAAC,EAAE,UAAU,GAAG,UAAU,CAAC;QAC9B,YAAY,EAAE,MAAM,CAAC;KACtB,CAAC,CAAC;IACH,KAAK,EAAE,KAAK,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;QACf,GAAG,EAAE,MAAM,CAAC;QACZ,GAAG,EAAE,MAAM,GAAG,WAAW,CAAC;QAC1B,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,YAAY,EAAE,MAAM,CAAC;KACtB,CAAC,CAAC;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,IAAI,EAAE;QACJ,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;QACnC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;QAClD,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;KAC/C,CAAC;IACF,UAAU,EAAE,KAAK,CAAC;QAChB,IAAI,EAAE,MAAM,CAAC;QACb,UAAU,EAAE,MAAM,CAAC;QACnB,YAAY,CAAC,EAAE,KAAK,CAAC;QACrB,aAAa,CAAC,EAAE,KAAK,CAAC;~~KACvB~~,CAAC,CAAC;IACH,YAAY,EAAE,MAAM,CAAC;~~CACtB~~,CAAC;~~AAoBF~~,wBAAgB,cAAc,CAAC,GAAG,EAAE,WAAW,EAAE,KAAK,EAAE,eAAe,GAAG,eAAe,~~CA+XxF~~"}
1	+ {"version":3,"file":"schemaCompiler.d.ts","sourceRoot":"","sources":["../../src/compiler/schemaCompiler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAU3D,MAAM,MAAM,KAAK,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAElD,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,KAAK,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;QACf,GAAG,CAAC,EAAE,UAAU,GAAG,UAAU,CAAC;QAC9B,YAAY,EAAE,MAAM,CAAC;KACtB,CAAC,CAAC;IACH,KAAK,EAAE,KAAK,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;QACf,GAAG,EAAE,MAAM,CAAC;QACZ,GAAG,EAAE,MAAM,GAAG,WAAW,CAAC;QAC1B,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,YAAY,EAAE,MAAM,CAAC;KACtB,CAAC,CAAC;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,IAAI,EAAE;QACJ,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;QACnC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;QAClD,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;KAC/C,CAAC;IACF,UAAU,EAAE,KAAK,CAAC;QAChB,IAAI,EAAE,MAAM,CAAC;QACb,UAAU,EAAE,MAAM,CAAC;QACnB,YAAY,CAAC,EAAE,KAAK,CAAC;QACrB,aAAa,CAAC,EAAE,KAAK,CAAC;QACtB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;KACrB,CAAC,CAAC;IACH,YAAY,EAAE,MAAM,CAAC;IAErB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AA6DF;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,WAAW,EAAE,KAAK,EAAE,eAAe,GAAG,eAAe,CA2gBxF"}

package/dist/compiler/schemaCompiler.js CHANGED Viewed

@@ -8,10 +8,71 @@ function qkey(q) {
 function makeInlineTypeName(parentTypeName, propName, _max) {
     const base = pascal(parentTypeName || "AnonParent");
     const prop = pascal(propName || "");
-    if (prop)
+    if (prop) {
         return prop;
+    }
     return `${base}Anon`;
 }
+// --- Minimal WS-Policy scanning (inline policies only; PolicyReference not resolved) ---
+function collectSecurityFromPolicyNodes(policyNodes) {
+    const found = new Set();
+    const targets = new Set([
+        "UsernameToken",
+        "TransportBinding",
+        "HttpsToken",
+        "TransportToken",
+        "AsymmetricBinding",
+        "SymmetricBinding",
+        "SignedSupportingTokens",
+        "X509Token",
+    ]);
+    const visit = (n) => {
+        if (n == null || typeof n !== "object")
+            return;
+        for (const [k, v] of Object.entries(n)) {
+            if (k.startsWith("@_"))
+                continue; // attribute
+            // localName match (prefix-agnostic) by checking tail after ':' or whole key if no ':'
+            const ln = k.includes(":") ? k.split(":").pop() : k;
+            if (targets.has(ln)) {
+                switch (ln) {
+                    case "UsernameToken":
+                        found.add("usernameToken");
+                        break;
+                    case "HttpsToken":
+                    case "TransportBinding":
+                    case "TransportToken":
+                        found.add("https");
+                        break;
+                    case "X509Token":
+                        found.add("x509");
+                        break;
+                    case "AsymmetricBinding":
+                    case "SymmetricBinding":
+                    case "SignedSupportingTokens":
+                        found.add("messageSecurity");
+                        break;
+                }
+            }
+            // recurse
+            if (v && typeof v === "object")
+                visit(v);
+        }
+    };
+    for (const p of policyNodes)
+        visit(p);
+    return Array.from(found);
+}
+/**
+ * Compile a WSDL catalog into an internal representation (CompiledCatalog).
+ * Steps:
+ * 1. Collect and index complexType, simpleType, and element definitions across all schemas.
+ * 2. Recursively compile each named type to a TS interface or alias, handling inheritance,
+ *    inline definitions, and XSD primitives.
+ * 3. Build metadata maps for runtime marshalling (attributes, children, nillable, occurrence).
+ * 4. Extract WSDL operations: pick the appropriate SOAP binding (v1.1 or v1.2), resolve its
+ *    portType reference, then enumerate operations and their soapAction URIs.
+ */
 export function compileCatalog(cat, _opts) {
     // symbol tables discovered across all schemas
     const complexTypes = new Map();
@@ -19,20 +80,25 @@ export function compileCatalog(cat, _opts) {
     const elements = new Map();
     for (const s of cat.schemas) {
         const tns = s.targetNS;
+        // merge WSDL-level prefixes with schema-level (schema wins)
+        const mergedPrefixes = { ...cat.prefixMap, ...s.prefixes };
         for (const n of getChildrenWithLocalName(s.xml, "complexType")) {
             const name = n["@_name"];
-            if (name)
-                complexTypes.set(qkey({ ns: tns, local: name }), { node: n, tns, prefixes: s.prefixes });
+            if (name) {
+                complexTypes.set(qkey({ ns: tns, local: name }), { node: n, tns, prefixes: mergedPrefixes });
+            }
         }
         for (const n of getChildrenWithLocalName(s.xml, "simpleType")) {
             const name = n["@_name"];
-            if (name)
-                simpleTypes.set(qkey({ ns: tns, local: name }), { node: n, tns, prefixes: s.prefixes });
+            if (name) {
+                simpleTypes.set(qkey({ ns: tns, local: name }), { node: n, tns, prefixes: mergedPrefixes });
+            }
         }
         for (const n of getChildrenWithLocalName(s.xml, "element")) {
             const name = n["@_name"];
-            if (name)
-                elements.set(qkey({ ns: tns, local: name }), { node: n, tns, prefixes: s.prefixes });
+            if (name) {
+                elements.set(qkey({ ns: tns, local: name }), { node: n, tns, prefixes: mergedPrefixes });
+            }
         }
     }
     // outputs & state
@@ -72,8 +138,9 @@ export function compileCatalog(cat, _opts) {
     function getOrCompileAlias(name, sNode, schemaNS, prefixes) {
         const key = `${schemaNS}|${name}`;
         const present = aliasMap.get(key);
-        if (present)
+        if (present) {
             return present;
+        }
         const { tsType, declared, jsdoc } = compileSimpleTypeNode(sNode, schemaNS, prefixes);
         const alias = { name: pascal(name), ns: schemaNS, tsType, declared, jsdoc };
         aliasMap.set(key, alias);
@@ -81,8 +148,9 @@ export function compileCatalog(cat, _opts) {
     }
     /** Resolve a QName reference to a TS type; compile targets if needed. */
     function resolveTypeRef(q, schemaNS, prefixes) {
-        if (!q.ns)
+        if (!q.ns) {
             q = resolveQName(q.local, schemaNS, prefixes);
+        }
         if (q.ns === XS) {
             const label = `xs:${q.local}`;
             return { tsType: xsdToTsPrimitive(label, _opts?.primitive), declared: label };
@@ -109,16 +177,20 @@ export function compileCatalog(cat, _opts) {
         const outName = pascal(name);
         const key = `${schemaNS}|${outName}`;
         const present = compiledMap.get(key);
-        if (present)
+        if (present) {
             return present;
+        }
         if (inProgress.has(key)) {
             // minimal cycle break
             return { name: outName, ns: schemaNS, attrs: [], elems: [] };
         }
         inProgress.add(key);
+        // mergeAttrs: combine base attributes with local ones, overriding duplicates by name
         const mergeAttrs = (into, list) => {
+            // build index of existing attribute names
             const idx = new Map();
             into.forEach((a, i) => idx.set(a.name, i));
+            // for each new attr, add or override existing
             for (const a of list) {
                 const pos = idx.get(a.name);
                 if (pos == null) {
@@ -126,10 +198,11 @@ export function compileCatalog(cat, _opts) {
                     into.push(a);
                 }
                 else {
-                    into[pos] = a; // override
+                    into[pos] = a; // override existing attribute details
                 }
             }
         };
+        // mergeElems: combine base elements (particles) with local ones, preserving unique names and overriding duplicates
         const mergeElems = (into, list) => {
             const idx = new Map();
             into.forEach((e, i) => idx.set(e.name, i));
@@ -140,41 +213,39 @@ export function compileCatalog(cat, _opts) {
                     into.push(e);
                 }
                 else {
-                    into[pos] = e; // override
+                    into[pos] = e; // override existing element details
                 }
             }
         };
+        // collectAttributes: read all <attribute> children, handle inline simpleType vs named type references
+        // maps each attribute to a TS type, tracks required vs optional via @use, and records the original declared XSD type
         const collectAttributes = (node) => {
             const out = [];
             const attrs = getChildrenWithLocalName(node, "attribute");
             for (const a of attrs) {
                 const an = a["@_name"];
-                if (!an)
+                if (!an) {
                     continue;
+                }
                 const inlineSimple = getFirstWithLocalName(a, "simpleType");
                 if (inlineSimple) {
+                    // inline enumeration or restriction inside attribute
                     const r = compileSimpleTypeNode(inlineSimple, schemaNS, prefixes);
-                    out.push({
-                        name: an,
-                        tsType: r.tsType,
-                        use: a["@_use"] === "required" ? "required" : "optional",
-                        declaredType: r.declared,
-                    });
+                    out.push({ name: an, tsType: r.tsType, use: a["@_use"] === "required" ? "required" : "optional", declaredType: r.declared });
                 }
                 else {
+                    // named type or default xs:string
                     const t = a["@_type"];
                     const q = t ? resolveQName(t, schemaNS, prefixes) : { ns: XS, local: "string" };
                     const r = resolveTypeRef(q, schemaNS, prefixes);
-                    out.push({
-                        name: an,
-                        tsType: r.tsType,
-                        use: a["@_use"] === "required" ? "required" : "optional",
-                        declaredType: r.declared,
-                    });
+                    out.push({ name: an, tsType: r.tsType, use: a["@_use"] === "required" ? "required" : "optional", declaredType: r.declared });
                 }
             }
             return out;
         };
+        // collectParticles: parse compositor elements (sequence, all, choice), extract <element> definitions
+        // handles inline complex/simple definitions by generating a unique inline type name
+        // resolves type refs or @ref, applies min/max occurrence and nillable flags
         const collectParticles = (ownerTypeName, node) => {
             const out = [];
             const groups = [
@@ -185,52 +256,33 @@ export function compileCatalog(cat, _opts) {
             for (const grp of groups) {
                 for (const e of getChildrenWithLocalName(grp, "element")) {
                     const nameOrRef = e["@_name"] || e["@_ref"];
-                    if (!nameOrRef)
+                    if (!nameOrRef) {
                         continue;
-                    let propName = e["@_name"] || undefined;
+                    }
+                    const propName = e["@_name"];
                     const min = e["@_minOccurs"] ? Number(e["@_minOccurs"]) : 1;
                     const maxAttr = e["@_maxOccurs"];
                     const max = maxAttr === "unbounded" ? "unbounded" : maxAttr ? Number(maxAttr) : 1;
                     const nillable = e["@_nillable"] === "true";
-                    // inline complex/simple types
+                    // inline complexType: create a nested interface with a generated name
                     const inlineComplex = getFirstWithLocalName(e, "complexType");
                     const inlineSimple = getFirstWithLocalName(e, "simpleType");
                     if (inlineComplex) {
                         const inlineName = makeInlineTypeName(ownerTypeName, propName || nameOrRef, max);
                         const rec = getOrCompileComplex(inlineName, inlineComplex, schemaNS, prefixes);
-                        out.push({
-                            name: propName || nameOrRef,
-                            tsType: rec.name,
-                            min,
-                            max,
-                            nillable,
-                            declaredType: `{${schemaNS}}${rec.name}`,
-                        });
+                        out.push({ name: propName || nameOrRef, tsType: rec.name, min, max, nillable, declaredType: `{${schemaNS}}${rec.name}` });
                     }
                     else if (inlineSimple) {
+                        // inline simpleType (e.g., list or enumeration)
                         const r = compileSimpleTypeNode(inlineSimple, schemaNS, prefixes);
-                        out.push({
-                            name: propName || nameOrRef,
-                            tsType: r.tsType,
-                            min,
-                            max,
-                            nillable,
-                            declaredType: r.declared,
-                        });
+                        out.push({ name: propName || nameOrRef, tsType: r.tsType, min, max, nillable, declaredType: r.declared });
                     }
                     else {
-                        // normal ref/type
+                        // named type or ref: resolve via QName
                         const t = e["@_type"] || e["@_ref"];
                         const q = t ? resolveQName(t, schemaNS, prefixes) : { ns: XS, local: "string" };
                         const r = resolveTypeRef(q, schemaNS, prefixes);
-                        out.push({
-                            name: propName || nameOrRef,
-                            tsType: r.tsType,
-                            min,
-                            max,
-                            nillable,
-                            declaredType: r.declared,
-                        });
+                        out.push({ name: propName || nameOrRef, tsType: r.tsType, min, max, nillable, declaredType: r.declared });
                     }
                 }
             }
@@ -277,7 +329,7 @@ export function compileCatalog(cat, _opts) {
                 if (baseAttr) {
                     r = resolveTypeRef(resolveQName(baseAttr, schemaNS, prefixes), schemaNS, prefixes);
                 }
-                // 👇👇 text node is modeled as "$value" (not "value")
+                // text node is modeled as "$value" (not "value")
                 mergeElems(elems, [{
                         name: "$value",
                         tsType: r.tsType,
@@ -292,10 +344,12 @@ export function compileCatalog(cat, _opts) {
                 inProgress.delete(key);
                 return result;
             };
-            if (ext)
+            if (ext) {
                 return model(ext);
-            if (res)
+            }
+            if (res) {
                 return model(res);
+            }
         }
         // Attributes + particles
         mergeAttrs(attrs, collectAttributes(cnode));
@@ -305,13 +359,84 @@ export function compileCatalog(cat, _opts) {
         inProgress.delete(key);
         return result;
     }
+    // Helper: compile a global element into a surface type (wrapper)
+    function compileElementAsType(name, enode, schemaNS, prefixes) {
+        const outName = pascal(name);
+        const key = `${schemaNS}|${outName}`;
+        const present = compiledMap.get(key);
+        if (present)
+            return present;
+        const inlineComplex = getFirstWithLocalName(enode, "complexType");
+        if (inlineComplex) {
+            return getOrCompileComplex(name, inlineComplex, schemaNS, prefixes);
+        }
+        const inlineSimple = getFirstWithLocalName(enode, "simpleType");
+        if (inlineSimple) {
+            const r = compileSimpleTypeNode(inlineSimple, schemaNS, prefixes);
+            const t = {
+                name: outName,
+                ns: schemaNS,
+                attrs: [],
+                elems: [{ name: "$value", tsType: r.tsType, min: 0, max: 1, nillable: false, declaredType: r.declared }],
+            };
+            compiledMap.set(key, t);
+            return t;
+        }
+        const tAttr = enode["@_type"];
+        if (tAttr) {
+            const q = resolveQName(tAttr, schemaNS, prefixes);
+            // If references a simple type → $value; if complex type → copy members
+            if (q.ns === XS) {
+                const label = `xs:${q.local}`;
+                const t = {
+                    name: outName,
+                    ns: schemaNS,
+                    attrs: [],
+                    elems: [{ name: "$value", tsType: xsdToTsPrimitive(label, _opts?.primitive), min: 0, max: 1, nillable: false, declaredType: label }],
+                };
+                compiledMap.set(key, t);
+                return t;
+            }
+            const baseRec = complexTypes.get(qkey(q));
+            if (baseRec) {
+                const base = getOrCompileComplex(baseRec.node["@_name"], baseRec.node, baseRec.tns, baseRec.prefixes);
+                const t = { name: outName, ns: schemaNS, attrs: [...(base.attrs || [])], elems: [...(base.elems || [])] };
+                compiledMap.set(key, t);
+                return t;
+            }
+            const srec = simpleTypes.get(qkey(q));
+            if (srec) {
+                const a = getOrCompileAlias(q.local, srec.node, srec.tns, srec.prefixes);
+                const t = {
+                    name: outName,
+                    ns: schemaNS,
+                    attrs: [],
+                    elems: [{ name: "$value", tsType: a.name, min: 0, max: 1, nillable: false, declaredType: `{${a.ns}}${q.local}` }],
+                };
+                compiledMap.set(key, t);
+                return t;
+            }
+        }
+        // default empty wrapper
+        const t = { name: outName, ns: schemaNS, attrs: [], elems: [] };
+        compiledMap.set(key, t);
+        return t;
+    }
     // compile every discovered complex type
     for (const rec of complexTypes.values()) {
         const name = rec.node["@_name"];
-        if (!name)
+        if (!name) {
             continue;
+        }
         getOrCompileComplex(name, rec.node, rec.tns, rec.prefixes);
     }
+    // compile global element wrappers, so metadata contains operation wrappers
+    for (const rec of elements.values()) {
+        const name = rec.node["@_name"];
+        if (!name)
+            continue;
+        compileElementAsType(name, rec.node, rec.tns, rec.prefixes);
+    }
     // emit lists
     const typesList = Array.from(compiledMap.values());
     const aliasList = Array.from(aliasMap.values());
@@ -332,41 +457,100 @@ export function compileCatalog(cat, _opts) {
         childType[t.name] = child;
         propMeta[t.name] = meta;
     }
-    // operations / soapAction (minimal)
+    // operations / soapAction (enriched)
+    // 1) Gather all binding definitions and select the SOAP binding (soap:binding or soap12:binding child).
+    // 2) Use the binding's @type to locate the matching portType in definitions.
+    // 3) Enumerate operations on that portType (wsdl:operation) for input/output WSDL messages.
+    // 4) In the chosen binding, extract the <soap:operation> child to read SOAP action URIs.
     const defs = cat.wsdlXml["wsdl:definitions"] || cat.wsdlXml["definitions"];
-    const portType = defs?.["wsdl:portType"] || defs?.["portType"];
-    const binding = defs?.["wsdl:binding"] || defs?.["binding"];
-    const pOps = normalizeArray(portType?.["wsdl:operation"] || portType?.["operation"]);
+    const tns = defs?.["@_targetNamespace"] || "";
+    const bindingDefs = normalizeArray(defs?.["wsdl:binding"] || defs?.["binding"]);
+    const soapBinding = bindingDefs.find(b => Object.keys(b).some(k => k === "soap:binding" || k === "soap12:binding")) || bindingDefs[0];
+    // binding @type typically looks like "tns:MyPortType", so resolve via prefixes map
+    const portTypeAttr = soapBinding?.["@_type"];
+    const portTypeQName = portTypeAttr ? resolveQName(portTypeAttr, tns, cat.prefixMap) : undefined;
+    const portTypeDefs = normalizeArray(defs?.["wsdl:portType"] || defs?.["portType"]);
+    const targetPortType = portTypeQName
+        ? portTypeDefs.find(pt => pt?.["@_name"] === portTypeQName.local)
+        : portTypeDefs[0];
+    // operations listed under <wsdl:portType>
+    const pOps = targetPortType ? getChildrenWithLocalName(targetPortType, "operation") : [];
     const bOps = new Map();
-    const bindingOps = normalizeArray(binding?.["wsdl:operation"] || binding?.["operation"]);
-    const bindingOpsAny = bindingOps.length ? bindingOps : getChildrenWithLocalName(binding || {}, "operation");
-    for (const bo of bindingOpsAny) {
-        const name = bo?.["@_name"];
-        if (!name)
-            continue;
-        let action = "";
-        for (const [k, v] of Object.entries(bo || {})) {
-            if (k === "operation" || k.endsWith(":operation")) {
-                const node = Array.isArray(v) ? v[0] : v;
-                action = node?.["@_soapAction"] || node?.["@_soapActionURI"] || node?.["@_soapActionUrl"] || "";
-                if (action)
-                    break;
-            }
-        }
+    // in the <wsdl:binding>, each operation has a nested <soap:operation> child
+    const opsNodes = getChildrenWithLocalName(soapBinding, "operation").filter(o => o["@_name"]);
+    for (const bo of opsNodes) {
+        // operation name must match portType operation name
+        const name = bo["@_name"];
+        // find nested soap:operation node for the soapAction attribute
+        const soapOps = getChildrenWithLocalName(bo, "operation");
+        const soapOp = soapOps[0];
+        const action = soapOp?.["@_soapAction"] || soapOp?.["@_soapActionURI"] || soapOp?.["@_soapActionUrl"] || "";
         bOps.set(name, action);
     }
-    const ops = [];
-    for (const po of pOps) {
+    const msgDefs = normalizeArray(defs?.["wsdl:message"] || defs?.["message"]);
+    const findMessage = (qstr) => {
+        if (!qstr)
+            return undefined;
+        const q = resolveQName(qstr, tns, cat.prefixMap);
+        return msgDefs.find(m => m?.["@_name"] === q.local);
+    };
+    const elementOfMessage = (msg) => {
+        if (!msg)
+            return undefined;
+        const parts = getChildrenWithLocalName(msg, "part");
+        // Prefer element-based part (doc/literal)
+        const withElem = parts.find(p => p?.["@_element"]);
+        const el = withElem?.["@_element"];
+        if (!el)
+            return undefined;
+        const q = resolveQName(el, tns, cat.prefixMap);
+        return { ns: q.ns, local: q.local };
+    };
+    // build operations list
+    const ops = (pOps
+        .map(po => {
         const name = po?.["@_name"];
         if (!name)
-            continue;
-        ops.push({ name, soapAction: bOps.get(name) || "" });
+            return undefined;
+        const inMsg = findMessage(getFirstWithLocalName(po, "input")?.["@_message"]);
+        const outMsg = findMessage(getFirstWithLocalName(po, "output")?.["@_message"]);
+        const inputElement = elementOfMessage(inMsg);
+        const outputElement = elementOfMessage(outMsg);
+        return { name, soapAction: bOps.get(name) || "", inputElement, outputElement };
+    })
+        .filter((x) => x != null));
+    // --- WS-Policy: scan for security requirements (inline policies only) ---
+    const bindingPolicies = getChildrenWithLocalName(soapBinding || {}, "Policy");
+    const bindingSec = collectSecurityFromPolicyNodes(bindingPolicies);
+    for (const op of ops) {
+        const bo = opsNodes.find(o => o?.["@_name"] === op.name) || {};
+        const opPolicies = getChildrenWithLocalName(bo, "Policy");
+        const opSec = collectSecurityFromPolicyNodes(opPolicies);
+        const secSet = new Set([...bindingSec, ...opSec]);
+        op.security = Array.from(secSet);
     }
+    // --- Service discovery (for client naming) ---
+    let serviceName;
+    const soapBindingName = soapBinding?.["@_name"];
+    const serviceDefs = normalizeArray(defs?.["wsdl:service"] || defs?.["service"]);
+    const serviceUsingBinding = serviceDefs.find(s => {
+        const ports = getChildrenWithLocalName(s, "port");
+        return ports.some(p => {
+            const bq = p?.["@_binding"];
+            if (!bq || !soapBindingName)
+                return false;
+            const q = resolveQName(bq, tns, cat.prefixMap);
+            return q.local === soapBindingName; // match by local name
+        });
+    });
+    serviceName = serviceUsingBinding?.["@_name"] || serviceDefs[0]?.["@_name"];
     return {
         types: typesList,
         aliases: aliasList,
         meta: { attrSpec, childType, propMeta },
         operations: ops,
         wsdlTargetNS: defs?.["@_targetNamespace"] || "",
+        serviceName,
+        wsdlUri: cat.wsdlUri,
     };
 }

package/dist/config.d.ts CHANGED Viewed

@@ -1,13 +1,40 @@
 import type { PrimitiveOptions } from "./xsd/primitives.js";
+/**
+ * Options to control WSDL-to-TypeScript compilation behavior.
+ */
 export type CompilerOptions = {
+    /**
+     * How to represent XML <choice> elements: as all-optional properties or a discriminated union.
+     */
     choice?: "all-optional" | "union";
+    /**
+     * Legacy flag: map all date/time/duration types to string or Date. Superceded by primitive.dateAs if set.
+     */
     dateAs?: "string" | "date";
+    /**
+     * Legacy flag: shorthand for int64As and bigIntegerAs. Maps integer types to number or string.
+     */
     intAs?: "number" | "string";
+    /**
+     * Emit errors if any type references cannot be resolved in the WSDL schema.
+     */
     failOnUnresolved?: boolean;
-    /** Attribute bag key for the runtime mapper (node-soap). */
+    /**
+     * Attribute bag key for the runtime mapper (node-soap).
+     */
     attributesKey?: string;
-    /** Controls how XSD primitives are mapped to TypeScript. Safe defaults apply. */
+    /**
+     * Optional override for the generated client class name.
+     * If provided, the emitter will export this exact class name.
+     */
+    clientName?: string;
+    /**
+     * Controls low-level mapping of XSD primitives to TypeScript types. Safe defaults are provided.
+     */
     primitive?: PrimitiveOptions;
 };
+/**
+ * Default compiler options. Users may override selectively.
+ */
 export declare const defaultOptions: CompilerOptions;
 //# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5D,MAAM,MAAM,eAAe,GAAG;IAC1B,MAAM,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC;IAClC,MAAM,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAC;IAC3B,KAAK,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAC5B,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B~~,4DAA4D~~;~~IAC5D~~,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,~~iFAAiF~~;~~IACjF~~,SAAS,CAAC,EAAE,gBAAgB,CAAC;CAChC,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,eAM5B,CAAC"}
1	+ {"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5D;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC1B;;OAEG;IACH,MAAM,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC;IAClC;;OAEG;IACH,MAAM,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAC;IAC3B;;OAEG;IACH,KAAK,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAC5B;;OAEG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;OAEG;IACH,SAAS,CAAC,EAAE,gBAAgB,CAAC;CAChC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,eAM5B,CAAC"}

package/dist/config.js CHANGED Viewed

@@ -1,3 +1,6 @@
+/**
+ * Default compiler options. Users may override selectively.
+ */
 export const defaultOptions = {
     choice: "all-optional",
     dateAs: "string",

package/dist/emit/clientEmitter.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"clientEmitter.d.ts","sourceRoot":"","sources":["../../src/emit/clientEmitter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;~~AAEpD~~,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,eAAe,EAAE,IAAI,EAAE,eAAe,GAAG;IAAE,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,~~QA6BpH~~"}
1	+ {"version":3,"file":"clientEmitter.d.ts","sourceRoot":"","sources":["../../src/emit/clientEmitter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAGpD,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,eAAe,EAAE,IAAI,EAAE,eAAe,GAAG;IAAE,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,QAkDpH"}

package/dist/emit/clientEmitter.js CHANGED Viewed

@@ -1,4 +1,5 @@
 import fs from "node:fs";
+import { pascal } from "../util/xml.js";
 export function emitClient(outFile, compiled, opts) {
     const ext = opts.importExt ?? ".js";
     const lines = [];
@@ -6,7 +7,18 @@ export function emitClient(outFile, compiled, opts) {
     lines.push(`import { ATTR_SPEC, CHILD_TYPE, PROP_META } from "./meta${ext}";`);
     lines.push(`import type * as T from "./types${ext}";`);
     lines.push("");
-    lines.push(`export class GeneratedSoapClient {`);
+    // 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");
+    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 });`);
@@ -14,14 +26,24 @@ export function emitClient(outFile, compiled, opts) {
     lines.push(`  }`);
     for (const op of compiled.operations) {
         const m = op.name;
-        lines.push(`  /** SOAPAction: ${op.soapAction} */`);
-        lines.push(`  async ${m}(args: any): Promise<any> {`);
+        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 : [];
+        lines.push(`  /** SOAPAction: ${op.soapAction}${secHints.length ? `\n   * Security (WSDL policy hint): ${secHints.join(", ")}` : ""} */`);
+        lines.push(`  async ${m}(args: ${inTs}): Promise<${outTs}> {`);
         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()."); }`);
+        }
         lines.push(`    const meta = { ATTR_SPEC, CHILD_TYPE, PROP_META } as const;`);
-        lines.push(`    const soapArgs = toSoapArgs(args, "${m}", meta, this.attributesKey);`);
+        lines.push(`    const soapArgs = toSoapArgs(args as any, "${inMetaKey}", meta, this.attributesKey);`);
         lines.push(`    return new Promise((resolve, reject) => {`);
         lines.push(`      c['${m}'](soapArgs, (err: any, result: any) => {`);
-        lines.push(`        if (err) reject(err); else resolve(fromSoapResult(result, "${m}", meta, this.attributesKey));`);
+        lines.push(`        if (err) reject(err); else resolve(fromSoapResult(result, "${outMetaKey}", meta, this.attributesKey));`);
         lines.push(`      });`);
         lines.push(`    });`);
         lines.push(`  }`);

package/dist/emit/runtimeEmitter.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"runtimeEmitter.d.ts","sourceRoot":"","sources":["../../src/emit/runtimeEmitter.ts"],"names":[],"mappings":"AAGA,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,~~QAuF1C~~"}
1	+ {"version":3,"file":"runtimeEmitter.d.ts","sourceRoot":"","sources":["../../src/emit/runtimeEmitter.ts"],"names":[],"mappings":"AAGA,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,QAoF1C"}

package/dist/emit/runtimeEmitter.js CHANGED Viewed

@@ -9,6 +9,7 @@ export type CreateSoapClientOptions = {
   endpoint?: string;
   wsdlOptions?: Record<string, any>;
   requestOptions?: Record<string, any>;
+  security?: any; // pass an instance of a node-soap security class, e.g., new soap.WSSecurity("user","pass")
 }
 export type AttrSpec = Record<string, readonly string[]>;
 export type ChildType = Record<string, Readonly<Record<string, string>>>;
@@ -17,12 +18,8 @@ export type PropMeta = Record<string, Readonly<Record<string, any>>>;
 export async function createSoapClient(opts: CreateSoapClientOptions): Promise<any> {
   const client = await soap.createClientAsync(opts.wsdlUrl, opts.wsdlOptions || {});
   if (opts.endpoint) client.setEndpoint(opts.endpoint);
-  if (opts.requestOptions) {
-    const { wsdlUrl, endpoint, wsdlOptions, ...req } = opts as any;
-    if (client.setSecurity && req) {
-      // security is caller's responsibility (if needed)
-    }
-  }
+  if (opts.security) client.setSecurity(opts.security);
+  // security and any request-specific configuration are the caller's responsibility
   return client;
 }

package/dist/index.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;~~AAYnD~~,wBAAsB,oBAAoB,~~CAAC~~,KAAK,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,eAAe,CAAA;CAAE,~~iBAiC5G~~;~~AAID~~,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"}
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"}

package/dist/index.js CHANGED Viewed

@@ -8,39 +8,50 @@ 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
 // noinspection JSUnusedGlobalSymbols
 export async function compileWsdlToProject(input) {
-    const opts = { ...defaultOptions, ...(input.options || {}) };
-    // Backward-compat: map legacy flags to primitive preferences unless explicitly provided
-    const primitive = { ...(opts.primitive || {}) };
-    if (opts.dateAs && primitive.dateAs == null)
-        primitive.dateAs = opts.dateAs === "date" ? "Date" : "string";
-    if (opts.intAs && (primitive.int64As == null || primitive.bigIntegerAs == null)) {
-        const as = opts.intAs; // "number" | "string"
-        if (primitive.int64As == null)
-            primitive.int64As = as;
-        if (primitive.bigIntegerAs == null)
-            primitive.bigIntegerAs = as;
+    // 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";
     }
-    const mergedOpts = { ...opts, primitive };
-    const catalog = await loadWsdl(input.wsdl);
-    console.log(`Loaded WSDL: ${catalog.wsdlUri}`);
-    const compiled = compileCatalog(catalog, mergedOpts);
-    console.log(`Schemas discovered: ${catalog.schemas.length}`);
-    console.log(`Compiled types: ${compiled.types.length}`);
-    console.log(`Operations: ${compiled.operations.length}`);
+    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)
+    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);
+    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 });
-    const typesPath = path.join(input.outDir, "types.ts");
-    const metaPath = path.join(input.outDir, "meta.ts");
-    const opsPath = path.join(input.outDir, "operations.json");
-    const clientPath = path.join(input.outDir, "client.ts");
-    const runtimePath = path.join(input.outDir, "runtime.ts");
-    emitTypes(typesPath, compiled);
-    emitMeta(metaPath, compiled, mergedOpts);
-    emitOperations(opsPath, compiled);
-    emitClient(clientPath, compiled, mergedOpts);
-    emitRuntime(path.join(runtimePath, "runtime.ts"));
+    // Define target paths
+    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 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);
 }
-// Public API re-exports for library users
+// Re-export public API for library consumers
 export { compileCatalog } from "./compiler/schemaCompiler.js";
 export { xsdToTsPrimitive } from "./xsd/primitives.js";

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@techspokes/typescript-wsdl-client",
-  "version": "0.1.9",
+  "version": "0.2.2",
   "description": "TypeScript WSDL → SOAP client generator with full xs:attribute support, complex types, sequences, inheritance, and namespace-collision merging.",
   "keywords": [
     "wsdl",
@@ -53,7 +53,7 @@
     "prepublishOnly": "npm run clean && npm run build",
     "test": "exit 0",
     "smoke": "tsx src/cli.ts --help",
-    "smoke:gen": "rimraf tmp && tsx src/cli.ts --wsdl examples/minimal/echo.wsdl --out tmp && tsc --noEmit --module NodeNext --moduleResolution NodeNext --target ES2022 tmp/types.ts tmp/meta.ts tmp/operations.ts tmp/runtime.ts tmp/client.ts src/types/soap.d.ts",
+    "smoke:gen": "rimraf tmp && tsx src/cli.ts --wsdl examples/minimal/weather.wsdl --out tmp && tsc --noEmit --module NodeNext --moduleResolution NodeNext --target ES2022 tmp/types.ts tmp/meta.ts tmp/operations.ts tmp/runtime.ts tmp/client.ts src/types/soap.d.ts",
     "ci": "npm run build && npm run typecheck && npm run smoke && npm run smoke:gen"
   },
   "devDependencies": {