@depup/graphql-codegen__plugin-helpers 6.2.0-depup.0

package/esm/helpers.js

@@ -0,0 +1,168 @@
+import { isListType, isNonNullType, isObjectType, Kind, visit, } from 'graphql';
+import { getBaseType } from './utils.js';
+export function isOutputConfigArray(type) {
+    return Array.isArray(type);
+}
+export function isConfiguredOutput(type) {
+    return typeof type === 'object';
+}
+export function normalizeOutputParam(config) {
+    // In case of direct array with a list of plugins
+    if (isOutputConfigArray(config)) {
+        return {
+            documents: [],
+            schema: [],
+            plugins: isConfiguredOutput(config) ? config.plugins : config,
+        };
+    }
+    if (isConfiguredOutput(config)) {
+        return config;
+    }
+    throw new Error(`Invalid "generates" config!`);
+}
+export function normalizeInstanceOrArray(type) {
+    if (Array.isArray(type)) {
+        return type;
+    }
+    if (!type) {
+        return [];
+    }
+    return [type];
+}
+export function normalizeConfig(config) {
+    if (typeof config === 'string') {
+        return [{ [config]: {} }];
+    }
+    if (Array.isArray(config)) {
+        return config.map(plugin => (typeof plugin === 'string' ? { [plugin]: {} } : plugin));
+    }
+    if (typeof config === 'object') {
+        return Object.keys(config).reduce((prev, pluginName) => [...prev, { [pluginName]: config[pluginName] }], []);
+    }
+    return [];
+}
+export function hasNullableTypeRecursively(type) {
+    if (!isNonNullType(type)) {
+        return true;
+    }
+    if (isListType(type) || isNonNullType(type)) {
+        return hasNullableTypeRecursively(type.ofType);
+    }
+    return false;
+}
+export function isUsingTypes(document, externalFragments, schema) {
+    let foundFields = 0;
+    const typesStack = [];
+    visit(document, {
+        SelectionSet: {
+            enter(node, key, parent, anscestors) {
+                const insideIgnoredFragment = anscestors.find((f) => f.kind && f.kind === 'FragmentDefinition' && externalFragments.includes(f.name.value));
+                if (insideIgnoredFragment) {
+                    return;
+                }
+                const selections = node.selections || [];
+                if (schema && selections.length > 0) {
+                    const nextTypeName = (() => {
+                        if (parent.kind === Kind.FRAGMENT_DEFINITION) {
+                            return parent.typeCondition.name.value;
+                        }
+                        if (parent.kind === Kind.FIELD) {
+                            const lastType = typesStack[typesStack.length - 1];
+                            if (!lastType) {
+                                throw new Error(`Unable to find parent type! Please make sure you operation passes validation`);
+                            }
+                            const field = lastType.getFields()[parent.name.value];
+                            if (!field) {
+                                throw new Error(`Unable to find field "${parent.name.value}" on type "${lastType}"!`);
+                            }
+                            return getBaseType(field.type).name;
+                        }
+                        if (parent.kind === Kind.OPERATION_DEFINITION) {
+                            if (parent.operation === 'query') {
+                                return schema.getQueryType().name;
+                            }
+                            if (parent.operation === 'mutation') {
+                                return schema.getMutationType().name;
+                            }
+                            if (parent.operation === 'subscription') {
+                                return schema.getSubscriptionType().name;
+                            }
+                        }
+                        else if (parent.kind === Kind.INLINE_FRAGMENT) {
+                            if (parent.typeCondition) {
+                                return parent.typeCondition.name.value;
+                            }
+                            return typesStack[typesStack.length - 1].name;
+                        }
+                        return null;
+                    })();
+                    typesStack.push(schema.getType(nextTypeName));
+                }
+            },
+            leave(node) {
+                const selections = node.selections || [];
+                if (schema && selections.length > 0) {
+                    typesStack.pop();
+                }
+            },
+        },
+        Field: {
+            enter: (node, key, parent, path, anscestors) => {
+                if (node.name.value.startsWith('__')) {
+                    return;
+                }
+                const insideIgnoredFragment = anscestors.find((f) => f.kind && f.kind === 'FragmentDefinition' && externalFragments.includes(f.name.value));
+                if (insideIgnoredFragment) {
+                    return;
+                }
+                const selections = node.selectionSet ? node.selectionSet.selections || [] : [];
+                const relevantFragmentSpreads = selections.filter(s => s.kind === Kind.FRAGMENT_SPREAD && !externalFragments.includes(s.name.value));
+                if (selections.length === 0 || relevantFragmentSpreads.length > 0) {
+                    foundFields++;
+                }
+                if (schema) {
+                    const lastType = typesStack[typesStack.length - 1];
+                    if (lastType && isObjectType(lastType)) {
+                        const field = lastType.getFields()[node.name.value];
+                        if (!field) {
+                            throw new Error(`Unable to find field "${node.name.value}" on type "${lastType}"!`);
+                        }
+                        const currentType = field.type;
+                        // To handle `Maybe` usage
+                        if (hasNullableTypeRecursively(currentType)) {
+                            foundFields++;
+                        }
+                    }
+                }
+            },
+        },
+        VariableDefinition: {
+            enter: (node, key, parent, path, anscestors) => {
+                const insideIgnoredFragment = anscestors.find((f) => f.kind && f.kind === 'FragmentDefinition' && externalFragments.includes(f.name.value));
+                if (insideIgnoredFragment) {
+                    return;
+                }
+                foundFields++;
+            },
+        },
+        InputValueDefinition: {
+            enter: (node, key, parent, path, anscestors) => {
+                const insideIgnoredFragment = anscestors.find((f) => f.kind && f.kind === 'FragmentDefinition' && externalFragments.includes(f.name.value));
+                if (insideIgnoredFragment) {
+                    return;
+                }
+                foundFields++;
+            },
+        },
+    });
+    return foundFields > 0;
+}
+export function normalizeImportExtension({ emitLegacyCommonJSImports, importExtension, }) {
+    if (importExtension !== undefined) {
+        return importExtension;
+    }
+    if (emitLegacyCommonJSImports === undefined || emitLegacyCommonJSImports === true) {
+        return '';
+    }
+    return '.js';
+}

package/esm/index.js

@@ -0,0 +1,8 @@
+export * from './federation.js';
+export * from './getCachedDocumentNodeFromSchema.js';
+export * from './helpers.js';
+export * from './oldVisit.js';
+export * from './profiler.js';
+export { resolveExternalModuleAndFn } from './resolve-external-module-and-fn.js';
+export * from './types.js';
+export * from './utils.js';

package/esm/oldVisit.js

@@ -0,0 +1,16 @@
+import { visit } from 'graphql';
+export function oldVisit(root, { enter: enterVisitors, leave: leaveVisitors, ...newVisitor }) {
+    if (typeof enterVisitors === 'object') {
+        for (const key in enterVisitors) {
+            newVisitor[key] ||= {};
+            newVisitor[key].enter = enterVisitors[key];
+        }
+    }
+    if (typeof leaveVisitors === 'object') {
+        for (const key in leaveVisitors) {
+            newVisitor[key] ||= {};
+            newVisitor[key].leave = leaveVisitors[key];
+        }
+    }
+    return visit(root, newVisitor);
+}

package/esm/profiler.js

@@ -0,0 +1,45 @@
+export function createNoopProfiler() {
+    return {
+        run(fn) {
+            return Promise.resolve().then(() => fn());
+        },
+        collect() {
+            return [];
+        },
+    };
+}
+export function createProfiler() {
+    const events = [];
+    return {
+        collect() {
+            return events;
+        },
+        run(fn, name, cat) {
+            let startTime;
+            return Promise.resolve()
+                .then(() => {
+                startTime = process.hrtime();
+            })
+                .then(() => fn())
+                .then(value => {
+                const duration = process.hrtime(startTime);
+                // Trace Event Format documentation:
+                // https://docs.google.com/document/d/1CvAClvFfyA5R-PhYUmn5OOQtYMH4h6I0nSsKchNAySU/preview
+                const event = {
+                    name,
+                    cat,
+                    ph: 'X',
+                    ts: hrtimeToMicroseconds(startTime),
+                    pid: 1,
+                    tid: 0,
+                    dur: hrtimeToMicroseconds(duration),
+                };
+                events.push(event);
+                return value;
+            });
+        },
+    };
+}
+function hrtimeToMicroseconds(hrtime) {
+    return (hrtime[0] * 1e9 + hrtime[1]) / 1000;
+}

package/esm/resolve-external-module-and-fn.js

@@ -0,0 +1,27 @@
+import { createRequire } from 'module';
+import { cwd } from 'process';
+import * as changeCaseAll from 'change-case-all';
+export function resolveExternalModuleAndFn(pointer) {
+    if (typeof pointer === 'function') {
+        return pointer;
+    }
+    let [moduleName, functionName] = pointer.split('#');
+    // Temp workaround until v2
+    if (moduleName === 'change-case') {
+        moduleName = 'change-case-all';
+    }
+    let loadedModule;
+    if (moduleName === 'change-case-all') {
+        loadedModule = changeCaseAll;
+    }
+    else {
+        // we have to use a path to a filename here (it does not need to exist.)
+        // https://github.com/dotansimha/graphql-code-generator/issues/6553
+        const cwdRequire = createRequire(cwd() + '/index.js');
+        loadedModule = cwdRequire(moduleName);
+        if (!(functionName in loadedModule) && typeof loadedModule !== 'function') {
+            throw new Error(`${functionName} couldn't be found in module ${moduleName}!`);
+        }
+    }
+    return loadedModule[functionName] || loadedModule;
+}

package/esm/types.js

@@ -0,0 +1,3 @@
+export function isComplexPluginOutput(obj) {
+    return typeof obj === 'object' && Object.prototype.hasOwnProperty.call(obj, 'content');
+}

package/esm/utils.js

@@ -0,0 +1,29 @@
+import { isListType, isNonNullType } from 'graphql';
+export function mergeOutputs(content) {
+    const result = { content: '', prepend: [], append: [] };
+    if (Array.isArray(content)) {
+        for (const item of content) {
+            if (typeof item === 'string') {
+                result.content += item;
+            }
+            else {
+                result.content += item.content;
+                result.prepend.push(...(item.prepend || []));
+                result.append.push(...(item.append || []));
+            }
+        }
+    }
+    return [...result.prepend, result.content, ...result.append].join('\n');
+}
+export function isWrapperType(t) {
+    return isListType(t) || isNonNullType(t);
+}
+export function getBaseType(type) {
+    if (isWrapperType(type)) {
+        return getBaseType(type.ofType);
+    }
+    return type;
+}
+export function removeNonNullWrapper(type) {
+    return isNonNullType(type) ? type.ofType : type;
+}

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@depup/graphql-codegen__plugin-helpers",
+  "version": "6.2.0-depup.0",
+  "description": "[DepUp] GraphQL Code Generator common utils and types",
+  "peerDependencies": {
+    "graphql": "^0.8.0 || ^0.9.0 || ^0.10.0 || ^0.11.0 || ^0.12.0 || ^0.13.0 || ^14.0.0 || ^15.0.0 || ^16.0.0"
+  },
+  "dependencies": {
+    "@graphql-tools/utils": "^11.0.0",
+    "change-case-all": "^2.1.0",
+    "common-tags": "1.8.2",
+    "import-from": "4.0.0",
+    "lodash": "^4.17.23",
+    "tslib": "^2.8.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dotansimha/graphql-code-generator.git",
+    "directory": "packages/utils/plugins-helpers"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=16"
+  },
+  "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"
+  },
+  "keywords": [
+    "depup",
+    "dependency-bumped",
+    "updated-deps",
+    "@graphql-codegen/plugin-helpers"
+  ],
+  "depup": {
+    "changes": {
+      "change-case-all": {
+        "from": "1.0.15",
+        "to": "^2.1.0"
+      },
+      "lodash": {
+        "from": "~4.17.0",
+        "to": "^4.17.23"
+      },
+      "tslib": {
+        "from": "~2.6.0",
+        "to": "^2.8.1"
+      }
+    },
+    "depsUpdated": 3,
+    "originalPackage": "@graphql-codegen/plugin-helpers",
+    "originalVersion": "6.2.0",
+    "processedAt": "2026-03-17T16:31:52.141Z",
+    "smokeTest": "passed"
+  }
+}

package/typings/federation.d.cts

@@ -0,0 +1,102 @@
+import { DirectiveNode, FieldDefinitionNode, GraphQLSchema, InterfaceTypeDefinitionNode, ObjectTypeDefinitionNode } from 'graphql';
+/**
+ * Federation Spec
+ */
+export declare const federationSpec: import("graphql").DocumentNode;
+type ReferenceSelectionSet = Record<string, boolean>;
+interface TypeMeta {
+    hasResolveReference: boolean;
+    resolvableKeyDirectives: readonly DirectiveNode[];
+    /**
+     * referenceSelectionSets
+     * @description Each element can be `ReferenceSelectionSet[]`.
+     * Elements at the root level are combined with `&` and nested elements are combined with `|`.
+     *
+     * @example:
+     * - [[A, B], [C], [D]]      -> (A | B) & C & D
+     * - [[A, B], [C, D], [E]] -> (A | B) & (C | D) & E
+     */
+    referenceSelectionSets: {
+        directive: '@key' | '@requires';
+        selectionSets: ReferenceSelectionSet[];
+    }[];
+    referenceSelectionSetsString: string;
+}
+export type FederationMeta = {
+    [typeName: string]: TypeMeta;
+};
+/**
+ * Adds `__resolveReference` in each ObjectType and InterfaceType involved in Federation.
+ * We do this to utilise the existing FieldDefinition logic of the plugin, which includes many logic:
+ * - mapper
+ * - return type
+ * @param schema
+ */
+export declare function addFederationReferencesToSchema(schema: GraphQLSchema): {
+    transformedSchema: GraphQLSchema;
+    federationMeta: FederationMeta;
+};
+/**
+ * Removes Federation Spec from GraphQL Schema
+ * @param schema
+ * @param config
+ */
+export declare function removeFederation(schema: GraphQLSchema): GraphQLSchema;
+export declare class ApolloFederation {
+    private enabled;
+    private schema;
+    private providesMap;
+    /**
+     * `fieldsToGenerate` is a meta object where the keys are object type names
+     * and the values are fields that must be generated for that object.
+     */
+    private fieldsToGenerate;
+    protected meta: FederationMeta;
+    constructor({ enabled, schema, meta }: {
+        enabled: boolean;
+        schema: GraphQLSchema;
+        meta: FederationMeta;
+    });
+    /**
+     * Excludes types definde by Federation
+     * @param typeNames List of type names
+     */
+    filterTypeNames(typeNames: string[]): string[];
+    /**
+     * Excludes `__resolveReference` fields
+     * @param fieldNames List of field names
+     */
+    filterFieldNames(fieldNames: string[]): string[];
+    /**
+     * Decides if directive should not be generated
+     * @param name directive's name
+     */
+    skipDirective(name: string): boolean;
+    /**
+     * Decides if scalar should not be generated
+     * @param name directive's name
+     */
+    skipScalar(name: string): boolean;
+    /**
+     * findFieldNodesToGenerate
+     * @description Function to find field nodes to generate.
+     * In a normal setup, all fields must be generated.
+     * However, in a Federatin setup, a field should not be generated if:
+     * - The field is marked as `@external` and there is no `@provides` path to the field
+     * - The parent object is marked as `@external` and there is no `@provides` path to the field
+     */
+    findFieldNodesToGenerate({ node, }: {
+        node: ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode;
+    }): readonly FieldDefinitionNode[];
+    isResolveReferenceField(fieldNode: FieldDefinitionNode): boolean;
+    addFederationTypeGenericIfApplicable({ genericTypes, typeName, federationTypesType, }: {
+        genericTypes: string[];
+        typeName: string;
+        federationTypesType: string;
+    }): void;
+    getMeta(): FederationMeta;
+    private isExternal;
+    private hasProvides;
+    private createMapOfProvides;
+}
+export {};

package/typings/federation.d.ts

@@ -0,0 +1,102 @@
+import { DirectiveNode, FieldDefinitionNode, GraphQLSchema, InterfaceTypeDefinitionNode, ObjectTypeDefinitionNode } from 'graphql';
+/**
+ * Federation Spec
+ */
+export declare const federationSpec: import("graphql").DocumentNode;
+type ReferenceSelectionSet = Record<string, boolean>;
+interface TypeMeta {
+    hasResolveReference: boolean;
+    resolvableKeyDirectives: readonly DirectiveNode[];
+    /**
+     * referenceSelectionSets
+     * @description Each element can be `ReferenceSelectionSet[]`.
+     * Elements at the root level are combined with `&` and nested elements are combined with `|`.
+     *
+     * @example:
+     * - [[A, B], [C], [D]]      -> (A | B) & C & D
+     * - [[A, B], [C, D], [E]] -> (A | B) & (C | D) & E
+     */
+    referenceSelectionSets: {
+        directive: '@key' | '@requires';
+        selectionSets: ReferenceSelectionSet[];
+    }[];
+    referenceSelectionSetsString: string;
+}
+export type FederationMeta = {
+    [typeName: string]: TypeMeta;
+};
+/**
+ * Adds `__resolveReference` in each ObjectType and InterfaceType involved in Federation.
+ * We do this to utilise the existing FieldDefinition logic of the plugin, which includes many logic:
+ * - mapper
+ * - return type
+ * @param schema
+ */
+export declare function addFederationReferencesToSchema(schema: GraphQLSchema): {
+    transformedSchema: GraphQLSchema;
+    federationMeta: FederationMeta;
+};
+/**
+ * Removes Federation Spec from GraphQL Schema
+ * @param schema
+ * @param config
+ */
+export declare function removeFederation(schema: GraphQLSchema): GraphQLSchema;
+export declare class ApolloFederation {
+    private enabled;
+    private schema;
+    private providesMap;
+    /**
+     * `fieldsToGenerate` is a meta object where the keys are object type names
+     * and the values are fields that must be generated for that object.
+     */
+    private fieldsToGenerate;
+    protected meta: FederationMeta;
+    constructor({ enabled, schema, meta }: {
+        enabled: boolean;
+        schema: GraphQLSchema;
+        meta: FederationMeta;
+    });
+    /**
+     * Excludes types definde by Federation
+     * @param typeNames List of type names
+     */
+    filterTypeNames(typeNames: string[]): string[];
+    /**
+     * Excludes `__resolveReference` fields
+     * @param fieldNames List of field names
+     */
+    filterFieldNames(fieldNames: string[]): string[];
+    /**
+     * Decides if directive should not be generated
+     * @param name directive's name
+     */
+    skipDirective(name: string): boolean;
+    /**
+     * Decides if scalar should not be generated
+     * @param name directive's name
+     */
+    skipScalar(name: string): boolean;
+    /**
+     * findFieldNodesToGenerate
+     * @description Function to find field nodes to generate.
+     * In a normal setup, all fields must be generated.
+     * However, in a Federatin setup, a field should not be generated if:
+     * - The field is marked as `@external` and there is no `@provides` path to the field
+     * - The parent object is marked as `@external` and there is no `@provides` path to the field
+     */
+    findFieldNodesToGenerate({ node, }: {
+        node: ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode;
+    }): readonly FieldDefinitionNode[];
+    isResolveReferenceField(fieldNode: FieldDefinitionNode): boolean;
+    addFederationTypeGenericIfApplicable({ genericTypes, typeName, federationTypesType, }: {
+        genericTypes: string[];
+        typeName: string;
+        federationTypesType: string;
+    }): void;
+    getMeta(): FederationMeta;
+    private isExternal;
+    private hasProvides;
+    private createMapOfProvides;
+}
+export {};

package/typings/getCachedDocumentNodeFromSchema.d.cts

@@ -0,0 +1,2 @@
+import { getDocumentNodeFromSchema } from '@graphql-tools/utils';
+export declare const getCachedDocumentNodeFromSchema: typeof getDocumentNodeFromSchema;

package/typings/getCachedDocumentNodeFromSchema.d.ts

@@ -0,0 +1,2 @@
+import { getDocumentNodeFromSchema } from '@graphql-tools/utils';
+export declare const getCachedDocumentNodeFromSchema: typeof getDocumentNodeFromSchema;

package/typings/helpers.d.cts

@@ -0,0 +1,13 @@
+import { DocumentNode, GraphQLOutputType, GraphQLSchema } from 'graphql';
+import { Types } from './types.cjs';
+export declare function isOutputConfigArray(type: any): type is Types.OutputConfig[];
+export declare function isConfiguredOutput(type: any): type is Types.ConfiguredOutput;
+export declare function normalizeOutputParam(config: Types.OutputConfig | Types.ConfiguredPlugin[] | Types.ConfiguredOutput): Types.ConfiguredOutput;
+export declare function normalizeInstanceOrArray<T>(type: T | T[]): T[];
+export declare function normalizeConfig(config: Types.OutputConfig | Types.OutputConfig[]): Types.ConfiguredPlugin[];
+export declare function hasNullableTypeRecursively(type: GraphQLOutputType): boolean;
+export declare function isUsingTypes(document: DocumentNode, externalFragments: string[], schema?: GraphQLSchema): boolean;
+export declare function normalizeImportExtension({ emitLegacyCommonJSImports, importExtension, }: {
+    emitLegacyCommonJSImports: boolean | undefined;
+    importExtension: '' | `.${string}` | undefined;
+}): '' | `.${string}`;

package/typings/helpers.d.ts

@@ -0,0 +1,13 @@
+import { DocumentNode, GraphQLOutputType, GraphQLSchema } from 'graphql';
+import { Types } from './types.js';
+export declare function isOutputConfigArray(type: any): type is Types.OutputConfig[];
+export declare function isConfiguredOutput(type: any): type is Types.ConfiguredOutput;
+export declare function normalizeOutputParam(config: Types.OutputConfig | Types.ConfiguredPlugin[] | Types.ConfiguredOutput): Types.ConfiguredOutput;
+export declare function normalizeInstanceOrArray<T>(type: T | T[]): T[];
+export declare function normalizeConfig(config: Types.OutputConfig | Types.OutputConfig[]): Types.ConfiguredPlugin[];
+export declare function hasNullableTypeRecursively(type: GraphQLOutputType): boolean;
+export declare function isUsingTypes(document: DocumentNode, externalFragments: string[], schema?: GraphQLSchema): boolean;
+export declare function normalizeImportExtension({ emitLegacyCommonJSImports, importExtension, }: {
+    emitLegacyCommonJSImports: boolean | undefined;
+    importExtension: '' | `.${string}` | undefined;
+}): '' | `.${string}`;

package/typings/index.d.cts

@@ -0,0 +1,9 @@
+export * from './federation.cjs';
+export * from './getCachedDocumentNodeFromSchema.cjs';
+export * from './helpers.cjs';
+export * from './oldVisit.cjs';
+export * from './profiler.cjs';
+export { resolveExternalModuleAndFn } from './resolve-external-module-and-fn.cjs';
+export * from './types.cjs';
+export { Types } from './types.cjs';
+export * from './utils.cjs';

package/typings/index.d.ts

@@ -0,0 +1,9 @@
+export * from './federation.js';
+export * from './getCachedDocumentNodeFromSchema.js';
+export * from './helpers.js';
+export * from './oldVisit.js';
+export * from './profiler.js';
+export { resolveExternalModuleAndFn } from './resolve-external-module-and-fn.js';
+export * from './types.js';
+export { Types } from './types.js';
+export * from './utils.js';

package/typings/oldVisit.d.cts

@@ -0,0 +1,9 @@
+import { ASTNode, visit } from 'graphql';
+type VisitFn = typeof visit;
+type NewVisitor = Partial<Parameters<VisitFn>[1]>;
+type OldVisitor = {
+    enter?: Partial<Record<keyof NewVisitor, NonNullable<NewVisitor[keyof NewVisitor]>['enter']>>;
+    leave?: Partial<Record<keyof NewVisitor, NonNullable<NewVisitor[keyof NewVisitor]>['leave']>>;
+} & NewVisitor;
+export declare function oldVisit(root: ASTNode, { enter: enterVisitors, leave: leaveVisitors, ...newVisitor }: OldVisitor): any;
+export {};

package/typings/oldVisit.d.ts

@@ -0,0 +1,9 @@
+import { ASTNode, visit } from 'graphql';
+type VisitFn = typeof visit;
+type NewVisitor = Partial<Parameters<VisitFn>[1]>;
+type OldVisitor = {
+    enter?: Partial<Record<keyof NewVisitor, NonNullable<NewVisitor[keyof NewVisitor]>['enter']>>;
+    leave?: Partial<Record<keyof NewVisitor, NonNullable<NewVisitor[keyof NewVisitor]>['leave']>>;
+} & NewVisitor;
+export declare function oldVisit(root: ASTNode, { enter: enterVisitors, leave: leaveVisitors, ...newVisitor }: OldVisitor): any;
+export {};