@graphql-mesh/soap 1.0.0-alpha-3fc47d119.0 → 1.0.0-alpha-20230420181317-a95037648

package/soap-graphql/index.d.ts

@@ -1,4 +0,0 @@
-import { soapGraphqlSchema, SoapGraphqlOptions } from './soap-graphql';
-export { SoapGraphqlOptions, soapGraphqlSchema };
-export * from './node-soap';
-export * from './soap2graphql';

package/soap-graphql/node-soap/index.d.ts

@@ -1,3 +0,0 @@
-import { createSoapClient, NodeSoapOptions, NodeSoapClient } from './node-soap';
-import { NodeSoapCaller } from './node-soap-caller';
-export { NodeSoapOptions, NodeSoapClient, NodeSoapCaller, createSoapClient };

package/soap-graphql/node-soap/node-soap-caller.d.ts

@@ -1,18 +0,0 @@
-import { SoapOperation } from '../soap2graphql/soap-endpoint';
-import { SoapCaller, SoapCallInput } from '../soap2graphql/soap-caller';
-import { NodeSoapClient } from './node-soap';
-import { LazyLoggerMessage, Logger } from '@graphql-mesh/types';
-/**
- * Default implementation of SoapCaller for node-soap.
- */
-export declare class NodeSoapCaller implements SoapCaller {
-    protected soapClient: NodeSoapClient;
-    protected logger: Logger;
-    constructor(soapClient: NodeSoapClient, logger: Logger);
-    call(input: SoapCallInput): Promise<any>;
-    protected requestFunctionForOperation(operation: SoapOperation): (requestMessage: any, callback: (err: any, res: any) => void) => void;
-    protected createSoapRequestMessage(input: SoapCallInput): Promise<any>;
-    protected deepCopy(obj: any): any;
-    protected createGraphqlResult(input: SoapCallInput, result: any): Promise<any>;
-    protected debug(message: LazyLoggerMessage): void;
-}

package/soap-graphql/node-soap/node-soap-endpoint.d.ts

@@ -1,58 +0,0 @@
-import { Logger } from '@graphql-mesh/types';
-import { SoapEndpoint, SoapType, SoapField, SoapService, SoapPort, SoapOperation } from '../soap2graphql/soap-endpoint';
-import { NodeSoapClient } from './node-soap';
-import { NodeSoapWsdlResolver } from './node-soap-resolver';
-export declare function createSoapEndpoint(soapClient: NodeSoapClient, logger: Logger): SoapEndpoint;
-export declare class NodeSoapEndpoint implements SoapEndpoint {
-    private soapClient;
-    private _resolver;
-    constructor(soapClient: NodeSoapClient, logger: Logger);
-    description(): string;
-    services(): NodeSoapService[];
-    resolver(): NodeSoapWsdlResolver;
-    private _describe;
-    protected describe(): any;
-}
-export declare class NodeSoapService implements SoapService {
-    private _wsdl;
-    private _name;
-    private _content;
-    constructor(_wsdl: NodeSoapEndpoint, _name: string, _content: any);
-    endpoint(): NodeSoapEndpoint;
-    name(): string;
-    private _ports;
-    ports(): NodeSoapPort[];
-    private createPorts;
-}
-export declare class NodeSoapPort implements SoapPort {
-    private _service;
-    private _name;
-    private _content;
-    constructor(_service: NodeSoapService, _name: string, _content: any);
-    endpoint(): NodeSoapEndpoint;
-    service(): NodeSoapService;
-    name(): string;
-    private _operations;
-    operations(): NodeSoapOperation[];
-    private createOperations;
-}
-export declare class NodeSoapOperation implements SoapOperation {
-    private _port;
-    private _name;
-    private _content;
-    constructor(_port: NodeSoapPort, _name: string, _content: any);
-    endpoint(): NodeSoapEndpoint;
-    service(): NodeSoapService;
-    port(): NodeSoapPort;
-    name(): string;
-    content(): any;
-    private _inputs;
-    args(): SoapField[];
-    private _output;
-    output(): {
-        type: SoapType;
-        isList: boolean;
-    };
-    resultField(): string;
-    private createOutput;
-}

package/soap-graphql/node-soap/node-soap-resolver.d.ts

@@ -1,26 +0,0 @@
-import { SoapType, SoapOperationArg } from '../soap2graphql/soap-endpoint';
-import { NodeSoapOperation } from './node-soap-endpoint';
-import { NodeSoapWsdl } from './node-soap';
-import { Logger } from '@graphql-mesh/types';
-export declare class NodeSoapWsdlResolver {
-    private wsdl;
-    private logger;
-    private alreadyResolved;
-    constructor(wsdl: NodeSoapWsdl, logger: Logger);
-    warn(...args: any[]): void;
-    debug(...args: any[]): void;
-    createOperationArgs(operation: NodeSoapOperation): SoapOperationArg[];
-    private createOperationArg;
-    createOperationOutput(operation: NodeSoapOperation): {
-        type: {
-            type: SoapType;
-            isList: boolean;
-        };
-        resultField: string;
-    };
-    private resolveContentToSoapType;
-    private findTypeName;
-    resolveWsdlNameToSoapType(namespace: string, wsdlTypeName: string, ownerStringForLog: string): SoapType;
-    private findXsdTypeDefinition;
-    private resolveTypeBody;
-}

package/soap-graphql/node-soap/node-soap.d.ts

@@ -1,21 +0,0 @@
-import soap from 'soap';
-/**
- * Type for the soap-client from node-soap.
- */
-export declare type NodeSoapClient = any | soap.Client;
-export declare type NodeSoapWsdl = any | soap.WSDL;
-/**
- * Creation options for a node-soap client.
- */
-export declare type NodeSoapOptions = {
-    options?: soap.IOptions;
-    /**
-     * For convenience:
-     * If set, the security of the created node-soap client will be set to basic-auth with the given options.
-     */
-    basicAuth?: {
-        username: string;
-        password: string;
-    };
-};
-export declare function createSoapClient(url: string, options?: NodeSoapOptions): Promise<NodeSoapClient>;

package/soap-graphql/soap-graphql.d.ts

@@ -1,62 +0,0 @@
-import { NodeSoapClient, NodeSoapOptions } from './node-soap/node-soap';
-import { SchemaOptions } from './soap2graphql/soap2graphql';
-import { SoapCaller } from './soap2graphql/soap-caller';
-import { Logger } from '@graphql-mesh/types';
-import { GraphQLSchema, GraphQLSchemaConfig } from 'graphql';
-export declare type SoapGraphqlOptions = {
-    /**
-     * node-soap client to use.
-     * Either this field or 'createClient' must be filled.
-     */
-    soapClient?: NodeSoapClient;
-    /**
-     * Creation parameters for a node-soap client.
-     * Will only be used if 'soapClient' is empty.
-     * Either this field or 'soapClient' must be filled.
-     */
-    createClient?: {
-        url: string;
-        options?: NodeSoapOptions;
-    };
-    /**
-     * Options for the GraphQL schema.
-     */
-    schemaOptions?: SchemaOptions;
-    /**
-     * Handler for executing a soap call based on input from GraphQL.
-     * Use this, if request do need pre-processing (resp.: responses need post-processing) before execution.
-     *
-     * default: NodeSoapCaller
-     */
-    soapCaller?: SoapCaller;
-    /**
-     * If set to true, (a lot of) debug-information will be dumped to console.log
-     * Do not use this in production!
-     *
-     * default: false
-     */
-    debug?: boolean;
-    /**
-     * If set to true, warnings will be printed to console.log
-     * A warning means: The GraphQL schema can be generated, but it might not work as intended.
-     *
-     * default: false
-     */
-    warnings?: boolean;
-    logger: Logger;
-};
-/**
- * Creates a GraphQL schema for the WSDL defined by the given parameters.
- *
- * The created GraphQL schema will include:
- * - A Mutation-field for every operation in the WSDL.
- * If the field is queried via GraphQL, the SOAP endpoint declared in the WSDL will be called and the result of the call will be returned via GraphQL.
- * - A GraphQL output type for every WSDL type that is: a) used as a result of an operation and b) declared in the schema section of the WSDL.
- * - A GraphQL interface type for every WSDL type that is: a) used as a base type of another type and b) declared in the schema section of the WSDL.
- * - A GraphQL input type for every WSDL type that is: a) used as a input type of an operation and b) declared in the schema section of the WSDL.
- * - A Query-field that returns the content of the WSDL (this is necessary, since a GraphQL schema must include at least one Query-field)
- *
- * @param options either an instance of SoapGraphQLOptions or the URL (http/https or path to a file) to a WSDL.
- */
-export declare function soapGraphqlSchema(options: SoapGraphqlOptions): Promise<GraphQLSchema>;
-export declare function soapGraphqlSchemaConfig(options: SoapGraphqlOptions): Promise<GraphQLSchemaConfig>;

package/soap-graphql/soap2graphql/custom-type-resolver.d.ts

@@ -1,64 +0,0 @@
-import { GraphQLScalarType, GraphQLOutputType, GraphQLInputType, GraphQLList } from 'graphql';
-/**
- * Resolver that converts WSDL types, that are not fully defined in the WSDL itself, to GraphQL types.
- * This is especially necessary for all primitive WSDL types (resp. scalar GraphQL types) like 'string', 'datetime', etc.
- *
- * You can provide your own resolver to handle custom types of your WSDL.
- * But you must still provide resolvment for primitive types like 'string', e.g by re-using DefaultTypeResolver.
- */
-export interface CustomTypeResolver {
-    outputType(typeName: string): GraphQLOutputType;
-    inputType(typeName: string): GraphQLInputType;
-}
-/**
- * Default implementation of CustomTypeResolver.
- * Based on https://www.w3.org/TR/xmlschema-2/#built-in-datatypes
- */
-export declare class DefaultTypeResolver implements CustomTypeResolver {
-    string: GraphQLScalarType<string, string>;
-    base64Binary: GraphQLScalarType<unknown, unknown>;
-    hexBinary: GraphQLScalarType<unknown, unknown>;
-    duration: GraphQLScalarType<unknown, unknown>;
-    gYearMonth: GraphQLScalarType<string, string>;
-    gYear: GraphQLScalarType<string, string>;
-    gMonthDay: GraphQLScalarType<string, string>;
-    gDay: GraphQLScalarType<string, string>;
-    gMonth: GraphQLScalarType<string, string>;
-    anyURI: GraphQLScalarType<unknown, unknown>;
-    QName: GraphQLScalarType<string, string>;
-    normalizedString: GraphQLScalarType<string, string>;
-    token: GraphQLScalarType<string, string>;
-    NMTOKEN: GraphQLScalarType<string, string>;
-    NMTOKENS: GraphQLScalarType<string, string>;
-    language: GraphQLScalarType<string, string>;
-    Name: GraphQLScalarType<string, string>;
-    NCName: GraphQLScalarType<string, string>;
-    IDREF: GraphQLScalarType<string, string>;
-    IDREFS: GraphQLList<GraphQLScalarType<string, string>>;
-    ENTITY: GraphQLScalarType<string, string>;
-    ENTITIES: GraphQLList<GraphQLScalarType<string, string>>;
-    ID: GraphQLScalarType<string, string>;
-    boolean: GraphQLScalarType<boolean, boolean>;
-    byte: GraphQLScalarType<unknown, unknown>;
-    unsignedByte: GraphQLScalarType<unknown, unknown>;
-    short: GraphQLScalarType<number, number>;
-    unsignedShort: GraphQLScalarType<unknown, unknown>;
-    int: GraphQLScalarType<number, number>;
-    unsignedInt: GraphQLScalarType<unknown, unknown>;
-    integer: GraphQLScalarType<number, number>;
-    positiveInteger: GraphQLScalarType<unknown, unknown>;
-    nonPositiveInteger: GraphQLScalarType<unknown, unknown>;
-    negativeInteger: GraphQLScalarType<unknown, unknown>;
-    nonNegativeInteger: GraphQLScalarType<unknown, unknown>;
-    long: GraphQLScalarType<unknown, unknown>;
-    unsignedLong: GraphQLScalarType<unknown, unknown>;
-    decimal: GraphQLScalarType<number, number>;
-    float: GraphQLScalarType<number, number>;
-    double: GraphQLScalarType<number, number>;
-    dateTime: GraphQLScalarType<unknown, unknown>;
-    date: GraphQLScalarType<unknown, unknown>;
-    time: GraphQLScalarType<unknown, unknown>;
-    resolve(typeName: string): GraphQLScalarType;
-    outputType(typeName: string): GraphQLOutputType;
-    inputType(typeName: string): GraphQLInputType;
-}

package/soap-graphql/soap2graphql/index.d.ts

@@ -1,6 +0,0 @@
-import { SoapCaller, SoapCallInput } from './soap-caller';
-import { NameResolver } from './name-resolver';
-import { CustomTypeResolver, DefaultTypeResolver } from './custom-type-resolver';
-import { SchemaOptions } from './soap2graphql';
-export { SchemaOptions, CustomTypeResolver, DefaultTypeResolver, NameResolver, SoapCaller, SoapCallInput };
-export * from './soap-endpoint';

package/soap-graphql/soap2graphql/name-resolver.d.ts

@@ -1,5 +0,0 @@
-import { SoapObjectType } from './soap-endpoint';
-export declare type NameResolver = (soapType: SoapObjectType) => string;
-export declare const defaultOutputNameResolver: NameResolver;
-export declare const defaultInputNameResolver: NameResolver;
-export declare const defaultInterfaceNameResolver: NameResolver;

package/soap-graphql/soap2graphql/schema-resolver.d.ts

@@ -1,30 +0,0 @@
-import { SchemaOptions } from './soap2graphql';
-import { SoapEndpoint, SoapService, SoapPort, SoapOperation } from './soap-endpoint';
-import { SoapCaller } from './soap-caller';
-import { GraphQLObjectType, GraphQLFieldConfigMap, GraphQLFieldConfig, GraphQLFieldConfigArgumentMap, GraphQLOutputType, GraphQLFieldResolver, GraphQLSchemaConfig } from 'graphql';
-import { Logger } from '@graphql-mesh/types';
-declare type RootType = 'query' | 'mutation';
-export declare class SchemaResolver {
-    private soapEndpoint;
-    private soapCaller;
-    private logger;
-    private readonly options;
-    private outputResolver;
-    private inputResolver;
-    constructor(soapEndpoint: SoapEndpoint, soapCaller: SoapCaller, options: SchemaOptions, logger: Logger);
-    defaultOptions(options: SchemaOptions): SchemaOptions;
-    resolve(): GraphQLSchemaConfig;
-    getFields(rootType: RootType): GraphQLFieldConfigMap<any, any>;
-    createQueryObject(): GraphQLObjectType;
-    createMutationObject(): GraphQLObjectType;
-    createSoapServiceField(service: SoapService, rootType: RootType): GraphQLFieldConfig<any, any>;
-    createSoapPortField(service: SoapService, port: SoapPort, rootType: RootType): GraphQLFieldConfig<any, any>;
-    getFieldConfig(operation: SoapOperation): GraphQLFieldConfig<any, any>;
-    createSoapOperationField(operation: SoapOperation, rootType: RootType): GraphQLFieldConfig<any, any>;
-    createSoapOperationFieldArgs(operation: SoapOperation): GraphQLFieldConfigArgumentMap;
-    resolveSoapOperationReturnType(operation: SoapOperation): GraphQLOutputType;
-    createSoapOperationFieldResolver<TSource, TContext>(operation: SoapOperation): GraphQLFieldResolver<TSource, {
-        [argName: string]: any;
-    }, TContext>;
-}
-export {};

package/soap-graphql/soap2graphql/soap-caller.d.ts

@@ -1,17 +0,0 @@
-import { SoapOperation } from './soap-endpoint';
-import { GraphQLResolveInfo } from 'graphql';
-export declare type SoapCallInput = {
-    operation: SoapOperation;
-    graphqlSource: any;
-    graphqlArgs: {
-        [argName: string]: any;
-    };
-    graphqlContext: any;
-    graphqlInfo: GraphQLResolveInfo;
-};
-export interface SoapCaller {
-    /**
-     * Executes a SOAP call.
-     */
-    call(input: SoapCallInput): Promise<any>;
-}

package/soap-graphql/soap2graphql/soap-endpoint.d.ts

@@ -1,66 +0,0 @@
-/**
- * SOAP endpoint defined by a WSDL.
- */
-export interface SoapEndpoint {
-    services(): SoapService[];
-    /**
-     * Returns a textual, human readable description of the soap endpoint.
-     * Note: ATM this is only used to have at least one query field in the GraphQLSchema.
-     */
-    description(): string;
-}
-export interface SoapService {
-    endpoint(): SoapEndpoint;
-    name(): string;
-    ports(): SoapPort[];
-}
-export interface SoapPort {
-    endpoint(): SoapEndpoint;
-    service(): SoapService;
-    name(): string;
-    operations(): SoapOperation[];
-}
-export interface SoapOperation {
-    endpoint(): SoapEndpoint;
-    service(): SoapService;
-    port(): SoapPort;
-    name(): string;
-    /**
-     * Arguments that this operation accepts.
-     */
-    args(): SoapOperationArg[];
-    /**
-     * Output that this operation provides if called.
-     */
-    output(): {
-        type: SoapType;
-        isList: boolean;
-    };
-    /**
-     * The field in the SOAP output message that contains the actual output.
-     */
-    resultField(): string;
-}
-/**
- * A type declared in the WSDL.
- */
-export declare type SoapType = SoapObjectType | SoapPrimitiveType;
-/**
- * A primitive type in the WSDL - only defined by its name.
- */
-export declare type SoapPrimitiveType = string;
-/**
- * An object type in the WSDL.
- * Defined by its name, fields and maybe a base type.
- */
-export interface SoapObjectType {
-    name: string;
-    base: SoapObjectType;
-    fields: SoapField[];
-}
-export interface SoapField {
-    name: string;
-    type: SoapType;
-    isList: boolean;
-}
-export declare type SoapOperationArg = SoapField;

package/soap-graphql/soap2graphql/soap2graphql.d.ts

@@ -1,83 +0,0 @@
-import { CustomTypeResolver } from './custom-type-resolver';
-import { NameResolver } from './name-resolver';
-import { SoapEndpoint } from './soap-endpoint';
-import { SoapCaller } from './soap-caller';
-import { Logger } from '@graphql-mesh/types';
-import { GraphQLSchemaConfig } from 'graphql';
-/**
- * Options for the GraphQL schema.
- */
-export declare type SchemaOptions = {
-    /**
-     * If true, the services defined in the WSDL will be represented as GraphQL-Type objects in the schema.
-     * The fields of the object will be the ports of the service (or the operation, dependent on 'includePorts').
-     *
-     * Most soap-endpoints only define one service; so including it in the schema will just be inconvenient.
-     * But if there are multiple services with operations of the same name, you should set this option to true.
-     * Otherwise only one of the identical-named operations will be callable.
-     *
-     * default: false
-     */
-    includeServices?: boolean;
-    /**
-     * If true, the ports defined in the WSDL will be represented as GraphQL-Type objects in the schema.
-     * The fields of the object will be the operations of the port.
-     *
-     * Most soap-endpoints only define one port; so including it in the schema will just be inconvenient.
-     * But if there are multiple ports with operations of the same name, you should set this option to true.
-     * Otherwise only one of the identical-named operations will be callable.
-     *
-     * default: false
-     */
-    includePorts?: boolean;
-    /**
-     * Resolver that will be used to convert WSDL types, that are not fully defined in the WSDL itself, to GraphQL types.
-     * This is especially necessary for all primitive WSDL types (resp. scalar GraphQL types) like 'string', 'datetime', etc.
-     *
-     * You can provide your own resolver to handle custom types of your WSDL.
-     * But you must still provide resolvment for primitive types like 'string', e.g by re-using DefaultTypeResolver.
-     *
-     * default: DefaultTypeResolver
-     */
-    customResolver?: CustomTypeResolver;
-    /**
-     * Function that proivides the name of a GraphQLOutputType.
-     * The created name must be unique in the GraphQL schema!
-     * (This is especially important, since SOAP allows to use the same type for input and output, but GraphQL does not)
-     *
-     * default: use the name of the WSDL type.
-     */
-    outputNameResolver?: NameResolver;
-    /**
-     * Function that proivides the name of a GraphQLInterfaceType.
-     * The created name must be unique in the GraphQL schema!
-     * (This is especially important, since SOAP allows to use the same type for input and output, but GraphQL does not)
-     *
-     * default: 'i' + WSDL type name.
-     */
-    interfaceNameResolver?: NameResolver;
-    /**
-     * Function that proivides the name of a GraphQLInputType.
-     * The created name must be unique in the GraphQL schema!
-     * (This is especially important, since SOAP allows to use the same type for input and output, but GraphQL does not)
-     *
-     * default: WSDL type name + 'Input'.
-     */
-    inputNameResolver?: NameResolver;
-    /**
-     * Automatically put operations starts with `query` or `get` into the Query type
-     * default: false
-     */
-    selectQueryOperationsAuto?: boolean;
-    /**
-     * Allows to explicitly override the default operation(Query or Mutation) for any SOAP operation
-     */
-    selectQueryOrMutationField?: SoapSelectQueryOrMutationFieldConfig[];
-};
-export interface SoapSelectQueryOrMutationFieldConfig {
-    service: string;
-    port: string;
-    operation: string;
-    type: 'query' | 'mutation';
-}
-export declare function createSchemaConfig(endpoint: SoapEndpoint, soapCaller: SoapCaller, options: SchemaOptions, logger: Logger): GraphQLSchemaConfig;