@wirebench/engine 2.2.0 → 3.1.0-rc.1

package/dist/soap/legacy-project/map.d.ts

@@ -6,7 +6,7 @@
  * is ready to be added to a project, plus the report of everything that did not come across.
  */
 import type { Environment, IdGenerator, Interface } from '../../project/model.js';
-import type { OperationSummary } from '../../types.js';
+import type { SoapOperationSummary } from '../types.js';
 import type { LegacyInterface, LegacyProject } from './model.js';
 /** One operation of a resolved definition, as the mapper needs it. */
 export interface ResolvedOperation {
@@ -17,7 +17,7 @@ export interface ResolvedOperation {
     readonly soapAction?: string;
 }
 /** The engine's operation summaries, as {@link ResolvedOperation}s. */
-export declare function resolvedOperationsOf(summaries: readonly OperationSummary[]): ResolvedOperation[];
+export declare function resolvedOperationsOf(summaries: readonly SoapOperationSummary[]): ResolvedOperation[];
 /** A legacy interface after the caller tried to resolve its definition. */
 export type ResolvedLegacyInterface = {
     readonly legacy: LegacyInterface;

package/dist/soap/legacy-project/map.js

@@ -9,6 +9,7 @@ import { createInterface, createRequest, generateId } from '../../project/model.
 import { slugify, uniqueSlug } from '../../project/paths.js';
 import { DEFAULT_WSA_CONFIG } from '../../wsa/model.js';
 import { qnameToString } from '../../wsdl/qname.js';
+import { rewriteProjectRefsToEnv } from './env-refs.js';
 /** The engine's operation summaries, as {@link ResolvedOperation}s. */
 export function resolvedOperationsOf(summaries) {
     return summaries.map((summary) => ({
@@ -170,6 +171,11 @@ function scriptPath(script, taken) {
  * element, in the same order.
  */
 export function mapLegacyProject(project, resolved, context) {
+    const original = project;
+    project = rewriteProjectRefsToEnv(project);
+    // Each `resolved` entry holds one of `project.interfaces` by identity; hand it the rewritten copy.
+    const rewritten = new Map(original.interfaces.map((iface, index) => [iface, project.interfaces[index]]));
+    resolved = resolved.map((entry) => ({ ...entry, legacy: rewritten.get(entry.legacy) ?? entry.legacy }));
     const newId = context.newId ?? generateId;
     const report = new ReportBuilder();
     const interfaces = [];

package/dist/soap/mime/multipart.d.ts

@@ -8,6 +8,7 @@
  * unquoted boundary parameters, folded headers and a missing `start` parameter are all
  * accepted and reported as problems rather than raised.
  */
+import { mediaTypeOf } from '../../http/media-type.js';
 import type { MimePart, MultipartPart, MultipartRoot } from './types.js';
 /** Default Content-ID of the envelope part when the caller does not choose one. */
 export declare const DEFAULT_ROOT_CONTENT_ID = "rootpart@wirebench";
@@ -35,8 +36,7 @@ export interface ParsedMultipart {
     /** Tolerance notes, e.g. `missing-boundary`, `missing-final-boundary`, `start-part-not-found`. */
     readonly problems: readonly string[];
 }
-/** The media type of a `Content-Type` header value, without its parameters. */
-export declare function mediaTypeOf(contentType: string): string;
+export { mediaTypeOf };
 /** One parameter of a `Content-Type`-style header value, unquoted; case-insensitive on the name. */
 export declare function mimeParameter(header: string, name: string): string | undefined;
 /** Strips the angle brackets from a Content-ID (`<a@b>` -> `a@b`). */

package/dist/soap/mime/multipart.js

@@ -9,15 +9,12 @@
  * accepted and reported as problems rather than raised.
  */
 import { randomBytes } from 'node:crypto';
+import { mediaTypeOf } from '../../http/media-type.js';
 /** Default Content-ID of the envelope part when the caller does not choose one. */
 export const DEFAULT_ROOT_CONTENT_ID = 'rootpart@wirebench';
 const CRLF = '\r\n';
 const KNOWN_ENCODINGS = ['binary', 'base64', '8bit', '7bit', 'quoted-printable'];
-/** The media type of a `Content-Type` header value, without its parameters. */
-export function mediaTypeOf(contentType) {
-    const semicolon = contentType.indexOf(';');
-    return (semicolon === -1 ? contentType : contentType.slice(0, semicolon)).trim();
-}
+export { mediaTypeOf };
 /** One parameter of a `Content-Type`-style header value, unquoted; case-insensitive on the name. */
 export function mimeParameter(header, name) {
     // The quoted-string branch follows RFC 2045's grammar: any character except `"` and `\`,

package/dist/soap/mime/send-pipeline.d.ts

@@ -5,7 +5,7 @@
  * Kept beside the MIME modules rather than in `send.ts` so the ordering rules live next to
  * the code that implements them.
  */
-import type { SoapExchange, SoapSendInput } from '../../types.js';
+import type { SoapExchange, SoapSendInput } from '../types.js';
 import type { ResponseAttachment } from './types.js';
 /** One problem recorded on the exchange. */
 export type SoapProblem = SoapExchange['problems'][number];

package/dist/soap/mime/send-pipeline.js

@@ -6,7 +6,7 @@
  * the code that implements them.
  */
 import { headerValue, setHeader } from '../../http/headers.js';
-import { decodeBody, encodeBody } from '../charset.js';
+import { decodeBody, encodeBody } from '../../http/charset.js';
 import { inlineFiles } from './inline-files.js';
 import { expandMtomResponse, prepareMtomRequest, xopContentType } from './mtom.js';
 import { DEFAULT_ROOT_CONTENT_ID, buildMultipartRelated, mediaTypeOf, parseMultipartRelated } from './multipart.js';

package/dist/soap/mime/types.d.ts

@@ -7,9 +7,7 @@
  * project directory and its cache) decides where bytes come from. See
  * `project/attachments-cache.ts` for the file-backed implementation.
  */
-import type { Attachment } from '../../project/model.js';
-/** Resolves one attachment's bytes. Rejects when the attachment cannot be read. */
-export type AttachmentResolver = (attachment: Attachment) => Promise<Uint8Array>;
+export type { AttachmentResolver } from '../../project/attachments-cache.js';
 /** Content transfer encodings this layer writes or understands. */
 export type TransferEncoding = 'binary' | 'base64' | '8bit' | '7bit' | 'quoted-printable';
 /**

package/dist/soap/module.d.ts

@@ -0,0 +1,2 @@
+/** The SOAP protocol: WSDL interfaces, their operations and their saved requests. */
+export declare const soapProtocol: import("../protocol/module.js").ProtocolModule;

package/dist/soap/module.js

@@ -0,0 +1,13 @@
+/** SOAP as a protocol module (spec §3). */
+import { defineProtocol } from '../protocol/module.js';
+import { soapRun } from './run.js';
+import { soapScripting } from './scripting.js';
+import { soapStorage } from './storage.js';
+/** The SOAP protocol: WSDL interfaces, their operations and their saved requests. */
+export const soapProtocol = defineProtocol({
+    kind: 'soap',
+    feature: { id: 'soap', title: 'SOAP', default: true, stage: 'stable', requires: [] },
+    storage: soapStorage,
+    run: soapRun,
+    scripting: soapScripting,
+});

package/dist/soap/namespace-scope.js

@@ -8,7 +8,7 @@
  * cannot change any name's meaning.
  */
 import { NS } from '../xml/namespaces.js';
-import { prefixForNamespace, RESERVED_PREFIXES } from './prefixes.js';
+import { prefixForNamespace, RESERVED_PREFIXES } from '../xml/prefixes.js';
 /** Prefixes the envelope pins regardless of what a mnemonic would suggest. */
 const PINNED = [
     [NS.XSD, 'xsd'],

package/dist/soap/operations.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Builds the operation-picker summary (`SoapOperationSummary[]`) for an imported
+ * WSDL definition: every binding operation, cross-referenced with the ports
+ * (and their services) that expose it.
+ */
+import type { WsdlDefinition } from '../wsdl/model.js';
+import type { SoapOperationSummary } from './types.js';
+/**
+ * Walks every `binding` x `operation` pair in `definition`, mapping each to
+ * the ports (and their services) that reference the binding.
+ */
+export declare function summarizeSoapOperations(definition: WsdlDefinition): readonly SoapOperationSummary[];

package/dist/{operations.js → soap/operations.js}

@@ -1,10 +1,10 @@
 /**
- * Builds the operation-picker summary (`OperationSummary[]`) for an imported
+ * Builds the operation-picker summary (`SoapOperationSummary[]`) for an imported
  * WSDL definition: every binding operation, cross-referenced with the ports
  * (and their services) that expose it.
  */
-import { findPortType } from './wsdl/model.js';
-import { qnameEquals } from './wsdl/qname.js';
+import { findPortType } from '../wsdl/model.js';
+import { qnameEquals } from '../wsdl/qname.js';
 /** The services/ports that bind to `binding`, across every service in the definition. */
 function portsFor(definition, binding) {
     const ports = [];
@@ -30,7 +30,7 @@ function abstractOperationFor(definition, binding, operationName) {
  * Walks every `binding` x `operation` pair in `definition`, mapping each to
  * the ports (and their services) that reference the binding.
  */
-export function summarizeOperations(definition) {
+export function summarizeSoapOperations(definition) {
     const summaries = [];
     for (const binding of definition.bindings) {
         const ports = portsFor(definition, binding);

package/dist/soap/run.d.ts

@@ -0,0 +1,70 @@
+import type { AssertionSubject } from '../assert/model.js';
+import type { Interface, OperationDef, Project, SoapOwnerAuth, SoapRequestDef } from '../project/model.js';
+import type { PropertyScopes } from '../project/properties.js';
+import type { ProtocolRun } from '../protocol/module.js';
+import type { RunContext } from '../run/context.js';
+import type { Resolved } from '../run/send-helpers.js';
+import type { SoapExchange, SoapSendInput } from './types.js';
+/** The editor's unsent envelope, endpoint and headers. A send uses them in place of the saved ones. */
+export interface SoapOverride {
+    readonly envelopeXml?: string;
+    /** The URL to send to, in place of the one the request's endpoint resolves to. */
+    readonly endpoint?: string;
+    /** The request's whole header list as the editor holds it: it replaces the saved one. */
+    readonly headers?: Readonly<Record<string, string>>;
+    /**
+     * An ad-hoc send's own transport knobs, which a saved request takes from the preferences: the
+     * TLS floor, request-body compression and the HTTP/2 offer.
+     */
+    readonly tlsMinVersion?: 'TLSv1.2' | 'TLSv1.3';
+    readonly compressBody?: 'gzip';
+    readonly allowH2?: boolean;
+}
+/** One saved SOAP request selected for a run, with enough context to send and report it. */
+export interface SoapSelected {
+    readonly kind: 'soap';
+    readonly path: string;
+    readonly group: string;
+    readonly iface: Interface;
+    readonly operation: OperationDef;
+    readonly request: SoapRequestDef;
+    /** What the editor holds and has not saved, for this send only. */
+    readonly override?: SoapOverride;
+}
+/** A SOAP request resolved, with the scopes its text expands against. */
+export interface ResolvedSoap extends Resolved<SoapSendInput> {
+    readonly scopes: PropertyScopes;
+}
+/** A SOAP request's own auth, combined with its endpoint's, falling back to the interface's. */
+export declare function soapEffectiveAuth(selected: SoapSelected): SoapOwnerAuth | undefined;
+/**
+ * One SOAP request resolved (spec §3.4): its endpoint, WS-Addressing, its WS-Security
+ * configuration and its secret tokens (behind `context.secretPlaceholders` when given), nothing
+ * connected and the credentials still as configured, so the input holds no `auth`. A reference
+ * nothing resolves is reported in `unresolved`, not thrown: the send refuses it, a preview shows it.
+ *
+ * @throws WirebenchError `endpoint-unresolved` | `secret-missing` | `wss-config-missing`
+ */
+export declare function resolveSoap(selected: SoapSelected, context: RunContext): Promise<ResolvedSoap>;
+/**
+ * The request's TLS identity and trust decision, the proxy for its endpoint, and its credentials
+ * (an OAuth2 token included), over a resolved input: what a send does after its pre-request
+ * script, so the script never sees a credential (spec §7).
+ *
+ * @throws WirebenchError `secret-missing` | `auth-grant-unsupported` | `keystore-missing`
+ */
+export declare function connectSoap(selected: SoapSelected, context: RunContext, input: SoapSendInput): Promise<SoapSendInput>;
+/**
+ * A SOAP response as assertions and sequence transfers see it, without contract validation: what a
+ * host that has no compiled definition at hand (the desktop's sequence runner) can build from the
+ * exchange alone.
+ */
+export declare function soapResponseSubject(exchange: SoapExchange): AssertionSubject;
+/**
+ * The SOAP item for `requestId`, built as a run builds it — and found even when its definition no
+ * longer has it (`orphaned`), which a run skips and a person may still send. Undefined when no SOAP
+ * request has that id.
+ */
+export declare function soapItemFor(project: Project, requestId: string): SoapSelected | undefined;
+/** SOAP's run facet. */
+export declare const soapRun: ProtocolRun<SoapSelected>;