@graphql-mesh/transport-soap 0.0.0

package/cjs/executor.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createExecutorFromSchemaAST = void 0;
+const fast_xml_parser_1 = require("fast-xml-parser");
+const graphql_1 = require("graphql");
+const cross_helpers_1 = require("@graphql-mesh/cross-helpers");
+const string_interpolation_1 = require("@graphql-mesh/string-interpolation");
+const utils_1 = require("@graphql-tools/utils");
+const fetch_1 = require("@whatwg-node/fetch");
+const parseXmlOptions_1 = require("./parseXmlOptions");
+function isOriginallyListType(type) {
+    if ((0, graphql_1.isNonNullType)(type)) {
+        return isOriginallyListType(type.ofType);
+    }
+    return (0, graphql_1.isListType)(type);
+}
+const defaultFieldResolver = function soapDefaultResolver(root, args, context, info) {
+    const rootField = root[info.fieldName];
+    if (typeof rootField === 'function') {
+        return rootField(args, context, info);
+    }
+    const fieldValue = rootField;
+    const isArray = Array.isArray(fieldValue);
+    const isPlural = isOriginallyListType(info.returnType);
+    if (isPlural && !isArray) {
+        return [fieldValue];
+    }
+    if (!isPlural && isArray) {
+        return fieldValue[0];
+    }
+    return fieldValue;
+};
+function normalizeArgsForConverter(args) {
+    if (args != null) {
+        if (typeof args === 'object') {
+            for (const key in args) {
+                args[key] = normalizeArgsForConverter(args[key]);
+            }
+        }
+        else {
+            return {
+                innerText: args,
+            };
+        }
+    }
+    return args;
+}
+function normalizeResult(result) {
+    if (result != null && typeof result === 'object') {
+        for (const key in result) {
+            if (key === 'innerText') {
+                return result.innerText;
+            }
+            result[key] = normalizeResult(result[key]);
+        }
+        if (Array.isArray(result) && result.length === 1) {
+            return result[0];
+        }
+    }
+    return result;
+}
+function createRootValueMethod({ soapAnnotations, fetchFn, jsonToXMLConverter, xmlToJSONConverter, operationHeadersFactory, }) {
+    return async function rootValueMethod(args, context, info) {
+        const requestJson = {
+            'soap:Envelope': {
+                attributes: {
+                    'xmlns:soap': 'http://www.w3.org/2003/05/soap-envelope',
+                },
+                'soap:Body': {
+                    attributes: {
+                        xmlns: soapAnnotations.bindingNamespace,
+                    },
+                    ...normalizeArgsForConverter(args),
+                },
+            },
+        };
+        const requestXML = jsonToXMLConverter.build(requestJson);
+        const currentFetchFn = context?.fetch || fetchFn;
+        const response = await currentFetchFn(soapAnnotations.endpoint, {
+            method: 'POST',
+            body: requestXML,
+            headers: {
+                'Content-Type': 'application/soap+xml; charset=utf-8',
+                ...operationHeadersFactory({
+                    args,
+                    context,
+                    info,
+                    env: cross_helpers_1.process.env,
+                }),
+            },
+        }, context, info);
+        const responseXML = await response.text();
+        const responseJSON = xmlToJSONConverter.parse(responseXML, parseXmlOptions_1.parseXmlOptions);
+        return normalizeResult(responseJSON.Envelope[0].Body[0][soapAnnotations.elementName]);
+    };
+}
+function createRootValue(schema, fetchFn, operationHeaders) {
+    const rootValue = {};
+    const rootTypes = (0, utils_1.getRootTypes)(schema);
+    const jsonToXMLConverter = new fast_xml_parser_1.XMLBuilder({
+        attributeNamePrefix: '',
+        attributesGroupName: 'attributes',
+        textNodeName: 'innerText',
+    });
+    const xmlToJSONConverter = new fast_xml_parser_1.XMLParser(parseXmlOptions_1.parseXmlOptions);
+    const operationHeadersFactory = (0, string_interpolation_1.getInterpolatedHeadersFactory)(operationHeaders);
+    for (const rootType of rootTypes) {
+        const rootFieldMap = rootType.getFields();
+        for (const fieldName in rootFieldMap) {
+            const annotations = (0, utils_1.getDirective)(schema, rootFieldMap[fieldName], 'soap');
+            if (!annotations) {
+                // skip fields without @soap directive
+                // we have to skip Query.placeholder field when only mutations were created
+                continue;
+            }
+            const soapAnnotations = Object.assign({}, ...annotations);
+            rootValue[fieldName] = createRootValueMethod({
+                soapAnnotations,
+                fetchFn,
+                jsonToXMLConverter,
+                xmlToJSONConverter,
+                operationHeadersFactory,
+            });
+        }
+    }
+    return rootValue;
+}
+function createExecutorFromSchemaAST(schema, fetchFn = fetch_1.fetch, operationHeaders = {}) {
+    let rootValue;
+    return function soapExecutor({ document, variables, context }) {
+        if (!rootValue) {
+            rootValue = createRootValue(schema, fetchFn, operationHeaders);
+        }
+        return (0, graphql_1.execute)({
+            schema,
+            document,
+            rootValue,
+            contextValue: context,
+            variableValues: variables,
+            fieldResolver: defaultFieldResolver,
+        });
+    };
+}
+exports.createExecutorFromSchemaAST = createExecutorFromSchemaAST;

package/cjs/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createExecutorFromSchemaAST = exports.getSubgraphExecutor = void 0;
+const executor_js_1 = require("./executor.js");
+const getSubgraphExecutor = function getSOAPSubgraphExecutor({ transportEntry, getSubgraph, fetch }) {
+    return (0, executor_js_1.createExecutorFromSchemaAST)(getSubgraph(), fetch, transportEntry.headers);
+};
+exports.getSubgraphExecutor = getSubgraphExecutor;
+var executor_js_2 = require("./executor.js");
+Object.defineProperty(exports, "createExecutorFromSchemaAST", { enumerable: true, get: function () { return executor_js_2.createExecutorFromSchemaAST; } });

package/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/cjs/parseXmlOptions.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseXmlOptions = void 0;
+exports.parseXmlOptions = {
+    attributeNamePrefix: '',
+    attributesGroupName: 'attributes',
+    textNodeName: 'innerText',
+    ignoreAttributes: false,
+    removeNSPrefix: true,
+    isArray: (_, __, ___, isAttribute) => !isAttribute,
+    allowBooleanAttributes: true,
+};

package/esm/executor.js

@@ -0,0 +1,140 @@
+import { XMLBuilder as JSONToXMLConverter, XMLParser } from 'fast-xml-parser';
+import { execute, isListType, isNonNullType, } from 'graphql';
+import { process } from '@graphql-mesh/cross-helpers';
+import { getInterpolatedHeadersFactory, } from '@graphql-mesh/string-interpolation';
+import { getDirective, getRootTypes } from '@graphql-tools/utils';
+import { fetch as defaultFetchFn } from '@whatwg-node/fetch';
+import { parseXmlOptions } from './parseXmlOptions';
+function isOriginallyListType(type) {
+    if (isNonNullType(type)) {
+        return isOriginallyListType(type.ofType);
+    }
+    return isListType(type);
+}
+const defaultFieldResolver = function soapDefaultResolver(root, args, context, info) {
+    const rootField = root[info.fieldName];
+    if (typeof rootField === 'function') {
+        return rootField(args, context, info);
+    }
+    const fieldValue = rootField;
+    const isArray = Array.isArray(fieldValue);
+    const isPlural = isOriginallyListType(info.returnType);
+    if (isPlural && !isArray) {
+        return [fieldValue];
+    }
+    if (!isPlural && isArray) {
+        return fieldValue[0];
+    }
+    return fieldValue;
+};
+function normalizeArgsForConverter(args) {
+    if (args != null) {
+        if (typeof args === 'object') {
+            for (const key in args) {
+                args[key] = normalizeArgsForConverter(args[key]);
+            }
+        }
+        else {
+            return {
+                innerText: args,
+            };
+        }
+    }
+    return args;
+}
+function normalizeResult(result) {
+    if (result != null && typeof result === 'object') {
+        for (const key in result) {
+            if (key === 'innerText') {
+                return result.innerText;
+            }
+            result[key] = normalizeResult(result[key]);
+        }
+        if (Array.isArray(result) && result.length === 1) {
+            return result[0];
+        }
+    }
+    return result;
+}
+function createRootValueMethod({ soapAnnotations, fetchFn, jsonToXMLConverter, xmlToJSONConverter, operationHeadersFactory, }) {
+    return async function rootValueMethod(args, context, info) {
+        const requestJson = {
+            'soap:Envelope': {
+                attributes: {
+                    'xmlns:soap': 'http://www.w3.org/2003/05/soap-envelope',
+                },
+                'soap:Body': {
+                    attributes: {
+                        xmlns: soapAnnotations.bindingNamespace,
+                    },
+                    ...normalizeArgsForConverter(args),
+                },
+            },
+        };
+        const requestXML = jsonToXMLConverter.build(requestJson);
+        const currentFetchFn = context?.fetch || fetchFn;
+        const response = await currentFetchFn(soapAnnotations.endpoint, {
+            method: 'POST',
+            body: requestXML,
+            headers: {
+                'Content-Type': 'application/soap+xml; charset=utf-8',
+                ...operationHeadersFactory({
+                    args,
+                    context,
+                    info,
+                    env: process.env,
+                }),
+            },
+        }, context, info);
+        const responseXML = await response.text();
+        const responseJSON = xmlToJSONConverter.parse(responseXML, parseXmlOptions);
+        return normalizeResult(responseJSON.Envelope[0].Body[0][soapAnnotations.elementName]);
+    };
+}
+function createRootValue(schema, fetchFn, operationHeaders) {
+    const rootValue = {};
+    const rootTypes = getRootTypes(schema);
+    const jsonToXMLConverter = new JSONToXMLConverter({
+        attributeNamePrefix: '',
+        attributesGroupName: 'attributes',
+        textNodeName: 'innerText',
+    });
+    const xmlToJSONConverter = new XMLParser(parseXmlOptions);
+    const operationHeadersFactory = getInterpolatedHeadersFactory(operationHeaders);
+    for (const rootType of rootTypes) {
+        const rootFieldMap = rootType.getFields();
+        for (const fieldName in rootFieldMap) {
+            const annotations = getDirective(schema, rootFieldMap[fieldName], 'soap');
+            if (!annotations) {
+                // skip fields without @soap directive
+                // we have to skip Query.placeholder field when only mutations were created
+                continue;
+            }
+            const soapAnnotations = Object.assign({}, ...annotations);
+            rootValue[fieldName] = createRootValueMethod({
+                soapAnnotations,
+                fetchFn,
+                jsonToXMLConverter,
+                xmlToJSONConverter,
+                operationHeadersFactory,
+            });
+        }
+    }
+    return rootValue;
+}
+export function createExecutorFromSchemaAST(schema, fetchFn = defaultFetchFn, operationHeaders = {}) {
+    let rootValue;
+    return function soapExecutor({ document, variables, context }) {
+        if (!rootValue) {
+            rootValue = createRootValue(schema, fetchFn, operationHeaders);
+        }
+        return execute({
+            schema,
+            document,
+            rootValue,
+            contextValue: context,
+            variableValues: variables,
+            fieldResolver: defaultFieldResolver,
+        });
+    };
+}

package/esm/index.js

@@ -0,0 +1,5 @@
+import { createExecutorFromSchemaAST } from './executor.js';
+export const getSubgraphExecutor = function getSOAPSubgraphExecutor({ transportEntry, getSubgraph, fetch }) {
+    return createExecutorFromSchemaAST(getSubgraph(), fetch, transportEntry.headers);
+};
+export { createExecutorFromSchemaAST } from './executor.js';

package/esm/parseXmlOptions.js

@@ -0,0 +1,9 @@
+export const parseXmlOptions = {
+    attributeNamePrefix: '',
+    attributesGroupName: 'attributes',
+    textNodeName: 'innerText',
+    ignoreAttributes: false,
+    removeNSPrefix: true,
+    isArray: (_, __, ___, isAttribute) => !isAttribute,
+    allowBooleanAttributes: true,
+};

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@graphql-mesh/transport-soap",
+  "version": "0.0.0",
+  "sideEffects": false,
+  "peerDependencies": {
+    "@graphql-mesh/cross-helpers": "^0.4.1",
+    "@graphql-mesh/transport-common": "^0.0.0",
+    "@graphql-mesh/types": "^0.96.2",
+    "@graphql-tools/utils": "^10.0.12",
+    "@whatwg-node/fetch": "^0.9.15",
+    "graphql": "*",
+    "tslib": "^2.4.0"
+  },
+  "dependencies": {
+    "@graphql-mesh/string-interpolation": "^0.5.3",
+    "fast-xml-parser": "^4.3.2"
+  },
+  "repository": {
+    "type": "git",
+    "url": "Urigo/graphql-mesh",
+    "directory": "packages/transports/soap"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
+  "typescript": {
+    "definition": "typings/index.d.ts"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./typings/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  }
+}

package/typings/executor.d.cts

@@ -0,0 +1,4 @@
+import { GraphQLSchema } from 'graphql';
+import { MeshFetch } from '@graphql-mesh/types';
+import { Executor } from '@graphql-tools/utils';
+export declare function createExecutorFromSchemaAST(schema: GraphQLSchema, fetchFn?: MeshFetch, operationHeaders?: Record<string, string>): Executor;

package/typings/executor.d.ts

@@ -0,0 +1,4 @@
+import { GraphQLSchema } from 'graphql';
+import { MeshFetch } from '@graphql-mesh/types';
+import { Executor } from '@graphql-tools/utils';
+export declare function createExecutorFromSchemaAST(schema: GraphQLSchema, fetchFn?: MeshFetch, operationHeaders?: Record<string, string>): Executor;

package/typings/index.d.cts

@@ -0,0 +1,3 @@
+import { TransportExecutorFactoryFn } from '@graphql-mesh/transport-common';
+export declare const getSubgraphExecutor: TransportExecutorFactoryFn<'soap'>;
+export { createExecutorFromSchemaAST } from './executor.cjs';

package/typings/index.d.ts

@@ -0,0 +1,3 @@
+import { TransportExecutorFactoryFn } from '@graphql-mesh/transport-common';
+export declare const getSubgraphExecutor: TransportExecutorFactoryFn<'soap'>;
+export { createExecutorFromSchemaAST } from './executor.js';

package/typings/parseXmlOptions.d.cts

@@ -0,0 +1,2 @@
+import type { X2jOptions } from 'fast-xml-parser';
+export declare const parseXmlOptions: Partial<X2jOptions>;

package/typings/parseXmlOptions.d.ts

@@ -0,0 +1,2 @@
+import type { X2jOptions } from 'fast-xml-parser';
+export declare const parseXmlOptions: Partial<X2jOptions>;