@techspokes/typescript-wsdl-client 1.1.5 → 1.1.8

package/dist/compiler/directSoapSource.js

@@ -2,7 +2,9 @@ import { directLimit } from './directExecutionPolicy.js';
 /** Shared authenticated single-resource SOAP bootstrap policy; no transport. */
 import { inspectDirectOperation } from './directOperation.js';
 import { copyOriginalSchemaResource } from '../loader/schemaInput.js';
-import { resolveLexicalQName, syntaxAttribute, WSDL_NAMESPACE, XSD_NAMESPACE } from '../loader/orderedSyntax.js';
+import { decodeMetadataXml, resolveLexicalQName, syntaxAttribute, WSDL_NAMESPACE, XSD_NAMESPACE } from '../loader/orderedSyntax.js';
+import { WSDL } from 'soap/lib/wsdl/index.js';
+import { normalizeWhitespace } from './datatypeValues.js';
 const WSDL_SOAP = 'http://schemas.xmlsoap.org/wsdl/soap/';
 const same = (a, b) => a.namespace === b.namespace && a.local === b.local;
 export const DIRECT_SOAP_SOURCE_MAX_BYTES = 64 * 1024;
@@ -13,6 +15,26 @@ export class DirectSoapSourceError extends Error {
         this.kind = kind;
     }
 }
+function validateSoapSelection(source, contract, config, check) {
+    const elements = (node) => { check(); return node.children.filter((child) => child.kind === 'element'); };
+    const definitions = source.root.root;
+    if (definitions.name.namespace !== WSDL_NAMESPACE || definitions.name.local !== 'definitions')
+        throw new DirectSoapSourceError('WSDL definitions required');
+    const services = elements(definitions).filter(n => n.name.namespace === WSDL_NAMESPACE && n.name.local === 'service'
+        && same({ namespace: syntaxAttribute(definitions, 'targetNamespace') ?? '', local: syntaxAttribute(n, 'name') ?? '' }, config.service));
+    if (services.length !== 1)
+        throw new DirectSoapSourceError('SOAP service mismatch');
+    const ports = elements(services[0]).filter(n => n.name.namespace === WSDL_NAMESPACE && n.name.local === 'port' && syntaxAttribute(n, 'name') === config.port);
+    if (ports.length !== 1)
+        throw new DirectSoapSourceError('SOAP port mismatch');
+    const binding = syntaxAttribute(ports[0], 'binding');
+    if (!binding || !same(resolveLexicalQName(binding, ports[0]), contract.selector.binding))
+        throw new DirectSoapSourceError('SOAP binding mismatch');
+    const addresses = elements(ports[0]).filter(n => n.name.namespace === WSDL_SOAP && n.name.local === 'address');
+    if (addresses.length !== 1 || elements(ports[0]).some(n => !(n.name.namespace === WSDL_SOAP && n.name.local === 'address')
+        && !(n.name.namespace === WSDL_NAMESPACE && n.name.local === 'documentation')))
+        throw new DirectSoapSourceError('SOAP port extension');
+}
 export function prepareDirectSoapSource(contract, config, check) {
     const { source, context: { budget } } = inspectDirectOperation(contract);
     if (source.resources.some(r => r.byteLength > directLimit(budget, DIRECT_SOAP_SOURCE_MAX_BYTES))) {
@@ -53,24 +75,8 @@ export function prepareDirectSoapSource(contract, config, check) {
             inspectSource(child);
     };
     inspectSource(source.root.root);
-    const definitions = source.root.root;
-    if (definitions.name.namespace !== WSDL_NAMESPACE || definitions.name.local !== 'definitions')
-        throw new DirectSoapSourceError('WSDL definitions required');
-    const services = elements(definitions).filter(n => n.name.namespace === WSDL_NAMESPACE && n.name.local === 'service'
-        && same({ namespace: syntaxAttribute(definitions, 'targetNamespace') ?? '', local: syntaxAttribute(n, 'name') ?? '' }, config.service));
-    if (services.length !== 1)
-        throw new DirectSoapSourceError('SOAP service mismatch');
-    const ports = elements(services[0]).filter(n => n.name.namespace === WSDL_NAMESPACE && n.name.local === 'port' && syntaxAttribute(n, 'name') === config.port);
-    if (ports.length !== 1)
-        throw new DirectSoapSourceError('SOAP port mismatch');
-    const binding = syntaxAttribute(ports[0], 'binding');
-    if (!binding || !same(resolveLexicalQName(binding, ports[0]), contract.selector.binding))
-        throw new DirectSoapSourceError('SOAP binding mismatch');
-    const addresses = elements(ports[0]).filter(n => n.name.namespace === WSDL_SOAP && n.name.local === 'address');
-    if (addresses.length !== 1 || elements(ports[0]).some(n => !(n.name.namespace === WSDL_SOAP && n.name.local === 'address')
-        && !(n.name.namespace === WSDL_NAMESPACE && n.name.local === 'documentation')))
-        throw new DirectSoapSourceError('SOAP port extension');
-    const original = copyOriginalSchemaResource(source, source.root.uri, amount => { check(); });
+    validateSoapSelection(source, contract, config, check);
+    const original = copyOriginalSchemaResource(source, source.root.uri, () => { check(); });
     // This packet admits UTF-8 source bootstrap only; response encoding remains
     // owned by the existing strict XML byte decoder.
     let wsdlText;
@@ -84,3 +90,144 @@ export function prepareDirectSoapSource(contract, config, check) {
         throw new DirectSoapSourceError('UTF-8 WSDL bootstrap required');
     return { original, wsdlText };
 }
+/** Check each native operation before sharing its source metadata.
+ * @param contract Authentic component operation.
+ * @param config Exact service and port.
+ * @param check Invocation cancellation/resource checks.
+ * @returns No metadata or portable authority.
+ * @throws For foreign handles, unsupported source profile, action or selection.
+ */
+export function validateComponentSoapSelection(contract, config, check) {
+    const { source } = inspectDirectOperation(contract);
+    check();
+    if (contract.basis !== 'native-component-premises-v1' || contract.correspondence !== 'dated-XSD-2004-components-v1')
+        throw new DirectSoapSourceError('Component source profile required');
+    if (/[^\x20-\x21\x23-\x7e]|\\/.test(contract.binding.action))
+        throw new DirectSoapSourceError('unsafe SOAPAction');
+    validateSoapSelection(source, contract, config, check);
+}
+/** Build the existing SOAP dependency from the exact authorized snapshot, with no file/network import fallback.
+ * @remarks Acyclic metadata resources are decoded independently under the native metadata policy. Original bytes and native semantics
+ *   are unchanged. The dependency receives private aliases and a fresh prefilled cache; its import hook accepts only
+ *   unambiguous native source edges to already prepared resources. This grants no endpoint or policy enforcement.
+ * @returns A prepared node-soap WSDL for the exact original service/port/binding.
+ * @throws DirectSoapSourceError For incompatible source/profile, unsafe dependency names, cycles or ambiguous imports.
+ *   Caller cancellation/resource exceptions propagate unchanged.
+ */
+export async function prepareComponentSoapWsdl(contract, config, check) {
+    const { source, context: { budget } } = inspectDirectOperation(contract);
+    validateComponentSoapSelection(contract, config, check);
+    const refuse = (rule) => { throw new DirectSoapSourceError(rule); };
+    const nodes = new Map(), dependencySyntax = new Set();
+    const key = (uri, path) => JSON.stringify([uri, path]);
+    for (const edge of source.edges) {
+        check();
+        dependencySyntax.add(key(edge.source.uri, edge.source.path));
+    }
+    for (const document of source.documents) {
+        const pending = [document.root];
+        while (pending.length) {
+            check();
+            const node = pending.pop();
+            budget.chargeWork(32 + node.children.length * 8 + node.attributes.length * 16);
+            const identity = key(node.source.uri, node.source.path);
+            nodes.set(identity, node);
+            if (['import', 'include', 'redefine'].includes(node.name.local) && !dependencySyntax.has(identity))
+                refuse('unowned dependency syntax');
+            for (const attribute of node.attributes) {
+                check();
+                if (attribute.name.local === 'name' && (attribute.value in Object.prototype || attribute.value === 'prototype'))
+                    refuse('dependency reserved name');
+            }
+            for (const prefix in node.namespaces) {
+                check();
+                if (['__proto__', 'prototype', 'constructor'].includes(prefix) || /["<&\r\n\t]/.test(node.namespaces[prefix]))
+                    refuse('dependency namespace interpolation');
+            }
+            for (const child of node.children)
+                if (child.kind === 'element')
+                    pending.push(child);
+        }
+    }
+    const resources = [...source.resources].sort((a, b) => a.uri < b.uri ? -1 : a.uri > b.uri ? 1 : 0);
+    const aliases = new Map(), originals = new Map();
+    const dependencies = new Map(), imports = new Map();
+    for (const [index, resource] of resources.entries()) {
+        check();
+        const alias = 'https://wsdl-snapshot.invalid/resource/' + index;
+        aliases.set(resource.uri, alias);
+        originals.set(alias, resource.uri);
+        dependencies.set(resource.uri, new Set());
+    }
+    const schemaUris = new Map(source.schemas.map(schema => [schema.key, schema.documentUri]));
+    for (const edge of source.edges) {
+        check();
+        if (!edge.to)
+            continue;
+        const target = schemaUris.get(edge.to) ?? edge.to, parent = edge.source.uri;
+        if (!aliases.has(target) || !aliases.has(parent))
+            refuse('dependency outside retained snapshot');
+        const node = nodes.get(key(edge.source.uri, edge.source.path));
+        if (!node)
+            refuse('dependency source unavailable');
+        const location = syntaxAttribute(node, edge.kind === 'wsdl-import' ? 'location' : 'schemaLocation');
+        if (location === undefined)
+            continue;
+        const slot = key(parent, normalizeWhitespace(location, 'collapse')), previous = imports.get(slot);
+        if (previous !== undefined && previous !== target)
+            refuse('ambiguous dependency import context');
+        imports.set(slot, target);
+        dependencies.get(parent).add(target);
+    }
+    const cache = Object.create(null), prepared = new Set();
+    const remaining = new Map(), dependents = new Map(), ready = [];
+    for (const [uri, required] of dependencies) {
+        check();
+        remaining.set(uri, required.size);
+        if (!required.size)
+            ready.push(uri);
+        for (const dependency of required) {
+            check();
+            let users = dependents.get(dependency);
+            if (!users) {
+                users = [];
+                dependents.set(dependency, users);
+            }
+            users.push(uri);
+        }
+    }
+    for (let cursor = 0; cursor < ready.length; cursor++) {
+        const uri = ready[cursor];
+        check();
+        const bytes = copyOriginalSchemaResource(source, uri, amount => { check(); budget.chargeWork(amount); });
+        budget.chargeWork(4096 + bytes.byteLength * 64);
+        const text = decodeMetadataXml(bytes);
+        const options = { WSDL_CACHE: cache, wsdl_options: { overrideImportLocation: (_path, parentAlias, location) => {
+                    check();
+                    const parent = originals.get(parentAlias);
+                    const target = parent === undefined ? undefined : imports.get(key(parent, normalizeWhitespace(location, 'collapse')));
+                    const alias = target === undefined ? undefined : aliases.get(target);
+                    if (!target || !alias || !prepared.has(target) || !Object.hasOwn(cache, alias))
+                        return refuse('unowned SOAP metadata import');
+                    return alias;
+                } } };
+        const alias = aliases.get(uri), wsdl = new WSDL(text, alias, options);
+        cache[alias] = wsdl;
+        await new Promise((resolve, reject) => wsdl.onReady(error => error ? reject(error) : resolve()));
+        check();
+        prepared.add(uri);
+        for (const dependent of dependents.get(uri) ?? []) {
+            check();
+            const count = remaining.get(dependent) - 1;
+            remaining.set(dependent, count);
+            if (count === 0)
+                ready.push(dependent);
+        }
+    }
+    if (prepared.size !== resources.length)
+        refuse('cyclic SOAP metadata dependencies');
+    const root = aliases.get(source.root.uri);
+    if (!root || !Object.hasOwn(cache, root))
+        return refuse('original root unavailable');
+    return cache[root];
+}

package/dist/compiler/directSourceCapsule.d.ts

@@ -1,8 +1,12 @@
 import type { SemanticBudget, SemanticBudgetLimits, ResolverUsage } from './semanticBudget.js';
 import type { DirectOperationContract, DirectOperationSelector } from './directOperation.js';
-import type { DirectValueMapping } from './directValues.js';
+import type { DirectValueMapping, ComponentValueMapping } from './directValues.js';
+import { ComponentSoapPreparation } from './componentSoapPreparation.js';
+import type { SchemaInputOptions } from '../loader/schemaInput.js';
 import type { SchemaResourcePolicy } from '../loader/schemaResources.js';
 import type { ExpandedName } from '../loader/orderedSyntax.js';
+import type { ComponentRecordProjection } from './componentRecordProjection.js';
+import type { ApplicationGroupsOptions } from './applicationGroups.js';
 export declare const DIRECT_CAPSULE_LIMITS: Readonly<{
     maxBytes: number;
     sourceBytes: number;
@@ -93,5 +97,73 @@ export declare function checkDirectSourceCompatibility(expected: unknown, contra
     admitted: false;
     usage: ResolverUsage;
 }> | DirectCapsuleFailure;
+export interface ReconstructedComponentSource {
+    readonly kind: 'reconstructed-component';
+    readonly contract: DirectOperationContract;
+    readonly mappings: readonly (ComponentValueMapping | ComponentRecordProjection)[];
+    readonly selection: DirectSourceSelection;
+    readonly responseProjection?: ComponentRecordProjection;
+    readonly admitted: false;
+    readonly usage: ResolverUsage;
+}
+/** Serialize native component provenance as data; no source, mapping or execution authority is serialized.
+ * @returns Deterministic original resource bytes and compatibility description, or explicit refusal.
+ * @throws TypeError For foreign operation handles. Caller cancellation is returned as a refusal.
+ */
+export declare function createComponentSourceCapsule(contract: DirectOperationContract, selection: DirectSourceSelection, signal?: AbortSignal, responseProjection?: ComponentRecordProjection): Promise<Readonly<{
+    kind: 'component-capsule';
+    bytes: Uint8Array;
+    admitted: false;
+    usage: ResolverUsage;
+}> | DirectCapsuleFailure>;
+/** Prepare a generator-owned operation once through the same native descriptor used by runtime reconstruction.
+ * @param contract Fresh source-owned operation, never a report or copied handle.
+ * @param selection Explicit resolved service and port.
+ * @param preparation Invocation-owned SOAP metadata reuse.
+ * @param signal Caller cancellation.
+ * @param responseProjection Optional native companion projection.
+ * @returns An authentic reconstruction retaining its exact issued capsule and mappings, or native refusal.
+ * @throws TypeError For foreign native operation identities.
+ * @constraints Runtime physical-source reconstruction is independent and unchanged.
+ */
+export declare function prepareComponentSourceForOperation(contract: DirectOperationContract, selection: DirectSourceSelection, preparation: ComponentSoapPreparation, signal?: AbortSignal, responseProjection?: ComponentRecordProjection, applicationGroups?: ApplicationGroupsOptions): Promise<ReconstructedComponentSource | DirectCapsuleFailure>;
+/** Copy capsule data retained by an authentic reconstruction without repeating preparation.
+ * @param expected Fresh owned reconstruction.
+ * @param signal Caller cancellation.
+ * @returns Deterministic capsule bytes; the data grants no runtime authority.
+ * @throws TypeError For copied or foreign reconstruction identities; cancellation/resource failures propagate.
+ */
+export declare function componentSourceCapsuleBytes(expected: ReconstructedComponentSource, signal?: AbortSignal): Uint8Array;
+/** Reconstruct from a physical root and caller-authorized dependencies; embedded bytes are comparison data only.
+ * @remarks Local imports may relocate together. All original resource bytes and explicit service/binding roots must match.
+ *   Loading policy, offline snapshots and namespace locations are supplied independently by the caller, never the capsule.
+ * @returns Fresh native operation/mapping authority with admitted=false, or explicit refusal.
+ */
+export interface ComponentSourceReconstructionOptions {
+    loading: SchemaInputOptions;
+    limits?: SemanticBudgetLimits;
+    signal?: AbortSignal;
+    /** Caller permission; artifact identifiers alone never acquire a standard library. */
+    standardLibraries?: readonly string[];
+    /** Explicit physical companion roots, associated with exact outer binding/operation selectors. */
+    recordSources?: readonly {
+        readonly selector: DirectOperationSelector;
+        readonly source: string;
+    }[];
+}
+export declare function reconstructComponentSourceCapsule(bytes: Uint8Array, localSource: string, options: Readonly<ComponentSourceReconstructionOptions>): Promise<ReconstructedComponentSource | DirectCapsuleFailure>;
+/** Private runtime seam retaining one sticky request for artifact reading, source qualification and exchange. */
+export declare function reconstructComponentSourceCapsuleInRequest(bytes: Uint8Array, localSource: string, options: Readonly<ComponentSourceReconstructionOptions>, budget: SemanticBudget): Promise<ReconstructedComponentSource | DirectCapsuleFailure>;
+/** Generator seam: expected bytes are checked against an already fresh, source-owned native operation.
+ * @remarks This accepts transient native authority only. Runtime consumers still reconstruct from independently
+ *   authorized physical files. It permits service-wide generation to reuse one native whole-source qualification.
+ */
+export declare function reconstructComponentSourceCapsuleForOperation(bytes: Uint8Array, contract: DirectOperationContract, selection: DirectSourceSelection, signal?: AbortSignal, responseProjection?: ComponentRecordProjection): Promise<ReconstructedComponentSource | DirectCapsuleFailure>;
+/** Authenticate transient reconstruction identity; saved/copy-shaped reports cannot be consumed by generators. */
+export declare function inspectReconstructedComponentSource(value: ReconstructedComponentSource): ReconstructedComponentSource;
+/** Group fresh operations for one service without merging source contexts or binding identities.
+ * @returns A deterministic operation order over the original native handles.
+ * @throws TypeError For foreign handles, duplicate operations, accessors or mixed sources/services/bindings.
+ */
+export declare function inspectComponentSourceService(values: readonly ReconstructedComponentSource[]): readonly ReconstructedComponentSource[];
 export {};
-//# sourceMappingURL=directSourceCapsule.d.ts.map