@eddeee888/gcg-typescript-resolver-files 0.16.0 → 0.18.0

package/{src → dist}/parseTypeMappers/collectTypeMappersFromSourceFile.js

@@ -1,24 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.collectTypeMappersFromSourceFile = void 0;
-const tslib_1 = require("tslib");
-const path = tslib_1.__importStar(require("path"));
-const ts_morph_1 = require("ts-morph");
-const utils_1 = require("../utils");
-const collectTypeMappersFromSourceFile = ({ typeMappersSourceFile, typeMappersSuffix, resolverTypesPath, emitLegacyCommonJSImports, importExtension, }, result) => {
+import * as path from 'path';
+import { SyntaxKind } from 'ts-morph';
+import { normalizeRelativePath, normalizeImportExtension, } from '../utils/index.js';
+export const collectTypeMappersFromSourceFile = ({ typeMappersSourceFile, typeMappersSuffix, resolverTypesPath, emitLegacyCommonJSImports, importExtension, }, result) => {
     // Look for interfaces with exported keywords
     typeMappersSourceFile.getInterfaces().forEach((interfaceDeclaration) => {
         if (!interfaceDeclaration.hasExportKeyword()) {
             return;
         }
         addTypeMapperDetailsIfValid({
-            kind: ts_morph_1.SyntaxKind.InterfaceDeclaration,
+            kind: SyntaxKind.InterfaceDeclaration,
             identifierNode: interfaceDeclaration.getNameNode(),
             typeMappersSuffix,
             typeMappersFilePath: typeMappersSourceFile.getFilePath(),
             resolverTypesPath,
             emitLegacyCommonJSImports,
-            importExtension
+            importExtension,
         }, result);
     });
     // Look for exported types with exported keywords
@@ -28,13 +24,13 @@ const collectTypeMappersFromSourceFile = ({ typeMappersSourceFile, typeMappersSu
         }
         const identifierNode = typeAlias.getNameNode();
         addTypeMapperDetailsIfValid({
-            kind: ts_morph_1.SyntaxKind.TypeAliasDeclaration,
+            kind: SyntaxKind.TypeAliasDeclaration,
             identifierNode,
             typeMappersSuffix,
             typeMappersFilePath: typeMappersSourceFile.getFilePath(),
             resolverTypesPath,
             emitLegacyCommonJSImports,
-            importExtension
+            importExtension,
         }, result);
     });
     // Look for named exports e.g.
@@ -49,13 +45,13 @@ const collectTypeMappersFromSourceFile = ({ typeMappersSourceFile, typeMappersSu
                 identifierNode = aliasNode;
             }
             addTypeMapperDetailsIfValid({
-                kind: ts_morph_1.SyntaxKind.ExportSpecifier,
+                kind: SyntaxKind.ExportSpecifier,
                 identifierNode,
                 typeMappersSuffix,
                 typeMappersFilePath: typeMappersSourceFile.getFilePath(),
                 resolverTypesPath,
                 emitLegacyCommonJSImports,
-                importExtension
+                importExtension,
             }, result);
         });
     });
@@ -69,18 +65,17 @@ const collectTypeMappersFromSourceFile = ({ typeMappersSourceFile, typeMappersSu
             return;
         }
         addTypeMapperDetailsIfValid({
-            kind: ts_morph_1.SyntaxKind.ClassDeclaration,
+            kind: SyntaxKind.ClassDeclaration,
             identifierNode,
             typeMappersSuffix,
             typeMappersFilePath: typeMappersSourceFile.getFilePath(),
             resolverTypesPath,
             emitLegacyCommonJSImports,
-            importExtension
+            importExtension,
         }, result);
     });
 };
-exports.collectTypeMappersFromSourceFile = collectTypeMappersFromSourceFile;
-const addTypeMapperDetailsIfValid = ({ kind, identifierNode, typeMappersSuffix, typeMappersFilePath, resolverTypesPath, emitLegacyCommonJSImports, importExtension }, result) => {
+const addTypeMapperDetailsIfValid = ({ kind, identifierNode, typeMappersSuffix, typeMappersFilePath, resolverTypesPath, emitLegacyCommonJSImports, importExtension, }, result) => {
     const identifierName = identifierNode.getText();
     if (!identifierName.endsWith(typeMappersSuffix)) {
         return;
@@ -101,8 +96,8 @@ const addTypeMapperDetailsIfValid = ({ kind, identifierNode, typeMappersSuffix,
         .split(path.sep)
         .join(path.posix.sep);
     const parsedRelativePathFromResolverTypesToSourceFile = path.parse(relativePath);
-    const relativeImportPathFromResolverTypesToSourceFile = (0, utils_1.normalizeRelativePath)(path.posix.join(parsedRelativePathFromResolverTypesToSourceFile.dir, parsedRelativePathFromResolverTypesToSourceFile.name));
-    const fileExtension = (0, utils_1.normalizeImportExtension)(importExtension, emitLegacyCommonJSImports);
+    const relativeImportPathFromResolverTypesToSourceFile = normalizeRelativePath(path.posix.join(parsedRelativePathFromResolverTypesToSourceFile.dir, parsedRelativePathFromResolverTypesToSourceFile.name));
+    const fileExtension = normalizeImportExtension(importExtension, emitLegacyCommonJSImports);
     const configImportPath = `${relativeImportPathFromResolverTypesToSourceFile}${fileExtension}#${identifierName}`;
     if (result[schemaType]) {
         throw new Error(`GraphQL type "${schemaType}" has duplicated "${identifierName}" mappers:\n  - ${configImportPath}\n  - ${result[schemaType].configImportPath}`);
@@ -117,4 +112,3 @@ const addTypeMapperDetailsIfValid = ({ kind, identifierNode, typeMappersSuffix,
         configImportPath,
     };
 };
-//# sourceMappingURL=collectTypeMappersFromSourceFile.js.map

package/dist/parseTypeMappers/index.d.ts

@@ -0,0 +1 @@
+export * from './parseTypeMappers.js';

package/dist/parseTypeMappers/index.js

@@ -0,0 +1 @@
+export * from './parseTypeMappers.js';

package/{src → dist}/parseTypeMappers/parseTypeMappers.d.ts

@@ -1,6 +1,6 @@
 import type { Project, SyntaxKind } from 'ts-morph';
-import type { ParseSourcesResult } from '../parseSources';
-import type { ImportExtension } from '../utils';
+import type { ParseSourcesResult } from '../parseSources/index.js';
+import type { ImportExtension } from '../utils/index.js';
 export interface ParseTypeMappersParams {
     sourceMap: ParseSourcesResult['sourceMap'];
     resolverTypesPath: string;

package/dist/parseTypeMappers/parseTypeMappers.js

@@ -0,0 +1,20 @@
+import * as path from 'path';
+import { collectTypeMappersFromSourceFile } from './collectTypeMappersFromSourceFile.js';
+export const parseTypeMappers = ({ sourceMap, resolverTypesPath, typeMappersRelativeTargetDir, typeMappersFileExtension, typeMappersSuffix, tsMorphProject, emitLegacyCommonJSImports, importExtension, }) => {
+    const result = Object.entries(sourceMap).reduce((res, [_, { sourcePath }]) => {
+        const typeMapperFilePath = path.posix.join(sourcePath.dir, typeMappersRelativeTargetDir, `${sourcePath.name}${typeMappersFileExtension}`);
+        const typeMappersSourceFile = tsMorphProject.addSourceFileAtPathIfExists(typeMapperFilePath);
+        if (!typeMappersSourceFile) {
+            return res;
+        }
+        collectTypeMappersFromSourceFile({
+            typeMappersSourceFile,
+            typeMappersSuffix,
+            resolverTypesPath,
+            emitLegacyCommonJSImports,
+            importExtension,
+        }, res);
+        return res;
+    }, {});
+    return result;
+};

package/{src → dist}/preset.d.ts

@@ -1,4 +1,4 @@
 import { type Types } from '@graphql-codegen/plugin-helpers';
-import { type RawPresetConfig } from './validatePresetConfig';
+import { type RawPresetConfig } from './validatePresetConfig/index.js';
 export declare const presetName = "@eddeee888/gcg-typescript-resolver-files";
 export declare const preset: Types.OutputPreset<RawPresetConfig>;

package/dist/preset.js

@@ -0,0 +1,214 @@
+import * as path from 'path';
+import * as addPlugin from '@graphql-codegen/add';
+import * as schemaAstPlugin from '@graphql-codegen/schema-ast';
+import * as typeScriptPlugin from '@graphql-codegen/typescript';
+import { plugin as typeScriptResolversPlugin } from '@graphql-codegen/typescript-resolvers';
+import { createNoopProfiler, } from '@graphql-codegen/plugin-helpers';
+import { Project } from 'ts-morph';
+import { defineConfig as defineServerConfig } from '@eddeee888/gcg-server-config';
+import { parseSources } from './parseSources/index.js';
+import { parseGraphQLSchema } from './parseGraphQLSchema/index.js';
+import { generateResolverFiles, } from './generateResolverFiles/index.js';
+import { generateTypeDefsFiles } from './generateTypeDefsFiles/index.js';
+import { getGraphQLObjectTypeResolversToGenerate } from './getGraphQLObjectTypeResolversToGenerate/index.js';
+import { addVirtualTypesFileToTsMorphProject } from './addVirtualTypesFileToTsMorphProject/index.js';
+import { parseTypeMappers } from './parseTypeMappers/index.js';
+import { validatePresetConfig, } from './validatePresetConfig/index.js';
+import { validateAndMergeParsedConfigs } from './validateAndMergeParsedConfigs/index.js';
+import { normalizeAddConfigPath } from './normalizeAddConfigPath/index.js';
+import { logger } from './utils/index.js';
+export const presetName = '@eddeee888/gcg-typescript-resolver-files';
+export const preset = {
+    buildGeneratesSection: async ({ schema, schemaAst, presetConfig: rawPresetConfig, baseOutputDir, config: baseConfig, profiler = createNoopProfiler(), }) => {
+        if (!schemaAst) {
+            throw new Error('Missing schemaAst');
+        }
+        const sources = schemaAst.extensions.extendedSources;
+        if (!Array.isArray(sources) || sources.length === 0) {
+            throw new Error('Empty Sources. Make sure schema files are parsed correctly.');
+        }
+        const { add, resolverTypesPath: relativeResolverTypesPathFromBaseOutputDir, resolverRelativeTargetDir, mappersRelativeTargetDir: typeMappersRelativeTargetDir, mappersFileExtension: typeMappersFileExtension, mappersSuffix: typeMappersSuffix, resolverMainFile, resolverMainFileMode, resolverGeneration, typeDefsFilePath, typeDefsFileMode, mergeSchema, moduleNamingMode, scalarsModule, scalarsOverrides, mode, whitelistedModules, blacklistedModules, externalResolvers, typesPluginsConfig, tsMorphProjectOptions, fixObjectTypeResolvers, emitLegacyCommonJSImports, importExtension, } = validatePresetConfig(rawPresetConfig, baseConfig);
+        const resolverTypesPath = path.posix.join(baseOutputDir, relativeResolverTypesPathFromBaseOutputDir);
+        const normalizedAdd = normalizeAddConfigPath({ add, baseOutputDir });
+        const { sourceMap } = parseSources({
+            sources,
+            baseOutputDir,
+            moduleNamingMode,
+        });
+        const tsMorphProject = await profiler.run(async () => new Project(tsMorphProjectOptions), createProfilerRunName('Initialising ts-morph project'));
+        const typeMappersMap = await profiler.run(async () => parseTypeMappers({
+            sourceMap,
+            resolverTypesPath,
+            typeMappersRelativeTargetDir,
+            typeMappersFileExtension,
+            typeMappersSuffix,
+            tsMorphProject,
+            emitLegacyCommonJSImports,
+            importExtension,
+        }), createProfilerRunName('parseTypeMappers'));
+        const generatesSection = [];
+        const parsedGraphQLSchemaMeta = await profiler.run(async () => parseGraphQLSchema({
+            schemaAst,
+            sourceMap,
+            resolverTypesPath,
+            scalarsModule,
+            scalarsOverrides,
+            typeMappersMap,
+            mode,
+            baseOutputDir,
+            resolverRelativeTargetDir,
+            whitelistedModules,
+            blacklistedModules,
+        }), createProfilerRunName('parseGraphQLSchema'));
+        const mergedConfig = validateAndMergeParsedConfigs({
+            unmanagedNonScalarResolvers: externalResolvers,
+            parsedGraphQLSchemaMeta,
+        });
+        // typescript and typescript-resolvers plugins config
+        const resolverTypesConfig = defineServerConfig({
+            optionalResolveType: true,
+            resolversNonOptionalTypename: {
+                unionMember: true,
+                interfaceImplementingType: true,
+            },
+            namingConvention: 'keep',
+            emitLegacyCommonJSImports,
+            ...typesPluginsConfig,
+            scalars: mergedConfig.scalarTypes,
+            mappers: {
+                ...mergedConfig.typeMappers,
+                ...typesPluginsConfig.mappers,
+            },
+        });
+        // typesSourceFile is the virtual `types.generated.ts`
+        // This is useful when we need to do static analysis as most types come from this file
+        // e.g. comparing mappers field type vs schema object field type
+        const { typesSourceFile, meta: generatedTypesFileMeta } = await profiler.run(() => addVirtualTypesFileToTsMorphProject({
+            tsMorphProject,
+            schemaAst,
+            resolverTypesConfig,
+            resolverTypesPath,
+            addConfig: normalizedAdd?.[resolverTypesPath],
+        }), createProfilerRunName('addVirtualTypesFileToTsMorphProject'));
+        const graphQLObjectTypeResolversToGenerate = await profiler.run(async () => fixObjectTypeResolvers.object === 'disabled'
+            ? {}
+            : getGraphQLObjectTypeResolversToGenerate({
+                mode: fixObjectTypeResolvers.object,
+                tsMorphProject,
+                typesSourceFile,
+                userDefinedSchemaObjectTypeMap: mergedConfig.userDefinedSchemaTypeMap.object,
+                typeMappersMap,
+                generatedTypesFileMeta,
+            }), createProfilerRunName('getGraphQLObjectTypeResolversToGenerate'));
+        const resolverTypesFilePlugins = [
+            { typescript: {} },
+            { ['typescript-resolvers']: {} },
+        ];
+        if (normalizedAdd?.[resolverTypesPath]) {
+            resolverTypesFilePlugins.push({
+                add: normalizedAdd[resolverTypesPath],
+            });
+        }
+        const resolverTypesFile = {
+            filename: resolverTypesPath,
+            pluginMap: {
+                typescript: typeScriptPlugin,
+                'typescript-resolvers': { plugin: typeScriptResolversPlugin },
+                add: addPlugin,
+            },
+            plugins: resolverTypesFilePlugins,
+            config: resolverTypesConfig,
+            schema,
+            documents: [],
+        };
+        generatesSection.push(resolverTypesFile);
+        // typeDefs
+        if (typeDefsFilePath) {
+            const typeDefsFiles = await profiler.run(async () => {
+                return generateTypeDefsFiles({
+                    baseOutputDir,
+                    typeDefsFilePath,
+                    typeDefsFileMode,
+                    sourceMap,
+                    whitelistedModules,
+                    blacklistedModules,
+                });
+            }, createProfilerRunName('generateTypeDefsFiles'));
+            Object.entries(typeDefsFiles).forEach(([filename, meta]) => {
+                const typeDefsFile = {
+                    filename: filename,
+                    pluginMap: { add: addPlugin },
+                    plugins: [{ add: { content: meta.content } }],
+                    config: {},
+                    schema,
+                    documents: [],
+                };
+                generatesSection.push(typeDefsFile);
+            });
+        }
+        // merge schema
+        if (mergeSchema) {
+            generatesSection.push({
+                filename: path.posix.join(baseOutputDir, mergeSchema.path),
+                pluginMap: { ['schema-ast']: schemaAstPlugin },
+                plugins: [{ ['schema-ast']: {} }],
+                schema,
+                documents: [],
+                config: mergeSchema.config,
+            });
+        }
+        // resolver files
+        const result = {
+            files: {},
+            externalImports: {},
+        };
+        await profiler.run(async () => generateResolverFiles({
+            config: {
+                baseOutputDir,
+                resolverTypesPath,
+                resolverRelativeTargetDir,
+                resolverMainFile,
+                resolverMainFileMode,
+                resolverGeneration,
+                typeMappersMap,
+                parsedGraphQLSchemaMeta,
+                graphQLObjectTypeResolversToGenerate,
+                tsMorph: {
+                    project: tsMorphProject,
+                    typesSourceFile,
+                },
+                fixObjectTypeResolvers,
+                unmanagedResolvers: {
+                    ...mergedConfig.unmanagedResolvers,
+                },
+                emitLegacyCommonJSImports,
+                importExtension,
+                generatedTypesFileMeta,
+            },
+            result,
+        }), createProfilerRunName('generateResolverFiles'));
+        const resultFilesArray = Object.entries(result.files);
+        const resolverFilesGenerateOptions = resultFilesArray
+            .filter(([_, file]) => {
+            // Only generate files that are:
+            // 1. `virtual` - because file doesn't exist yet
+            // 2. on `filesystem` and with `contentUpdated` - because file content has been updated, so we want to apply the changes
+            return (file.filesystem.type === 'virtual' ||
+                (file.filesystem.type === 'filesystem' &&
+                    file.filesystem.contentUpdated === true));
+        })
+            .map(([filename, { content }]) => {
+            return {
+                filename,
+                pluginMap: { add: addPlugin },
+                plugins: [{ add: { content } }],
+                config: {},
+                schema,
+                documents: [],
+            };
+        });
+        logger.debug(`Applying changes to ${resolverFilesGenerateOptions.length}/${resultFilesArray.length} files. (${resultFilesArray.length - resolverFilesGenerateOptions.length} skipped files because they are already on filesystem and are not updated)`);
+        return [...resolverFilesGenerateOptions, ...generatesSection];
+    },
+};
+const createProfilerRunName = (traceName) => `[${presetName}]: ${traceName}`;