@techspokes/typescript-wsdl-client 1.1.4 → 1.1.8

package/dist/compiler/wildcardAlgebra.js

@@ -0,0 +1,155 @@
+import { SemanticError } from './resolveCanonicalGraph.js';
+// Compatibility callers may already account for work; new semantic callers
+// pass their shared request charge. No semantic receipt or cache is issued here.
+const noCharge = () => { };
+function textEqual(a, b, charge) {
+    charge(1 + a.length + b.length);
+    return a === b;
+}
+function contains(values, value, charge) {
+    charge();
+    for (const item of values) {
+        charge();
+        if (textEqual(item, value, charge))
+            return true;
+    }
+    return false;
+}
+/** Deterministic insertion avoids an engine-dependent uncharged sort. */
+function canonical(values, charge) {
+    charge();
+    const result = [];
+    for (const value of values) {
+        charge();
+        let at = 0;
+        while (at < result.length) {
+            charge(1 + value.length + result[at].length);
+            if (value <= result[at])
+                break;
+            at++;
+        }
+        if (at < result.length && textEqual(value, result[at], charge))
+            continue;
+        charge(1 + result.length - at); // Entry and shifts, before allocation/mutation.
+        result.splice(at, 0, value);
+    }
+    charge(result.length + 1);
+    return Object.freeze(result);
+}
+function constraint(kind, values, charge) {
+    const namespaces = canonical(values, charge);
+    charge(4);
+    return Object.freeze({ kind, namespaces });
+}
+/** Canonical mathematical namespace properties; no XML lexical form is invented. */
+export function canonicalNamespaceConstraint(value, charge) {
+    return constraint(value.kind, value.namespaces, charge);
+}
+export function wildcardNamespaces(wildcard, charge = noCharge) {
+    const raw = wildcard.namespace.value;
+    charge(4 * raw.length + 4); // Scans and token/text output before regex/split.
+    const value = raw.replace(/^[\x20\t\r\n]+|[\x20\t\r\n]+$/g, '');
+    const namespace = wildcard.namespace.context.effectiveNamespace;
+    if (value === '##any')
+        return constraint('not', [], charge);
+    if (value === '##other')
+        return constraint('not', ['', namespace], charge);
+    const tokens = value.split(/[\x20\t\r\n]+/);
+    charge(tokens.length + 1);
+    const values = [];
+    for (const token of tokens) {
+        charge(token.length + 3);
+        if (!token || token.startsWith('##') && token !== '##local' && token !== '##targetNamespace') {
+            throw new SemanticError('invalid-schema', 'Invalid wildcard namespace constraint', undefined, wildcard.namespace.context.source);
+        }
+        charge();
+        values.push(token === '##local' ? '' : token === '##targetNamespace' ? namespace : token);
+    }
+    return constraint('set', values, charge);
+}
+export function namespaceAllows(value, namespace, charge = noCharge) {
+    const present = contains(value.namespaces, namespace, charge);
+    return value.kind === 'set' ? present : !present;
+}
+/** Mathematical inclusion; the XSD Wildcard Subset rule is stricter. */
+export function namespaceSetSubset(derived, base, charge = noCharge) {
+    charge();
+    if (derived.kind === 'set') {
+        for (const namespace of derived.namespaces) {
+            charge();
+            if (!namespaceAllows(base, namespace, charge))
+                return false;
+        }
+        return true;
+    }
+    if (base.kind === 'set')
+        return false; // A cofinite set cannot fit a finite one.
+    for (const namespace of base.namespaces) {
+        charge();
+        if (!contains(derived.namespaces, namespace, charge))
+            return false;
+    }
+    return true;
+}
+/** XSD 1.0 cos-ns-subset: non-any negations must have the same value. */
+export function namespaceSubset(derived, base, charge = noCharge) {
+    charge();
+    if (base.kind === 'not' && base.namespaces.length === 0)
+        return true;
+    if (derived.kind === 'set')
+        return namespaceSetSubset(derived, base, charge);
+    if (base.kind !== 'not')
+        return false;
+    return namespaceSetSubset(derived, base, charge) && namespaceSetSubset(base, derived, charge);
+}
+function combine(a, b, union, charge) {
+    charge();
+    const values = [];
+    const append = (value) => { charge(); values.push(value); };
+    if (a.kind === b.kind) {
+        const concatenate = union === (a.kind === 'set');
+        for (const value of a.namespaces) {
+            charge();
+            if (concatenate || contains(b.namespaces, value, charge))
+                append(value);
+        }
+        if (concatenate)
+            for (const value of b.namespaces) {
+                charge();
+                append(value);
+            }
+        return constraint(a.kind, values, charge);
+    }
+    const excluded = a.kind === 'not' ? a : b;
+    const included = a.kind === 'set' ? a : b;
+    const from = union ? excluded : included, subtract = union ? included : excluded;
+    for (const value of from.namespaces) {
+        charge();
+        if (!contains(subtract.namespaces, value, charge))
+            append(value);
+    }
+    return constraint(union ? 'not' : 'set', values, charge);
+}
+export function namespaceUnion(a, b, charge = noCharge) {
+    return combine(a, b, true, charge);
+}
+export function namespaceIntersection(a, b, charge = noCharge) {
+    return combine(a, b, false, charge);
+}
+/** Abstract namespace-property expressibility, not XML syntax representability.
+ * A finite set (including empty), any, or not(namespace/absent) is expressible.
+ * Keep an unexpressible mathematical intersection intact for diagnostics.
+ */
+export function namespaceExpressible(value, charge = noCharge) {
+    charge();
+    if (value.kind === 'set')
+        return true;
+    const excluded = canonical(value.namespaces, charge);
+    return excluded.length === 0 || excluded.length <= 2 && contains(excluded, '', charge);
+}
+/** The ur-type identity exception belongs to the invoking rule, never spelling. */
+export function processContentsRestricts(derived, base, charge = noCharge) {
+    charge();
+    const rank = { skip: 0, lax: 1, strict: 2 };
+    return rank[derived] >= rank[base];
+}

package/dist/compiler/wsdlPolicyRequirements.d.ts

@@ -0,0 +1,43 @@
+import type { SchemaInput } from '../loader/schemaInput.js';
+import type { SyntaxElement, SyntaxSource } from '../loader/orderedSyntax.js';
+import type { SemanticBudget, ResourceLimitFailure } from './semanticBudget.js';
+export declare const POLICY_12 = "http://schemas.xmlsoap.org/ws/2004/09/policy";
+export declare const SECURITY_POLICY_11 = "http://schemas.xmlsoap.org/ws/2005/07/securitypolicy";
+declare const suites: readonly ["Basic256", "Basic192", "Basic128", "TripleDes", "Basic256Rsa15", "Basic192Rsa15", "Basic128Rsa15", "TripleDesRsa15", "Basic256Sha256", "Basic192Sha256", "Basic128Sha256", "TripleDesSha256", "Basic256Sha256Rsa15", "Basic192Sha256Rsa15", "Basic128Sha256Rsa15", "TripleDesSha256Rsa15"];
+declare const layouts: readonly ["Strict", "Lax", "LaxTsFirst", "LaxTsLast"];
+export type TransportPolicyRequirements = Readonly<{
+    kind: 'https-transport';
+    requireClientCertificate: boolean;
+    algorithmSuite: typeof suites[number];
+    layout: typeof layouts[number];
+    includeTimestamp: boolean;
+    source: SyntaxSource;
+    enforced: false;
+}>;
+export type BindingPolicyRequirements = Readonly<{
+    kind: 'none';
+}> | TransportPolicyRequirements;
+export interface WsdlPolicyRequirements {
+    readonly kind: 'wsdl-policy-requirements';
+    readonly admitted: false;
+    isPolicyMetadata(node: SyntaxElement): boolean;
+    forBinding(binding: SyntaxElement): BindingPolicyRequirements;
+}
+export type PolicyRequirementsFailure = Readonly<{
+    kind: 'unsupported' | 'invalid-schema';
+    rule: string;
+    source: SyntaxSource;
+}>;
+/** Authenticate the exact loaded snapshot; copied reports or source-shaped records confer no policy authority. */
+export declare function assertWsdlPolicyRequirements(input: SchemaInput, value: WsdlPolicyRequirements): void;
+/** Interpret a closed single-alternative HTTPS transport-policy fragment and same-document binding references.
+ * @remarks Unknown assertions, external/nested references, multiple alternatives/attachments and digest references
+ *   remain explicit refusals. No policy fetch, endpoint permission, algorithm execution or security-header emission occurs.
+ *   The July 2005 defaults are Lax layout and no timestamp. Client-certificate omission is outside this qualified fragment.
+ * @returns Source-owned requirements or an explicit unsupported/invalid/resource result; enforcement remains false.
+ * @throws TypeError For unauthenticated source or foreign binding inspection. Caller cancellation propagates unchanged.
+ * @see https://www.w3.org/submissions/WS-Policy/
+ * @see https://specs.xmlsoap.org/ws/2005/07/securitypolicy/ws-securitypolicy.pdf
+ */
+export declare function prepareWsdlPolicyRequirements(input: SchemaInput, budget: SemanticBudget, check: () => void): WsdlPolicyRequirements | PolicyRequirementsFailure | ResourceLimitFailure;
+export {};

package/dist/compiler/wsdlPolicyRequirements.js

@@ -0,0 +1,239 @@
+/** Source-owned WS-Policy requirements; recognition never grants transport or message-security admission. */
+import { assertLoadedSchemaInput } from '../loader/schemaInput.js';
+import { syntaxAttribute, syntaxElements, isXmlNCName, WSDL_NAMESPACE } from '../loader/orderedSyntax.js';
+import { normalizeWhitespace } from './datatypeValues.js';
+export const POLICY_12 = 'http://schemas.xmlsoap.org/ws/2004/09/policy';
+export const SECURITY_POLICY_11 = 'http://schemas.xmlsoap.org/ws/2005/07/securitypolicy';
+const WSU = 'http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd';
+const suites = ['Basic256', 'Basic192', 'Basic128', 'TripleDes', 'Basic256Rsa15', 'Basic192Rsa15', 'Basic128Rsa15',
+    'TripleDesRsa15', 'Basic256Sha256', 'Basic192Sha256', 'Basic128Sha256', 'TripleDesSha256',
+    'Basic256Sha256Rsa15', 'Basic192Sha256Rsa15', 'Basic128Sha256Rsa15', 'TripleDesSha256Rsa15'];
+const layouts = ['Strict', 'Lax', 'LaxTsFirst', 'LaxTsLast'];
+const issued = new WeakMap();
+class Stop extends Error {
+    result;
+    constructor(result) {
+        super(result.rule);
+        this.result = result;
+    }
+}
+/** Authenticate the exact loaded snapshot; copied reports or source-shaped records confer no policy authority. */
+export function assertWsdlPolicyRequirements(input, value) {
+    assertLoadedSchemaInput(input);
+    if (issued.get(value) !== input)
+        throw new TypeError('Fresh source-bound WSDL policy requirements required');
+}
+/** Interpret a closed single-alternative HTTPS transport-policy fragment and same-document binding references.
+ * @remarks Unknown assertions, external/nested references, multiple alternatives/attachments and digest references
+ *   remain explicit refusals. No policy fetch, endpoint permission, algorithm execution or security-header emission occurs.
+ *   The July 2005 defaults are Lax layout and no timestamp. Client-certificate omission is outside this qualified fragment.
+ * @returns Source-owned requirements or an explicit unsupported/invalid/resource result; enforcement remains false.
+ * @throws TypeError For unauthenticated source or foreign binding inspection. Caller cancellation propagates unchanged.
+ * @see https://www.w3.org/submissions/WS-Policy/
+ * @see https://specs.xmlsoap.org/ws/2005/07/securitypolicy/ws-securitypolicy.pdf
+ */
+export function prepareWsdlPolicyRequirements(input, budget, check) {
+    assertLoadedSchemaInput(input);
+    return budget.guard(() => {
+        const fail = (node, rule, kind = 'unsupported') => {
+            budget.chargeWork(64 + rule.length);
+            throw new Stop(Object.freeze({ kind, rule, source: node.source }));
+        };
+        const elements = (node) => {
+            check();
+            budget.chargeWork(32 + node.children.length * 8 + node.attributes.length * 16);
+            for (const child of node.children)
+                if (child.kind === 'text' && /[^\t\r\n ]/.test(child.value))
+                    fail(node, 'policy-text', 'invalid-schema');
+            return syntaxElements(node);
+        };
+        const attrs = (node, allowed = [], id = false) => {
+            for (const attribute of node.attributes) {
+                check();
+                budget.chargeWork(32 + attribute.value.length * 4);
+                if (attribute.name.namespace === '' && allowed.includes(attribute.name.local))
+                    continue;
+                if (id && attribute.name.namespace === WSU && attribute.name.local === 'Id')
+                    continue;
+                fail(node, 'policy-attribute');
+            }
+        };
+        const is = (node, namespace, local) => node.name.namespace === namespace && node.name.local === local;
+        // Framework flattening is iterative and refuses choice instead of guessing an alternative.
+        const assertions = (policy) => {
+            const pending = [policy], result = [];
+            while (pending.length) {
+                check();
+                const node = pending.pop();
+                if (node.name.namespace === POLICY_12 && ['Policy', 'All', 'ExactlyOne'].includes(node.name.local)) {
+                    attrs(node, [], node === policy && node.name.local === 'Policy');
+                    const children = elements(node);
+                    if (node.name.local === 'ExactlyOne' && children.length !== 1)
+                        fail(node, 'policy-alternatives');
+                    for (let i = children.length - 1; i >= 0; i--) {
+                        check();
+                        pending.push(children[i]);
+                    }
+                }
+                else {
+                    if (node.name.namespace === POLICY_12)
+                        fail(node, 'nested-policy-reference-or-operator');
+                    result.push(node);
+                }
+            }
+            return result;
+        };
+        const nested = (node) => {
+            attrs(node);
+            const children = elements(node);
+            if (children.length !== 1 || !is(children[0], POLICY_12, 'Policy'))
+                return fail(node, 'nested-policy-required');
+            return assertions(children[0]);
+        };
+        const leaf = (node) => { attrs(node); if (elements(node).length)
+            fail(node, 'policy-leaf-content'); };
+        const transport = (node) => {
+            const parts = nested(node), byName = new Map();
+            for (const part of parts) {
+                check();
+                if (part.name.namespace !== SECURITY_POLICY_11 || !['TransportToken', 'AlgorithmSuite', 'Layout', 'IncludeTimestamp'].includes(part.name.local))
+                    fail(part, 'transport-policy-assertion');
+                if (byName.has(part.name.local))
+                    fail(part, 'duplicate-transport-property', 'invalid-schema');
+                byName.set(part.name.local, part);
+            }
+            const token = byName.get('TransportToken'), suite = byName.get('AlgorithmSuite');
+            if (!token || !suite)
+                return fail(node, 'transport-token-and-algorithm-suite-required', 'invalid-schema');
+            const tokens = nested(token);
+            if (tokens.length !== 1 || !is(tokens[0], SECURITY_POLICY_11, 'HttpsToken'))
+                return fail(token, 'transport-token-kind');
+            const https = tokens[0];
+            attrs(https, ['RequireClientCertificate']);
+            if (elements(https).length)
+                fail(https, 'https-token-additional-policy');
+            const certificate = syntaxAttribute(https, 'RequireClientCertificate');
+            if (certificate === undefined)
+                return fail(https, 'https-token-client-certificate-default-unqualified');
+            const lexical = normalizeWhitespace(certificate, 'collapse');
+            if (!['true', '1', 'false', '0'].includes(lexical))
+                fail(https, 'https-token-client-certificate-boolean', 'invalid-schema');
+            const algorithms = nested(suite);
+            if (algorithms.length !== 1 || algorithms[0].name.namespace !== SECURITY_POLICY_11 || !suites.some(name => name === algorithms[0].name.local))
+                return fail(suite, 'algorithm-suite');
+            leaf(algorithms[0]);
+            let layout = 'Lax';
+            const layoutNode = byName.get('Layout');
+            if (layoutNode) {
+                const selected = nested(layoutNode);
+                if (selected.length !== 1 || selected[0].name.namespace !== SECURITY_POLICY_11 || !layouts.some(name => name === selected[0].name.local))
+                    return fail(layoutNode, 'security-header-layout');
+                leaf(selected[0]);
+                layout = selected[0].name.local;
+            }
+            const timestamp = byName.get('IncludeTimestamp');
+            if (timestamp)
+                leaf(timestamp);
+            budget.chargeWork(128);
+            return Object.freeze({ kind: 'https-transport', requireClientCertificate: lexical === 'true' || lexical === '1',
+                algorithmSuite: algorithms[0].name.local, layout, includeTimestamp: timestamp !== undefined,
+                source: node.source, enforced: false });
+        };
+        try {
+            const metadata = new Set(), bindings = new Map();
+            const none = Object.freeze({ kind: 'none' });
+            for (const document of input.documents) {
+                check();
+                if (!is(document.root, WSDL_NAMESPACE, 'definitions'))
+                    continue;
+                const ids = new Map(), pending = [document.root];
+                while (pending.length) {
+                    check();
+                    const node = pending.pop(), lexicalId = syntaxAttribute(node, 'Id', WSU);
+                    if (lexicalId !== undefined) {
+                        budget.chargeWork(32 + lexicalId.length * 4);
+                        const id = normalizeWhitespace(lexicalId, 'collapse');
+                        if (!isXmlNCName(id) || ids.has(id))
+                            fail(node, 'policy-id-uniqueness', 'invalid-schema');
+                        ids.set(id, node);
+                    }
+                    for (const child of syntaxElements(node)) {
+                        check();
+                        pending.push(child);
+                    }
+                }
+                const policies = new Map();
+                const parse = (policy) => {
+                    const cached = policies.get(policy);
+                    if (cached)
+                        return cached;
+                    const leaves = assertions(policy);
+                    if (leaves.length > 1)
+                        return fail(policy, 'policy-assertion-combination');
+                    if (leaves.length && !is(leaves[0], SECURITY_POLICY_11, 'TransportBinding'))
+                        return fail(leaves[0], 'policy-assertion');
+                    const result = leaves.length ? transport(leaves[0]) : none;
+                    policies.set(policy, result);
+                    return result;
+                };
+                for (const node of syntaxElements(document.root))
+                    if (is(node, POLICY_12, 'Policy')) {
+                        parse(node);
+                        metadata.add(node);
+                    }
+                for (const binding of syntaxElements(document.root, WSDL_NAMESPACE, 'binding')) {
+                    const attachments = syntaxElements(binding).filter(node => node.name.namespace === POLICY_12);
+                    if (attachments.length > 1)
+                        fail(binding, 'multiple-policy-attachments');
+                    let result = none;
+                    for (const attachment of attachments) {
+                        if (is(attachment, POLICY_12, 'Policy'))
+                            result = parse(attachment);
+                        else if (is(attachment, POLICY_12, 'PolicyReference')) {
+                            attrs(attachment, ['URI']);
+                            if (elements(attachment).length)
+                                fail(attachment, 'policy-reference-content');
+                            const uri = syntaxAttribute(attachment, 'URI');
+                            if (!uri?.startsWith('#'))
+                                return fail(attachment, 'external-policy-reference');
+                            if (new URL(attachment.baseUri).href.split('#')[0] !== new URL(document.uri).href.split('#')[0])
+                                return fail(attachment, 'external-policy-reference');
+                            let id;
+                            try {
+                                id = decodeURIComponent(uri.slice(1));
+                            }
+                            catch {
+                                return fail(attachment, 'policy-reference-fragment', 'invalid-schema');
+                            }
+                            const target = ids.get(id);
+                            if (!target || !is(target, POLICY_12, 'Policy'))
+                                return fail(attachment, 'policy-reference-target', 'invalid-schema');
+                            if (!metadata.has(target))
+                                return fail(attachment, 'policy-reference-placement');
+                            result = parse(target);
+                        }
+                        else
+                            return fail(attachment, 'policy-attachment');
+                        metadata.add(attachment);
+                    }
+                    bindings.set(binding, result);
+                }
+            }
+            const owner = Object.freeze({ kind: 'wsdl-policy-requirements', admitted: false,
+                isPolicyMetadata(node) { return metadata.has(node); },
+                forBinding(binding) {
+                    const value = bindings.get(binding);
+                    if (!value)
+                        throw new TypeError('Original source binding required for policy requirements');
+                    return value;
+                } });
+            issued.set(owner, input);
+            return owner;
+        }
+        catch (error) {
+            if (error instanceof Stop)
+                return error.result;
+            throw error;
+        }
+    });
+}

package/dist/config.d.ts

@@ -64,4 +64,3 @@ export declare function resolveCompilerOptions(input: Partial<CompilerOptions>,
     wsdl: string;
     out: string;
 }): CompilerOptions;
-//# sourceMappingURL=config.d.ts.map

package/dist/gateway/generateCheckedGateway.d.ts

@@ -0,0 +1,32 @@
+import type { ReconstructedComponentSource } from '../compiler/directSourceCapsule.js';
+interface CheckedGatewayOptions {
+    /** Internal non-writing preparation; native qualification and lowering still run. */
+    readonly emit?: boolean;
+    readonly clientDir: string;
+    readonly gatewayDir: string;
+    readonly openapiFile: string;
+    readonly routePath: string;
+    readonly signal?: AbortSignal;
+}
+/** Lower component mappings through the existing checked gateway emitter, retaining native supplemental validation. */
+export declare function generateComponentGateway(expected: ReconstructedComponentSource, options: CheckedGatewayOptions): Promise<{
+    doc: unknown;
+    emit: () => Promise<void>;
+}>;
+/** Compose per-operation checked routers without merging native source, service or binding identities.
+ * @returns One OpenAPI document and exact operation-to-route mapping, both descriptions rather than authority.
+ * @throws For mixed native handles, invalid/colliding paths, cancellation or filesystem failures.
+ */
+export declare function generateComponentServiceGateway(expected: readonly ReconstructedComponentSource[], options: {
+    clientDir: string;
+    gatewayDir: string;
+    openapiFile: string;
+    basePath: string;
+    signal?: AbortSignal;
+    emit?: boolean;
+}): Promise<{
+    doc: unknown;
+    routes: Readonly<Record<string, string>>;
+    emit: () => Promise<void>;
+}>;
+export {};