@eddeee888/gcg-typescript-resolver-files 0.17.0 → 0.18.1

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}`;

package/dist/utils/cwd.js

@@ -0,0 +1,7 @@
+import * as path from 'path';
+/**
+ * It is process.cwd() but normalised for all OS
+ */
+export const cwd = () => {
+    return process.cwd().split(path.sep).join(path.posix.sep);
+};

package/dist/utils/fmt.js

@@ -0,0 +1,15 @@
+import { presetName } from '../preset.js';
+/**
+ * Shared message formatter
+ */
+export const fmt = {
+    error: (input, type) => {
+        return `[${presetName}] \x1b[31mERROR:\x1b[0m ${type} - ${input}`;
+    },
+    warn: (input) => {
+        return `[${presetName}] \x1b[33mWARN:\x1b[0m ${input}`;
+    },
+    debug: (input) => {
+        return `[${presetName}] \x1b[35mDEBUG:\x1b[0m ${input}`;
+    },
+};

package/dist/utils/index.d.ts

@@ -0,0 +1,12 @@
+export * from './cwd.js';
+export * from './logger.js';
+export * from './fmt.js';
+export * from './parseLocationForWhitelistedModule.js';
+export * from './isNativeNamedType.js';
+export * from './isRootObjectType.js';
+export * from './isWhitelistedModule.js';
+export * from './printImportLine.js';
+export * from './normalizeRelativePath.js';
+export * from './relativeModulePath.js';
+export * from './isMatchResolverNamePattern.js';
+export * from './normalizeImportExtension.js';

package/dist/utils/index.js

@@ -0,0 +1,12 @@
+export * from './cwd.js';
+export * from './logger.js';
+export * from './fmt.js';
+export * from './parseLocationForWhitelistedModule.js';
+export * from './isNativeNamedType.js';
+export * from './isRootObjectType.js';
+export * from './isWhitelistedModule.js';
+export * from './printImportLine.js';
+export * from './normalizeRelativePath.js';
+export * from './relativeModulePath.js';
+export * from './isMatchResolverNamePattern.js';
+export * from './normalizeImportExtension.js';

package/{src → dist}/utils/isMatchResolverNamePattern.js

@@ -1,15 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isMatchResolverNamePattern = void 0;
-const tslib_1 = require("tslib");
-const micromatch_1 = tslib_1.__importDefault(require("micromatch"));
+import micromatch from 'micromatch';
 /**
  * @description Wrapper function to return true if `value` matches on of the `pattern`s
  */
-const isMatchResolverNamePattern = ({ pattern, value, }) => {
+export const isMatchResolverNamePattern = ({ pattern, value, }) => {
     const normalizedPatterns = typeof pattern === 'string' ? [pattern] : pattern;
     const nonEmptyNormalizedPatterns = normalizedPatterns.filter(Boolean);
-    const matchedValues = (0, micromatch_1.default)([value], nonEmptyNormalizedPatterns, {
+    const matchedValues = micromatch([value], nonEmptyNormalizedPatterns, {
         // `micromatch` mainly matches filesystems whilst we want this function
         // to match object-like path pattern e.g.
         // - `book.Query.books`
@@ -20,5 +16,3 @@ const isMatchResolverNamePattern = ({ pattern, value, }) => {
     });
     return matchedValues.length > 0;
 };
-exports.isMatchResolverNamePattern = isMatchResolverNamePattern;
-//# sourceMappingURL=isMatchResolverNamePattern.js.map

package/dist/utils/isNativeNamedType.js

@@ -0,0 +1,13 @@
+import { isIntrospectionType, isSpecifiedScalarType, } from 'graphql';
+export const isNativeNamedType = (namedType) => {
+    // "Native" NamedType in this context means the following:
+    // 1. introspection types i.e. with `__` prefixes
+    // 2. base scalars e.g. Boolean, Int, etc.
+    // 3. Other natives (mostly base scalars) which was not defined in the schema i.e. no `astNode`
+    if (isSpecifiedScalarType(namedType) ||
+        isIntrospectionType(namedType) ||
+        !namedType.astNode) {
+        return true;
+    }
+    return false;
+};

package/dist/utils/isRootObjectType.js

@@ -0,0 +1,3 @@
+export const isRootObjectType = (typeName) => typeName === 'Query' ||
+    typeName === 'Mutation' ||
+    typeName === 'Subscription';

package/{src → dist}/utils/isWhitelistedModule.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isWhitelistedModule = void 0;
-const isWhitelistedModule = ({ moduleName, whitelistedModules, blacklistedModules, }) => {
+export const isWhitelistedModule = ({ moduleName, whitelistedModules, blacklistedModules, }) => {
     if (blacklistedModules.includes(moduleName)) {
         return false;
     }
@@ -12,5 +9,3 @@ const isWhitelistedModule = ({ moduleName, whitelistedModules, blacklistedModule
         : whitelistedModules.includes(moduleName);
     return isInWhitelistedModule;
 };
-exports.isWhitelistedModule = isWhitelistedModule;
-//# sourceMappingURL=isWhitelistedModule.js.map

package/{src → dist}/utils/logger.d.ts

@@ -1,4 +1,4 @@
-import { fmt } from './fmt';
+import { fmt } from './fmt.js';
 export declare const logger: {
     debug: (input: string) => void;
     warn: (input: string) => void;

package/dist/utils/logger.js

@@ -0,0 +1,13 @@
+import { presetName } from '../preset.js';
+import { fmt } from './fmt.js';
+export const logger = {
+    debug: (...args) => {
+        const debugEnvVar = process.env.DEBUG || '';
+        if (debugEnvVar.includes(presetName)) {
+            console.debug(`\x1b[34m${fmt.debug(...args)}`);
+        }
+    },
+    warn: (...args) => {
+        console.warn(`\x1b[34m${fmt.warn(...args)}`);
+    },
+};

package/dist/utils/normalizeImportExtension.js

@@ -0,0 +1,9 @@
+export function normalizeImportExtension(importExtension, emitLegacyCommonJSImports) {
+    if (importExtension !== undefined) {
+        return importExtension;
+    }
+    if (emitLegacyCommonJSImports !== undefined) {
+        return emitLegacyCommonJSImports ? '' : '.js';
+    }
+    return '';
+}

package/dist/utils/normalizeRelativePath.js

@@ -0,0 +1,6 @@
+export const normalizeRelativePath = (path) => {
+    if (!path.startsWith('../') || !path.startsWith('./')) {
+        return `./${path}`;
+    }
+    return path;
+};

package/{src → dist}/utils/parseLocationForWhitelistedModule.d.ts

@@ -1,5 +1,5 @@
 import type { Location } from 'graphql';
-import type { ParseSourcesResult, ParsedSource } from '../parseSources';
+import type { ParseSourcesResult, ParsedSource } from '../parseSources/index.js';
 export interface ParseLocationForWhitelistedModule {
     location: Location | undefined;
     sourceMap: ParseSourcesResult['sourceMap'];

package/dist/utils/parseLocationForWhitelistedModule.js

@@ -0,0 +1,17 @@
+import { isWhitelistedModule } from './isWhitelistedModule.js';
+export const parseLocationForWhitelistedModule = ({ location, sourceMap, whitelistedModules, blacklistedModules, }) => {
+    if (!location) {
+        throw new Error('Location is invalid');
+    }
+    const sourceFilename = location.source.name;
+    const sourceFile = sourceMap[sourceFilename];
+    if (!sourceFile) {
+        throw new Error(`Unable to find ${sourceFilename} in sourceMap`);
+    }
+    const isWhitelisted = isWhitelistedModule({
+        moduleName: sourceFile.moduleName,
+        whitelistedModules,
+        blacklistedModules,
+    });
+    return isWhitelisted ? sourceFile : undefined;
+};

package/{src → dist}/utils/printImportLine.d.ts

@@ -1,4 +1,4 @@
-import { type ImportExtension } from "./normalizeImportExtension";
+import { type ImportExtension } from './normalizeImportExtension.js';
 export interface ImportLineMeta {
     isTypeImport: boolean;
     module: string;

package/{src → dist}/utils/printImportLine.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.printImportLine = printImportLine;
-const normalizeImportExtension_1 = require("./normalizeImportExtension");
-function printImportLine({ isTypeImport, module, moduleType, namedImports, defaultImport, emitLegacyCommonJSImports, importExtension, }) {
+import { normalizeImportExtension, } from './normalizeImportExtension.js';
+export function printImportLine({ isTypeImport, module, moduleType, namedImports, defaultImport, emitLegacyCommonJSImports, importExtension, }) {
     const typeImportKeyword = isTypeImport ? 'type' : '';
     const hasDefaultImport = Boolean(defaultImport);
     const hasNamedImports = namedImports.length > 0;
@@ -13,7 +10,7 @@ function printImportLine({ isTypeImport, module, moduleType, namedImports, defau
     if (moduleType !== 'preserve') {
         const isFile = moduleType === 'file';
         if (isFile) {
-            fileExt = (0, normalizeImportExtension_1.normalizeImportExtension)(importExtension, emitLegacyCommonJSImports);
+            fileExt = normalizeImportExtension(importExtension, emitLegacyCommonJSImports);
         }
     }
     return `import ${typeImportKeyword} ${defaultImport || ''} ${hasDefaultImport && hasNamedImports ? ',' : ''} ${namedImportsString} from '${normalizeModuleExtensionForImport(module)}${fileExt}';`;
@@ -33,4 +30,3 @@ const printNamedImportSpecifier = (namedImport) => {
     }
     return `${namedImport.propertyName} as ${namedImport.identifierName}`;
 };
-//# sourceMappingURL=printImportLine.js.map

package/dist/utils/relativeModulePath.js

@@ -0,0 +1,6 @@
+import * as path from 'path';
+import { normalizeRelativePath } from './normalizeRelativePath.js';
+export const relativeModulePath = (from, to) => {
+    const rawPath = path.posix.relative(from, to);
+    return normalizeRelativePath(rawPath);
+};

package/dist/validateAndMergeParsedConfigs/index.d.ts

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

package/dist/validateAndMergeParsedConfigs/index.js

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

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

@@ -1,5 +1,5 @@
-import type { ParsedGraphQLSchemaMeta } from '../parseGraphQLSchema';
-import type { ParsedPresetConfig, ScalarsOverridesType } from '../validatePresetConfig';
+import type { ParsedGraphQLSchemaMeta } from '../parseGraphQLSchema/index.js';
+import type { ParsedPresetConfig, ScalarsOverridesType } from '../validatePresetConfig/index.js';
 interface MergedConfig {
     userDefinedSchemaTypeMap: ParsedGraphQLSchemaMeta['userDefinedSchemaTypeMap'];
     scalarTypes: Record<string, ScalarsOverridesType>;

package/{src → dist}/validateAndMergeParsedConfigs/validateAndMergeParsedConfigs.js

@@ -1,19 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateAndMergeParsedConfigs = void 0;
-const utils_1 = require("../utils");
+import { fmt } from '../utils/index.js';
 /**
  * validateAndMergeParsedConfigs is used to make sure all parsed configs do not incorrectly override each other.
  * Use this to ensure there's only one way of doing something. e.g.
  *   - scalarsOverrides must be used over externalResolvers to override scalars
  */
-const validateAndMergeParsedConfigs = ({ unmanagedNonScalarResolvers, parsedGraphQLSchemaMeta: { userDefinedSchemaTypeMap, pluginsConfig: { scalarsModuleResolvers, unmanagedScalarResolvers, defaultScalarTypesMap, defaultTypeMappers, }, }, }) => {
+export const validateAndMergeParsedConfigs = ({ unmanagedNonScalarResolvers, parsedGraphQLSchemaMeta: { userDefinedSchemaTypeMap, pluginsConfig: { scalarsModuleResolvers, unmanagedScalarResolvers, defaultScalarTypesMap, defaultTypeMappers, }, }, }) => {
     Object.keys(scalarsModuleResolvers).forEach((schemaType) => {
-        var _a;
         if (
         // If the scalar is defined on the filesystem, it means user wants to use their custom definition.
         // This means we should use it, instead of importing it from scalar module
-        (_a = userDefinedSchemaTypeMap.scalar[schemaType]) === null || _a === void 0 ? void 0 : _a.resolverFile.isOnFilesystem) {
+        userDefinedSchemaTypeMap.scalar[schemaType]?.resolverFile.isOnFilesystem) {
             delete scalarsModuleResolvers[schemaType];
         }
     });
@@ -27,15 +23,22 @@ const validateAndMergeParsedConfigs = ({ unmanagedNonScalarResolvers, parsedGrap
     }, {});
     Object.keys(unmanagedNonScalarResolvers).forEach((schemaType) => {
         if (userDefinedSchemaTypeMap.scalar[schemaType]) {
-            throw new Error(utils_1.fmt.error(`Scalar "${schemaType}" found in presetConfig.externalResolvers. Use presetConfig.scalarsOverrides to override scalar implementation and type. Remove "${schemaType}" from presetConfig.externalResolvers.`, 'Validation'));
+            throw new Error(fmt.error(`Scalar "${schemaType}" found in presetConfig.externalResolvers. Use presetConfig.scalarsOverrides to override scalar implementation and type. Remove "${schemaType}" from presetConfig.externalResolvers.`, 'Validation'));
         }
     });
     return {
         userDefinedSchemaTypeMap,
-        scalarTypes: Object.assign({}, defaultScalarTypesMap),
-        typeMappers: Object.assign(Object.assign({}, schemaEnumTypeMappers), defaultTypeMappers),
-        unmanagedResolvers: Object.assign(Object.assign(Object.assign({}, unmanagedNonScalarResolvers), scalarsModuleResolvers), unmanagedScalarResolvers),
+        scalarTypes: {
+            ...defaultScalarTypesMap,
+        },
+        typeMappers: {
+            ...schemaEnumTypeMappers,
+            ...defaultTypeMappers,
+        },
+        unmanagedResolvers: {
+            ...unmanagedNonScalarResolvers,
+            ...scalarsModuleResolvers,
+            ...unmanagedScalarResolvers,
+        },
     };
 };
-exports.validateAndMergeParsedConfigs = validateAndMergeParsedConfigs;
-//# sourceMappingURL=validateAndMergeParsedConfigs.js.map