@wirebench/engine 2.1.1

package/dist/validate/wsi/assertions/message/r2113.d.ts

@@ -0,0 +1,11 @@
+import type { WsiMessageAssertion } from '../../types.js';
+/**
+ * BP 1.1 R2113: an envelope carries no `soapenc:arrayType` attribute on any of its elements.
+ * The profile rules out SOAP encoding, and `arrayType` is the attribute that carries an encoded
+ * array's item type and dimensions — so its presence means the message is not the literal
+ * instance the description promised.
+ *
+ * The description-level counterparts (a `wsdl:arrayType` attribute, a type derived from
+ * `soapenc:Array`) stay in the WSDL catalogue as R2110/R2111.
+ */
+export declare const R2113: WsiMessageAssertion;

package/dist/validate/wsi/assertions/message/r2113.js

@@ -0,0 +1,33 @@
+import { NOT_APPLICABLE } from '../../types.js';
+import { SOAP_ENCODING_NS, attributesOf, envelopeElements, envelopes, messageFinding } from './helpers.js';
+/** Both SOAP encoding namespaces; an `arrayType` in either one is out of profile. */
+const ENCODING_NAMESPACES = [SOAP_ENCODING_NS['1.1'], SOAP_ENCODING_NS['1.2']];
+/**
+ * BP 1.1 R2113: an envelope carries no `soapenc:arrayType` attribute on any of its elements.
+ * The profile rules out SOAP encoding, and `arrayType` is the attribute that carries an encoded
+ * array's item type and dimensions — so its presence means the message is not the literal
+ * instance the description promised.
+ *
+ * The description-level counterparts (a `wsdl:arrayType` attribute, a type derived from
+ * `soapenc:Array`) stay in the WSDL catalogue as R2110/R2111.
+ */
+export const R2113 = {
+    id: 'R2113',
+    title: 'An envelope carries no soapenc:arrayType attribute',
+    level: 'REQUIRED',
+    section: '4.3 Use of SOAP Encoding',
+    check(context) {
+        const findings = [];
+        const views = envelopes(context);
+        for (const view of views) {
+            for (const element of envelopeElements(view)) {
+                for (const attribute of attributesOf(element)) {
+                    if (attribute.localName === 'arrayType' && ENCODING_NAMESPACES.includes(attribute.namespaceUri ?? '')) {
+                        findings.push(messageFinding(view, element, `"${element.nodeName}" carries soapenc:arrayType="${attribute.value}"`));
+                    }
+                }
+            }
+        }
+        return views.length === 0 ? NOT_APPLICABLE : findings;
+    },
+};

package/dist/validate/wsi/assertions/message/r2211.d.ts

@@ -0,0 +1,7 @@
+import type { WsiMessageAssertion } from '../../types.js';
+/**
+ * BP 1.1 R2211: an rpc-literal message carries no `xsi:nil="true"` on a part accessor. An rpc
+ * part accessor is not a schema element declaration, so it has no `nillable` to make nil legal —
+ * an omitted part says "absent" in a way every receiver agrees on.
+ */
+export declare const R2211: WsiMessageAssertion;

package/dist/validate/wsi/assertions/message/r2211.js

@@ -0,0 +1,42 @@
+import { NS } from '../../../../xml/namespaces.js';
+import { NOT_APPLICABLE } from '../../types.js';
+import { attributesOf, envelopes, messageFinding, partAccessors } from './helpers.js';
+/** The `xsi:nil` values that actually assert nil-ness. */
+const NIL = ['1', 'true'];
+/**
+ * BP 1.1 R2211: an rpc-literal message carries no `xsi:nil="true"` on a part accessor. An rpc
+ * part accessor is not a schema element declaration, so it has no `nillable` to make nil legal —
+ * an omitted part says "absent" in a way every receiver agrees on.
+ */
+export const R2211 = {
+    id: 'R2211',
+    title: 'An rpc-literal part accessor carries no xsi:nil',
+    level: 'REQUIRED',
+    section: '4.4 rpc-literal',
+    check(context) {
+        if (context.binding.style !== 'rpc' || context.binding.use !== 'literal') {
+            return NOT_APPLICABLE;
+        }
+        const findings = [];
+        let accessors = 0;
+        for (const view of envelopes(context)) {
+            // The body child is the operation wrapper; its children are the part accessors.
+            for (const wrapper of partAccessors(view)) {
+                let child = wrapper.firstChild;
+                while (child !== null) {
+                    if (child.nodeType === 1) {
+                        const element = child;
+                        accessors += 1;
+                        for (const attribute of attributesOf(element)) {
+                            if (attribute.namespaceUri === NS.XSI && attribute.localName === 'nil' && NIL.includes(attribute.value)) {
+                                findings.push(messageFinding(view, element, `the rpc-literal part accessor "${element.nodeName}" carries xsi:nil="${attribute.value}"`));
+                            }
+                        }
+                    }
+                    child = child.nextSibling;
+                }
+            }
+        }
+        return accessors === 0 ? NOT_APPLICABLE : findings;
+    },
+};

package/dist/validate/wsi/assertions/r2001.d.ts

@@ -0,0 +1,15 @@
+import type { WsiAssertion } from '../types.js';
+/**
+ * BP 1.1 R2001: a description "MUST only use the WSDL 'import' statement to import another WSDL
+ * description". Every `wsdl:import` is therefore checked to point at a document whose root element
+ * is `wsdl:definitions`; an import whose target could not be fetched is left alone (the resolver
+ * already reports that as its own problem).
+ *
+ * A `wsdl:import` of an *XML Schema* violates this requirement too, but it is the subject of the
+ * more specific {@link R2002} ("use xs:import for schemas"), so it is reported there only and
+ * skipped here — otherwise every such import would be flagged twice for one construct.
+ *
+ * A target the resolver could not classify at all never reaches the bundle; it shows up as a
+ * `not-xml` resolve problem instead, which is exactly the "not a WSDL description" case.
+ */
+export declare const R2001: WsiAssertion;

package/dist/validate/wsi/assertions/r2001.js

@@ -0,0 +1,47 @@
+import { NS } from '../../../xml/namespaces.js';
+import { childElements, optionalAttribute } from '../../../wsdl/dom-utils.js';
+import { NOT_APPLICABLE } from '../types.js';
+import { bundledDocumentFor, findingAt, resolveAgainst, wsdlDocuments } from './helpers.js';
+/**
+ * BP 1.1 R2001: a description "MUST only use the WSDL 'import' statement to import another WSDL
+ * description". Every `wsdl:import` is therefore checked to point at a document whose root element
+ * is `wsdl:definitions`; an import whose target could not be fetched is left alone (the resolver
+ * already reports that as its own problem).
+ *
+ * A `wsdl:import` of an *XML Schema* violates this requirement too, but it is the subject of the
+ * more specific {@link R2002} ("use xs:import for schemas"), so it is reported there only and
+ * skipped here — otherwise every such import would be flagged twice for one construct.
+ *
+ * A target the resolver could not classify at all never reaches the bundle; it shows up as a
+ * `not-xml` resolve problem instead, which is exactly the "not a WSDL description" case.
+ */
+export const R2001 = {
+    id: 'R2001',
+    title: 'wsdl:import only imports WSDL documents',
+    level: 'REQUIRED',
+    section: '4.2 Document Structure',
+    check(context) {
+        const findings = [];
+        let imports = 0;
+        for (const doc of wsdlDocuments(context)) {
+            for (const importEl of childElements(doc.definitions, NS.WSDL, 'import')) {
+                const location = optionalAttribute(importEl, 'location');
+                if (location === undefined) {
+                    continue;
+                }
+                imports += 1;
+                const resolved = resolveAgainst(location, doc.location);
+                // A bundled target is either 'wsdl' or 'xsd'; the schema case belongs to R2002, so the
+                // only violation left to report here is a target the resolver could not classify at all.
+                const target = resolved === undefined ? undefined : bundledDocumentFor(context, resolved);
+                const unclassified = target === undefined &&
+                    resolved !== undefined &&
+                    context.bundle.problems.some((problem) => problem.code === 'not-xml' && problem.location === resolved);
+                if (unclassified) {
+                    findings.push(findingAt(doc.location, importEl, `wsdl:import location="${location}" refers to a document whose root element is not wsdl:definitions`));
+                }
+            }
+        }
+        return imports === 0 ? NOT_APPLICABLE : findings;
+    },
+};

package/dist/validate/wsi/assertions/r2002.d.ts

@@ -0,0 +1,11 @@
+import type { WsiAssertion } from '../types.js';
+/**
+ * BP 1.1 R2002: to import XML Schema definitions, a description "MUST use the XML Schema 'import'
+ * statement" — i.e. an `xs:import` inside `wsdl:types`, never a `wsdl:import`. This flags each
+ * `wsdl:import` that resolves to an `xs:schema` document.
+ *
+ * Such an import also breaches {@link R2001} ("wsdl:import imports WSDL only"); this assertion is
+ * the more specific of the two, so R2001 defers the schema case to it and the construct is
+ * reported once.
+ */
+export declare const R2002: WsiAssertion;

package/dist/validate/wsi/assertions/r2002.js

@@ -0,0 +1,38 @@
+import { NS } from '../../../xml/namespaces.js';
+import { childElements, optionalAttribute } from '../../../wsdl/dom-utils.js';
+import { NOT_APPLICABLE } from '../types.js';
+import { bundledDocumentFor, findingAt, resolveAgainst, wsdlDocuments } from './helpers.js';
+/**
+ * BP 1.1 R2002: to import XML Schema definitions, a description "MUST use the XML Schema 'import'
+ * statement" — i.e. an `xs:import` inside `wsdl:types`, never a `wsdl:import`. This flags each
+ * `wsdl:import` that resolves to an `xs:schema` document.
+ *
+ * Such an import also breaches {@link R2001} ("wsdl:import imports WSDL only"); this assertion is
+ * the more specific of the two, so R2001 defers the schema case to it and the construct is
+ * reported once.
+ */
+export const R2002 = {
+    id: 'R2002',
+    title: 'Schemas are imported with xs:import, not wsdl:import',
+    level: 'REQUIRED',
+    section: '4.2 Document Structure',
+    check(context) {
+        const findings = [];
+        let imports = 0;
+        for (const doc of wsdlDocuments(context)) {
+            for (const importEl of childElements(doc.definitions, NS.WSDL, 'import')) {
+                const location = optionalAttribute(importEl, 'location');
+                if (location === undefined) {
+                    continue;
+                }
+                imports += 1;
+                const resolved = resolveAgainst(location, doc.location);
+                const target = resolved === undefined ? undefined : bundledDocumentFor(context, resolved);
+                if (target?.kind === 'xsd') {
+                    findings.push(findingAt(doc.location, importEl, `wsdl:import location="${location}" imports a schema; use xs:import inside wsdl:types instead`));
+                }
+            }
+        }
+        return imports === 0 ? NOT_APPLICABLE : findings;
+    },
+};

package/dist/validate/wsi/assertions/r2003.d.ts

@@ -0,0 +1,7 @@
+import type { WsiAssertion } from '../types.js';
+/**
+ * BP 1.1 R2003: a description "MUST use the XML Schema 'import' statement only within the
+ * xsd:schema element of the types section". An `xs:import` placed directly under `wsdl:types` (or
+ * anywhere else in the document) is flagged.
+ */
+export declare const R2003: WsiAssertion;

package/dist/validate/wsi/assertions/r2003.js

@@ -0,0 +1,32 @@
+import { NS } from '../../../xml/namespaces.js';
+import { NOT_APPLICABLE } from '../types.js';
+import { descendants, findingAt, wsdlDocuments } from './helpers.js';
+/**
+ * BP 1.1 R2003: a description "MUST use the XML Schema 'import' statement only within the
+ * xsd:schema element of the types section". An `xs:import` placed directly under `wsdl:types` (or
+ * anywhere else in the document) is flagged.
+ */
+export const R2003 = {
+    id: 'R2003',
+    title: 'xs:import appears only inside an xs:schema of wsdl:types',
+    level: 'REQUIRED',
+    section: '4.2 Document Structure',
+    check(context) {
+        const findings = [];
+        let imports = 0;
+        for (const doc of wsdlDocuments(context)) {
+            for (const element of descendants(doc.definitions)) {
+                if (element.namespaceURI !== NS.XSD || element.localName !== 'import') {
+                    continue;
+                }
+                imports += 1;
+                const parent = element.parentNode;
+                const parentEl = parent !== null && parent.nodeType === 1 ? parent : undefined;
+                if (parentEl?.namespaceURI !== NS.XSD || parentEl.localName !== 'schema') {
+                    findings.push(findingAt(doc.location, element, 'xs:import must be a child of an xs:schema inside wsdl:types'));
+                }
+            }
+        }
+        return imports === 0 ? NOT_APPLICABLE : findings;
+    },
+};

package/dist/validate/wsi/assertions/r2005.d.ts

@@ -0,0 +1,7 @@
+import type { WsiAssertion } from '../types.js';
+/**
+ * BP 1.1 R2005: the `targetNamespace` of an imported schema must be identical to the `namespace`
+ * attribute of the `xs:import` that referenced it. Imports without a `schemaLocation`, and imports
+ * whose target was not fetched, carry nothing to compare and are skipped.
+ */
+export declare const R2005: WsiAssertion;

package/dist/validate/wsi/assertions/r2005.js

@@ -0,0 +1,40 @@
+import { NS } from '../../../xml/namespaces.js';
+import { childElements, optionalAttribute } from '../../../wsdl/dom-utils.js';
+import { NOT_APPLICABLE } from '../types.js';
+import { bundledDocumentFor, findingAt, resolveAgainst, schemaElements } from './helpers.js';
+/**
+ * BP 1.1 R2005: the `targetNamespace` of an imported schema must be identical to the `namespace`
+ * attribute of the `xs:import` that referenced it. Imports without a `schemaLocation`, and imports
+ * whose target was not fetched, carry nothing to compare and are skipped.
+ */
+export const R2005 = {
+    id: 'R2005',
+    title: 'An imported schema targetNamespace matches the xs:import namespace',
+    level: 'REQUIRED',
+    section: '4.2 Document Structure',
+    check(context) {
+        const findings = [];
+        let compared = 0;
+        for (const view of schemaElements(context)) {
+            for (const importEl of childElements(view.schema, NS.XSD, 'import')) {
+                const schemaLocation = optionalAttribute(importEl, 'schemaLocation');
+                if (schemaLocation === undefined) {
+                    continue;
+                }
+                const resolved = resolveAgainst(schemaLocation, view.location);
+                const target = resolved === undefined ? undefined : bundledDocumentFor(context, resolved);
+                const root = target?.document.documentElement ?? null;
+                if (target === undefined || root === null || root.namespaceURI !== NS.XSD) {
+                    continue;
+                }
+                compared += 1;
+                const declared = optionalAttribute(importEl, 'namespace') ?? '';
+                const actual = optionalAttribute(root, 'targetNamespace') ?? '';
+                if (declared !== actual) {
+                    findings.push(findingAt(view.location, importEl, `xs:import namespace="${declared}" does not match the imported schema's targetNamespace "${actual}"`));
+                }
+            }
+        }
+        return compared === 0 ? NOT_APPLICABLE : findings;
+    },
+};

package/dist/validate/wsi/assertions/r2101.d.ts

@@ -0,0 +1,14 @@
+import type { WsiAssertion } from '../types.js';
+/**
+ * BP 1.1 R2101: a description "MUST NOT use QName references to WSDL components in namespaces
+ * that have been neither imported, nor defined in the referring WSDL document". Checked here are
+ * the references to *WSDL* components: `wsdl:binding/@type`, `wsdl:port/@binding`, the
+ * `@message` of an abstract `wsdl:input`/`output`/`fault` and of a `soapbind:header`/
+ * `headerfault`. A `wsdl:import` *declares* a namespace rather than referring to one, so it is not
+ * itself a reference to check.
+ *
+ * The parallel requirement for *schema* components (`wsdl:part/@element|@type`) is {@link R2102}.
+ * A namespace counts as known when it is a `wsdl:definitions/@targetNamespace` or an
+ * `xs:schema/@targetNamespace` of the bundle, or the `namespace` of a `wsdl:import`/`xs:import`.
+ */
+export declare const R2101: WsiAssertion;

package/dist/validate/wsi/assertions/r2101.js

@@ -0,0 +1,65 @@
+import { NS } from '../../../xml/namespaces.js';
+import { optionalAttribute } from '../../../wsdl/dom-utils.js';
+import { NOT_APPLICABLE } from '../types.js';
+import { SOAP_BINDING_NAMESPACES, attributeQName, declaredNamespaces, descendants, findingAt, targetNamespaceOf, wsdlDocuments, } from './helpers.js';
+/** Every attribute of `definitions` that is a QName reference to a WSDL component. */
+function componentReferences(definitions) {
+    const references = [];
+    for (const element of descendants(definitions)) {
+        if (element.namespaceURI === NS.WSDL) {
+            if (element.localName === 'binding' && element.parentNode === definitions) {
+                references.push({ element, attribute: 'type' });
+            }
+            else if (element.localName === 'port') {
+                references.push({ element, attribute: 'binding' });
+            }
+            else if (element.localName === 'input' || element.localName === 'output' || element.localName === 'fault') {
+                // Only the abstract sides carry @message; the binding sides do not.
+                references.push({ element, attribute: 'message' });
+            }
+        }
+        else if (SOAP_BINDING_NAMESPACES.includes(element.namespaceURI) &&
+            (element.localName === 'header' || element.localName === 'headerfault')) {
+            references.push({ element, attribute: 'message' });
+        }
+    }
+    return references;
+}
+/**
+ * BP 1.1 R2101: a description "MUST NOT use QName references to WSDL components in namespaces
+ * that have been neither imported, nor defined in the referring WSDL document". Checked here are
+ * the references to *WSDL* components: `wsdl:binding/@type`, `wsdl:port/@binding`, the
+ * `@message` of an abstract `wsdl:input`/`output`/`fault` and of a `soapbind:header`/
+ * `headerfault`. A `wsdl:import` *declares* a namespace rather than referring to one, so it is not
+ * itself a reference to check.
+ *
+ * The parallel requirement for *schema* components (`wsdl:part/@element|@type`) is {@link R2102}.
+ * A namespace counts as known when it is a `wsdl:definitions/@targetNamespace` or an
+ * `xs:schema/@targetNamespace` of the bundle, or the `namespace` of a `wsdl:import`/`xs:import`.
+ */
+export const R2101 = {
+    id: 'R2101',
+    title: 'WSDL component references name only imported or locally defined namespaces',
+    level: 'REQUIRED',
+    section: '4.4 XML Schema',
+    check(context) {
+        const known = declaredNamespaces(context);
+        const findings = [];
+        let references = 0;
+        for (const doc of wsdlDocuments(context)) {
+            const tns = targetNamespaceOf(doc.definitions);
+            for (const { element, attribute } of componentReferences(doc.definitions)) {
+                const raw = optionalAttribute(element, attribute);
+                if (raw === undefined) {
+                    continue;
+                }
+                const qname = attributeQName(element, attribute, tns);
+                references += 1;
+                if (qname === undefined || !known.has(qname.namespaceUri)) {
+                    findings.push(findingAt(doc.location, element, `${element.localName ?? ''} ${attribute}="${raw}" refers to a namespace that is neither defined nor imported`));
+                }
+            }
+        }
+        return references === 0 ? NOT_APPLICABLE : findings;
+    },
+};

package/dist/validate/wsi/assertions/r2102.d.ts

@@ -0,0 +1,10 @@
+import type { WsiAssertion } from '../types.js';
+/**
+ * BP 1.1 R2102: a QName reference to a *schema component* — the `element` or `type` of a
+ * `wsdl:part` — "MUST use the namespace defined in the targetNamespace attribute on the
+ * xsd:schema element", i.e. it must name a namespace the description actually defines or imports.
+ *
+ * The companion {@link R2101} covers references to *WSDL* components (a binding's port type, a
+ * port's binding, an operation's messages); this one covers the schema side.
+ */
+export declare const R2102: WsiAssertion;

package/dist/validate/wsi/assertions/r2102.js

@@ -0,0 +1,41 @@
+import { NS } from '../../../xml/namespaces.js';
+import { childElements, optionalAttribute } from '../../../wsdl/dom-utils.js';
+import { NOT_APPLICABLE } from '../types.js';
+import { attributeQName, declaredNamespaces, findingAt, messageParts, targetNamespaceOf, wsdlDocuments, } from './helpers.js';
+/**
+ * BP 1.1 R2102: a QName reference to a *schema component* — the `element` or `type` of a
+ * `wsdl:part` — "MUST use the namespace defined in the targetNamespace attribute on the
+ * xsd:schema element", i.e. it must name a namespace the description actually defines or imports.
+ *
+ * The companion {@link R2101} covers references to *WSDL* components (a binding's port type, a
+ * port's binding, an operation's messages); this one covers the schema side.
+ */
+export const R2102 = {
+    id: 'R2102',
+    title: 'Part element/type references name only imported or locally defined namespaces',
+    level: 'REQUIRED',
+    section: '4.4 XML Schema',
+    check(context) {
+        const known = declaredNamespaces(context);
+        const findings = [];
+        let references = 0;
+        for (const doc of wsdlDocuments(context)) {
+            const tns = targetNamespaceOf(doc.definitions);
+            for (const message of childElements(doc.definitions, NS.WSDL, 'message')) {
+                for (const part of messageParts(message)) {
+                    for (const attribute of ['element', 'type']) {
+                        const qname = attributeQName(part, attribute, tns);
+                        if (qname === undefined) {
+                            continue;
+                        }
+                        references += 1;
+                        if (!known.has(qname.namespaceUri)) {
+                            findings.push(findingAt(doc.location, part, `wsdl:part ${attribute}="${optionalAttribute(part, attribute) ?? ''}" is in namespace "${qname.namespaceUri}", which is neither defined nor imported`));
+                        }
+                    }
+                }
+            }
+        }
+        return references === 0 ? NOT_APPLICABLE : findings;
+    },
+};

package/dist/validate/wsi/assertions/r2105.d.ts

@@ -0,0 +1,8 @@
+import type { WsiAssertion } from '../types.js';
+/**
+ * BP 1.1 R2105: every `xs:schema` contained in a `wsdl:types` element "MUST have a targetNamespace
+ * attribute with a valid and non-null value". Both an absent `targetNamespace` and a present but
+ * empty one (`targetNamespace=""`, the no-namespace schema) fail. Standalone schema documents are
+ * governed by XML Schema itself and are not examined here.
+ */
+export declare const R2105: WsiAssertion;

package/dist/validate/wsi/assertions/r2105.js

@@ -0,0 +1,39 @@
+import { NS } from '../../../xml/namespaces.js';
+import { childElements, firstChildElement } from '../../../wsdl/dom-utils.js';
+import { NOT_APPLICABLE } from '../types.js';
+import { findingAt, wsdlDocuments } from './helpers.js';
+/**
+ * BP 1.1 R2105: every `xs:schema` contained in a `wsdl:types` element "MUST have a targetNamespace
+ * attribute with a valid and non-null value". Both an absent `targetNamespace` and a present but
+ * empty one (`targetNamespace=""`, the no-namespace schema) fail. Standalone schema documents are
+ * governed by XML Schema itself and are not examined here.
+ */
+export const R2105 = {
+    id: 'R2105',
+    title: 'Every inline xs:schema declares a non-empty targetNamespace',
+    level: 'REQUIRED',
+    section: '4.4 XML Schema',
+    check(context) {
+        const findings = [];
+        let schemas = 0;
+        for (const doc of wsdlDocuments(context)) {
+            const typesEl = firstChildElement(doc.definitions, NS.WSDL, 'types');
+            if (typesEl === undefined) {
+                continue;
+            }
+            for (const schema of childElements(typesEl, NS.XSD, 'schema')) {
+                schemas += 1;
+                // "a valid and non-null value": an absent attribute and a present-but-empty one both
+                // fail. getAttribute is used directly because optionalAttribute collapses the two.
+                const declared = schema.getAttribute('targetNamespace');
+                if (declared === null) {
+                    findings.push(findingAt(doc.location, schema, 'Inline xs:schema has no targetNamespace attribute'));
+                }
+                else if (declared === '') {
+                    findings.push(findingAt(doc.location, schema, 'Inline xs:schema declares an empty targetNamespace'));
+                }
+            }
+        }
+        return schemas === 0 ? NOT_APPLICABLE : findings;
+    },
+};

package/dist/validate/wsi/assertions/r2110.d.ts

@@ -0,0 +1,8 @@
+import type { WsiAssertion } from '../types.js';
+/**
+ * BP 1.1 R2110: in a description, "declarations MUST NOT extend or restrict the soapenc:Array
+ * type" — the SOAP 1.1 section 5 array shape is outside the profile. Every
+ * `xs:extension`/`xs:restriction` inside an `xs:complexContent` is checked against the SOAP
+ * encoding namespaces.
+ */
+export declare const R2110: WsiAssertion;

package/dist/validate/wsi/assertions/r2110.js

@@ -0,0 +1,38 @@
+import { NS } from '../../../xml/namespaces.js';
+import { childElements, optionalAttribute } from '../../../wsdl/dom-utils.js';
+import { NOT_APPLICABLE } from '../types.js';
+import { attributeQName, descendants, findingAt, schemaElements } from './helpers.js';
+const ENCODING_NAMESPACES = new Set([NS.SOAP11_ENC, NS.SOAP12_ENC]);
+/**
+ * BP 1.1 R2110: in a description, "declarations MUST NOT extend or restrict the soapenc:Array
+ * type" — the SOAP 1.1 section 5 array shape is outside the profile. Every
+ * `xs:extension`/`xs:restriction` inside an `xs:complexContent` is checked against the SOAP
+ * encoding namespaces.
+ */
+export const R2110 = {
+    id: 'R2110',
+    title: 'No type extends or restricts soapenc:Array',
+    level: 'REQUIRED',
+    section: '4.4 XML Schema',
+    check(context) {
+        const findings = [];
+        let derivations = 0;
+        for (const view of schemaElements(context)) {
+            for (const complexContent of descendants(view.schema)) {
+                if (complexContent.namespaceURI !== NS.XSD || complexContent.localName !== 'complexContent') {
+                    continue;
+                }
+                for (const kind of ['extension', 'restriction']) {
+                    for (const derivation of childElements(complexContent, NS.XSD, kind)) {
+                        derivations += 1;
+                        const base = attributeQName(derivation, 'base', '');
+                        if (base !== undefined && ENCODING_NAMESPACES.has(base.namespaceUri) && base.localName === 'Array') {
+                            findings.push(findingAt(view.location, derivation, `xs:${kind} base="${optionalAttribute(derivation, 'base') ?? ''}" derives from soapenc:Array`));
+                        }
+                    }
+                }
+            }
+        }
+        return derivations === 0 ? NOT_APPLICABLE : findings;
+    },
+};

package/dist/validate/wsi/assertions/r2111.d.ts

@@ -0,0 +1,6 @@
+import type { WsiAssertion } from '../types.js';
+/**
+ * BP 1.1 R2111: a description's type declarations "MUST NOT use the wsdl:arrayType attribute" —
+ * the SOAP-encoded array annotation has no place in a literal description.
+ */
+export declare const R2111: WsiAssertion;

package/dist/validate/wsi/assertions/r2111.js

@@ -0,0 +1,30 @@
+import { NS } from '../../../xml/namespaces.js';
+import { NOT_APPLICABLE } from '../types.js';
+import { descendants, findingAt, schemaElements } from './helpers.js';
+/**
+ * BP 1.1 R2111: a description's type declarations "MUST NOT use the wsdl:arrayType attribute" —
+ * the SOAP-encoded array annotation has no place in a literal description.
+ */
+export const R2111 = {
+    id: 'R2111',
+    title: 'No type declaration carries wsdl:arrayType',
+    level: 'REQUIRED',
+    section: '4.4 XML Schema',
+    check(context) {
+        const findings = [];
+        let declarations = 0;
+        for (const view of schemaElements(context)) {
+            for (const element of descendants(view.schema)) {
+                if (element.namespaceURI !== NS.XSD) {
+                    continue;
+                }
+                declarations += 1;
+                const value = element.getAttributeNS(NS.WSDL, 'arrayType');
+                if (value !== null && value !== '') {
+                    findings.push(findingAt(view.location, element, `xs:${element.localName ?? ''} carries wsdl:arrayType="${value}"`));
+                }
+            }
+        }
+        return declarations === 0 ? NOT_APPLICABLE : findings;
+    },
+};

package/dist/validate/wsi/assertions/r2112.d.ts

@@ -0,0 +1,7 @@
+import type { WsiAssertion } from '../types.js';
+/**
+ * BP 1.1 R2112: in a description, "elements SHOULD NOT be named using the convention ArrayOfXXX" —
+ * the naming survives from SOAP encoding and misleads consumers of a literal description. This is
+ * a `SHOULD`, so a hit is reported as a warning rather than a failure.
+ */
+export declare const R2112: WsiAssertion;

package/dist/validate/wsi/assertions/r2112.js

@@ -0,0 +1,35 @@
+import { NS } from '../../../xml/namespaces.js';
+import { childElements, optionalAttribute } from '../../../wsdl/dom-utils.js';
+import { NOT_APPLICABLE } from '../types.js';
+import { findingAt, schemaElements } from './helpers.js';
+const ARRAY_OF = /^ArrayOf.+/;
+/**
+ * BP 1.1 R2112: in a description, "elements SHOULD NOT be named using the convention ArrayOfXXX" —
+ * the naming survives from SOAP encoding and misleads consumers of a literal description. This is
+ * a `SHOULD`, so a hit is reported as a warning rather than a failure.
+ */
+export const R2112 = {
+    id: 'R2112',
+    title: 'Global declarations avoid the ArrayOfXXX naming convention',
+    level: 'RECOMMENDED',
+    section: '4.4 XML Schema',
+    check(context) {
+        const findings = [];
+        let declarations = 0;
+        for (const view of schemaElements(context)) {
+            for (const kind of ['element', 'complexType', 'simpleType']) {
+                for (const declaration of childElements(view.schema, NS.XSD, kind)) {
+                    const name = optionalAttribute(declaration, 'name');
+                    if (name === undefined) {
+                        continue;
+                    }
+                    declarations += 1;
+                    if (ARRAY_OF.test(name)) {
+                        findings.push(findingAt(view.location, declaration, `xs:${kind} "${name}" uses the ArrayOfXXX naming convention`));
+                    }
+                }
+            }
+        }
+        return declarations === 0 ? NOT_APPLICABLE : findings;
+    },
+};

package/dist/validate/wsi/assertions/r2201.d.ts

@@ -0,0 +1,7 @@
+import type { WsiAssertion } from '../types.js';
+/**
+ * BP 1.1 R2201: a document-literal binding "MUST, in each of its soapbind:body element(s), have at
+ * most one part listed in the parts attribute, if the parts attribute is specified" — a literal
+ * body carries exactly one child element.
+ */
+export declare const R2201: WsiAssertion;