@nmarks/graphql-codegen-per-operation-file-preset 1.0.0

package/README.md

@@ -0,0 +1,209 @@
+# @graphql-codegen/per-operation-file-preset
+
+Generate **one file per GraphQL operation or fragment**, named after the operation/fragment itself.
+
+## Installation
+
+```bash
+npm install @graphql-codegen/per-operation-file-preset
+```
+
+## Usage
+
+```typescript
+// codegen.ts
+import type { CodegenConfig } from '@graphql-codegen/cli';
+
+const config: CodegenConfig = {
+  schema: 'schema.graphql',
+  documents: 'src/**/*.ts',
+  generates: {
+    'src/': {
+      preset: 'per-operation-file',
+      presetConfig: {
+        baseTypesPath: 'types.ts',
+      },
+      plugins: ['typescript-operations'],
+    },
+  },
+};
+export default config;
+```
+
+## How It Works
+
+Unlike the `near-operation-file` preset which generates one file per source file, this preset generates **one file per operation/fragment**.
+
+### Example
+
+**Input:**
+```typescript
+// src/queries/user.ts
+export const GetUserQuery = gql`
+  query GetUser($id: ID!) {
+    user(id: $id) {
+      id
+      name
+    }
+  }
+`;
+
+export const GetUsersQuery = gql`
+  query GetUsers {
+    users {
+      id
+      name
+    }
+  }
+`;
+```
+
+**Output:**
+```
+src/queries/__generated__/GetUser.ts    # Generated types for GetUser query
+src/queries/__generated__/GetUsers.ts   # Generated types for GetUsers query
+```
+
+### Fragments
+
+**Input:**
+```typescript
+// src/fragments/user.ts
+export const UserFieldsFragment = gql`
+  fragment UserFields on User {
+    id
+    name
+    email
+  }
+`;
+```
+
+**Output:**
+```
+src/fragments/__generated__/UserFields.ts
+```
+
+## Configuration
+
+### `baseTypesPath` (required)
+
+Path to your base schema types file (generated by the `typescript` plugin).
+
+```typescript
+presetConfig: {
+  baseTypesPath: 'types.ts'
+}
+```
+
+You can also use npm packages:
+```typescript
+presetConfig: {
+  baseTypesPath: '~@myapp/graphql-types'
+}
+```
+
+### `folder` (optional)
+
+Folder name for generated files, relative to the source file location.
+
+**Default:** `__generated__`
+
+```typescript
+presetConfig: {
+  baseTypesPath: 'types.ts',
+  folder: 'generated'  // Use 'generated' instead of '__generated__'
+}
+```
+
+### `extension` (optional)
+
+File extension for generated files.
+
+**Default:** `.ts`
+
+```typescript
+presetConfig: {
+  baseTypesPath: 'types.ts',
+  extension: '.generated.ts'
+}
+```
+
+### `importTypesNamespace` (optional)
+
+Namespace for importing base schema types.
+
+**Default:** `Types`
+
+```typescript
+presetConfig: {
+  baseTypesPath: 'types.ts',
+  importTypesNamespace: 'SchemaTypes'
+}
+```
+
+### `cwd` (optional)
+
+Override the current working directory.
+
+**Default:** `process.cwd()`
+
+```typescript
+presetConfig: {
+  baseTypesPath: 'types.ts',
+  cwd: '/custom/path'
+}
+```
+
+## Fragment Imports
+
+The preset automatically handles fragment imports. If an operation uses a fragment from another file, it will generate the correct import statement.
+
+**Example:**
+
+```typescript
+// src/fragments/user.ts
+fragment UserFields on User { id name }
+
+// src/queries/user.ts
+query GetUser($id: ID!) {
+  user(id: $id) {
+    ...UserFields
+  }
+}
+```
+
+**Generated:**
+
+```typescript
+// src/queries/__generated__/GetUser.ts
+import { UserFieldsFragment, UserFieldsFragmentDoc } from '../../fragments/__generated__/UserFields';
+// ... rest of generated code
+```
+
+## Comparison with near-operation-file
+
+| Feature | near-operation-file | per-operation-file |
+|---------|-------------------|-------------------|
+| **File Strategy** | One file per source file | One file per operation/fragment |
+| **Output Naming** | Based on source filename | Based on operation/fragment name |
+| **Multiple Operations** | Combined in one file | Split into separate files |
+| **Fragment Imports** | ✅ Supported | ✅ Supported |
+| **Use Case** | Co-location with source | Migration from other tools, explicit operation files |
+
+## When to Use This Preset
+
+Use `per-operation-file` when:
+- ✅ Migrating from tools that generate one file per operation
+- ✅ You want explicit, discoverable operation files
+- ✅ You have multiple operations per source file
+- ✅ You want operation names to match generated file names
+
+Use `near-operation-file` when:
+- ✅ You want generated files to mirror your source structure
+- ✅ You prefer one-to-one mapping between source and generated files
+- ✅ You typically have one operation per source file
+
+## License
+
+MIT
+

package/cjs/fragment-resolver.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = buildFragmentResolver;
+const graphql_1 = require("graphql");
+const visitor_plugin_common_1 = require("@graphql-codegen/visitor-plugin-common");
+const utils_js_1 = require("./utils.js");
+/**
+ * Creates fragment imports based on possible types and usage
+ */
+function createFragmentImports(baseVisitor, fragmentName, possibleTypes, usedTypes) {
+    const fragmentImports = [];
+    // Always include the document import
+    fragmentImports.push({
+        name: baseVisitor.getFragmentVariableName(fragmentName),
+        kind: 'document',
+    });
+    const fragmentSuffix = baseVisitor.getFragmentSuffix(fragmentName);
+    if (possibleTypes.length === 1) {
+        fragmentImports.push({
+            name: baseVisitor.convertName(fragmentName, {
+                useTypesPrefix: true,
+                suffix: fragmentSuffix,
+            }),
+            kind: 'type',
+        });
+    }
+    else if (possibleTypes.length > 0) {
+        const typesToImport = usedTypes && usedTypes.length > 0 ? usedTypes : possibleTypes;
+        typesToImport.forEach(typeName => {
+            fragmentImports.push({
+                name: baseVisitor.convertName(fragmentName, {
+                    useTypesPrefix: true,
+                    suffix: `_${typeName}` + (fragmentSuffix.length > 0 ? `_${fragmentSuffix}` : ''),
+                }),
+                kind: 'type',
+            });
+        });
+    }
+    return fragmentImports;
+}
+/**
+ * Used by `buildFragmentResolver` to build a mapping of fragmentNames to paths, importNames, and other useful info
+ *
+ * KEY DIFFERENCE from near-operation-file:
+ * The filePath is generated based on the fragment NAME, not the source file location
+ */
+function buildFragmentRegistry(baseVisitor, { folder, extension }, { documents }, schemaObject) {
+    const duplicateFragmentNames = [];
+    const registry = documents.reduce((prev, documentRecord) => {
+        const fragments = documentRecord.document.definitions.filter(d => d.kind === graphql_1.Kind.FRAGMENT_DEFINITION);
+        for (const fragment of fragments) {
+            const schemaType = schemaObject.getType(fragment.typeCondition.name.value);
+            if (!schemaType) {
+                throw new Error(`Fragment "${fragment.name.value}" is set on non-existing type "${fragment.typeCondition.name.value}"!`);
+            }
+            const fragmentName = fragment.name.value;
+            // KEY CHANGE: Generate path based on fragment name, not source file
+            const filePath = (0, utils_js_1.generateOperationFilePath)(documentRecord.location, fragmentName, folder, extension);
+            const possibleTypes = (0, visitor_plugin_common_1.getPossibleTypes)(schemaObject, schemaType);
+            const possibleTypeNames = possibleTypes.map(t => t.name);
+            const imports = createFragmentImports(baseVisitor, fragment.name.value, possibleTypeNames);
+            if (prev[fragmentName] && (0, graphql_1.print)(fragment) !== (0, graphql_1.print)(prev[fragmentName].node)) {
+                duplicateFragmentNames.push(fragmentName);
+            }
+            prev[fragmentName] = {
+                filePath,
+                imports,
+                onType: fragment.typeCondition.name.value,
+                node: fragment,
+                possibleTypes: possibleTypeNames,
+            };
+        }
+        return prev;
+    }, {});
+    if (duplicateFragmentNames.length) {
+        throw new Error(`Multiple fragments with the name(s) "${duplicateFragmentNames.join(', ')}" were found.`);
+    }
+    return registry;
+}
+/**
+ * Creates a BaseVisitor with standard configuration
+ */
+function createBaseVisitor(config, schemaObject) {
+    return new visitor_plugin_common_1.BaseVisitor(config, {
+        scalars: (0, visitor_plugin_common_1.buildScalarsFromConfig)(schemaObject, config),
+        dedupeOperationSuffix: (0, visitor_plugin_common_1.getConfigValue)(config.dedupeOperationSuffix, false),
+        omitOperationSuffix: (0, visitor_plugin_common_1.getConfigValue)(config.omitOperationSuffix, false),
+        fragmentVariablePrefix: (0, visitor_plugin_common_1.getConfigValue)(config.fragmentVariablePrefix, ''),
+        fragmentVariableSuffix: (0, visitor_plugin_common_1.getConfigValue)(config.fragmentVariableSuffix, 'FragmentDoc'),
+    });
+}
+/**
+ * Builds a fragment "resolver" that collects `externalFragments` definitions and `fragmentImportStatements`
+ */
+function buildFragmentResolver(collectorOptions, presetOptions, schemaObject, dedupeFragments = false) {
+    const { config } = presetOptions;
+    const baseVisitor = createBaseVisitor(config, schemaObject);
+    const fragmentRegistry = buildFragmentRegistry(baseVisitor, collectorOptions, presetOptions, schemaObject);
+    const { baseOutputDir } = presetOptions;
+    const { baseDir, typesImport } = collectorOptions;
+    function resolveFragments(generatedFilePath, documentFileContent) {
+        const { fragmentsInUse, usedFragmentTypes } = (0, utils_js_1.analyzeFragmentUsage)(documentFileContent, fragmentRegistry, schemaObject);
+        const externalFragments = [];
+        const fragmentFileImports = {};
+        for (const [fragmentName, level] of Object.entries(fragmentsInUse)) {
+            const fragmentDetails = fragmentRegistry[fragmentName];
+            if (!fragmentDetails)
+                continue;
+            // add top level references to the import object
+            // we don't check or global namespace because the calling config can do so
+            if (level === 0 ||
+                (dedupeFragments &&
+                    ['OperationDefinition', 'FragmentDefinition'].includes(documentFileContent.definitions[0].kind))) {
+                if (fragmentDetails.filePath !== generatedFilePath) {
+                    // don't emit imports to same location
+                    const usedTypesForFragment = usedFragmentTypes[fragmentName] || [];
+                    const filteredImports = createFragmentImports(baseVisitor, fragmentName, fragmentDetails.possibleTypes, usedTypesForFragment);
+                    if (!fragmentFileImports[fragmentDetails.filePath]) {
+                        fragmentFileImports[fragmentDetails.filePath] = [];
+                    }
+                    fragmentFileImports[fragmentDetails.filePath].push(...filteredImports);
+                }
+            }
+            externalFragments.push({
+                level,
+                isExternal: true,
+                name: fragmentName,
+                onType: fragmentDetails.onType,
+                node: fragmentDetails.node,
+            });
+        }
+        return {
+            externalFragments,
+            fragmentImports: Object.entries(fragmentFileImports).map(([fragmentsFilePath, identifiers]) => ({
+                baseDir,
+                baseOutputDir,
+                outputPath: generatedFilePath,
+                importSource: {
+                    path: fragmentsFilePath,
+                    identifiers,
+                },
+                emitLegacyCommonJSImports: presetOptions.config.emitLegacyCommonJSImports,
+                importExtension: presetOptions.config.importExtension,
+                typesImport,
+            })),
+        };
+    }
+    return resolveFragments;
+}

package/cjs/index.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preset = void 0;
+const tslib_1 = require("tslib");
+const path_1 = require("path");
+const graphql_1 = require("graphql");
+const add_1 = tslib_1.__importDefault(require("@graphql-codegen/add"));
+const visitor_plugin_common_1 = require("@graphql-codegen/visitor-plugin-common");
+const resolve_document_imports_js_1 = require("./resolve-document-imports.js");
+const utils_js_1 = require("./utils.js");
+/**
+ * Extract operation and fragment names from a document
+ */
+function extractDefinitions(document) {
+    const definitions = [];
+    for (const def of document.definitions) {
+        if (def.kind === graphql_1.Kind.OPERATION_DEFINITION && def.name) {
+            definitions.push({ name: def.name.value, definition: def });
+        }
+        else if (def.kind === graphql_1.Kind.FRAGMENT_DEFINITION) {
+            definitions.push({ name: def.name.value, definition: def });
+        }
+    }
+    return definitions;
+}
+exports.preset = {
+    buildGeneratesSection: options => {
+        var _a;
+        const schemaObject = options.schemaAst
+            ? options.schemaAst
+            : (0, graphql_1.buildASTSchema)(options.schema, options.config);
+        const baseDir = options.presetConfig.cwd || process.cwd();
+        const extension = options.presetConfig.extension || '.ts';
+        const folder = options.presetConfig.folder || '__generated__';
+        const importTypesNamespace = options.presetConfig.importTypesNamespace || 'Types';
+        const { baseTypesPath } = options.presetConfig;
+        if (!baseTypesPath) {
+            throw new Error(`Preset "per-operation-file" requires you to specify "baseTypesPath" configuration!`);
+        }
+        const shouldAbsolute = !baseTypesPath.startsWith('~');
+        const pluginMap = {
+            ...options.pluginMap,
+            add: add_1.default,
+        };
+        // Resolve fragment dependencies using our adapted fragment resolver
+        // Fragment paths will be generated based on fragment names
+        const sources = (0, resolve_document_imports_js_1.resolveDocumentImports)(options, schemaObject, {
+            baseDir,
+            folder,
+            extension,
+            schemaTypesSource: {
+                path: shouldAbsolute ? (0, path_1.join)(options.baseOutputDir, baseTypesPath) : baseTypesPath,
+                namespace: importTypesNamespace,
+            },
+            typesImport: (_a = options.config.useTypeImports) !== null && _a !== void 0 ? _a : false,
+        }, (0, visitor_plugin_common_1.getConfigValue)(options.config.dedupeFragments, false));
+        const artifacts = [];
+        // Now split each source into separate files per operation/fragment
+        for (const source of sources) {
+            const definitions = extractDefinitions(source.documents[0].document);
+            for (const { name, definition } of definitions) {
+                const filename = (0, utils_js_1.generateOperationFilePath)(source.documents[0].location, name, folder, extension);
+                // Create a document with just this operation/fragment
+                const singleDefDocument = {
+                    kind: graphql_1.Kind.DOCUMENT,
+                    definitions: [definition],
+                };
+                const singleDefSource = {
+                    rawSDL: source.documents[0].rawSDL, // TODO: might need to filter this
+                    document: singleDefDocument,
+                    location: source.documents[0].location,
+                };
+                // Update fragment imports to use the correct output path for this operation
+                const updatedFragmentImports = source.fragmentImports.map(fragmentImport => ({
+                    ...fragmentImport,
+                    outputPath: filename, // Update to actual output path
+                }));
+                const plugins = [
+                    ...(options.config.globalNamespace
+                        ? []
+                        : source.importStatements.map(importStatement => ({
+                            add: { content: importStatement },
+                        }))),
+                    ...options.plugins,
+                ];
+                const config = {
+                    ...options.config,
+                    exportFragmentSpreadSubTypes: true,
+                    namespacedImportName: importTypesNamespace,
+                    externalFragments: source.externalFragments,
+                    fragmentImports: updatedFragmentImports,
+                };
+                artifacts.push({
+                    ...options,
+                    filename,
+                    documents: [singleDefSource],
+                    plugins,
+                    pluginMap,
+                    config,
+                    schema: options.schema,
+                    schemaAst: schemaObject,
+                    skipDocumentsValidation: typeof options.config.skipDocumentsValidation === 'undefined'
+                        ? { skipDuplicateValidation: true }
+                        : options.config.skipDocumentsValidation,
+                });
+            }
+        }
+        return artifacts;
+    },
+};
+exports.default = exports.preset;

package/cjs/package.json

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

package/cjs/resolve-document-imports.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveDocumentImports = resolveDocumentImports;
+const tslib_1 = require("tslib");
+const plugin_helpers_1 = require("@graphql-codegen/plugin-helpers");
+const visitor_plugin_common_1 = require("@graphql-codegen/visitor-plugin-common");
+const fragment_resolver_js_1 = tslib_1.__importDefault(require("./fragment-resolver.js"));
+/**
+ * Transform the preset's provided documents into single-file generator sources, while resolving fragment and user-defined imports
+ *
+ * Resolves user provided imports and fragment imports using the `DocumentImportResolverOptions`.
+ * Does not define specific plugins, but rather returns a string[] of `importStatements` for the calling plugin to make use of
+ */
+function resolveDocumentImports(presetOptions, schemaObject, importResolverOptions, dedupeFragments = false) {
+    const resolveFragments = (0, fragment_resolver_js_1.default)(importResolverOptions, presetOptions, schemaObject, dedupeFragments);
+    const { baseOutputDir, documents } = presetOptions;
+    const { schemaTypesSource, baseDir, typesImport } = importResolverOptions;
+    return documents.map(documentFile => {
+        try {
+            // NOTE: We pass a placeholder filename here since we'll generate proper filenames per-operation later
+            // The important part is that fragment resolution will use the correct paths from the registry
+            const placeholderFilePath = documentFile.location;
+            const importStatements = [];
+            const { externalFragments, fragmentImports } = resolveFragments(placeholderFilePath, documentFile.document);
+            const externalFragmentsInjectedDocument = {
+                ...documentFile.document,
+                definitions: [
+                    ...documentFile.document.definitions,
+                    ...externalFragments.map(fragment => fragment.node),
+                ],
+            };
+            if ((0, plugin_helpers_1.isUsingTypes)(externalFragmentsInjectedDocument, [], schemaObject)) {
+                const schemaTypesImportStatement = (0, visitor_plugin_common_1.generateImportStatement)({
+                    baseDir,
+                    emitLegacyCommonJSImports: presetOptions.config.emitLegacyCommonJSImports,
+                    importExtension: presetOptions.config.importExtension,
+                    importSource: (0, visitor_plugin_common_1.resolveImportSource)(schemaTypesSource),
+                    baseOutputDir,
+                    outputPath: placeholderFilePath,
+                    typesImport,
+                });
+                importStatements.unshift(schemaTypesImportStatement);
+            }
+            return {
+                filename: placeholderFilePath,
+                documents: [documentFile],
+                importStatements,
+                fragmentImports,
+                externalFragments,
+            };
+        }
+        catch (e) {
+            throw new Error(`Unable to validate GraphQL document! \n
+         File ${documentFile.location} caused error:
+         ${e.message || e.toString()}`);
+        }
+    });
+}

package/cjs/utils.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateOperationFilePath = generateOperationFilePath;
+exports.analyzeFragmentUsage = analyzeFragmentUsage;
+exports.extractExternalFragmentsInUse = extractExternalFragmentsInUse;
+const path_1 = require("path");
+const graphql_1 = require("graphql");
+const visitor_plugin_common_1 = require("@graphql-codegen/visitor-plugin-common");
+/**
+ * Generate output file path for a specific operation/fragment
+ */
+function generateOperationFilePath(sourceLocation, operationName, folder, extension) {
+    const dir = (0, path_1.dirname)(sourceLocation);
+    return (0, path_1.join)(dir, folder, `${operationName}${extension}`).replace(/\\/g, '/');
+}
+/**
+ * Analyzes fragment usage in a GraphQL document.
+ * Returns information about which fragments are used and which specific types they're used with.
+ */
+function analyzeFragmentUsage(documentNode, fragmentRegistry, schema) {
+    const localFragments = getLocalFragments(documentNode);
+    const fragmentsInUse = extractExternalFragmentsInUse(documentNode, fragmentRegistry, localFragments);
+    const usedFragmentTypes = analyzeFragmentTypeUsage(documentNode, fragmentRegistry, schema, localFragments, fragmentsInUse);
+    return { fragmentsInUse, usedFragmentTypes };
+}
+/**
+ * Get all fragment definitions that are local to this document
+ */
+function getLocalFragments(documentNode) {
+    const localFragments = new Set();
+    (0, graphql_1.visit)(documentNode, {
+        FragmentDefinition: node => {
+            localFragments.add(node.name.value);
+        },
+    });
+    return localFragments;
+}
+function extractExternalFragmentsInUse(documentNode, fragmentNameToFile, localFragment, result = {}, level = 0) {
+    // Then, look for all used fragments in this document
+    (0, graphql_1.visit)(documentNode, {
+        FragmentSpread: node => {
+            if (!localFragment.has(node.name.value) &&
+                (result[node.name.value] === undefined || level < result[node.name.value])) {
+                result[node.name.value] = level;
+                if (fragmentNameToFile[node.name.value]) {
+                    extractExternalFragmentsInUse(fragmentNameToFile[node.name.value].node, fragmentNameToFile, localFragment, result, level + 1);
+                }
+            }
+        },
+    });
+    return result;
+}
+/**
+ * Analyze which specific types each fragment is used with (for polymorphic fragments)
+ */
+function analyzeFragmentTypeUsage(documentNode, fragmentRegistry, schema, localFragments, fragmentsInUse) {
+    const usedFragmentTypes = {};
+    const typeInfo = new graphql_1.TypeInfo(schema);
+    (0, graphql_1.visit)(documentNode, (0, graphql_1.visitWithTypeInfo)(typeInfo, {
+        Field: (node) => {
+            if (!node.selectionSet)
+                return;
+            const fieldType = typeInfo.getType();
+            if (!fieldType)
+                return;
+            const baseType = getBaseType(fieldType);
+            if ((0, graphql_1.isObjectType)(baseType) || (0, graphql_1.isInterfaceType)(baseType) || (0, graphql_1.isUnionType)(baseType)) {
+                analyzeSelectionSetTypeContext(node.selectionSet, baseType.name, usedFragmentTypes, fragmentRegistry, schema, localFragments);
+            }
+        },
+    }));
+    const result = {};
+    // Fill in missing types for multi-type fragments
+    for (const fragmentName in fragmentsInUse) {
+        const fragment = fragmentRegistry[fragmentName];
+        if (!fragment || fragment.possibleTypes.length <= 1)
+            continue;
+        const usedTypes = usedFragmentTypes[fragmentName];
+        result[fragmentName] = (usedTypes === null || usedTypes === void 0 ? void 0 : usedTypes.size) > 0 ? Array.from(usedTypes) : fragment.possibleTypes;
+    }
+    return result;
+}
+/**
+ * Analyze fragment usage within a specific selection set and type context
+ */
+function analyzeSelectionSetTypeContext(selectionSet, currentTypeName, usedFragmentTypes, fragmentRegistry, schema, localFragments) {
+    var _a, _b;
+    var _c;
+    const { spreads, inlines } = (0, visitor_plugin_common_1.separateSelectionSet)(selectionSet.selections);
+    // Process fragment spreads in this type context
+    for (const spread of spreads) {
+        if (localFragments.has(spread.name.value))
+            continue;
+        const fragment = fragmentRegistry[spread.name.value];
+        if (!fragment || fragment.possibleTypes.length <= 1)
+            continue;
+        const currentType = schema.getType(currentTypeName);
+        if (!currentType)
+            continue;
+        const possibleTypes = (0, visitor_plugin_common_1.getPossibleTypes)(schema, currentType).map(t => t.name);
+        const matchingTypes = possibleTypes.filter(type => fragment.possibleTypes.includes(type));
+        if (matchingTypes.length > 0) {
+            const typeSet = ((_a = usedFragmentTypes[_c = spread.name.value]) !== null && _a !== void 0 ? _a : (usedFragmentTypes[_c] = new Set()));
+            matchingTypes.forEach(type => typeSet.add(type));
+        }
+    }
+    // Process inline fragments
+    for (const inline of inlines) {
+        if (((_b = inline.typeCondition) === null || _b === void 0 ? void 0 : _b.name.value) && inline.selectionSet) {
+            analyzeSelectionSetTypeContext(inline.selectionSet, inline.typeCondition.name.value, usedFragmentTypes, fragmentRegistry, schema, localFragments);
+        }
+    }
+}
+function getBaseType(type) {
+    let baseType = type;
+    while ('ofType' in baseType && baseType.ofType) {
+        baseType = baseType.ofType;
+    }
+    return baseType;
+}