@depup/graphql-codegen__typescript-operations 5.0.9-depup.0 → 6.1.1-depup.0

package/esm/index.js

@@ -1,38 +1,57 @@
+import { concatAST } from 'graphql';
 import { oldVisit } from '@graphql-codegen/plugin-helpers';
+import { transformSchemaAST } from '@graphql-codegen/schema-ast';
 import { optimizeOperations } from '@graphql-codegen/visitor-plugin-common';
-import { concatAST, Kind } from 'graphql';
 import { TypeScriptDocumentsVisitor } from './visitor.js';
-export const plugin = async (inputSchema, rawDocuments, config) => {
-    const schema = config.nullability?.errorHandlingClient ? await semanticToStrict(inputSchema) : inputSchema;
+export const plugin = async (inputSchema, rawDocuments, config, { outputFile }) => {
+    const schema = config.nullability?.errorHandlingClient
+        ? await semanticToStrict(inputSchema)
+        : inputSchema;
     const documents = config.flattenGeneratedTypes
         ? optimizeOperations(schema, rawDocuments, {
             includeFragments: config.flattenGeneratedTypesIncludeFragments,
         })
         : rawDocuments;
-    const allAst = concatAST(documents.map(v => v.document));
-    const allFragments = [
-        ...allAst.definitions.filter(d => d.kind === Kind.FRAGMENT_DEFINITION).map(fragmentDef => ({
-            node: fragmentDef,
-            name: fragmentDef.name.value,
-            onType: fragmentDef.typeCondition.name.value,
-            isExternal: false,
-        })),
-        ...(config.externalFragments || []),
-    ];
-    const visitor = new TypeScriptDocumentsVisitor(schema, config, allFragments);
-    const visitorResult = oldVisit(allAst, {
+    const parsedDocuments = documents.reduce((prev, document) => {
+        prev.all.documentFiles.push(document);
+        prev.all.documentNodes.push(document.document);
+        // `!document.type` case could happen in a few scenarios:
+        // - the plugin is programmatically triggered
+        // - in existing tests
+        if (!document.type || document.type === 'standard') {
+            prev.standard.documentFiles.push(document);
+            prev.standard.documentNodes.push(document.document);
+        }
+        return prev;
+    }, {
+        all: { documentFiles: [], documentNodes: [] },
+        standard: { documentFiles: [], documentNodes: [] },
+    });
+    // For Fragment types to resolve correctly, we must get read all docs (`standard` and `external`)
+    // Fragment types are usually (but not always) in `external` files in certain setup, like a monorepo.
+    const allDocumentsAST = concatAST(parsedDocuments.all.documentNodes);
+    const visitor = new TypeScriptDocumentsVisitor(schema, config, allDocumentsAST, outputFile);
+    // We only visit `standard` documents to generate types.
+    // `external` documents are included as references for typechecking and completeness i.e. only used for reading purposes, no writing.
+    const documentsToVisitAST = concatAST(parsedDocuments.standard.documentNodes);
+    const operationsResult = oldVisit(documentsToVisitAST, {
         leave: visitor,
     });
-    let content = visitorResult.definitions.join('\n');
+    const operationsDefinitions = operationsResult.definitions;
     if (config.addOperationExport) {
-        const exportConsts = [];
-        for (const d of allAst.definitions) {
+        for (const d of allDocumentsAST.definitions) {
             if ('name' in d) {
-                exportConsts.push(`export declare const ${d.name.value}: import("graphql").DocumentNode;`);
+                operationsDefinitions.push(`export declare const ${d.name.value}: import("graphql").DocumentNode;`);
             }
         }
-        content = visitorResult.definitions.concat(exportConsts).join('\n');
     }
+    const schemaTypes = oldVisit(transformSchemaAST(schema, config).ast, { leave: visitor });
+    // IMPORTANT: when a visitor leaves a node with no transformation logic,
+    // It will leave the node as an object.
+    // Here, we filter in nodes that have been turned into strings, i.e. they have been transformed
+    // This way, we do not have to explicitly declare a method for every node type to convert them to null
+    const schemaTypesDefinitions = schemaTypes.definitions.filter(def => typeof def === 'string');
+    let content = [...schemaTypesDefinitions, ...operationsDefinitions].join('\n');
     if (config.globalNamespace) {
         content = `
     declare global {
@@ -40,7 +59,15 @@ export const plugin = async (inputSchema, rawDocuments, config) => {
     }`;
     }
     return {
-        prepend: [...visitor.getImports(), ...visitor.getGlobalDeclarations(visitor.config.noExport)],
+        prepend: [
+            ...visitor.getImports(),
+            ...visitor.getExternalSchemaTypeImports(),
+            ...visitor.getEnumsImports(),
+            ...visitor.getScalarsImports(),
+            ...visitor.getGlobalDeclarations(visitor.config.noExport),
+            visitor.getExactUtilityType(),
+            visitor.getIncrementalUtilityType(),
+        ],
         content,
     };
 };

package/esm/ts-operation-variables-to-object.js

@@ -1,6 +1,51 @@
-import { TypeScriptOperationVariablesToObject as TSOperationVariablesToObject } from '@graphql-codegen/typescript';
-export class TypeScriptOperationVariablesToObject extends TSOperationVariablesToObject {
+import { Kind } from 'graphql';
+import { DEFAULT_INPUT_SCALARS, OperationVariablesToObject, printTypeScriptMaybeType, } from '@graphql-codegen/visitor-plugin-common';
+export class TypeScriptOperationVariablesToObject extends OperationVariablesToObject {
+    _config;
+    constructor(_config, _scalars, _convertName, _namespacedImportName, _enumNames, _enumPrefix, _enumSuffix, _enumValues, _applyCoercion) {
+        super(_scalars, _convertName, _namespacedImportName, _enumNames, _enumPrefix, _enumSuffix, _enumValues, _applyCoercion, {});
+        this._config = _config;
+    }
+    formatFieldString(fieldName, isNonNullType, hasDefaultValue) {
+        return `${fieldName}${this.getAvoidOption(isNonNullType, hasDefaultValue) ? '?' : ''}`;
+    }
     formatTypeString(fieldType, _isNonNullType, _hasDefaultValue) {
         return fieldType;
     }
+    clearOptional(str) {
+        const maybeSuffix = this._config.inputMaybeValue.replace('T', ''); // e.g. turns `T | null | undefined` to ` | null | undefined`
+        if (str.endsWith(maybeSuffix)) {
+            return (str = str.substring(0, str.length - maybeSuffix.length));
+        }
+        return str;
+    }
+    getAvoidOption(isNonNullType, hasDefaultValue) {
+        const options = this._config.avoidOptionals;
+        return (((options.variableValue || !options.defaultValue) && hasDefaultValue) ||
+            (!options.variableValue && !isNonNullType));
+    }
+    getScalar(name) {
+        return this._scalars[name]?.input ?? DEFAULT_INPUT_SCALARS[name].input ?? 'unknown';
+    }
+    getPunctuation() {
+        return ';';
+    }
+    wrapAstTypeWithModifiers(baseType, typeNode, applyCoercion = false) {
+        if (typeNode.kind === Kind.NON_NULL_TYPE) {
+            const type = this.wrapAstTypeWithModifiers(baseType, typeNode.type, applyCoercion);
+            return this.clearOptional(type);
+        }
+        if (typeNode.kind === Kind.LIST_TYPE) {
+            const innerType = this.wrapAstTypeWithModifiers(baseType, typeNode.type, applyCoercion);
+            const listInputCoercionExtension = applyCoercion ? ` | ${innerType}` : '';
+            return this.wrapMaybe(`${this._config.immutableTypes ? 'ReadonlyArray' : 'Array'}<${innerType}>${listInputCoercionExtension}`);
+        }
+        return this.wrapMaybe(baseType);
+    }
+    wrapMaybe(type) {
+        return printTypeScriptMaybeType({
+            type,
+            pattern: this._config.inputMaybeValue,
+        });
+    }
 }

package/esm/ts-selection-set-processor.js

@@ -23,15 +23,7 @@ export class TypeScriptSelectionSetProcessor extends BaseSelectionSetProcessor {
         });
         let resString = formattedUnionTransform('Pick', parentName, escapedFieldNames);
         if (hasConditionals) {
-            const avoidOptional = 
-            // TODO: check type and exec only if relevant
-            this.config.avoidOptionals === true ||
-                (typeof this.config.avoidOptionals === 'object' &&
-                    (this.config.avoidOptionals.field ||
-                        this.config.avoidOptionals.inputValue ||
-                        this.config.avoidOptionals.object));
-            const transform = avoidOptional ? 'MakeMaybe' : 'MakeOptional';
-            resString = `${this.config.namespacedImportName ? `${this.config.namespacedImportName}.` : ''}${formattedUnionTransform(transform, resString, escapedConditionalsList)}`;
+            resString = `${this.config.namespacedImportName ? `${this.config.namespacedImportName}.` : ''}${formattedUnionTransform('MakeOptional', resString, escapedConditionalsList)}`;
         }
         return [resString];
     }
@@ -47,7 +39,9 @@ export class TypeScriptSelectionSetProcessor extends BaseSelectionSetProcessor {
                 useTypesPrefix: true,
             });
         const selections = fields.map(aliasedField => {
-            const value = aliasedField.fieldName === '__typename' ? `'${schemaType.name}'` : `${parentName}['${aliasedField.fieldName}']`;
+            const value = aliasedField.fieldName === '__typename'
+                ? `'${schemaType.name}'`
+                : `${parentName}['${aliasedField.fieldName}']`;
             return `${aliasedField.alias}: ${value}`;
         });
         return [formatSelections(selections)];