sequence is not respected

[toughlex-donatas]

https://www.w3schools.com/xml/el_sequence.asp

The sequence element specifies that the child elements must appear in a sequence.

https://learn.microsoft.com/en-us/previous-versions/dotnet/netframework-4.0/ms256089(v=vs.100)

Requires the elements in the group to appear in the specified sequence within the containing element.

This library does not ensure this behavior.

Probably needed changes are somewhere here

node-soap/src/wsdl/index.ts

Line 748 in 15032f0

let currentChildXmlnsAttrib = '';

[w666]

Hi @toughlex-donatas,

Could you please add a bit more details? How did you find this issue? Is there an example that you can share, like code snippet or xml file?

Thanks.

[toughlex-donatas]

To replicate the problem you could create a test in https://github.com/vpulim/node-soap/blob/master/test/wsdl-test.js and use this wsdl https://github.com/vpulim/node-soap/blob/master/test/wsdl/marketo.wsdl
Try to call GetLeadChanges for example, you will see that SOAP XML ParamsGetLeadChanges will not have its children ordered in correct order.
There are APIs that don't work with unordered sequence elements.

[w666]

Had a look on it, does not look like an easy fix. Will have another look later when have more time.

[kouak]

Here's a helper I've made for this purpose.

This function is a utility that recursively reconstructs a JavaScript object to match the exact property order defined in a schema. It also acts as a sanitizer by filtering out any properties from the input object that are not present in the schema.

export function reorderKeys<T extends Schema, O extends { [key: string]: any }>(
  schema: T,
): (obj: O) => O {
  return (obj: O): O => {
    // Loop through schema, pull property from Object
    return Object.keys(schema).reduce<any>((prev, curr) => {
      const lookupKey: string = curr.replace(/\[\]$/, '');
      const isArrayExpected: boolean = curr.endsWith('[]');

      if (!(lookupKey in obj)) {
        return prev;
      }

      const currSchema = schema[curr];

      if (typeof currSchema === 'string') {
        prev[lookupKey] = obj[lookupKey];
        return prev;
      }

      if (typeof currSchema === 'object') {
        if (
          Object.keys(currSchema).filter(
            (k) => k !== 'targetNSAlias' && k !== 'targetNamespace',
          ).length
        ) {
          prev[lookupKey] =
            isArrayExpected && obj[lookupKey] && Array.isArray(obj[lookupKey])
              ? obj[lookupKey].map(reorderKeys(currSchema))
              : reorderKeys(currSchema)(obj[lookupKey]);
          return prev;
        }

        prev[lookupKey] = obj[lookupKey];
        return prev;
      }

      return prev;
    }, {});
  };
}

Usage :

const schema = client.describe().Service.Port.method.input;

// const schema = {
//   id: "xs:string",
//   config: {
//     isEnabled: "xs:boolean",
//     mode: "xs:string",
//   },
//   timestamp: "xs:dateTime",
// };

const prepareData = reorderKeys(schema);

const inputWithWrongOrder = {
  timestamp: '2025-01-01T00:00:00Z',
  config: {
    mode: 'VERBOSE',
    isEnabled: true
  },
  id: 'REQ-001'
};

const fixedInput = prepareData(inputWithWrongOrder);
// const fixedInput = {
//   id: 'REQ-001',
//   config: {
//     isEnabled: true,
//     mode: 'VERBOSE',
//   },
//   timestamp: '2025-01-01T00:00:00Z',
// };

await client.Service.Port.method(fixedInput); // OK

[smokhov]

Thank you @kouak for the workaround suggestions. We were hoping @rjordakiev in #1348 as well as in his branch rjordakiev@c346fa2 has a complete fix with a test, but he seems to have gone silent lately. The proposed fix introduces the group element to sort and solve the sequencing issue, which seems like a correct approach, but he had no tests for the group element, but only for the ordering itself in that other branch.