@techspokes/typescript-wsdl-client 1.2.0 → 1.4.0

package/dist/compiler/soapHeaders.d.ts

@@ -1,4 +1,4 @@
-/** SOAP 1.1 response-header clauses for the component transport's default ultimate-receiver role. */
+/** SOAP response-header clauses for the component transport's default ultimate-receiver role. */
 import type { ExpandedName, SyntaxElement } from '../loader/orderedSyntax.js';
 export type ComponentSoapHeaderResult = Readonly<{
     kind: 'ignored-optional-headers';
@@ -9,8 +9,14 @@ export type ComponentSoapHeaderResult = Readonly<{
 }>;
 /** Assess borrowed parsed Header syntax without claiming unknown block semantics.
  * @remarks SOAP 1.1 sections 4.2 through 4.2.3 require qualified block names and define absent mustUnderstand
- *   as 0. Only immediate block attributes govern header processing. Actor-directed processing and mandatory
- *   block semantics remain unsupported; no security/header emission capability is acquired here.
+ *   as 0. SOAP 1.2 additionally defines boolean lexicals and role/relay attributes. Only immediate block
+ *   attributes govern processing. Unknown mandatory blocks targeted at this receiver remain unsupported.
+ * @param header Parsed Header in the selected envelope namespace.
+ * @param check Invocation-owned cancellation and work accounting.
+ * @param version Selected SOAP binding version; omission retains SOAP 1.1 compatibility.
+ * @returns Unprocessed block names or an explicit protocol/capability refusal.
+ * @throws Propagates caller cancellation and resource exceptions from check.
  * @see https://www.w3.org/TR/2000/NOTE-SOAP-20000508/
+ * @see https://www.w3.org/TR/soap12-part1/#soapheadblock
  */
-export declare function assessComponentSoapHeader(header: SyntaxElement, check: () => void): ComponentSoapHeaderResult;
+export declare function assessComponentSoapHeader(header: SyntaxElement, check: () => void, version?: '1.1' | '1.2'): ComponentSoapHeaderResult;

package/dist/compiler/soapHeaders.js

@@ -1,13 +1,20 @@
 const SOAP = 'http://schemas.xmlsoap.org/soap/envelope/';
 /** Assess borrowed parsed Header syntax without claiming unknown block semantics.
  * @remarks SOAP 1.1 sections 4.2 through 4.2.3 require qualified block names and define absent mustUnderstand
- *   as 0. Only immediate block attributes govern header processing. Actor-directed processing and mandatory
- *   block semantics remain unsupported; no security/header emission capability is acquired here.
+ *   as 0. SOAP 1.2 additionally defines boolean lexicals and role/relay attributes. Only immediate block
+ *   attributes govern processing. Unknown mandatory blocks targeted at this receiver remain unsupported.
+ * @param header Parsed Header in the selected envelope namespace.
+ * @param check Invocation-owned cancellation and work accounting.
+ * @param version Selected SOAP binding version; omission retains SOAP 1.1 compatibility.
+ * @returns Unprocessed block names or an explicit protocol/capability refusal.
+ * @throws Propagates caller cancellation and resource exceptions from check.
  * @see https://www.w3.org/TR/2000/NOTE-SOAP-20000508/
+ * @see https://www.w3.org/TR/soap12-part1/#soapheadblock
  */
-export function assessComponentSoapHeader(header, check) {
+export function assessComponentSoapHeader(header, check, version = '1.1') {
     check();
-    if (header.name.namespace !== SOAP || header.name.local !== 'Header' || header.attributes.length)
+    const namespace = version === '1.2' ? 'http://www.w3.org/2003/05/soap-envelope' : SOAP;
+    if (header.name.namespace !== namespace || header.name.local !== 'Header' || header.attributes.length)
         return Object.freeze({ kind: 'protocol', rule: 'SOAP Header shape' });
     const headers = [];
     for (const child of header.children) {
@@ -20,21 +27,33 @@ export function assessComponentSoapHeader(header, check) {
         if (!child.name.namespace)
             return Object.freeze({ kind: 'protocol', rule: 'SOAP header block namespace required' });
         let mandatory = false;
+        let targeted = true;
         for (const attribute of child.attributes) {
             check();
-            if (attribute.name.namespace !== SOAP)
+            if (attribute.name.namespace !== namespace)
                 continue;
+            if (version === '1.2' && attribute.name.local === 'role') {
+                if (!/^[A-Za-z][A-Za-z0-9+.-]*:/.test(attribute.value))
+                    return Object.freeze({ kind: 'protocol', rule: 'SOAP role URI' });
+                targeted = [namespace + '/role/next', namespace + '/role/ultimateReceiver'].includes(attribute.value);
+                continue;
+            }
+            if (version === '1.2' && attribute.name.local === 'relay') {
+                if (!['true', 'false', '1', '0'].includes(attribute.value))
+                    return Object.freeze({ kind: 'protocol', rule: 'SOAP relay boolean' });
+                continue;
+            }
             if (attribute.name.local === 'actor')
                 return Object.freeze({ kind: 'unsupported', rule: 'SOAP actor header capability required' });
             if (attribute.name.local === 'mustUnderstand') {
-                if (attribute.value !== '0' && attribute.value !== '1')
-                    return Object.freeze({ kind: 'protocol', rule: 'SOAP 1.1 mustUnderstand value' });
-                mandatory = attribute.value === '1';
+                if (!(version === '1.2' ? ['true', 'false', '1', '0'] : ['0', '1']).includes(attribute.value))
+                    return Object.freeze({ kind: 'protocol', rule: `SOAP ${version} mustUnderstand value` });
+                mandatory = attribute.value === '1' || attribute.value === 'true';
             }
             else if (attribute.name.local !== 'encodingStyle')
                 return Object.freeze({ kind: 'unsupported', rule: 'unknown SOAP header attribute' });
         }
-        if (mandatory)
+        if (mandatory && targeted)
             return Object.freeze({ kind: 'unsupported', rule: 'incoming mandatory SOAP header' });
         headers.push(Object.freeze({ ...child.name }));
     }

package/dist/compiler/sourceCorrections.d.ts

@@ -0,0 +1,118 @@
+import type { SchemaInput } from "../loader/schemaInput.js";
+import type { OfflineSchemaResource } from "../loader/schemaResources.js";
+import type { GraphNode, NodeId } from "./canonicalGraph.js";
+export type SourceCorrectionSelector = Readonly<{
+    id: NodeId;
+    uri: string;
+    digest: string;
+}>;
+export type SourceCorrectionInventoryNode = Readonly<{
+    id: NodeId;
+    kind: GraphNode["kind"];
+    role: string;
+    namespace: string;
+    name?: Readonly<{
+        namespace: string;
+        local: string;
+    }>;
+    syntaxName: Readonly<{
+        namespace: string;
+        local: string;
+    }>;
+    uri: string;
+    digest: string;
+    path: string;
+    start: number;
+    end: number;
+    attributes: readonly Readonly<{
+        name: string;
+        namespace: string;
+        lexicalName: string;
+        value: string;
+    }>[];
+    occurs?: Readonly<{
+        min: string;
+        max: string | "unbounded";
+    }>;
+    wildcard?: Readonly<{
+        namespace: string;
+        processContents: string;
+    }>;
+    children?: readonly NodeId[];
+    parent?: NodeId;
+    chameleon: boolean;
+    ambiguousContext: boolean;
+}>;
+export type SourceCorrectionInventory = Readonly<{
+    version: 1;
+    resources: readonly Readonly<{
+        uri: string;
+        digest: string;
+        byteLength: number;
+    }>[];
+    nodes: readonly SourceCorrectionInventoryNode[];
+}>;
+type OccursCorrection = Readonly<{
+    kind: "set-occurs";
+    target: SourceCorrectionSelector;
+    min: string;
+    max: string | "unbounded";
+}>;
+type WildcardCorrection = Readonly<{
+    kind: "set-wildcard-namespaces";
+    target: SourceCorrectionSelector;
+    namespaces: readonly string[];
+}>;
+type InsertPosition = "append" | Readonly<{
+    kind: "before" | "after";
+    target: SourceCorrectionSelector;
+}>;
+type InsertElement = Readonly<{
+    kind: "declaration";
+    name: string;
+    type: Readonly<{
+        namespace: string;
+        local: string;
+    }>;
+    min: string;
+    max: string | "unbounded";
+} | {
+    kind: "reference";
+    target: SourceCorrectionSelector;
+    min: string;
+    max: string | "unbounded";
+}>;
+type InsertCorrection = Readonly<{
+    kind: "insert-element";
+    target: SourceCorrectionSelector;
+    position: InsertPosition;
+    element: InsertElement;
+}>;
+type Correction = OccursCorrection | WildcardCorrection | InsertCorrection;
+export type SourceCorrectionProvenance = Readonly<{
+    version: 1;
+    canonicalRecipeDigest: string;
+    resources: readonly Readonly<{
+        uri: string;
+        originalDigest: string;
+        effectiveDigest: string;
+        changed: boolean;
+    }>[];
+    corrections: readonly Readonly<{
+        kind: Correction["kind"];
+        target: SourceCorrectionSelector;
+    }>[];
+}>;
+export type PreparedCorrectedSourceInputs = Readonly<{
+    inventory: SourceCorrectionInventory;
+    resources: ReadonlyMap<string, OfflineSchemaResource>;
+    provenance: SourceCorrectionProvenance;
+}>;
+export declare class SourceCorrectionError extends Error {
+    readonly category: "invalid-recipe" | "stale-source" | "ambiguous-target" | "unsupported-target" | "resource-limit" | "cancelled";
+    constructor(category: "invalid-recipe" | "stale-source" | "ambiguous-target" | "unsupported-target" | "resource-limit" | "cancelled", message: string);
+}
+export declare function inspectSourceCorrectionInventory(inputs: readonly SchemaInput[], signal?: AbortSignal): SourceCorrectionInventory;
+/** Validate and apply a versioned correction recipe to an authenticated source union. */
+export declare function prepareCorrectedSourceInputs(inputs: readonly SchemaInput[], recipeValue: unknown, signal?: AbortSignal): PreparedCorrectedSourceInputs;
+export {};