@gqlkit-ts/cli 0.3.0 → 0.4.0

package/src/config-loader/validator.ts

@@ -1,3 +1,4 @@
+import type { ImportExtension } from "../config/types.js";
 import type { Diagnostic } from "../type-extractor/types/index.js";
 import {
   DEFAULT_RESOLVERS_PATH,
@@ -186,6 +187,31 @@ function validateTsconfigPath(
   return { resolved: value, diagnostics: [] };
 }
 
+function validateImportExtension(
+  value: unknown,
+  configPath: string,
+): { resolved: ImportExtension; diagnostics: Diagnostic[] } {
+  if (value === undefined) {
+    return { resolved: "js", diagnostics: [] };
+  }
+
+  if (value !== "js" && value !== "none" && value !== "ts") {
+    return {
+      resolved: "js",
+      diagnostics: [
+        {
+          code: "CONFIG_INVALID_IMPORT_EXTENSION",
+          message: 'output.importExtension must be "js", "none", or "ts"',
+          severity: "error",
+          location: { file: configPath, line: 1, column: 1 },
+        },
+      ],
+    };
+  }
+
+  return { resolved: value, diagnostics: [] };
+}
+
 function validateOutputConfig(
   output: unknown,
   configPath: string,
@@ -198,6 +224,7 @@ function validateOutputConfig(
         resolversPath: DEFAULT_RESOLVERS_PATH,
         typeDefsPath: DEFAULT_TYPEDEFS_PATH,
         schemaPath: DEFAULT_SCHEMA_PATH,
+        importExtension: "js",
       },
       diagnostics: [],
     };
@@ -228,10 +255,15 @@ function validateOutputConfig(
     "output.schemaPath",
     configPath,
   );
+  const importExtensionResult = validateImportExtension(
+    output["importExtension"],
+    configPath,
+  );
 
   diagnostics.push(...resolversPathResult.diagnostics);
   diagnostics.push(...typeDefsPathResult.diagnostics);
   diagnostics.push(...schemaPathResult.diagnostics);
+  diagnostics.push(...importExtensionResult.diagnostics);
 
   if (diagnostics.length > 0) {
     return { resolved: undefined, diagnostics };
@@ -242,6 +274,7 @@ function validateOutputConfig(
       resolversPath: resolversPathResult.resolved,
       typeDefsPath: typeDefsPathResult.resolved,
       schemaPath: schemaPathResult.resolved,
+      importExtension: importExtensionResult.resolved,
     },
     diagnostics: [],
   };

package/src/gen-orchestrator/orchestrator.ts

@@ -91,6 +91,12 @@ interface ResolversResult {
   diagnostics: Diagnostics;
 }
 
+interface ScalarConfig {
+  readonly customScalarNames: string[];
+  readonly globalTypeMappings: GlobalTypeMapping[];
+  readonly configScalars: ConfigScalarMapping[];
+}
+
 interface PipelineContext {
   readonly config: GenerationConfig;
   readonly sourceFiles: ReadonlyArray<string>;
@@ -101,6 +107,7 @@ interface PipelineContext {
   readonly typesResult: TypesResult | null;
   readonly resolversResult: ResolversResult | null;
   readonly directiveDefinitions: DirectiveDefinitionInfo[] | null;
+  readonly scalarConfig: ScalarConfig | null;
   readonly diagnostics: Diagnostic[];
   readonly aborted: boolean;
 }
@@ -449,6 +456,7 @@ function createInitialContext(config: GenerationConfig): PipelineContext {
     typesResult: null,
     resolversResult: null,
     directiveDefinitions: null,
+    scalarConfig: null,
     diagnostics: [],
     aborted: false,
   };
@@ -514,11 +522,7 @@ function collectTypeNamesStep(ctx: PipelineContext): PipelineContext {
   };
 }
 
-function prepareScalarConfig(config: GenerationConfig): {
-  customScalarNames: string[];
-  globalTypeMappings: GlobalTypeMapping[];
-  configScalars: ConfigScalarMapping[];
-} {
+function prepareScalarConfig(config: GenerationConfig): ScalarConfig {
   const customScalarNames =
     config.customScalars?.map((s) => s.graphqlName) ?? [];
 
@@ -556,18 +560,25 @@ function prepareScalarConfig(config: GenerationConfig): {
   return { customScalarNames, globalTypeMappings, configScalars };
 }
 
+function prepareScalarConfigStep(ctx: PipelineContext): PipelineContext {
+  if (ctx.aborted) return ctx;
+
+  return { ...ctx, scalarConfig: prepareScalarConfig(ctx.config) };
+}
+
 function extractTypesStep(ctx: PipelineContext): PipelineContext {
   if (
     ctx.aborted ||
     !ctx.program ||
     !ctx.knownTypeNames ||
     !ctx.knownTypeSymbols ||
-    !ctx.underlyingSymbolToTypeName
+    !ctx.underlyingSymbolToTypeName ||
+    !ctx.scalarConfig
   )
     return ctx;
 
   const { customScalarNames, globalTypeMappings, configScalars } =
-    prepareScalarConfig(ctx.config);
+    ctx.scalarConfig;
 
   const typesResult = extractTypesCore({
     program: ctx.program,
@@ -591,11 +602,12 @@ function extractResolversStep(ctx: PipelineContext): PipelineContext {
     !ctx.knownTypeNames ||
     !ctx.knownTypeSymbols ||
     !ctx.underlyingSymbolToTypeName ||
-    !ctx.typesResult
+    !ctx.typesResult ||
+    !ctx.scalarConfig
   )
     return ctx;
 
-  const { globalTypeMappings } = prepareScalarConfig(ctx.config);
+  const { globalTypeMappings } = ctx.scalarConfig;
 
   const resolversResult = extractResolversCore({
     program: ctx.program,
@@ -663,11 +675,16 @@ function generateSchemaStep(ctx: PipelineContext): {
   ctx: PipelineContext;
   schemaResult: ReturnType<typeof generateSchema> | null;
 } {
-  if (ctx.aborted || !ctx.typesResult || !ctx.resolversResult) {
+  if (
+    ctx.aborted ||
+    !ctx.typesResult ||
+    !ctx.resolversResult ||
+    !ctx.scalarConfig
+  ) {
     return { ctx, schemaResult: null };
   }
 
-  const { customScalarNames } = prepareScalarConfig(ctx.config);
+  const { customScalarNames } = ctx.scalarConfig;
   const allCustomScalarNames = [
     ...customScalarNames,
     ...ctx.typesResult.detectedScalarNames,
@@ -687,6 +704,7 @@ function generateSchemaStep(ctx: PipelineContext): {
     enablePruning: null,
     sourceRoot: ctx.config.cwd,
     knownTypeNames: ctx.knownTypeNames,
+    importExtension: ctx.config.output.importExtension,
   });
 
   const newDiagnostics = [...ctx.diagnostics, ...schemaResult.diagnostics];
@@ -739,6 +757,7 @@ export async function executeGeneration(
   ctx = await scanSourceFilesStep(ctx);
   ctx = createProgramStep(ctx);
   ctx = collectTypeNamesStep(ctx);
+  ctx = prepareScalarConfigStep(ctx);
   ctx = extractTypesStep(ctx);
   ctx = extractResolversStep(ctx);
   ctx = extractDirectivesStep(ctx);

package/src/resolver-extractor/extractor/define-api-extractor.ts

@@ -200,23 +200,23 @@ function extractTypeNameFromType(
 function detectResolverFromMetadataType(
   callExpr: ts.CallExpression,
   checker: ts.TypeChecker,
-): DefineApiResolverType | undefined {
+): DefineApiResolverType | null {
   const returnType = checker.getTypeAtLocation(callExpr);
 
   const metadataProp = returnType.getProperty(RESOLVER_METADATA_PROPERTY);
   if (!metadataProp) {
-    return undefined;
+    return null;
   }
 
   const metadataType = checker.getTypeOfSymbol(metadataProp);
   const actualType = getActualMetadataType(metadataType);
   if (!actualType) {
-    return undefined;
+    return null;
   }
 
   const kindProp = actualType.getProperty("kind");
   if (!kindProp) {
-    return undefined;
+    return null;
   }
 
   const kindType = checker.getTypeOfSymbol(kindProp);
@@ -227,7 +227,7 @@ function detectResolverFromMetadataType(
     }
   }
 
-  return undefined;
+  return null;
 }
 
 function isInlineTypeLiteralDeclaration(declaration: ts.Declaration): boolean {

package/src/schema-generator/builder/ast-builder.ts

@@ -48,13 +48,13 @@ import type {
 } from "../integrator/result-integrator.js";
 
 export interface BuildDocumentOptions {
-  readonly sourceRoot?: string;
+  readonly sourceRoot: string | null;
 }
 
 function appendSourceLocation(
   description: string | null,
   sourceFile: string | null,
-  sourceRoot: string | undefined,
+  sourceRoot: string | null,
 ): string | null {
   if (!sourceRoot || !sourceFile) {
     return description;
@@ -113,7 +113,7 @@ function buildOneOfDirective(): ConstDirectiveNode {
 
 function buildDirectiveArgumentValue(
   value: DirectiveArgumentValue,
-  expectedTypeName?: string,
+  expectedTypeName: string | null,
 ): ConstValueNode {
   switch (value.kind) {
     case "string":
@@ -159,7 +159,7 @@ function buildDirectiveArgumentValue(
         fields: value.fields.map((f) => ({
           kind: Kind.OBJECT_FIELD as const,
           name: buildNameNode(f.name),
-          value: buildDirectiveArgumentValue(f.value),
+          value: buildDirectiveArgumentValue(f.value, null),
         })),
       };
   }
@@ -167,7 +167,7 @@ function buildDirectiveArgumentValue(
 
 function buildDirectiveArgument(
   arg: DirectiveArgument,
-  expectedTypeName?: string,
+  expectedTypeName: string | null,
 ): ConstArgumentNode {
   return {
     kind: Kind.ARGUMENT,
@@ -178,7 +178,7 @@ function buildDirectiveArgument(
 
 function buildCustomDirective(
   directive: DirectiveInfo,
-  directiveDefMap?: Map<string, DirectiveDefinitionInfo>,
+  directiveDefMap: Map<string, DirectiveDefinitionInfo> | null,
 ): ConstDirectiveNode {
   const def = directiveDefMap?.get(directive.name);
   const argTypeMap = new Map<string, string>();
@@ -189,7 +189,7 @@ function buildCustomDirective(
   }
 
   const args = directive.args.map((arg) =>
-    buildDirectiveArgument(arg, argTypeMap.get(arg.name)),
+    buildDirectiveArgument(arg, argTypeMap.get(arg.name) ?? null),
   );
 
   return {
@@ -202,7 +202,7 @@ function buildCustomDirective(
 function buildDirectives(
   directives: ReadonlyArray<DirectiveInfo> | null,
   deprecated: DeprecationInfo | null,
-  directiveDefMap?: Map<string, DirectiveDefinitionInfo>,
+  directiveDefMap: Map<string, DirectiveDefinitionInfo> | null,
 ): ConstDirectiveNode[] {
   const result: ConstDirectiveNode[] = [];
 
@@ -278,7 +278,12 @@ function buildInputValueDefinitionNode(
       ? { description: buildStringValueNode(inputValue.description) }
       : {}),
     ...(inputValue.defaultValue
-      ? { defaultValue: buildDirectiveArgumentValue(inputValue.defaultValue) }
+      ? {
+          defaultValue: buildDirectiveArgumentValue(
+            inputValue.defaultValue,
+            null,
+          ),
+        }
       : {}),
     ...(directives.length > 0 ? { directives } : {}),
   };
@@ -290,7 +295,7 @@ function sortByName<T extends { name: string }>(items: ReadonlyArray<T>): T[] {
 
 function buildBaseFieldDefinitionNode(
   field: BaseField,
-  directiveDefMap?: Map<string, DirectiveDefinitionInfo>,
+  directiveDefMap: Map<string, DirectiveDefinitionInfo> | null,
 ): FieldDefinitionNode {
   const directives = buildDirectives(
     field.directives,
@@ -311,8 +316,8 @@ function buildBaseFieldDefinitionNode(
 
 function buildFieldDefinitionNode(
   field: ExtensionField,
-  sourceRoot?: string,
-  directiveDefMap?: Map<string, DirectiveDefinitionInfo>,
+  sourceRoot: string | null,
+  directiveDefMap: Map<string, DirectiveDefinitionInfo> | null,
 ): FieldDefinitionNode {
   const directives = buildDirectives(
     field.directives,
@@ -338,11 +343,14 @@ function buildFieldDefinitionNode(
   };
 }
 
-function buildObjectTypeDefinitionNode(
+function buildTypeDefinitionNode(
   baseType: BaseType,
-  sourceRoot?: string,
-  directiveDefMap?: Map<string, DirectiveDefinitionInfo>,
-): ObjectTypeDefinitionNode {
+  kind:
+    | typeof Kind.OBJECT_TYPE_DEFINITION
+    | typeof Kind.INTERFACE_TYPE_DEFINITION,
+  sourceRoot: string | null,
+  directiveDefMap: Map<string, DirectiveDefinitionInfo> | null,
+): ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode {
   const sortedFields = baseType.fields ? sortByName(baseType.fields) : [];
   const directives = buildDirectives(
     baseType.directives,
@@ -364,7 +372,7 @@ function buildObjectTypeDefinitionNode(
       : undefined;
 
   return {
-    kind: Kind.OBJECT_TYPE_DEFINITION,
+    kind,
     name: buildNameNode(baseType.name),
     fields: sortedFields.map((f) =>
       buildBaseFieldDefinitionNode(f, directiveDefMap),
@@ -372,49 +380,12 @@ function buildObjectTypeDefinitionNode(
     ...(description ? { description: buildStringValueNode(description) } : {}),
     ...(directives.length > 0 ? { directives } : {}),
     ...(interfaces ? { interfaces } : {}),
-  };
-}
-
-function buildInterfaceTypeDefinitionNode(
-  baseType: BaseType,
-  sourceRoot?: string,
-  directiveDefMap?: Map<string, DirectiveDefinitionInfo>,
-): InterfaceTypeDefinitionNode {
-  const sortedFields = baseType.fields ? sortByName(baseType.fields) : [];
-  const directives = buildDirectives(
-    baseType.directives,
-    baseType.deprecated,
-    directiveDefMap,
-  );
-
-  const description = appendSourceLocation(
-    baseType.description,
-    baseType.sourceFile,
-    sourceRoot,
-  );
-
-  const interfaces =
-    baseType.implementedInterfaces && baseType.implementedInterfaces.length > 0
-      ? [...baseType.implementedInterfaces]
-          .sort((a, b) => a.localeCompare(b))
-          .map(buildNamedTypeNode)
-      : undefined;
-
-  return {
-    kind: Kind.INTERFACE_TYPE_DEFINITION,
-    name: buildNameNode(baseType.name),
-    fields: sortedFields.map((f) =>
-      buildBaseFieldDefinitionNode(f, directiveDefMap),
-    ),
-    ...(description ? { description: buildStringValueNode(description) } : {}),
-    ...(directives.length > 0 ? { directives } : {}),
-    ...(interfaces ? { interfaces } : {}),
-  };
+  } as ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode;
 }
 
 function buildUnionTypeDefinitionNode(
   baseType: BaseType,
-  sourceRoot?: string,
+  sourceRoot: string | null,
 ): UnionTypeDefinitionNode {
   const sortedMembers = baseType.unionMembers
     ? [...baseType.unionMembers].sort((a, b) => a.localeCompare(b))
@@ -454,7 +425,7 @@ function buildEnumValueDefinitionNode(
 
 function buildEnumTypeDefinitionNode(
   baseType: BaseType,
-  sourceRoot?: string,
+  sourceRoot: string | null,
 ): EnumTypeDefinitionNode {
   const enumValues = baseType.enumValues ?? [];
 
@@ -474,7 +445,7 @@ function buildEnumTypeDefinitionNode(
 
 function buildScalarTypeDefinitionNode(
   name: string,
-  description?: string,
+  description: string | null,
 ): ScalarTypeDefinitionNode {
   return {
     kind: Kind.SCALAR_TYPE_DEFINITION,
@@ -485,7 +456,7 @@ function buildScalarTypeDefinitionNode(
 
 function buildInputFieldDefinitionNode(
   field: BaseField,
-  directiveDefMap?: Map<string, DirectiveDefinitionInfo>,
+  directiveDefMap: Map<string, DirectiveDefinitionInfo> | null,
 ): InputValueDefinitionNode {
   const directives = buildDirectives(
     field.directives,
@@ -501,7 +472,7 @@ function buildInputFieldDefinitionNode(
       ? { description: buildStringValueNode(field.description) }
       : {}),
     ...(field.defaultValue
-      ? { defaultValue: buildDirectiveArgumentValue(field.defaultValue) }
+      ? { defaultValue: buildDirectiveArgumentValue(field.defaultValue, null) }
       : {}),
     ...(directives.length > 0 ? { directives } : {}),
   };
@@ -509,8 +480,8 @@ function buildInputFieldDefinitionNode(
 
 function buildInputObjectTypeDefinitionNode(
   inputType: InputType,
-  sourceRoot?: string,
-  directiveDefMap?: Map<string, DirectiveDefinitionInfo>,
+  sourceRoot: string | null,
+  directiveDefMap: Map<string, DirectiveDefinitionInfo> | null,
 ): InputObjectTypeDefinitionNode {
   const sortedFields = sortByName(inputType.fields);
 
@@ -538,8 +509,8 @@ function buildInputObjectTypeDefinitionNode(
 
 function buildObjectTypeExtensionNode(
   typeExtension: TypeExtension,
-  sourceRoot?: string,
-  directiveDefMap?: Map<string, DirectiveDefinitionInfo>,
+  sourceRoot: string | null,
+  directiveDefMap: Map<string, DirectiveDefinitionInfo> | null,
 ): ObjectTypeExtensionNode {
   const sortedFields = sortByName(typeExtension.fields);
   return {
@@ -553,8 +524,8 @@ function buildObjectTypeExtensionNode(
 
 function buildInterfaceTypeExtensionNode(
   typeExtension: TypeExtension,
-  sourceRoot?: string,
-  directiveDefMap?: Map<string, DirectiveDefinitionInfo>,
+  sourceRoot: string | null,
+  directiveDefMap: Map<string, DirectiveDefinitionInfo> | null,
 ): InterfaceTypeExtensionNode {
   const sortedFields = sortByName(typeExtension.fields);
   return {
@@ -600,9 +571,9 @@ function buildDirectiveDefinitionNode(
 
 export function buildDocumentNode(
   integratedResult: IntegratedResult,
-  options?: BuildDocumentOptions,
+  options: BuildDocumentOptions,
 ): DocumentNode {
-  const sourceRoot = options?.sourceRoot;
+  const sourceRoot = options.sourceRoot;
   const definitions: DefinitionNode[] = [];
 
   // Build directive definition map for argument type lookup
@@ -628,19 +599,9 @@ export function buildDocumentNode(
     );
     for (const scalar of sortedScalars) {
       definitions.push(
-        buildScalarTypeDefinitionNode(
-          scalar.scalarName,
-          scalar.description ?? undefined,
-        ),
+        buildScalarTypeDefinitionNode(scalar.scalarName, scalar.description),
       );
     }
-  } else if (integratedResult.customScalarNames) {
-    const sortedScalarNames = [...integratedResult.customScalarNames].sort(
-      (a, b) => a.localeCompare(b),
-    );
-    for (const scalarName of sortedScalarNames) {
-      definitions.push(buildScalarTypeDefinitionNode(scalarName));
-    }
   }
 
   const sortedBaseTypes = [...integratedResult.baseTypes].sort((a, b) =>
@@ -650,11 +611,21 @@ export function buildDocumentNode(
   for (const baseType of sortedBaseTypes) {
     if (baseType.kind === "Interface") {
       definitions.push(
-        buildInterfaceTypeDefinitionNode(baseType, sourceRoot, directiveDefMap),
+        buildTypeDefinitionNode(
+          baseType,
+          Kind.INTERFACE_TYPE_DEFINITION,
+          sourceRoot,
+          directiveDefMap,
+        ),
       );
     } else if (baseType.kind === "Object") {
       definitions.push(
-        buildObjectTypeDefinitionNode(baseType, sourceRoot, directiveDefMap),
+        buildTypeDefinitionNode(
+          baseType,
+          Kind.OBJECT_TYPE_DEFINITION,
+          sourceRoot,
+          directiveDefMap,
+        ),
       );
     } else if (baseType.kind === "Union") {
       definitions.push(buildUnionTypeDefinitionNode(baseType, sourceRoot));

package/src/schema-generator/emitter/code-emitter.ts

@@ -1,6 +1,7 @@
 import path from "node:path";
 import type { AutoGeneratedResolveType } from "../../auto-type-generator/resolve-type-generator.js";
 import { TYPENAME_FIELD_NAMES } from "../../auto-type-generator/typename-types.js";
+import type { ImportExtension } from "../../config/types.js";
 import { toPosixPath } from "../../shared/index.js";
 import type { CollectedScalarType } from "../../type-extractor/collector/scalar-collector.js";
 import {
@@ -23,7 +24,7 @@ const GENERATED_FILE_HEADER =
 
 function formatDocumentNodeAsCode(
   integratedResult: IntegratedResult,
-  options?: BuildDocumentOptions,
+  options: BuildDocumentOptions,
 ): string {
   const doc = buildDocumentNode(integratedResult, options);
 
@@ -32,7 +33,7 @@ function formatDocumentNodeAsCode(
 
 export function emitTypeDefsCode(
   integratedResult: IntegratedResult,
-  options?: BuildDocumentOptions,
+  options: BuildDocumentOptions,
 ): string {
   const documentNodeCode = formatDocumentNodeAsCode(integratedResult, options);
 
@@ -44,13 +45,31 @@ export const typeDefs: DocumentNode = ${documentNodeCode} as DocumentNode;
 `;
 }
 
-function computeRelativeImportPath(fromDir: string, toFile: string): string {
+function applyExtension(
+  relativePath: string,
+  importExtension: ImportExtension,
+): string {
+  switch (importExtension) {
+    case "js":
+      return relativePath.replace(/\.ts$/, ".js");
+    case "ts":
+      return relativePath;
+    case "none":
+      return relativePath.replace(/\.ts$/, "");
+  }
+}
+
+function computeRelativeImportPath(
+  fromDir: string,
+  toFile: string,
+  importExtension: ImportExtension,
+): string {
   const relativePath = toPosixPath(path.relative(fromDir, toFile));
-  const withoutExt = relativePath.replace(/\.ts$/, ".js");
-  if (!withoutExt.startsWith(".")) {
-    return `./${withoutExt}`;
+  const withExt = applyExtension(relativePath, importExtension);
+  if (!withExt.startsWith(".")) {
+    return `./${withExt}`;
   }
-  return withoutExt;
+  return withExt;
 }
 
 interface ScalarTypeImport {
@@ -94,6 +113,7 @@ function collectScalarTypeImports(
 function buildScalarTypeImports(
   scalarTypeImports: ScalarTypeImport[],
   outputDir: string,
+  importExtension: ImportExtension,
 ): string[] {
   const importsByFile = new Map<string, string[]>();
 
@@ -108,7 +128,11 @@ function buildScalarTypeImports(
 
   for (const sourceFile of sortedFiles) {
     const typeNames = importsByFile.get(sourceFile) ?? [];
-    const importPath = computeRelativeImportPath(outputDir, sourceFile);
+    const importPath = computeRelativeImportPath(
+      outputDir,
+      sourceFile,
+      importExtension,
+    );
     imports.push(
       `import type { ${typeNames.sort().join(", ")} } from "${importPath}";`,
     );
@@ -172,13 +196,18 @@ function collectResolverImportsByFile(
 function buildResolverImports(
   importsByFile: Map<string, Set<string>>,
   outputDir: string,
+  importExtension: ImportExtension,
 ): string[] {
   const imports: string[] = [];
   const sortedFiles = [...importsByFile.keys()].sort();
 
   for (const sourceFile of sortedFiles) {
     const valueNames = importsByFile.get(sourceFile) ?? new Set<string>();
-    const importPath = computeRelativeImportPath(outputDir, sourceFile);
+    const importPath = computeRelativeImportPath(
+      outputDir,
+      sourceFile,
+      importExtension,
+    );
     const sortedValues = [...valueNames].sort();
 
     if (sortedValues.length > 0) {
@@ -331,6 +360,7 @@ interface EmitResolversCodeParams {
   readonly customScalars: ReadonlyArray<CollectedScalarType>;
   readonly numericEnums: ReadonlyArray<NumericEnumInfo>;
   readonly stringEnumMappings: ReadonlyArray<StringEnumMappingInfo>;
+  readonly importExtension: ImportExtension;
 }
 
 export function emitResolversCode(params: EmitResolversCodeParams): string {
@@ -340,6 +370,7 @@ export function emitResolversCode(params: EmitResolversCodeParams): string {
     customScalars,
     numericEnums,
     stringEnumMappings,
+    importExtension,
   } = params;
   const hasCustomScalars = customScalars.length > 0;
   const imports: string[] = [];
@@ -349,11 +380,17 @@ export function emitResolversCode(params: EmitResolversCodeParams): string {
   }
 
   const importsByFile = collectResolverImportsByFile(resolverInfo);
-  imports.push(...buildResolverImports(importsByFile, outputDir));
+  imports.push(
+    ...buildResolverImports(importsByFile, outputDir, importExtension),
+  );
 
   if (hasCustomScalars) {
     const scalarTypeImports = collectScalarTypeImports(customScalars);
-    const scalarImports = buildScalarTypeImports(scalarTypeImports, outputDir);
+    const scalarImports = buildScalarTypeImports(
+      scalarTypeImports,
+      outputDir,
+      importExtension,
+    );
     imports.push(...scalarImports);
   }
 

package/src/schema-generator/emitter/sdl-emitter.ts

@@ -3,10 +3,6 @@ import { type DocumentNode, print } from "graphql";
 const GENERATED_FILE_HEADER =
   "# This file is auto-generated by gqlkit. DO NOT EDIT.";
 
-/**
- * DocumentNode を SDL 形式の文字列に変換する。
- * graphql パッケージの print() 関数を使用して SDL を生成する。
- */
 export function emitSdlContent(documentNode: DocumentNode): string {
   const sdl = print(documentNode);
   return `${GENERATED_FILE_HEADER}\n\n${sdl}`;