@graphql-mesh/incontext-sdk-codegen/esm/codegenPlugin.js

import { resolvers } from 'graphql-scalars';
import { getCachedDocumentNodeFromSchema, } from '@graphql-codegen/plugin-helpers';
import { path } from '@graphql-mesh/cross-helpers';
import { handleFederationSupergraph } from '@graphql-mesh/fusion-runtime';
import { defaultPrintFn } from '@graphql-mesh/transport-common';
import { writeFile } from '@graphql-mesh/utils';
import { MapperKind, mapSchema } from '@graphql-tools/utils';
import { wrapSchema } from '@graphql-tools/wrap';
import { generateIncontextSDKTypes, generateUnifiedContextTypeFromIdentifiers, } from './generateIncontextSDKTypes.js';
export const codegenPlugin = {
    async plugin(unifiedGraph, _documents, config, info) {
        const outputFileDirName = info.outputFile ? path.dirname(info.outputFile) : process.cwd();
        const { inContextSDK, getSubschema } = handleFederationSupergraph({
            unifiedGraph,
            getUnifiedGraphSDL() {
                return defaultPrintFn(getCachedDocumentNodeFromSchema(unifiedGraph));
            },
            onSubgraphExecute(subgraphName, executionRequest) {
                return {};
            },
        });
        const imports = new Set();
        const identifiers = new Set();
        for (const sourceName in inContextSDK) {
            const subschemaConfig = getSubschema(sourceName);
            const transformedSchema = mapSchema(wrapSchema(subschemaConfig), {
                [MapperKind.ROOT_FIELD](_, fieldName) {
                    if (fieldName === '_entities') {
                        return null;
                    }
                },
            });
            const scalarTypes = {};
            for (const scalarName in resolvers) {
                if (transformedSchema.getType(scalarName)) {
                    const codegenScalarType = resolvers[scalarName]?.extensions?.codegenScalarType;
                    if (typeof codegenScalarType === 'string') {
                        scalarTypes[scalarName] = codegenScalarType;
                    }
                }
            }
            const typesResult = await generateIncontextSDKTypes({
                schema: transformedSchema,
                name: sourceName,
                contextVariables: {},
                flattenTypes: false,
                codegenConfig: {
                    scalars: scalarTypes,
                    skipTypename: false,
                    nonOptionalTypename: true,
                    useTypeImports: true,
                    ...config,
                },
                unifiedContextIdentifier: '{}',
            });
            identifiers.add(typesResult.identifier);
            const targetPath = `./subgraphs/${sourceName}`;
            imports.add(`import type { ${typesResult.identifier} } from '${targetPath}';`);
            await writeFile(path.join(outputFileDirName, targetPath + '.ts'), typesResult.codeAst);
        }
        const unifiedContextType = generateUnifiedContextTypeFromIdentifiers([...identifiers]);
        const content = `
${[...imports].join('\n')}

${unifiedContextType}
`;
        return {
            content,
        };
    },
};