@gqlkit-ts/cli 0.2.0 → 0.4.0

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;
 }
@@ -262,6 +269,8 @@ function convertArgsToInputValues(
     externalEnumSymbol: arg.tsType.externalEnumSymbol ?? null,
     externalEnumDescription: arg.tsType.externalEnumDescription ?? null,
     externalEnumDeprecated: arg.tsType.externalEnumDeprecated ?? null,
+    inlineUnionMembers:
+      arg.tsType.kind === "union" ? (arg.tsType.members ?? null) : null,
   }));
 }
 
@@ -277,19 +286,30 @@ function convertDefineApiToFields(
   const typeExtensionMap = new Map<string, GraphQLFieldDefinition[]>();
 
   for (const resolver of resolvers) {
+    const returnType = resolver.returnType;
     const fieldDef: GraphQLFieldDefinition = {
       name: resolver.fieldName,
-      type: convertTsTypeToGraphQLType(resolver.returnType),
+      type: convertTsTypeToGraphQLType(returnType),
       args: resolver.args ? convertArgsToInputValues(resolver.args) : null,
-      sourceLocation: {
-        file: resolver.sourceFile,
-        line: 1,
-        column: 1,
-      },
+      sourceLocation: resolver.sourceLocation,
       resolverExportName: resolver.fieldName,
       description: resolver.description,
       deprecated: resolver.deprecated,
       directives: resolver.directives,
+      returnTypeInlineObjectProperties:
+        returnType.inlineObjectProperties ?? null,
+      returnTypeInlineObjectDescription:
+        returnType.inlineObjectDescription ?? null,
+      returnTypeInlineObjectDeprecated:
+        returnType.inlineObjectDeprecated ?? null,
+      returnTypeInlineEnumMembers: returnType.inlineEnumMembers ?? null,
+      returnTypeInlineUnionMembers:
+        returnType.kind === "union" ? (returnType.members ?? null) : null,
+      returnTypeExternalEnumSymbol: returnType.externalEnumSymbol ?? null,
+      returnTypeExternalEnumDescription:
+        returnType.externalEnumDescription ?? null,
+      returnTypeExternalEnumDeprecated:
+        returnType.externalEnumDeprecated ?? null,
     };
 
     if (resolver.resolverType === "query") {
@@ -436,6 +456,7 @@ function createInitialContext(config: GenerationConfig): PipelineContext {
     typesResult: null,
     resolversResult: null,
     directiveDefinitions: null,
+    scalarConfig: null,
     diagnostics: [],
     aborted: false,
   };
@@ -501,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) ?? [];
 
@@ -543,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,
@@ -578,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,
@@ -650,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,
@@ -673,6 +703,8 @@ function generateSchemaStep(ctx: PipelineContext): {
         : null,
     enablePruning: null,
     sourceRoot: ctx.config.cwd,
+    knownTypeNames: ctx.knownTypeNames,
+    importExtension: ctx.config.output.importExtension,
   });
 
   const newDiagnostics = [...ctx.diagnostics, ...schemaResult.diagnostics];
@@ -725,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/extract-resolvers.ts

@@ -10,6 +10,7 @@ import type {
   InlineEnumMemberInfo,
   InlineObjectPropertyDef,
   SourceLocation,
+  TSTypeReference,
 } from "../type-extractor/types/index.js";
 import type { AbstractResolverInfo } from "./extractor/define-api-extractor.js";
 
@@ -28,6 +29,8 @@ export interface GraphQLInputValue {
   readonly externalEnumDescription: string | null;
   /** @deprecated tag from the external enum type itself (null for string literal unions) */
   readonly externalEnumDeprecated: DeprecationInfo | null;
+  /** Inline union members when arg type is a union type (for @oneOf input objects) */
+  readonly inlineUnionMembers: ReadonlyArray<TSTypeReference> | null;
 }
 
 export interface GraphQLFieldDefinition {
@@ -39,6 +42,22 @@ export interface GraphQLFieldDefinition {
   readonly description: string | null;
   readonly deprecated: DeprecationInfo | null;
   readonly directives: ReadonlyArray<DirectiveInfo> | null;
+  /** Inline object properties when return type is an inline object type */
+  readonly returnTypeInlineObjectProperties: ReadonlyArray<InlineObjectPropertyDef> | null;
+  /** TSDoc description from the inline object type alias (Requirement 7.2) */
+  readonly returnTypeInlineObjectDescription: string | null;
+  /** @deprecated tag from the inline object type alias (Requirement 7.3) */
+  readonly returnTypeInlineObjectDeprecated: DeprecationInfo | null;
+  /** Inline enum members when return type is an inline enum (string literal union or external TypeScript enum) */
+  readonly returnTypeInlineEnumMembers: ReadonlyArray<InlineEnumMemberInfo> | null;
+  /** Inline union members when return type is a union type (for Payload union types) */
+  readonly returnTypeInlineUnionMembers: ReadonlyArray<TSTypeReference> | null;
+  /** External TypeScript enum symbol for deduplication across multiple references */
+  readonly returnTypeExternalEnumSymbol: ts.Symbol | null;
+  /** TSDoc description from the external enum type itself (null for string literal unions) */
+  readonly returnTypeExternalEnumDescription: string | null;
+  /** @deprecated tag from the external enum type itself (null for string literal unions) */
+  readonly returnTypeExternalEnumDeprecated: DeprecationInfo | null;
 }
 
 export interface QueryFieldDefinitions {

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

@@ -62,6 +62,11 @@ export interface DefineApiResolverInfo {
   readonly args: ReadonlyArray<ArgumentDefinition> | null;
   readonly returnType: TSTypeReference;
   readonly sourceFile: string;
+  readonly sourceLocation: {
+    readonly file: string;
+    readonly line: number;
+    readonly column: number;
+  };
   readonly exportedInputTypes: ReadonlyArray<ExportedInputType>;
   readonly description: string | null;
   readonly deprecated: DeprecationInfo | null;
@@ -195,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);
@@ -222,7 +227,7 @@ function detectResolverFromMetadataType(
     }
   }
 
-  return undefined;
+  return null;
 }
 
 function isInlineTypeLiteralDeclaration(declaration: ts.Declaration): boolean {
@@ -277,48 +282,15 @@ function shouldUnwrapAsGqlField(type: ts.Type): boolean {
   return hasDirectiveMetadata(type);
 }
 
-/**
- * Checks if a type is structurally equivalent to Record<string, never>.
- * This is a special type that represents "no arguments".
- * Detection is based on type structure, not type names.
- */
-function isNoArgsType(type: ts.Type, checker: ts.TypeChecker): boolean {
-  const apparentType = checker.getApparentType(type);
-
-  // Check for string index signature with 'never' value type
-  const indexInfos = checker.getIndexInfosOfType(apparentType);
-  const hasNeverStringIndex = indexInfos.some((info) => {
-    return (
-      (info.keyType.flags & ts.TypeFlags.String) !== 0 &&
-      (info.type.flags & ts.TypeFlags.Never) !== 0
-    );
-  });
-
-  if (!hasNeverStringIndex) {
-    return false;
-  }
-
-  // Check that there are no named properties (excluding metadata properties)
-  const properties = apparentType
-    .getProperties()
-    .filter((p) => !p.getName().startsWith("$"));
-
-  return properties.length === 0;
-}
-
 /**
  * Checks if a type has only index signatures with no named properties.
  * Types like `{ [key: string]: number }` return true.
- * Does NOT return true for NoArgs type.
+ * Returns false for NoArgs type (Record<string, never>).
  */
 function hasOnlyIndexSignatures(
   type: ts.Type,
   checker: ts.TypeChecker,
 ): boolean {
-  if (isNoArgsType(type, checker)) {
-    return false;
-  }
-
   const targetType = checker.getApparentType(type);
 
   const indexInfos = checker.getIndexInfosOfType(targetType);
@@ -328,6 +300,17 @@ function hasOnlyIndexSignatures(
     return false;
   }
 
+  const hasNeverStringIndex = indexInfos.some((info) => {
+    return (
+      (info.keyType.flags & ts.TypeFlags.String) !== 0 &&
+      (info.type.flags & ts.TypeFlags.Never) !== 0
+    );
+  });
+
+  if (hasNeverStringIndex) {
+    return false;
+  }
+
   const properties = targetType
     .getProperties()
     .filter((p) => !p.getName().startsWith(" $"));
@@ -458,37 +441,6 @@ function validateArgsType(
   return diagnostics;
 }
 
-/**
- * Checks if the extracted args are empty and the original type was not NoArgs.
- * This indicates the type resolved to an empty object.
- * Does not emit warnings for types that only have index signatures (they get INDEX_SIGNATURE_ONLY error instead).
- */
-function checkEmptyArgsType(
-  argsType: ts.Type,
-  argsTypeNode: ts.TypeNode,
-  args: ArgumentDefinition[] | null,
-  checker: ts.TypeChecker,
-): Diagnostic | null {
-  if (isNoArgsType(argsType, checker)) {
-    return null;
-  }
-
-  if (hasOnlyIndexSignatures(argsType, checker)) {
-    return null;
-  }
-
-  if (args !== null && args.length === 0) {
-    const typeName = getTypeNameForDiagnostic(argsType, checker);
-    return {
-      code: "EMPTY_TYPE_PROPERTIES",
-      message: `Type '${typeName}' has no properties. Consider adding properties or using a different type.`,
-      severity: "warning",
-      location: getSourceLocationFromNode(argsTypeNode),
-    };
-  }
-  return null;
-}
-
 interface ExtractTypeArgumentsFromCallParams {
   readonly node: ts.CallExpression;
   readonly inputContext: FieldTypeResolverContext;
@@ -538,18 +490,6 @@ function extractTypeArgumentsFromCall(
       ? null
       : extractArgsFromType(argsType, inputContext, argsTypeNode);
 
-    if (!isNoArgs) {
-      const emptyDiagnostic = checkEmptyArgsType(
-        argsType,
-        argsTypeNode,
-        args,
-        checker,
-      );
-      if (emptyDiagnostic) {
-        diagnostics.push(emptyDiagnostic);
-      }
-    }
-
     const directives = extractDirectivesFromTypeNode(
       directiveTypeNode,
       checker,
@@ -594,18 +534,6 @@ function extractTypeArgumentsFromCall(
     ? null
     : extractArgsFromType(argsType, inputContext, argsTypeNode);
 
-  if (!isNoArgs) {
-    const emptyDiagnostic = checkEmptyArgsType(
-      argsType,
-      argsTypeNode,
-      args,
-      checker,
-    );
-    if (emptyDiagnostic) {
-      diagnostics.push(emptyDiagnostic);
-    }
-  }
-
   const directives = extractDirectivesFromTypeNode(directiveTypeNode, checker);
 
   return {
@@ -784,6 +712,11 @@ export function extractDefineApiResolvers(
         diagnostics.push(...typeInfo.diagnostics);
 
         const tsdocInfo = extractTsDocInfo(node, checker);
+        const sourceLocation = getSourceLocationFromNode(declaration.name) ?? {
+          file: filePath,
+          line: 1,
+          column: 1,
+        };
 
         resolvers.push({
           fieldName,
@@ -793,6 +726,7 @@ export function extractDefineApiResolvers(
           args: typeInfo.args,
           returnType: typeInfo.returnType,
           sourceFile: filePath,
+          sourceLocation,
           exportedInputTypes,
           description: tsdocInfo.description,
           deprecated: tsdocInfo.deprecated,

package/src/resolver-extractor/index.ts

@@ -11,9 +11,3 @@ export type {
   AbstractResolverInfo,
   AbstractResolverKind,
 } from "./extractor/define-api-extractor.js";
-export type {
-  OnlyConstraintViolation,
-  OnlyConstraintViolationCode,
-  ValidateOnlyConstraintsOptions,
-  ValidationContext,
-} from "./validator/only-validator.js";

package/src/resolver-extractor/validator/abstract-resolver-validator.ts

@@ -16,6 +16,7 @@ import type { AbstractResolverInfo } from "../extractor/define-api-extractor.js"
 export interface ValidateAbstractResolversOptions {
   readonly abstractResolvers: ReadonlyArray<AbstractResolverInfo>;
   readonly baseTypes: ReadonlyArray<BaseType>;
+  readonly typenameAutoResolveTypeNames?: ReadonlySet<string>;
 }
 
 export interface ValidateAbstractResolversResult {
@@ -113,21 +114,26 @@ function createMissingResolverDiagnostic(
   };
 }
 
+interface DetectMissingAbstractTypeResolversParams {
+  readonly resolvers: ReadonlyArray<AbstractResolverInfo>;
+  readonly typeMap: Map<string, BaseType>;
+  readonly typenameAutoResolveTypeNames: ReadonlySet<string>;
+}
+
 /**
  * Detects abstract types (union/interface) that have no resolveType defined
  * and whose member/implementing types don't all have isTypeOf defined.
  *
- * @param resolvers - All abstract resolvers to check
- * @param typeMap - Map of type names to their definitions
+ * @param params - Parameters including resolvers, type map, and auto-generated typename resolveType names
  * @returns Array of warning diagnostics for missing resolvers
  */
 function detectMissingAbstractTypeResolvers(
-  resolvers: ReadonlyArray<AbstractResolverInfo>,
-  typeMap: Map<string, BaseType>,
+  params: DetectMissingAbstractTypeResolversParams,
 ): Diagnostic[] {
+  const { resolvers, typeMap, typenameAutoResolveTypeNames } = params;
   const diagnostics: Diagnostic[] = [];
 
-  const resolveTypeSet = new Set<string>();
+  const resolveTypeSet = new Set<string>(typenameAutoResolveTypeNames);
   const isTypeOfSet = new Set<string>();
 
   for (const resolver of resolvers) {
@@ -241,10 +247,12 @@ export function validateAbstractResolvers(
   );
   diagnostics.push(...duplicateDiagnostics);
 
-  const missingResolverWarnings = detectMissingAbstractTypeResolvers(
-    options.abstractResolvers,
+  const missingResolverWarnings = detectMissingAbstractTypeResolvers({
+    resolvers: options.abstractResolvers,
     typeMap,
-  );
+    typenameAutoResolveTypeNames:
+      options.typenameAutoResolveTypeNames ?? new Set(),
+  });
   diagnostics.push(...missingResolverWarnings);
 
   return { diagnostics };