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

package/{src → dist}/generateResolverFiles/handleGraphQLInterfaceType.js

@@ -1,24 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleGraphQLInterfaceType = void 0;
-const utils_1 = require("../utils");
-const handleGraphQLInterfaceType = ({ fieldFilePath, isFileAlreadyOnFilesystem, resolverName, normalizedResolverName, resolversTypeMeta, moduleName, relativePathFromBaseToModule, }, { result, config: { resolverGeneration, emitLegacyCommonJSImports, importExtension } }) => {
-    if (!(0, utils_1.isMatchResolverNamePattern)({
+import { printImportLine, isMatchResolverNamePattern, logger, } from '../utils/index.js';
+export const handleGraphQLInterfaceType = ({ fieldFilePath, isFileAlreadyOnFilesystem, resolverName, normalizedResolverName, resolversTypeMeta, moduleName, relativePathFromBaseToModule, }, { result, config: { resolverGeneration, emitLegacyCommonJSImports, importExtension }, }) => {
+    if (!isMatchResolverNamePattern({
         pattern: resolverGeneration.interface,
         value: normalizedResolverName.withModule,
     }) &&
         !isFileAlreadyOnFilesystem) {
-        utils_1.logger.debug(`Skipped Interface resolver generation: "${normalizedResolverName.withModule}". Pattern: "${resolverGeneration.interface}".`);
+        logger.debug(`Skipped Interface resolver generation: "${normalizedResolverName.withModule}". Pattern: "${resolverGeneration.interface}".`);
         return;
     }
     const resolverTypeString = resolversTypeMeta.typeString;
-    const resolverTypeImportDeclaration = (0, utils_1.printImportLine)({
+    const resolverTypeImportDeclaration = printImportLine({
         isTypeImport: true,
         module: resolversTypeMeta.module,
         moduleType: resolversTypeMeta.moduleType,
         namedImports: [resolversTypeMeta.typeNamedImport],
         emitLegacyCommonJSImports,
-        importExtension
+        importExtension,
     });
     const variableStatement = `export const ${resolverName}: ${resolverTypeString} = { /* Implement ${resolverName} interface logic here */ };`;
     result.files[fieldFilePath] = {
@@ -44,5 +41,3 @@ const handleGraphQLInterfaceType = ({ fieldFilePath, isFileAlreadyOnFilesystem,
         },
     };
 };
-exports.handleGraphQLInterfaceType = handleGraphQLInterfaceType;
-//# sourceMappingURL=handleGraphQLInterfaceType.js.map

package/{src → dist}/generateResolverFiles/handleGraphQLObjectType.d.ts

@@ -1,4 +1,4 @@
-import type { GraphQLTypeHandler } from './types';
+import type { GraphQLTypeHandler } from './types.js';
 export declare const handleGraphQLObjectType: GraphQLTypeHandler<null, {
     fieldsToPick?: string[];
 }>;

package/{src → dist}/generateResolverFiles/handleGraphQLObjectType.js

@@ -1,11 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleGraphQLObjectType = void 0;
-const utils_1 = require("../utils");
-const handleGraphQLObjectType = ({ fieldFilePath, resolverName, isFileAlreadyOnFilesystem, normalizedResolverName, resolversTypeMeta, moduleName, relativePathFromBaseToModule, fieldsToPick = [], // If fieldsToPick.length === 0, it means the current object handles all resolvers
+import { printImportLine, isMatchResolverNamePattern, logger, } from '../utils/index.js';
+export const handleGraphQLObjectType = ({ fieldFilePath, resolverName, isFileAlreadyOnFilesystem, normalizedResolverName, resolversTypeMeta, moduleName, relativePathFromBaseToModule, fieldsToPick = [], // If fieldsToPick.length === 0, it means the current object handles all resolvers
 generatedTypesFileMeta, }, { result, config: { resolverGeneration, typeMappersMap, graphQLObjectTypeResolversToGenerate, emitLegacyCommonJSImports, importExtension, }, }) => {
-    var _a;
-    const matchedPatternToGenerate = (0, utils_1.isMatchResolverNamePattern)({
+    const matchedPatternToGenerate = isMatchResolverNamePattern({
         pattern: resolverGeneration.object,
         value: normalizedResolverName.withModule,
     });
@@ -13,12 +9,12 @@ generatedTypesFileMeta, }, { result, config: { resolverGeneration, typeMappersMa
     if (!matchedPatternToGenerate &&
         !mapperDetails &&
         !isFileAlreadyOnFilesystem) {
-        utils_1.logger.debug(`Skipped Object resolver generation: "${normalizedResolverName.withModule}". "Pattern: ${resolverGeneration.object}".`);
+        logger.debug(`Skipped Object resolver generation: "${normalizedResolverName.withModule}". "Pattern: ${resolverGeneration.object}".`);
         return;
     }
     const forcedGenerationWarning = (() => {
         if (!matchedPatternToGenerate && mapperDetails) {
-            utils_1.logger.debug(`Object resolver generation was NOT skipped because there is a associated mapper: "${normalizedResolverName.withModule}". "Pattern: ${resolverGeneration.object}". Mapper: ${mapperDetails.mapper.name}`);
+            logger.debug(`Object resolver generation was NOT skipped because there is a associated mapper: "${normalizedResolverName.withModule}". "Pattern: ${resolverGeneration.object}". Mapper: ${mapperDetails.mapper.name}`);
             return `/*
     * Note: This object type is generated because "${mapperDetails.mapper.name}" is declared. This is to ensure runtime safety.
     *
@@ -39,7 +35,7 @@ generatedTypesFileMeta, }, { result, config: { resolverGeneration, typeMappersMa
         fieldsToPick.push('__isTypeOf');
     }
     if (hasFieldsToPick &&
-        ((_a = generatedTypesFileMeta.generatedResolverTypes.userDefined[normalizedResolverName.base].federation) === null || _a === void 0 ? void 0 : _a.hasResolveReference)) {
+        generatedTypesFileMeta.generatedResolverTypes.userDefined[normalizedResolverName.base].federation?.hasResolveReference) {
         fieldsToPick.push('__resolveReference');
     }
     // - `typeString` contains the resolver type
@@ -79,13 +75,13 @@ generatedTypesFileMeta, }, { result, config: { resolverGeneration, typeMappersMa
     const variableStatement = `${forcedGenerationWarning}export const ${resolverName}: ${typeString} = {
     /* Implement ${resolverName} resolver logic here */
   };`;
-    const resolverTypeImportDeclaration = (0, utils_1.printImportLine)({
+    const resolverTypeImportDeclaration = printImportLine({
         isTypeImport: true,
         module: resolversTypeMeta.module,
         moduleType: resolversTypeMeta.moduleType,
         namedImports: [resolversTypeMeta.typeNamedImport],
         emitLegacyCommonJSImports,
-        importExtension
+        importExtension,
     });
     result.files[fieldFilePath] = {
         __filetype: 'objectType',
@@ -112,5 +108,3 @@ generatedTypesFileMeta, }, { result, config: { resolverGeneration, typeMappersMa
         },
     };
 };
-exports.handleGraphQLObjectType = handleGraphQLObjectType;
-//# sourceMappingURL=handleGraphQLObjectType.js.map

package/dist/generateResolverFiles/handleGraphQLRootObjectTypeField.d.ts

@@ -0,0 +1,3 @@
+import { type RootObjectType } from '../utils/index.js';
+import type { GraphQLTypeHandler } from './types.js';
+export declare const handleGraphQLRootObjectTypeField: GraphQLTypeHandler<RootObjectType>;

package/{src → dist}/generateResolverFiles/handleGraphQLRootObjectTypeField.js

@@ -1,22 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleGraphQLRootObjectTypeField = void 0;
-const utils_1 = require("../utils");
-const handleGraphQLRootObjectTypeField = ({ fieldFilePath, isFileAlreadyOnFilesystem, resolverName, belongsToRootObject, normalizedResolverName, resolversTypeMeta, moduleName, relativePathFromBaseToModule, }, { result, config: { resolverGeneration, emitLegacyCommonJSImports, importExtension } }) => {
+import { printImportLine, isMatchResolverNamePattern, logger, } from '../utils/index.js';
+export const handleGraphQLRootObjectTypeField = ({ fieldFilePath, isFileAlreadyOnFilesystem, resolverName, belongsToRootObject, normalizedResolverName, resolversTypeMeta, moduleName, relativePathFromBaseToModule, }, { result, config: { resolverGeneration, emitLegacyCommonJSImports, importExtension }, }) => {
     if ((belongsToRootObject === 'Query' &&
-        !(0, utils_1.isMatchResolverNamePattern)({
+        !isMatchResolverNamePattern({
             pattern: resolverGeneration.query,
             value: normalizedResolverName.withModule,
         }) &&
         !isFileAlreadyOnFilesystem) ||
         (belongsToRootObject === 'Mutation' &&
-            !(0, utils_1.isMatchResolverNamePattern)({
+            !isMatchResolverNamePattern({
                 pattern: resolverGeneration.mutation,
                 value: normalizedResolverName.withModule,
             }) &&
             !isFileAlreadyOnFilesystem) ||
         (belongsToRootObject === 'Subscription' &&
-            !(0, utils_1.isMatchResolverNamePattern)({
+            !isMatchResolverNamePattern({
                 pattern: resolverGeneration.subscription,
                 value: normalizedResolverName.withModule,
             }) &&
@@ -28,7 +25,7 @@ const handleGraphQLRootObjectTypeField = ({ fieldFilePath, isFileAlreadyOnFilesy
                 : belongsToRootObject === 'Subscription'
                     ? resolverGeneration.subscription
                     : 'Unknown';
-        utils_1.logger.debug(`Skipped ${belongsToRootObject} resolver generation: "${normalizedResolverName.withModule}". Pattern: "${resolverGenerationPattern}".`);
+        logger.debug(`Skipped ${belongsToRootObject} resolver generation: "${normalizedResolverName.withModule}". Pattern: "${resolverGenerationPattern}".`);
         return;
     }
     const suggestion = `/* Implement ${normalizedResolverName.base} resolver logic here */`;
@@ -39,13 +36,13 @@ const handleGraphQLRootObjectTypeField = ({ fieldFilePath, isFileAlreadyOnFilesy
       subscribe: async (_parent, _arg, _ctx) => { ${suggestion} },
     }`;
     }
-    const resolverTypeImportDeclaration = (0, utils_1.printImportLine)({
+    const resolverTypeImportDeclaration = printImportLine({
         isTypeImport: true,
         module: resolversTypeMeta.module,
         moduleType: resolversTypeMeta.moduleType,
         namedImports: [resolversTypeMeta.typeNamedImport],
         emitLegacyCommonJSImports,
-        importExtension
+        importExtension,
     });
     result.files[fieldFilePath] = {
         __filetype: 'rootObjectTypeFieldResolver',
@@ -72,5 +69,3 @@ const handleGraphQLRootObjectTypeField = ({ fieldFilePath, isFileAlreadyOnFilesy
         },
     };
 };
-exports.handleGraphQLRootObjectTypeField = handleGraphQLRootObjectTypeField;
-//# sourceMappingURL=handleGraphQLRootObjectTypeField.js.map

package/{src → dist}/generateResolverFiles/handleGraphQLScalarType.d.ts

@@ -1,2 +1,2 @@
-import type { GraphQLTypeHandler } from './types';
+import type { GraphQLTypeHandler } from './types.js';
 export declare const handleGraphQLScalarType: GraphQLTypeHandler;

package/{src → dist}/generateResolverFiles/handleGraphQLScalarType.js

@@ -1,24 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleGraphQLScalarType = void 0;
-const utils_1 = require("../utils");
+import { printImportLine, isMatchResolverNamePattern, logger, } from '../utils/index.js';
 const graphQLScalarType = 'GraphQLScalarType';
-const handleGraphQLScalarType = ({ fieldFilePath, isFileAlreadyOnFilesystem, resolverName, normalizedResolverName, moduleName, relativePathFromBaseToModule, }, { result, config: { resolverGeneration, emitLegacyCommonJSImports, importExtension } }) => {
-    if (!(0, utils_1.isMatchResolverNamePattern)({
+export const handleGraphQLScalarType = ({ fieldFilePath, isFileAlreadyOnFilesystem, resolverName, normalizedResolverName, moduleName, relativePathFromBaseToModule, }, { result, config: { resolverGeneration, emitLegacyCommonJSImports, importExtension }, }) => {
+    if (!isMatchResolverNamePattern({
         pattern: resolverGeneration.scalar,
         value: normalizedResolverName.withModule,
     }) &&
         !isFileAlreadyOnFilesystem) {
-        utils_1.logger.debug(`Skipped Scalar resolver generation: "${normalizedResolverName.withModule}". Pattern: "${resolverGeneration.scalar}".`);
+        logger.debug(`Skipped Scalar resolver generation: "${normalizedResolverName.withModule}". Pattern: "${resolverGeneration.scalar}".`);
         return;
     }
-    const resolverTypeImportDeclaration = (0, utils_1.printImportLine)({
+    const resolverTypeImportDeclaration = printImportLine({
         isTypeImport: false,
         module: 'graphql',
         moduleType: 'module',
         namedImports: [graphQLScalarType],
         emitLegacyCommonJSImports,
-        importExtension
+        importExtension,
     });
     const variableStatement = `export const ${resolverName} = new ${graphQLScalarType}({
     name: '${resolverName}',
@@ -56,5 +53,3 @@ const handleGraphQLScalarType = ({ fieldFilePath, isFileAlreadyOnFilesystem, res
         },
     };
 };
-exports.handleGraphQLScalarType = handleGraphQLScalarType;
-//# sourceMappingURL=handleGraphQLScalarType.js.map

package/{src → dist}/generateResolverFiles/handleGraphQLUnionType.d.ts

@@ -1,2 +1,2 @@
-import type { GraphQLTypeHandler } from './types';
+import type { GraphQLTypeHandler } from './types.js';
 export declare const handleGraphQLUnionType: GraphQLTypeHandler;

package/{src → dist}/generateResolverFiles/handleGraphQLUnionType.js

@@ -1,17 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleGraphQLUnionType = void 0;
-const utils_1 = require("../utils");
-const handleGraphQLUnionType = ({ fieldFilePath, isFileAlreadyOnFilesystem, resolverName, normalizedResolverName, resolversTypeMeta, moduleName, relativePathFromBaseToModule, }, { result, config: { resolverGeneration, emitLegacyCommonJSImports, importExtension } }) => {
-    if (!(0, utils_1.isMatchResolverNamePattern)({
+import { printImportLine, isMatchResolverNamePattern, logger, } from '../utils/index.js';
+export const handleGraphQLUnionType = ({ fieldFilePath, isFileAlreadyOnFilesystem, resolverName, normalizedResolverName, resolversTypeMeta, moduleName, relativePathFromBaseToModule, }, { result, config: { resolverGeneration, emitLegacyCommonJSImports, importExtension }, }) => {
+    if (!isMatchResolverNamePattern({
         pattern: resolverGeneration.union,
         value: normalizedResolverName.withModule,
     }) &&
         !isFileAlreadyOnFilesystem) {
-        utils_1.logger.debug(`Skipped Union resolver generation: "${normalizedResolverName.withModule}". Pattern: "${resolverGeneration.union}".`);
+        logger.debug(`Skipped Union resolver generation: "${normalizedResolverName.withModule}". Pattern: "${resolverGeneration.union}".`);
         return;
     }
-    const resolverTypeImportDeclaration = (0, utils_1.printImportLine)({
+    const resolverTypeImportDeclaration = printImportLine({
         isTypeImport: true,
         module: resolversTypeMeta.module,
         moduleType: resolversTypeMeta.moduleType,
@@ -43,5 +40,3 @@ const handleGraphQLUnionType = ({ fieldFilePath, isFileAlreadyOnFilesystem, reso
         },
     };
 };
-exports.handleGraphQLUnionType = handleGraphQLUnionType;
-//# sourceMappingURL=handleGraphQLUnionType.js.map

package/dist/generateResolverFiles/index.d.ts

@@ -0,0 +1,2 @@
+export { generateResolverFiles } from './generateResolverFiles.js';
+export type * from './types.js';

package/dist/generateResolverFiles/index.js

@@ -0,0 +1 @@
+export { generateResolverFiles } from './generateResolverFiles.js';

package/{src → dist}/generateResolverFiles/postProcessFiles.d.ts

@@ -1,4 +1,4 @@
-import type { GenerateResolverFilesContext } from './types';
+import type { GenerateResolverFilesContext } from './types.js';
 /**
  * postProcessFiles does static analysis on existing files OR to-be-generated files
  * e.g.

package/{src → dist}/generateResolverFiles/postProcessFiles.js

@@ -1,20 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.postProcessFiles = void 0;
-const tslib_1 = require("tslib");
-const path = tslib_1.__importStar(require("path"));
-const utils_1 = require("../utils");
-const getVariableStatementWithExpectedIdentifier_1 = require("./getVariableStatementWithExpectedIdentifier");
-const addObjectTypeResolversPropertyAssignmentNodesIfNotImplemented_1 = require("./addObjectTypeResolversPropertyAssignmentNodesIfNotImplemented");
-const ensureEnumTypeResolversAreGenerated_1 = require("./ensureEnumTypeResolversAreGenerated");
-const getImportStatementWithExpectedNamedImport_1 = require("./getImportStatementWithExpectedNamedImport");
+import * as path from 'path';
+import { cwd } from '../utils/index.js';
+import { getVariableStatementWithExpectedIdentifier } from './getVariableStatementWithExpectedIdentifier.js';
+import { addObjectTypeResolversPropertyAssignmentNodesIfNotImplemented, } from './addObjectTypeResolversPropertyAssignmentNodesIfNotImplemented.js';
+import { ensureEnumTypeResolversAreGenerated } from './ensureEnumTypeResolversAreGenerated.js';
+import { getImportStatementWithExpectedNamedImport } from './getImportStatementWithExpectedNamedImport.js';
 /**
  * postProcessFiles does static analysis on existing files OR to-be-generated files
  * e.g.
  * - Make sure correct variables are exported
  * - Make sure object types have field resolvers if mapper type's field cannot be used as schema type's field
  */
-const postProcessFiles = ({ config: { tsMorph: { project }, fixObjectTypeResolvers, }, result, }) => {
+export const postProcessFiles = ({ config: { tsMorph: { project }, fixObjectTypeResolvers, }, result, }) => {
     const sourceFilesToProcess = [];
     // 1. Load resolver files into ts-morph project so we can run static analysis
     Object.entries(result.files).forEach(([filePath, file]) => {
@@ -46,7 +42,7 @@ const postProcessFiles = ({ config: { tsMorph: { project }, fixObjectTypeResolve
     // these property assigments are to be removed if there's no TypeScript error
     const addedPropertyAssignmentNodes = {};
     sourceFilesToProcess.forEach(({ sourceFile, resolverFile }) => {
-        const normalizedRelativePath = path.posix.relative((0, utils_1.cwd)(), sourceFile.getFilePath());
+        const normalizedRelativePath = path.posix.relative(cwd(), sourceFile.getFilePath());
         const { addedVariableStatement } = ensureExportedResolver(sourceFile, resolverFile);
         if (resolverFile.__filetype !== 'scalarResolver' ||
             // For scalarResolver, only add `import { GraphQLScalarType } ...` if variable statement was added.
@@ -57,7 +53,7 @@ const postProcessFiles = ({ config: { tsMorph: { project }, fixObjectTypeResolve
         if ((fixObjectTypeResolvers.object === 'smart' ||
             fixObjectTypeResolvers.object === 'fast') &&
             resolverFile.__filetype === 'objectType') {
-            (0, addObjectTypeResolversPropertyAssignmentNodesIfNotImplemented_1.addObjectTypeResolversPropertyAssignmentNodesIfNotImplemented)({
+            addObjectTypeResolversPropertyAssignmentNodesIfNotImplemented({
                 addedPropertyAssignmentNodes,
                 sourceFile,
                 resolverFile,
@@ -67,17 +63,19 @@ const postProcessFiles = ({ config: { tsMorph: { project }, fixObjectTypeResolve
         if ((fixObjectTypeResolvers.enum === 'smart' ||
             fixObjectTypeResolvers.enum === 'fast') &&
             resolverFile.__filetype === 'enumResolver') {
-            (0, ensureEnumTypeResolversAreGenerated_1.ensureEnumTypeResolversAreGenerated)(sourceFile, resolverFile);
+            ensureEnumTypeResolversAreGenerated(sourceFile, resolverFile);
         }
         // Overwrite existing files with fixes
-        result.files[normalizedRelativePath] = Object.assign(Object.assign({}, resolverFile), { content: sourceFile.getText() });
+        result.files[normalizedRelativePath] = {
+            ...resolverFile,
+            content: sourceFile.getText(),
+        };
     });
     // 3. ensure object type's added property assignments are removed if there's no related TypeScript error
     // We do this only once at the project level instead of sourceFile level to speed up the process
     if (fixObjectTypeResolvers.object === 'smart') {
         project.getPreEmitDiagnostics().forEach((d) => {
-            var _a;
-            const filename = (_a = d.getSourceFile()) === null || _a === void 0 ? void 0 : _a.getFilePath().toString();
+            const filename = d.getSourceFile()?.getFilePath().toString();
             if (!filename || !addedPropertyAssignmentNodes[filename]) {
                 return;
             }
@@ -103,18 +101,19 @@ const postProcessFiles = ({ config: { tsMorph: { project }, fixObjectTypeResolve
     }
     // 4. Apply to result files the updated content done in step 2. and 3. above
     sourceFilesToProcess.forEach(({ sourceFile, resolverFile }) => {
-        const normalizedRelativePath = path.posix.relative((0, utils_1.cwd)(), sourceFile.getFilePath());
+        const normalizedRelativePath = path.posix.relative(cwd(), sourceFile.getFilePath());
         // Overwrite existing files with fixes
-        result.files[normalizedRelativePath] = Object.assign(Object.assign({}, resolverFile), { content: sourceFile.getText() });
+        result.files[normalizedRelativePath] = {
+            ...resolverFile,
+            content: sourceFile.getText(),
+        };
     });
 };
-exports.postProcessFiles = postProcessFiles;
 /**
  * Ensure correctly named resolvers are exported
  */
 const ensureExportedResolver = (sourceFile, resolverFile) => {
-    var _a;
-    const { variableStatement, isExported } = (0, getVariableStatementWithExpectedIdentifier_1.getVariableStatementWithExpectedIdentifier)(sourceFile, resolverFile);
+    const { variableStatement, isExported } = getVariableStatementWithExpectedIdentifier(sourceFile, resolverFile);
     /**
      * If we found the variable statement replace its type with the expected resolver type string
      *
@@ -123,11 +122,11 @@ const ensureExportedResolver = (sourceFile, resolverFile) => {
      *    e.g. `Book` might become `Pick<Book, 'title' | 'author'>`
      */
     let ensureCorrectResolverType = undefined;
-    if (variableStatement && ((_a = resolverFile.meta.resolverType) === null || _a === void 0 ? void 0 : _a.final)) {
+    if (variableStatement && resolverFile.meta.resolverType?.final) {
         const variableDeclaration = variableStatement
             .getDeclarationList()
             .getDeclarations()[0];
-        const typeNode = variableDeclaration === null || variableDeclaration === void 0 ? void 0 : variableDeclaration.getTypeNode();
+        const typeNode = variableDeclaration?.getTypeNode();
         ensureCorrectResolverType = typeNode
             ? () => {
                 const trimTypeString = (value) => value.replace(/[\n\r\s]/g, '');
@@ -193,10 +192,9 @@ const ensureExportedResolver = (sourceFile, resolverFile) => {
  * Ensure correctly imported resolves type generated by typescript-resolvers plugin
  */
 const ensureImportedType = (sourceFile, resolverFile) => {
-    const { importDeclaration } = (0, getImportStatementWithExpectedNamedImport_1.getImportStatementWithExpectedNamedImport)(sourceFile, resolverFile);
+    const { importDeclaration } = getImportStatementWithExpectedNamedImport(sourceFile, resolverFile);
     if (!importDeclaration) {
         sourceFile.insertStatements(0, resolverFile.meta.resolverTypeImportDeclaration);
         resolverFile.filesystem.contentUpdated = true;
     }
 };
-//# sourceMappingURL=postProcessFiles.js.map

package/{src → dist}/generateResolverFiles/types.d.ts

@@ -1,11 +1,11 @@
 import type { SourceFile, Project } from 'ts-morph';
 import type * as typeScriptResolversPlugin from '@graphql-codegen/typescript-resolvers';
-import type { GraphQLObjectTypeResolversToGenerate } from '../getGraphQLObjectTypeResolversToGenerate';
-import type { TypeMappersMap } from '../parseTypeMappers';
-import type { ImportExtension, ImportLineMeta, RootObjectType } from '../utils';
-import type { ParsedPresetConfig } from '../validatePresetConfig';
-import type { NormalizedResolverName } from '../parseGraphQLSchema';
-import type { ParsedGraphQLSchemaMeta } from '../parseGraphQLSchema';
+import type { GraphQLObjectTypeResolversToGenerate } from '../getGraphQLObjectTypeResolversToGenerate/index.js';
+import type { TypeMappersMap } from '../parseTypeMappers/index.js';
+import type { ImportExtension, ImportLineMeta, RootObjectType } from '../utils/index.js';
+import type { ParsedPresetConfig } from '../validatePresetConfig/index.js';
+import type { NormalizedResolverName } from '../parseGraphQLSchema/index.js';
+import type { ParsedGraphQLSchemaMeta } from '../parseGraphQLSchema/index.js';
 export type GeneratedTypesFileMeta = {
     generatedResolverTypes: NonNullable<Awaited<ReturnType<typeof typeScriptResolversPlugin.plugin>>['meta']>['generatedResolverTypes'];
 };

package/dist/generateResolverFiles/types.js

@@ -0,0 +1 @@
+export {};

package/{src → dist}/generateResolverFiles/visitNamedType.d.ts

@@ -1,5 +1,5 @@
-import type { GraphQLTypeHandler, GenerateResolverFilesContext } from './types';
-import type { ResolverDetails } from '../parseGraphQLSchema';
+import type { GraphQLTypeHandler, GenerateResolverFilesContext } from './types.js';
+import type { ResolverDetails } from '../parseGraphQLSchema/index.js';
 export declare const visitNamedType: <T = null>({ moduleName, relativePathFromBaseToModule, normalizedResolverName, resolverFile, relativePathToResolverTypesFile, typeNamedImport, typeString, belongsToRootObject, visitor, }: ResolverDetails & {
     belongsToRootObject: T;
     visitor: GraphQLTypeHandler<T>;

package/{src → dist}/generateResolverFiles/visitNamedType.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.visitNamedType = void 0;
-const addExternalResolverImport_1 = require("./addExternalResolverImport");
-const visitNamedType = ({ moduleName, relativePathFromBaseToModule, normalizedResolverName, resolverFile, relativePathToResolverTypesFile, typeNamedImport, typeString, belongsToRootObject, visitor, }, ctx) => {
+import { addExternalResolverImport } from './addExternalResolverImport.js';
+export const visitNamedType = ({ moduleName, relativePathFromBaseToModule, normalizedResolverName, resolverFile, relativePathToResolverTypesFile, typeNamedImport, typeString, belongsToRootObject, visitor, }, ctx) => {
     const unmanagedResolversImportSyntax = ctx.config.unmanagedResolvers[normalizedResolverName.base];
     if (unmanagedResolversImportSyntax) {
-        (0, addExternalResolverImport_1.addExternalResolverImport)({
+        addExternalResolverImport({
             moduleName,
             relativePathFromBaseToModule,
             normalizedResolverName: normalizedResolverName.base,
@@ -33,5 +30,3 @@ const visitNamedType = ({ moduleName, relativePathFromBaseToModule, normalizedRe
         generatedTypesFileMeta: ctx.config.generatedTypesFileMeta,
     }, ctx);
 };
-exports.visitNamedType = visitNamedType;
-//# sourceMappingURL=visitNamedType.js.map

package/dist/generateTypeDefsFiles/generateTypeDefsContent.js

@@ -0,0 +1,7 @@
+import { mergeTypeDefs } from '@graphql-tools/merge';
+export const generateTypeDefsContent = ({ mergedSDL, }) => {
+    const documentNode = mergeTypeDefs(mergedSDL, { noLocation: true });
+    const documentNodeString = JSON.stringify(documentNode);
+    return `import type { DocumentNode } from 'graphql';
+  export const typeDefs = ${documentNodeString} as unknown as DocumentNode`;
+};

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

@@ -1,6 +1,6 @@
-import type { StandardFile } from '../generateResolverFiles';
-import type { ParseSourcesResult } from '../parseSources';
-import type { TypeDefsFileMode } from '../validatePresetConfig';
+import type { StandardFile } from '../generateResolverFiles/index.js';
+import type { ParseSourcesResult } from '../parseSources/index.js';
+import type { TypeDefsFileMode } from '../validatePresetConfig/index.js';
 interface GenerateTypeDefsFilesParams {
     baseOutputDir: string;
     typeDefsFilePath: string;

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

@@ -1,14 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateTypeDefsFiles = void 0;
-const tslib_1 = require("tslib");
-const path = tslib_1.__importStar(require("path"));
-const utils_1 = require("../utils");
-const generateTypeDefsContent_1 = require("./generateTypeDefsContent");
-const generateTypeDefsFiles = ({ baseOutputDir, typeDefsFilePath, typeDefsFileMode, sourceMap, blacklistedModules, whitelistedModules, }) => {
+import * as path from 'path';
+import { cwd, isWhitelistedModule } from '../utils/index.js';
+import { generateTypeDefsContent } from './generateTypeDefsContent.js';
+export const generateTypeDefsFiles = ({ baseOutputDir, typeDefsFilePath, typeDefsFileMode, sourceMap, blacklistedModules, whitelistedModules, }) => {
     const filesContent = {};
     Object.values(sourceMap).forEach(({ moduleName, source, sourcePath }) => {
-        const isWhitelisted = (0, utils_1.isWhitelistedModule)({
+        const isWhitelisted = isWhitelistedModule({
             moduleName,
             whitelistedModules,
             blacklistedModules,
@@ -33,7 +29,7 @@ const generateTypeDefsFiles = ({ baseOutputDir, typeDefsFilePath, typeDefsFileMo
             // sourcePath.dir is absolute which does not work well to use as filenames for Windows
             // example of cases where it does not work:
             //   - when `prettier` is run in afterAllFileWrite hooks with absolute Windows path
-            const relativeSourcePathDir = path.posix.relative((0, utils_1.cwd)(), sourcePath.dir);
+            const relativeSourcePathDir = path.posix.relative(cwd(), sourcePath.dir);
             appendSDLToFile({
                 filesContent,
                 filePath: path.posix.join(relativeSourcePathDir, typeDefsFilePath),
@@ -52,13 +48,12 @@ const generateTypeDefsFiles = ({ baseOutputDir, typeDefsFilePath, typeDefsFileMo
                 type: 'virtual',
                 contentUpdated: false,
             },
-            content: (0, generateTypeDefsContent_1.generateTypeDefsContent)({ mergedSDL: content }),
+            content: generateTypeDefsContent({ mergedSDL: content }),
             mainImportIdentifier: 'typeDefs',
         };
     });
     return result;
 };
-exports.generateTypeDefsFiles = generateTypeDefsFiles;
 const appendSDLToFile = ({ rawSDL, filePath, filesContent, }) => {
     if (!rawSDL) {
         return;
@@ -68,4 +63,3 @@ const appendSDLToFile = ({ rawSDL, filePath, filesContent, }) => {
     }
     filesContent[filePath] += `${rawSDL}\n`;
 };
-//# sourceMappingURL=generateTypeDefsFiles.js.map

package/dist/generateTypeDefsFiles/index.d.ts

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

package/dist/generateTypeDefsFiles/index.js

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

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

@@ -1,7 +1,7 @@
 import { type SourceFile, type Project } from 'ts-morph';
-import type { TypeMappersMap } from '../parseTypeMappers';
-import type { ParsedGraphQLSchemaMeta } from '../parseGraphQLSchema';
-import type { GeneratedTypesFileMeta } from '../generateResolverFiles';
+import type { TypeMappersMap } from '../parseTypeMappers/index.js';
+import type { ParsedGraphQLSchemaMeta } from '../parseGraphQLSchema/index.js';
+import type { GeneratedTypesFileMeta } from '../generateResolverFiles/index.js';
 export type GraphQLObjectTypeResolversToGenerate = Record<string, Record<string, {
     resolverName: string;
     resolverDeclaration: string;