@techspokes/typescript-wsdl-client 1.1.8 → 1.2.0

package/dist/compiler/rpcStringValues.js

@@ -0,0 +1,196 @@
+/** Bounded SOAP 1.1 RPC string serialization, without a second schema engine.
+ * @since 1.1.9
+ * @see https://www.w3.org/TR/2000/NOTE-SOAP-20000508/ Sections 5 and 7.
+ */
+import { isXmlNCName, resolveLexicalQName, syntaxAttribute, syntaxElements, XSD_NAMESPACE, XML_NAMESPACE } from '../loader/orderedSyntax.js';
+import { isXmlCharacters } from './directStructurePlan.js';
+import { directDataOwnership } from './directExecutionPolicy.js';
+const SOAP = 'http://schemas.xmlsoap.org/soap/envelope/';
+const ENC = 'http://schemas.xmlsoap.org/soap/encoding/';
+const XSI = 'http://www.w3.org/2001/XMLSchema-instance';
+/** Build canonical inline string parameters in source declaration order.
+ * @param root Source-owned typed parameters.
+ * @param value Data-only application object.
+ * @param control Shared invocation ownership and work budget.
+ * @returns A generated RPC wrapper and preserved string values.
+ * @throws Through the supplied failure callback for invalid application values.
+ */
+export function expandRpcStrings(root, value, control) {
+    const { budget, check, fail } = control;
+    let owned;
+    try {
+        owned = directDataOwnership(budget).snapshot(value, check);
+    }
+    catch (error) {
+        if (error instanceof TypeError)
+            return fail('value-invalid', 'rpc-data-object-required');
+        throw error;
+    }
+    if (!owned || typeof owned !== 'object' || Array.isArray(owned))
+        return fail('value-invalid', 'rpc-data-object-required');
+    const object = owned;
+    const keys = Object.keys(object), names = new Set(root.parts.map(part => { check(); return part.name; }));
+    budget.chargeWork(64 + keys.length * 32 + names.size * 32);
+    if (keys.length !== root.parts.length || keys.some(key => { check(); return !names.has(key); }))
+        return fail('value-invalid', 'rpc-required-string-parts');
+    const namespaces = { xml: XML_NAMESPACE, '': '', rpc: root.bodyNamespace, xsi: XSI, xsd: XSD_NAMESPACE, enc: ENC, soap: SOAP };
+    const attribute = (namespace, local, value) => ({ name: { namespace, local }, lexicalName: local, value });
+    const result = Object.create(null);
+    const children = root.parts.map(part => {
+        check();
+        const text = object[part.name];
+        if (typeof text !== 'string')
+            return fail('value-invalid', 'rpc-required-string-parts');
+        budget.chargeWork(64 + text.length * 8);
+        if (!isXmlCharacters(text))
+            return fail('value-invalid', 'rpc-string-xml-characters');
+        result[part.name] = text;
+        return { kind: 'element', name: { namespace: '', local: part.name }, lexicalName: part.name, namespaces, baseUri: root.source.uri,
+            attributes: [attribute(XSI, 'type', 'xsd:string')], children: [{ kind: 'text', value: text, source: root.source }], source: root.source };
+    });
+    return { payload: { kind: 'element', name: root.wrapper, lexicalName: 'rpc:' + root.wrapper.local, namespaces,
+            baseUri: root.source.uri, attributes: [attribute(SOAP, 'encodingStyle', ENC)], children, source: root.source }, value: result };
+}
+/** Decode only the selected inline/local-reference string profile within one retained Body.
+ * @param root Source-owned typed parameters and body namespace.
+ * @param payload Observed RPC wrapper or observed SOAP Body.
+ * @param output Whether SOAP response local names are insignificant.
+ * @param control Shared native invocation budget and explicit failure callback.
+ * @returns Values keyed by the original WSDL part names.
+ * @throws Through the failure callback for malformed, ambiguous or unsupported encoded values.
+ */
+export function readRpcStrings(root, payload, output, control) {
+    const { budget, check, fail } = control;
+    const elements = (node) => {
+        check();
+        budget.chargeWork(32 + node.children.length * 8 + node.attributes.length * 16);
+        if (node.children.some(c => c.kind === 'text' && /[^\t\r\n ]/.test(c.value)))
+            return fail('mismatch', 'rpc-unexpected-text', node);
+        return syntaxElements(node);
+    };
+    const encoding = (node) => {
+        const declared = syntaxAttribute(node, 'encodingStyle', SOAP);
+        if (declared !== undefined && declared.trim() !== ENC)
+            return fail('unsupported', 'rpc-encoding-style', node);
+    };
+    const rootMarker = (node) => {
+        const marker = syntaxAttribute(node, 'root', ENC);
+        if (marker !== undefined && marker !== '0' && marker !== '1')
+            return fail('mismatch', 'rpc-root-marker', node);
+        return marker;
+    };
+    const attrs = (node, wrapper = false) => {
+        encoding(node);
+        rootMarker(node);
+        for (const attr of node.attributes) {
+            check();
+            if (attr.name.namespace === SOAP && attr.name.local === 'encodingStyle' || attr.name.namespace === ENC && attr.name.local === 'root'
+                || attr.name.namespace === '' && attr.name.local === 'id' || !wrapper && (attr.name.namespace === '' && attr.name.local === 'href'
+                || attr.name.namespace === XSI && attr.name.local === 'type'))
+                continue;
+            return fail('unsupported', 'rpc-encoded-attribute', node);
+        }
+    };
+    const body = payload.name.namespace === SOAP && payload.name.local === 'Body' ? payload : undefined;
+    if (body) {
+        encoding(body);
+        if (body.attributes.some(a => a.name.namespace !== SOAP || a.name.local !== 'encodingStyle'))
+            return fail('unsupported', 'rpc-body-attribute', body);
+    }
+    const top = body ? elements(body) : [payload];
+    const ids = new Map();
+    const pending = [...top];
+    while (pending.length) {
+        check();
+        const node = pending.pop();
+        budget.chargeWork(32 + node.children.length * 8);
+        const id = syntaxAttribute(node, 'id');
+        if (id !== undefined) {
+            if (!isXmlNCName(id) || ids.has(id))
+                return fail('mismatch', 'rpc-duplicate-or-invalid-id', node);
+            ids.set(id, node);
+        }
+        pending.push(...syntaxElements(node));
+    }
+    const wrappers = top.filter(node => {
+        check();
+        return node.name.namespace === root.bodyNamespace && rootMarker(node) !== '0'
+            && syntaxAttribute(node, 'href') === undefined && syntaxAttribute(node, 'type', XSI) === undefined
+            && (!output ? node.name.local === root.wrapper.local : true);
+    });
+    if (wrappers.length !== 1)
+        return fail('mismatch', 'rpc-unambiguous-response-root', payload);
+    const wrapper = wrappers[0];
+    attrs(wrapper, true);
+    const parameters = elements(wrapper);
+    if (parameters.length !== root.parts.length)
+        return fail('mismatch', 'rpc-result-accessor-count', wrapper);
+    const visited = new Set([wrapper]);
+    const stringValue = (initial) => {
+        const chain = new Set();
+        let node = initial, inheritedType = true;
+        // @constraints Flat local-reference chains must not consume the JavaScript call stack.
+        for (;;) {
+            check();
+            budget.chargeWork(32 + node.children.length * 8);
+            attrs(node);
+            if (chain.has(node))
+                return fail('unsupported', 'rpc-cyclic-reference', node);
+            chain.add(node);
+            visited.add(node);
+            const explicit = syntaxAttribute(node, 'type', XSI);
+            const implicit = node.name.namespace === ENC && node.name.local === 'string';
+            if (node.name.namespace === ENC && !implicit)
+                return fail('unsupported', 'rpc-string-type', node);
+            if (explicit !== undefined) {
+                let type;
+                try {
+                    type = resolveLexicalQName(explicit, node);
+                }
+                catch {
+                    return fail('unsupported', 'rpc-string-type', node);
+                }
+                if (type.local !== 'string' || type.namespace !== XSD_NAMESPACE && type.namespace !== ENC)
+                    return fail('unsupported', 'rpc-string-type', node);
+            }
+            else if (!inheritedType && !implicit)
+                return fail('unsupported', 'rpc-string-type-required', node);
+            const href = syntaxAttribute(node, 'href');
+            if (href !== undefined) {
+                if (syntaxElements(node).length || node.children.some(c => c.kind === 'text' && /[^\t\r\n ]/.test(c.value)))
+                    return fail('mismatch', 'rpc-reference-content', node);
+                if (!href.startsWith('#') || !isXmlNCName(href.slice(1)))
+                    return fail('unsupported', 'rpc-local-reference-required', node);
+                const target = ids.get(href.slice(1));
+                if (!target)
+                    return fail('mismatch', 'rpc-dangling-reference', node);
+                node = target;
+                inheritedType = false;
+                continue;
+            }
+            if (syntaxElements(node).length)
+                return fail('unsupported', 'rpc-string-compound-value', node);
+            const value = node.children.map(c => c.kind === 'text' ? c.value : '').join('');
+            budget.chargeWork(32 + value.length * 8);
+            return value;
+        }
+    };
+    const result = Object.create(null);
+    root.parts.forEach((part, index) => {
+        check();
+        const accessor = parameters[index];
+        if (accessor.name.namespace !== '' || !output && accessor.name.local !== part.name)
+            return fail('mismatch', 'rpc-parameter-name-order', accessor);
+        if (rootMarker(accessor) !== undefined)
+            return fail('unsupported', 'rpc-accessor-root-marker', accessor);
+        result[part.name] = stringValue(accessor);
+    });
+    for (const independent of top) {
+        check();
+        if (independent === wrapper)
+            continue;
+        if (!visited.has(independent) || rootMarker(independent) === '1')
+            return fail('mismatch', 'rpc-unexpected-body-content', independent);
+    }
+    return result;
+}

package/dist/compiler/rpcTypedValues.d.ts

@@ -0,0 +1,48 @@
+import type { GraphNode, Reference } from './canonicalGraph.js';
+import type { SemanticContext } from './semanticContext.js';
+import type { RpcMessageRoot } from './directOperation.js';
+import type { DirectProjectionPlan } from './directStructurePlan.js';
+import type { ExpandedName, SyntaxElement } from '../loader/orderedSyntax.js';
+type Scalar = string | boolean;
+export type RpcTypedValue = Readonly<Record<string, Scalar | Readonly<Record<string, boolean>>>>;
+type Fail = (kind: 'value-invalid' | 'unsupported' | 'mismatch', rule: string, node?: SyntaxElement) => never;
+type Control = {
+    check(): void;
+    fail: Fail;
+};
+export interface RpcPartPlan {
+    readonly name: string;
+    readonly reference: Reference;
+    readonly owner: GraphNode;
+    readonly type: ExpandedName;
+    readonly projection: DirectProjectionPlan;
+}
+/** Plan actual message parts; original source references remain native authority.
+ * @param context Exact qualified context.
+ * @param root Source-owned RPC message.
+ * @param control Shared cancellation and refusal controls.
+ * @returns Native scalar/flat Boolean record plans in WSDL declaration order.
+ */
+export declare function planRpcParts(context: SemanticContext, root: RpcMessageRoot, control: Control): readonly RpcPartPlan[];
+/** Expand typed values with native restrictions and canonical inline type accessors.
+ * @param context Exact qualified context.
+ * @param root Source-owned RPC parameters.
+ * @param plans Native type plans.
+ * @param application Data-only JSON value.
+ * @param control Shared invocation controls.
+ * @returns Canonical RPC wrapper plus its validated application value.
+ */
+export declare function expandRpcTyped(context: SemanticContext, root: RpcMessageRoot, plans: readonly RpcPartPlan[], application: unknown, control: Control): {
+    payload: SyntaxElement;
+    value: RpcTypedValue;
+};
+/** Validate actual dispatched inline parameters through native scalar/particle duties.
+ * @param context Exact source context.
+ * @param root Source-owned RPC input.
+ * @param plans Native type plans.
+ * @param payload Actual outgoing envelope Body or wrapper.
+ * @param control Shared execution controls.
+ * @returns Validated values keyed by original message part names.
+ */
+export declare function readRpcTyped(context: SemanticContext, root: RpcMessageRoot, plans: readonly RpcPartPlan[], payload: SyntaxElement, control: Control): RpcTypedValue;
+export {};

package/dist/compiler/rpcTypedValues.js

@@ -0,0 +1,190 @@
+/** Typed RPC composition over native scalar and record owners.
+ * @since 1.1.9
+ * @constraints Canonical inline parameters; no encoded request graph or array support.
+ */
+import { globalId } from './canonicalGraph.js';
+import { planProjectionType, matchOrderedProjection, isXmlCharacters } from './directStructurePlan.js';
+import { assessProjectionTypeOperand } from './projectionScalar.js';
+import { resolveLexicalQName, syntaxAttribute, syntaxElements, XSD_NAMESPACE, XML_NAMESPACE } from '../loader/orderedSyntax.js';
+import { directDataOwnership } from './directExecutionPolicy.js';
+const SOAP = 'http://schemas.xmlsoap.org/soap/envelope/';
+const ENC = 'http://schemas.xmlsoap.org/soap/encoding/';
+const XSI = 'http://www.w3.org/2001/XMLSchema-instance';
+/** Plan actual message parts; original source references remain native authority.
+ * @param context Exact qualified context.
+ * @param root Source-owned RPC message.
+ * @param control Shared cancellation and refusal controls.
+ * @returns Native scalar/flat Boolean record plans in WSDL declaration order.
+ */
+export function planRpcParts(context, root, control) {
+    const found = context.lookup(globalId('message', root.message));
+    if (found.kind !== 'found' || found.node.kind !== 'wsdl' || found.node.role !== 'message')
+        return control.fail('unsupported', 'rpc-message-owner');
+    const owner = found.node;
+    return Object.freeze(root.parts.map(part => {
+        control.check();
+        context.budget.chargeWork(128);
+        const resolved = context.resolve(part.type);
+        const type = resolved.kind === 'builtin' ? resolved.name : resolved.kind === 'found' && resolved.node.identity.kind === 'global'
+            ? resolved.node.identity.name : control.fail('unsupported', 'rpc-named-type-required');
+        const projection = planProjectionType(context, owner, part.type, control.check, () => control.fail('unsupported', 'rpc-native-type-shape'));
+        const scalar = (value) => value.kind === 'scalar' && !value.list && !value.nillable
+            && ['string', 'boolean', 'decimal', 'integer', 'date', 'dateTime'].includes(value.builtin.local);
+        if (projection.root.kind === 'scalar') {
+            if (!scalar(projection.root))
+                return control.fail('unsupported', 'rpc-scalar-representation');
+        }
+        else {
+            const record = projection.records.find(record => record.type.id === projection.root.type);
+            if (projection.records.length !== 1 || record.content !== 'element-only' || record.attributes.length || record.attributeWildcard
+                || !record.ordered || record.keyed || record.contextual || record.slots.some(slot => !scalar(slot.value)
+                || slot.value.kind !== 'scalar' || slot.value.builtin.local !== 'boolean' || slot.particle.occurs.min !== '1' || slot.particle.occurs.max !== '1'))
+                return control.fail('unsupported', 'rpc-flat-boolean-record');
+        }
+        return Object.freeze({ name: part.name, reference: part.type, owner, type, projection });
+    }));
+}
+function scalar(context, owner, reference, shape, lexical, node, control) {
+    if (shape.kind !== 'scalar' || !isXmlCharacters(lexical))
+        return control.fail('value-invalid', 'rpc-scalar-characters', node);
+    const assessed = assessProjectionTypeOperand(context, owner, reference, { value: lexical, context: { namespaces: node.namespaces, source: node.source } }, control.check);
+    if (assessed.kind !== 'projection-scalar-operand')
+        return control.fail('value-invalid', 'rule' in assessed ? assessed.rule : 'rpc-scalar-budget', node);
+    if (shape.constraint?.kind === 'fixed' && assessed.operand.canonical !== shape.constraint.canonical)
+        return control.fail('value-invalid', 'fixed-element-value', node);
+    return shape.builtin.local === 'boolean' ? assessed.operand.canonical === 'true' : lexical;
+}
+function recordOf(part) { return part.projection.records[0]; }
+function object(value, names, control) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return control.fail('value-invalid', 'rpc-data-object-required');
+    const keys = Object.keys(value);
+    if (keys.length !== names.length || keys.some(key => !names.includes(key)))
+        return control.fail('value-invalid', 'rpc-required-parts');
+    return value;
+}
+/** Expand typed values with native restrictions and canonical inline type accessors.
+ * @param context Exact qualified context.
+ * @param root Source-owned RPC parameters.
+ * @param plans Native type plans.
+ * @param application Data-only JSON value.
+ * @param control Shared invocation controls.
+ * @returns Canonical RPC wrapper plus its validated application value.
+ */
+export function expandRpcTyped(context, root, plans, application, control) {
+    let owned;
+    try {
+        owned = directDataOwnership(context.budget).snapshot(application, control.check);
+    }
+    catch (error) {
+        if (error instanceof TypeError)
+            return control.fail('value-invalid', 'rpc-data-object-required');
+        throw error;
+    }
+    const input = object(owned, plans.map(part => part.name), control);
+    const namespaces = { xml: XML_NAMESPACE, '': '', rpc: root.bodyNamespace, xsi: XSI, xsd: XSD_NAMESPACE, enc: ENC, soap: SOAP };
+    const typeNamespaces = [...new Set(plans.map(part => part.type.namespace))].filter(ns => ns !== XSD_NAMESPACE).sort();
+    typeNamespaces.forEach((namespace, index) => { namespaces['t' + index] = namespace; });
+    const element = (name, value, shape, owner, reference, type) => {
+        control.check();
+        context.budget.chargeWork(256);
+        const prefix = type?.namespace === XSD_NAMESPACE ? 'xsd' : type ? 't' + typeNamespaces.indexOf(type.namespace) : '';
+        const node = { kind: 'element', name, lexicalName: name.local, namespaces, baseUri: root.source.uri, source: root.source,
+            attributes: type ? [{ name: { namespace: XSI, local: 'type' }, lexicalName: 'xsi:type', value: prefix + ':' + type.local }] : [], children: [] };
+        if (shape.kind !== 'scalar')
+            return control.fail('unsupported', 'rpc-scalar-required');
+        const lexical = shape.builtin.local === 'boolean' ? typeof value === 'boolean' ? String(value) : control.fail('value-invalid', 'boolean-required')
+            : typeof value === 'string' ? value : control.fail('value-invalid', 'string-required');
+        scalar(context, owner, reference, shape, lexical, node, control);
+        return { ...node, children: [{ kind: 'text', value: lexical, source: root.source }] };
+    };
+    const children = plans.map(part => {
+        if (part.projection.root.kind === 'scalar')
+            return element({ namespace: '', local: part.name }, input[part.name], part.projection.root, part.owner, part.reference, part.type);
+        const record = recordOf(part), value = object(input[part.name], record.slots.map(slot => slot.element.name.local), control);
+        const fields = record.slots.map(slot => element(slot.element.name, value[slot.element.name.local], slot.value, slot.element, slot.element.type, slot.value.kind === 'scalar' ? slot.value.builtin : undefined));
+        const prefix = 't' + typeNamespaces.indexOf(part.type.namespace);
+        return { kind: 'element', name: { namespace: '', local: part.name }, lexicalName: part.name, namespaces, baseUri: root.source.uri, source: root.source,
+            attributes: [{ name: { namespace: XSI, local: 'type' }, lexicalName: 'xsi:type', value: prefix + ':' + part.type.local }], children: fields };
+    });
+    const payload = { kind: 'element', name: root.wrapper, lexicalName: 'rpc:' + root.wrapper.local, namespaces,
+        baseUri: root.source.uri, source: root.source, attributes: [{ name: { namespace: SOAP, local: 'encodingStyle' }, lexicalName: 'soap:encodingStyle', value: ENC }], children };
+    return { payload, value: readRpcTyped(context, root, plans, payload, control) };
+}
+/** Validate actual dispatched inline parameters through native scalar/particle duties.
+ * @param context Exact source context.
+ * @param root Source-owned RPC input.
+ * @param plans Native type plans.
+ * @param payload Actual outgoing envelope Body or wrapper.
+ * @param control Shared execution controls.
+ * @returns Validated values keyed by original message part names.
+ */
+export function readRpcTyped(context, root, plans, payload, control) {
+    const elements = (node) => {
+        control.check();
+        context.budget.chargeWork(64 + node.children.length * 16);
+        if (node.children.some(child => child.kind === 'text' && /[^\t\r\n ]/.test(child.value)))
+            return control.fail('mismatch', 'rpc-unexpected-text', node);
+        return syntaxElements(node);
+    };
+    const attrs = (node, type) => {
+        for (const attribute of node.attributes) {
+            control.check();
+            if (attribute.name.namespace === SOAP && attribute.name.local === 'encodingStyle' && attribute.value === ENC)
+                continue;
+            if (type && attribute.name.namespace === XSI && attribute.name.local === 'type') {
+                let actual;
+                try {
+                    actual = resolveLexicalQName(attribute.value, node);
+                }
+                catch {
+                    return control.fail('unsupported', 'rpc-typed-accessor', node);
+                }
+                if (actual.namespace === type.namespace && actual.local === type.local)
+                    continue;
+            }
+            return control.fail('unsupported', 'rpc-typed-accessor', node);
+        }
+    };
+    if (payload.name.namespace === SOAP && payload.name.local === 'Body') {
+        attrs(payload);
+        const wrappers = elements(payload);
+        if (wrappers.length !== 1)
+            return control.fail('mismatch', 'rpc-request-wrapper', payload);
+        payload = wrappers[0];
+    }
+    if (payload.name.namespace !== root.wrapper.namespace || payload.name.local !== root.wrapper.local)
+        return control.fail('mismatch', 'rpc-request-wrapper', payload);
+    attrs(payload);
+    const parameters = elements(payload);
+    if (parameters.length !== plans.length)
+        return control.fail('mismatch', 'rpc-parameter-count', payload);
+    const result = Object.create(null);
+    plans.forEach((part, index) => {
+        const node = parameters[index];
+        if (node.name.namespace !== '' || node.name.local !== part.name)
+            return control.fail('mismatch', 'rpc-parameter-name-order', node);
+        attrs(node, part.type);
+        const readScalar = (node, owner, reference, shape) => {
+            if (syntaxElements(node).length)
+                return control.fail('mismatch', 'rpc-scalar-content', node);
+            return scalar(context, owner, reference, shape, node.children.map(child => child.kind === 'text' ? child.value : '').join(''), node, control);
+        };
+        if (part.projection.root.kind === 'scalar')
+            result[part.name] = readScalar(node, part.owner, part.reference, part.projection.root);
+        else {
+            const record = recordOf(part), fields = elements(node);
+            const matched = matchOrderedProjection(context, record, fields.map(field => field.name), control.check);
+            if (!matched || matched.some(slot => 'kind' in slot))
+                return control.fail('mismatch', 'rpc-native-record-content', node);
+            const value = Object.create(null);
+            fields.forEach(field => {
+                const slot = record.slots.find(slot => slot.element.name.local === field.name.local && slot.element.name.namespace === field.name.namespace);
+                attrs(field, slot.value.kind === 'scalar' ? slot.value.builtin : undefined);
+                value[slot.element.name.local] = readScalar(field, slot.element, slot.element.type, slot.value);
+            });
+            result[part.name] = value;
+        }
+    });
+    return result;
+}