@graphql-mesh/transport-rest 0.0.0

package/esm/directives/process.js

@@ -0,0 +1,177 @@
+import { isEnumType, isInterfaceType, isScalarType, isUnionType, } from 'graphql';
+import { ObjMapScalar } from '@graphql-mesh/transport-common';
+import { getDirective, getDirectives } from '@graphql-tools/utils';
+import { processDictionaryDirective } from './dictionary';
+import { processDiscriminatorAnnotations } from './discriminator';
+import { processFlattenAnnotations } from './flatten';
+import { getTypeResolverForAbstractType } from './getTypeResolverForAbstractType';
+import { addHTTPRootFieldResolver } from './httpOperation';
+import { processLinkFieldAnnotations } from './link';
+import { processPubSubOperationAnnotations } from './pubsubOperation';
+import { processResolveRootAnnotations } from './resolveRoot';
+import { processResolveRootFieldAnnotations } from './resolveRootField';
+import { processResponseMetadataAnnotations } from './responseMetadata';
+import { addExecutionLogicToScalar, processScalarType } from './scalars';
+import { processTypeScriptAnnotations } from './typescriptAnnotations';
+export function processDirectives(schema, { globalFetch, logger, pubsub, ...extraGlobalOptions } = {}) {
+    const nonExecutableObjMapScalar = schema.getType('ObjMap');
+    if (nonExecutableObjMapScalar && isScalarType(nonExecutableObjMapScalar)) {
+        addExecutionLogicToScalar(nonExecutableObjMapScalar, ObjMapScalar);
+    }
+    const transportDirectives = getDirective(schema, schema, 'transport');
+    const currDirective = transportDirectives?.[0];
+    const globalOptions = {
+        endpoint: currDirective?.location,
+        operationHeaders: currDirective?.headers,
+        queryParams: currDirective?.queryParams,
+        queryStringOptions: currDirective?.queryStringOptions,
+        ...extraGlobalOptions,
+    };
+    if (typeof globalOptions.operationHeaders === 'string') {
+        globalOptions.operationHeaders = JSON.parse(globalOptions.operationHeaders);
+    }
+    if (typeof globalOptions.queryParams === 'string') {
+        globalOptions.queryParams = JSON.parse(globalOptions.queryParams);
+    }
+    const typeMap = schema.getTypeMap();
+    for (const typeName in typeMap) {
+        const type = typeMap[typeName];
+        const exampleAnnotations = getDirective(schema, type, 'example');
+        if (exampleAnnotations?.length) {
+            const examples = [];
+            for (const exampleAnnotation of exampleAnnotations) {
+                if (exampleAnnotation?.value) {
+                    examples.push(exampleAnnotation.value);
+                }
+            }
+            type.extensions = type.extensions || {};
+            type.extensions.examples = examples;
+        }
+        if (isScalarType(type)) {
+            processScalarType(schema, type);
+        }
+        if (isInterfaceType(type)) {
+            const directiveAnnotations = getDirectives(schema, type);
+            for (const directiveAnnotation of directiveAnnotations) {
+                switch (directiveAnnotation.name) {
+                    case 'discriminator':
+                        processDiscriminatorAnnotations({
+                            interfaceType: type,
+                            discriminatorFieldName: directiveAnnotation.args.field,
+                        });
+                        break;
+                }
+            }
+        }
+        if (isUnionType(type)) {
+            const directiveAnnotations = getDirectives(schema, type);
+            let statusCodeTypeNameIndexMap;
+            let discriminatorField;
+            let discriminatorMapping;
+            for (const directiveAnnotation of directiveAnnotations) {
+                switch (directiveAnnotation.name) {
+                    case 'statusCodeTypeName':
+                        statusCodeTypeNameIndexMap = statusCodeTypeNameIndexMap || {};
+                        statusCodeTypeNameIndexMap[directiveAnnotation.args.statusCode] =
+                            directiveAnnotation.args.typeName;
+                        break;
+                    case 'discriminator':
+                        discriminatorField = directiveAnnotation.args.field;
+                        discriminatorMapping = directiveAnnotation.args.mapping;
+                        break;
+                }
+            }
+            type.resolveType = getTypeResolverForAbstractType({
+                possibleTypes: type.getTypes(),
+                discriminatorField,
+                discriminatorMapping,
+                statusCodeTypeNameMap: statusCodeTypeNameIndexMap,
+            });
+        }
+        if (isEnumType(type)) {
+            const directiveAnnotations = getDirectives(schema, type);
+            for (const directiveAnnotation of directiveAnnotations) {
+                switch (directiveAnnotation.name) {
+                    case 'typescript':
+                        processTypeScriptAnnotations(type, directiveAnnotation.args.type);
+                        break;
+                }
+            }
+            const enumValues = type.getValues();
+            for (const enumValue of enumValues) {
+                const directiveAnnotations = getDirectives(schema, enumValue);
+                for (const directiveAnnotation of directiveAnnotations) {
+                    switch (directiveAnnotation.name) {
+                        case 'enum': {
+                            const realValue = JSON.parse(directiveAnnotation.args.value);
+                            enumValue.value = realValue;
+                            type._valueLookup.set(realValue, enumValue);
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        if ('getFields' in type) {
+            const fields = type.getFields();
+            for (const fieldName in fields) {
+                const field = fields[fieldName];
+                const directiveAnnotations = getDirectives(schema, field);
+                for (const directiveAnnotation of directiveAnnotations) {
+                    switch (directiveAnnotation.name) {
+                        case 'resolveRoot':
+                            processResolveRootAnnotations(field);
+                            break;
+                        case 'resolveRootField':
+                            processResolveRootFieldAnnotations(field, directiveAnnotation.args.field);
+                            break;
+                        case 'flatten':
+                            processFlattenAnnotations(field);
+                            break;
+                        case 'pubsubOperation':
+                            processPubSubOperationAnnotations({
+                                field: field,
+                                pubsubTopic: directiveAnnotation.args.pubsubTopic,
+                                globalPubsub: pubsub,
+                                logger,
+                            });
+                            break;
+                        case 'httpOperation':
+                            addHTTPRootFieldResolver(schema, field, logger, globalFetch, 
+                            // TODO: Fix JSON parsing here for queryParams and headers
+                            {
+                                sourceName: directiveAnnotation.args.sourceName,
+                                endpoint: directiveAnnotation.args.endpoint,
+                                path: directiveAnnotation.args.path,
+                                httpMethod: directiveAnnotation.args.httpMethod,
+                                operationSpecificHeaders: typeof directiveAnnotation.args.operationSpecificHeaders === 'string'
+                                    ? JSON.parse(directiveAnnotation.args.operationSpecificHeaders)
+                                    : directiveAnnotation.args.operationSpecificHeaders,
+                                isBinary: directiveAnnotation.args.isBinary,
+                                requestBaseBody: typeof directiveAnnotation.args.requestBaseBody === 'string'
+                                    ? JSON.parse(directiveAnnotation.args.requestBaseBody)
+                                    : directiveAnnotation.args.requestBaseBody,
+                                queryParamArgMap: typeof directiveAnnotation.args.queryParamArgMap === 'string'
+                                    ? JSON.parse(directiveAnnotation.args.queryParamArgMap)
+                                    : directiveAnnotation.args.queryParamArgMap,
+                                queryStringOptionsByParam: typeof directiveAnnotation.args.queryStringOptionsByParam === 'string'
+                                    ? JSON.parse(directiveAnnotation.args.queryStringOptionsByParam)
+                                    : directiveAnnotation.args.queryStringOptionsByParam,
+                                jsonApiFields: directiveAnnotation.args.jsonApiFields,
+                            }, globalOptions);
+                            break;
+                        case 'responseMetadata':
+                            processResponseMetadataAnnotations(field);
+                            break;
+                        case 'link':
+                            processLinkFieldAnnotations(field, directiveAnnotation.args.defaultRootType, directiveAnnotation.args.defaultField);
+                            break;
+                        case 'dictionary':
+                            processDictionaryDirective(fields, field);
+                    }
+                }
+            }
+        }
+    }
+    return schema;
+}

package/esm/directives/pubsubOperation.js

@@ -0,0 +1,27 @@
+import { stringInterpolator } from '@graphql-mesh/string-interpolation';
+import { createGraphQLError } from '@graphql-tools/utils';
+export function processPubSubOperationAnnotations({ field, globalPubsub, pubsubTopic, logger: globalLogger, }) {
+    field.subscribe = function pubSubSubscribeFn(root, args, context, info) {
+        const logger = context?.logger || globalLogger;
+        const operationLogger = logger.child(`${info.parentType.name}.${field.name}`);
+        const pubsub = context?.pubsub || globalPubsub;
+        if (!pubsub) {
+            return createGraphQLError(`You should have PubSub defined in either the config or the context!`);
+        }
+        const interpolationData = { root, args, context, info, env: process.env };
+        let interpolatedPubSubTopic = stringInterpolator.parse(pubsubTopic, interpolationData);
+        if (interpolatedPubSubTopic.startsWith('webhook:')) {
+            const [, expectedMethod, expectedUrl] = interpolatedPubSubTopic.split(':');
+            const expectedPath = new URL(expectedUrl, 'http://localhost').pathname;
+            interpolatedPubSubTopic = `webhook:${expectedMethod}:${expectedPath}`;
+        }
+        operationLogger.debug(`${info.parentType.name}.${field.name} => Subscribing to pubSubTopic: ${interpolatedPubSubTopic}`);
+        return pubsub.asyncIterator(interpolatedPubSubTopic);
+    };
+    field.resolve = function pubSubResolver(root, args, context, info) {
+        const logger = context?.logger || globalLogger;
+        const operationLogger = logger.child(`${info.parentType.name}.${field.name}`);
+        operationLogger.debug('Received ', root, ' from ', pubsubTopic);
+        return root;
+    };
+}

package/esm/directives/regexp.js

@@ -0,0 +1,20 @@
+export function processRegExpAnnotations(scalar, pattern) {
+    function coerceString(value) {
+        if (value != null) {
+            const vStr = value.toString();
+            const regexp = new RegExp(pattern);
+            if (!regexp.test(vStr)) {
+                throw new Error(`${scalar.name} must match ${pattern} but given ${vStr}`);
+            }
+            return vStr;
+        }
+    }
+    scalar.serialize = coerceString;
+    scalar.parseValue = coerceString;
+    scalar.parseLiteral = ast => {
+        if ('value' in ast) {
+            return coerceString(ast.value);
+        }
+        return null;
+    };
+}

package/esm/directives/resolveDataByUnionInputType.js

@@ -0,0 +1,35 @@
+import { isInputObjectType, isListType, isNonNullType, } from 'graphql';
+import { sanitizeNameForGraphQL } from '@graphql-mesh/utils';
+import { asArray, getDirective } from '@graphql-tools/utils';
+export function resolveDataByUnionInputType(data, type, schema) {
+    if (data) {
+        if (isListType(type)) {
+            return asArray(data).map(elem => resolveDataByUnionInputType(elem, type.ofType, schema));
+        }
+        if (isNonNullType(type)) {
+            return resolveDataByUnionInputType(data, type.ofType, schema);
+        }
+        if (isInputObjectType(type)) {
+            const typeOneOfDirectives = getDirective(schema, type, 'oneOf');
+            const isOneOf = typeOneOfDirectives?.length;
+            const fieldMap = type.getFields();
+            data = asArray(data)[0];
+            for (const propertyName in data) {
+                const fieldName = sanitizeNameForGraphQL(propertyName);
+                const field = fieldMap[fieldName];
+                if (field) {
+                    if (isOneOf) {
+                        const resolvedData = resolveDataByUnionInputType(data[fieldName], field.type, schema);
+                        return resolvedData;
+                    }
+                    const fieldData = data[fieldName];
+                    data[fieldName] = undefined;
+                    const fieldResolveRootFieldDirectives = getDirective(schema, field, 'resolveRootField');
+                    const realFieldName = fieldResolveRootFieldDirectives?.[0]?.field || fieldName;
+                    data[realFieldName] = resolveDataByUnionInputType(fieldData, field.type, schema);
+                }
+            }
+        }
+    }
+    return data;
+}

package/esm/directives/resolveRoot.js

@@ -0,0 +1,6 @@
+function rootResolver(root) {
+    return root;
+}
+export function processResolveRootAnnotations(field) {
+    field.resolve = rootResolver;
+}

package/esm/directives/resolveRootField.js

@@ -0,0 +1,25 @@
+import { isListType, isNonNullType } from 'graphql';
+function isOriginallyListType(type) {
+    if (isNonNullType(type)) {
+        return isOriginallyListType(type.ofType);
+    }
+    return isListType(type);
+}
+export function processResolveRootFieldAnnotations(field, propertyName) {
+    if (!field.resolve || field.resolve.name === 'defaultFieldResolver') {
+        field.resolve = (root, args, context, info) => {
+            const actualFieldObj = root[propertyName];
+            if (actualFieldObj != null) {
+                const isArray = Array.isArray(actualFieldObj);
+                const isListType = isOriginallyListType(info.returnType);
+                if (isListType && !isArray) {
+                    return [actualFieldObj];
+                }
+                else if (!isListType && isArray) {
+                    return actualFieldObj[0];
+                }
+            }
+            return actualFieldObj;
+        };
+    }
+}

package/esm/directives/responseMetadata.js

@@ -0,0 +1,12 @@
+export function processResponseMetadataAnnotations(field) {
+    field.resolve = function responseMetadataResolver(root) {
+        return {
+            url: root.$url,
+            headers: root.$response.header,
+            method: root.$method,
+            status: root.$statusCode,
+            statusText: root.$statusText,
+            body: root.$response.body,
+        };
+    };
+}

package/esm/directives/scalars.js

@@ -0,0 +1,48 @@
+import { resolvers as scalarResolvers } from 'graphql-scalars';
+import { ObjMapScalar } from '@graphql-mesh/transport-common';
+import { getDirectives } from '@graphql-tools/utils';
+import { processLengthAnnotations } from './length.js';
+import { processRegExpAnnotations } from './regexp.js';
+import { processTypeScriptAnnotations } from './typescriptAnnotations.js';
+export function processScalarType(schema, type) {
+    if (type.name in scalarResolvers) {
+        const actualScalar = scalarResolvers[type.name];
+        addExecutionLogicToScalar(type, actualScalar);
+    }
+    if (type.name === 'ObjMap') {
+        addExecutionLogicToScalar(type, ObjMapScalar);
+    }
+    const directiveAnnotations = getDirectives(schema, type);
+    for (const directiveAnnotation of directiveAnnotations) {
+        switch (directiveAnnotation.name) {
+            case 'length':
+                processLengthAnnotations(type, directiveAnnotation.args);
+                break;
+            case 'regexp':
+                processRegExpAnnotations(type, directiveAnnotation.args.pattern);
+                break;
+            case 'typescript':
+                processTypeScriptAnnotations(type, directiveAnnotation.args.type);
+                break;
+        }
+    }
+}
+export function addExecutionLogicToScalar(nonExecutableScalar, actualScalar) {
+    Object.defineProperties(nonExecutableScalar, {
+        serialize: {
+            value: actualScalar.serialize,
+        },
+        parseValue: {
+            value: actualScalar.parseValue,
+        },
+        parseLiteral: {
+            value: actualScalar.parseLiteral,
+        },
+        extensions: {
+            value: {
+                ...actualScalar.extensions,
+                ...nonExecutableScalar.extensions,
+            },
+        },
+    });
+}

package/esm/directives/typescriptAnnotations.js

@@ -0,0 +1,4 @@
+export function processTypeScriptAnnotations(type, typeDefinition) {
+    type.extensions = type.extensions || {};
+    type.extensions.codegenScalarType = typeDefinition;
+}

package/esm/index.js

@@ -0,0 +1,15 @@
+import { createDefaultExecutor } from '@graphql-mesh/transport-common';
+import { processDirectives } from './directives/process';
+export const getSubgraphExecutor = function getRESTSubgraphExecutor({ transportEntry, getSubgraph, fetch, pubsub, logger }) {
+    const preProcessedSchema = getSubgraph();
+    const processDirectiveOpts = {
+        globalFetch: fetch,
+        pubsub,
+        logger,
+        ...transportEntry.options,
+    };
+    const processedSchema = processDirectives(preProcessedSchema, processDirectiveOpts);
+    const executor = createDefaultExecutor(processedSchema);
+    return executor;
+};
+export { processDirectives } from './directives/process';

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@graphql-mesh/transport-rest",
+  "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-mesh/utils": "^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",
+    "dset": "^3.1.3",
+    "graphql-fields": "^2.0.3",
+    "graphql-scalars": "^1.22.4",
+    "qs": "6.11.2",
+    "url-join": "4.0.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "Urigo/graphql-mesh",
+    "directory": "packages/transports/rest"
+  },
+  "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/directives/dictionary.d.cts

@@ -0,0 +1,2 @@
+import { GraphQLField } from 'graphql';
+export declare function processDictionaryDirective(fieldMap: Record<string, GraphQLField<any, any>>, field: GraphQLField<any, any>): void;

package/typings/directives/dictionary.d.ts

@@ -0,0 +1,2 @@
+import { GraphQLField } from 'graphql';
+export declare function processDictionaryDirective(fieldMap: Record<string, GraphQLField<any, any>>, field: GraphQLField<any, any>): void;

package/typings/directives/discriminator.d.cts

@@ -0,0 +1,5 @@
+import { GraphQLInterfaceType } from 'graphql';
+export declare function processDiscriminatorAnnotations({ interfaceType, discriminatorFieldName, }: {
+    interfaceType: GraphQLInterfaceType;
+    discriminatorFieldName: string;
+}): void;

package/typings/directives/discriminator.d.ts

@@ -0,0 +1,5 @@
+import { GraphQLInterfaceType } from 'graphql';
+export declare function processDiscriminatorAnnotations({ interfaceType, discriminatorFieldName, }: {
+    interfaceType: GraphQLInterfaceType;
+    discriminatorFieldName: string;
+}): void;

package/typings/directives/flatten.d.cts

@@ -0,0 +1,2 @@
+import { GraphQLField } from 'graphql';
+export declare function processFlattenAnnotations(field: GraphQLField<any, any>): void;

package/typings/directives/flatten.d.ts

@@ -0,0 +1,2 @@
+import { GraphQLField } from 'graphql';
+export declare function processFlattenAnnotations(field: GraphQLField<any, any>): void;

package/typings/directives/getTypeResolverForAbstractType.d.cts

@@ -0,0 +1,7 @@
+import { GraphQLObjectType, GraphQLTypeResolver } from 'graphql';
+export declare function getTypeResolverForAbstractType({ possibleTypes, discriminatorField, discriminatorMapping, statusCodeTypeNameMap, }: {
+    possibleTypes: readonly GraphQLObjectType[];
+    discriminatorField?: string;
+    discriminatorMapping?: Record<string, string>;
+    statusCodeTypeNameMap?: Record<string, string>;
+}): GraphQLTypeResolver<any, any>;

package/typings/directives/getTypeResolverForAbstractType.d.ts

@@ -0,0 +1,7 @@
+import { GraphQLObjectType, GraphQLTypeResolver } from 'graphql';
+export declare function getTypeResolverForAbstractType({ possibleTypes, discriminatorField, discriminatorMapping, statusCodeTypeNameMap, }: {
+    possibleTypes: readonly GraphQLObjectType[];
+    discriminatorField?: string;
+    discriminatorMapping?: Record<string, string>;
+    statusCodeTypeNameMap?: Record<string, string>;
+}): GraphQLTypeResolver<any, any>;

package/typings/directives/httpOperation.d.cts

@@ -0,0 +1,28 @@
+import { GraphQLField, GraphQLSchema } from 'graphql';
+import { IStringifyOptions } from 'qs';
+import { Logger, MeshFetch } from '@graphql-mesh/types';
+type HTTPMethod = 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE' | 'PATCH';
+export interface HTTPRootFieldResolverOpts {
+    sourceName: string;
+    endpoint: string;
+    path: string;
+    httpMethod: HTTPMethod;
+    operationSpecificHeaders: Record<string, string>;
+    isBinary: boolean;
+    requestBaseBody: any;
+    queryParamArgMap: Record<string, string>;
+    queryStringOptionsByParam: Record<string, IStringifyOptions & {
+        destructObject?: boolean;
+    }>;
+    jsonApiFields: boolean;
+}
+export interface GlobalOptions {
+    sourceName: string;
+    endpoint: string;
+    timeout: number;
+    operationHeaders: Record<string, string>;
+    queryStringOptions: IStringifyOptions;
+    queryParams: Record<string, string | number | boolean>;
+}
+export declare function addHTTPRootFieldResolver(schema: GraphQLSchema, field: GraphQLField<any, any>, globalLogger: Logger, globalFetch: MeshFetch, { path, operationSpecificHeaders, httpMethod, isBinary, requestBaseBody, queryParamArgMap, queryStringOptionsByParam, jsonApiFields, }: HTTPRootFieldResolverOpts, { sourceName, endpoint, timeout, operationHeaders: globalOperationHeaders, queryStringOptions: globalQueryStringOptions, queryParams: globalQueryParams, }: GlobalOptions): void;
+export {};

package/typings/directives/httpOperation.d.ts

@@ -0,0 +1,28 @@
+import { GraphQLField, GraphQLSchema } from 'graphql';
+import { IStringifyOptions } from 'qs';
+import { Logger, MeshFetch } from '@graphql-mesh/types';
+type HTTPMethod = 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE' | 'PATCH';
+export interface HTTPRootFieldResolverOpts {
+    sourceName: string;
+    endpoint: string;
+    path: string;
+    httpMethod: HTTPMethod;
+    operationSpecificHeaders: Record<string, string>;
+    isBinary: boolean;
+    requestBaseBody: any;
+    queryParamArgMap: Record<string, string>;
+    queryStringOptionsByParam: Record<string, IStringifyOptions & {
+        destructObject?: boolean;
+    }>;
+    jsonApiFields: boolean;
+}
+export interface GlobalOptions {
+    sourceName: string;
+    endpoint: string;
+    timeout: number;
+    operationHeaders: Record<string, string>;
+    queryStringOptions: IStringifyOptions;
+    queryParams: Record<string, string | number | boolean>;
+}
+export declare function addHTTPRootFieldResolver(schema: GraphQLSchema, field: GraphQLField<any, any>, globalLogger: Logger, globalFetch: MeshFetch, { path, operationSpecificHeaders, httpMethod, isBinary, requestBaseBody, queryParamArgMap, queryStringOptionsByParam, jsonApiFields, }: HTTPRootFieldResolverOpts, { sourceName, endpoint, timeout, operationHeaders: globalOperationHeaders, queryStringOptions: globalQueryStringOptions, queryParams: globalQueryParams, }: GlobalOptions): void;
+export {};

package/typings/directives/isFileUpload.d.cts

@@ -0,0 +1,4 @@
+export declare function isFileUpload(obj: any): obj is {
+    createReadStream: () => AsyncIterable<Uint8Array>;
+    mimetype: string;
+};

package/typings/directives/isFileUpload.d.ts

@@ -0,0 +1,4 @@
+export declare function isFileUpload(obj: any): obj is {
+    createReadStream: () => AsyncIterable<Uint8Array>;
+    mimetype: string;
+};

package/typings/directives/jsonApiFields.d.cts

@@ -0,0 +1,2 @@
+import { GraphQLResolveInfo } from 'graphql';
+export declare function getJsonApiFieldsQuery(info: GraphQLResolveInfo): string;

package/typings/directives/jsonApiFields.d.ts

@@ -0,0 +1,2 @@
+import { GraphQLResolveInfo } from 'graphql';
+export declare function getJsonApiFieldsQuery(info: GraphQLResolveInfo): string;

package/typings/directives/length.d.cts

@@ -0,0 +1,5 @@
+import { GraphQLScalarType } from 'graphql';
+export declare function processLengthAnnotations(scalar: GraphQLScalarType, { min: minLength, max: maxLength, }: {
+    min?: number;
+    max?: number;
+}): void;

package/typings/directives/length.d.ts

@@ -0,0 +1,5 @@
+import { GraphQLScalarType } from 'graphql';
+export declare function processLengthAnnotations(scalar: GraphQLScalarType, { min: minLength, max: maxLength, }: {
+    min?: number;
+    max?: number;
+}): void;

package/typings/directives/link.d.cts

@@ -0,0 +1,2 @@
+import { GraphQLField } from 'graphql';
+export declare function processLinkFieldAnnotations(field: GraphQLField<any, any>, defaultRootTypeName: string, defaultFieldName: string): void;

package/typings/directives/link.d.ts

@@ -0,0 +1,2 @@
+import { GraphQLField } from 'graphql';
+export declare function processLinkFieldAnnotations(field: GraphQLField<any, any>, defaultRootTypeName: string, defaultFieldName: string): void;

package/typings/directives/process.d.cts

@@ -0,0 +1,12 @@
+import { GraphQLSchema } from 'graphql';
+import { Logger, MeshFetch, MeshPubSub } from '@graphql-mesh/types';
+export interface ProcessDirectiveArgs {
+    pubsub?: MeshPubSub;
+    logger?: Logger;
+    globalFetch?: MeshFetch;
+    endpoint?: string;
+    timeout?: number;
+    operationHeaders?: Record<string, string>;
+    queryParams?: Record<string, any>;
+}
+export declare function processDirectives(schema: GraphQLSchema, { globalFetch, logger, pubsub, ...extraGlobalOptions }?: ProcessDirectiveArgs): GraphQLSchema;

package/typings/directives/process.d.ts

@@ -0,0 +1,12 @@
+import { GraphQLSchema } from 'graphql';
+import { Logger, MeshFetch, MeshPubSub } from '@graphql-mesh/types';
+export interface ProcessDirectiveArgs {
+    pubsub?: MeshPubSub;
+    logger?: Logger;
+    globalFetch?: MeshFetch;
+    endpoint?: string;
+    timeout?: number;
+    operationHeaders?: Record<string, string>;
+    queryParams?: Record<string, any>;
+}
+export declare function processDirectives(schema: GraphQLSchema, { globalFetch, logger, pubsub, ...extraGlobalOptions }?: ProcessDirectiveArgs): GraphQLSchema;

package/typings/directives/pubsubOperation.d.cts

@@ -0,0 +1,10 @@
+import { GraphQLField } from 'graphql';
+import { Logger, MeshPubSub } from '@graphql-mesh/types';
+interface ProcessPubSubOperationAnnotationsOpts {
+    field: GraphQLField<any, any>;
+    globalPubsub: MeshPubSub;
+    pubsubTopic: string;
+    logger: Logger;
+}
+export declare function processPubSubOperationAnnotations({ field, globalPubsub, pubsubTopic, logger: globalLogger, }: ProcessPubSubOperationAnnotationsOpts): void;
+export {};

package/typings/directives/pubsubOperation.d.ts

@@ -0,0 +1,10 @@
+import { GraphQLField } from 'graphql';
+import { Logger, MeshPubSub } from '@graphql-mesh/types';
+interface ProcessPubSubOperationAnnotationsOpts {
+    field: GraphQLField<any, any>;
+    globalPubsub: MeshPubSub;
+    pubsubTopic: string;
+    logger: Logger;
+}
+export declare function processPubSubOperationAnnotations({ field, globalPubsub, pubsubTopic, logger: globalLogger, }: ProcessPubSubOperationAnnotationsOpts): void;
+export {};

package/typings/directives/regexp.d.cts

@@ -0,0 +1,2 @@
+import { GraphQLScalarType } from 'graphql';
+export declare function processRegExpAnnotations(scalar: GraphQLScalarType, pattern: string): void;

package/typings/directives/regexp.d.ts

@@ -0,0 +1,2 @@
+import { GraphQLScalarType } from 'graphql';
+export declare function processRegExpAnnotations(scalar: GraphQLScalarType, pattern: string): void;