@gqlkit-ts/cli 0.2.0 → 0.3.0

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

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

@@ -1,4 +1,6 @@
 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 { toPosixPath } from "../../shared/index.js";
 import type { CollectedScalarType } from "../../type-extractor/collector/scalar-collector.js";
 import {
@@ -248,6 +250,30 @@ function buildTypeResolverEntry(
   return `    ${type.typeName}: {\n${entries.join("\n")}\n    },`;
 }
 
+function getResolveTypeExpression(
+  fieldPattern: AutoGeneratedResolveType["fieldPattern"],
+): string {
+  const { usedFieldNames } = fieldPattern;
+
+  if (usedFieldNames.size === 1) {
+    const fieldName = [...usedFieldNames][0]!;
+    return `obj.${fieldName}`;
+  }
+
+  const expressions = TYPENAME_FIELD_NAMES.filter((name) =>
+    usedFieldNames.has(name),
+  ).map((name) => `obj.${name}`);
+
+  return expressions.join(" ?? ");
+}
+
+function buildAutoResolveTypeEntry(
+  autoResolveType: AutoGeneratedResolveType,
+): string {
+  const expression = getResolveTypeExpression(autoResolveType.fieldPattern);
+  return `    ${autoResolveType.unionTypeName}: {\n      __resolveType: (obj) => ${expression},\n    },`;
+}
+
 function buildTypeEntries(
   resolverInfo: ResolverInfo,
   customScalars: ReadonlyArray<CollectedScalarType>,
@@ -269,15 +295,21 @@ function buildTypeEntries(
     abstractResolversByType.set(abstractResolver.typeName, abstractResolver);
   }
 
+  const autoResolveTypeByUnion = new Map<string, AutoGeneratedResolveType>(
+    resolverInfo.autoGeneratedResolveTypes.map((r) => [r.unionTypeName, r]),
+  );
+
   const allTypeNames = new Set<string>([
     ...typesWithFields.keys(),
     ...abstractResolversByType.keys(),
+    ...autoResolveTypeByUnion.keys(),
   ]);
   const sortedTypeNames = [...allTypeNames].sort();
 
   for (const typeName of sortedTypeNames) {
     const typeWithFields = typesWithFields.get(typeName);
     const abstractResolver = abstractResolversByType.get(typeName) ?? null;
+    const autoResolveType = autoResolveTypeByUnion.get(typeName);
 
     if (typeWithFields !== undefined) {
       typeEntries.push(
@@ -285,6 +317,8 @@ function buildTypeEntries(
       );
     } else if (abstractResolver !== null) {
       typeEntries.push(buildAbstractOnlyTypeEntry(abstractResolver));
+    } else if (autoResolveType !== undefined) {
+      typeEntries.push(buildAutoResolveTypeEntry(autoResolveType));
     }
   }
 

package/src/schema-generator/generate-schema.ts

@@ -1,6 +1,10 @@
 import {
+  collectTypenameExtractions,
+  collectTypenameResolveTypes,
   generateAutoTypes,
   validateNameCollisions,
+  validateSchemaTypenames,
+  validateTypenames,
 } from "../auto-type-generator/index.js";
 import type { ExtractResolversResult } from "../resolver-extractor/index.js";
 import type { DirectiveDefinitionInfo } from "../shared/directive-definition-extractor.js";
@@ -28,6 +32,7 @@ export interface GenerateSchemaInput {
   readonly directiveDefinitions: ReadonlyArray<DirectiveDefinitionInfo> | null;
   readonly enablePruning: boolean | null;
   readonly sourceRoot: string | null;
+  readonly knownTypeNames: ReadonlySet<string> | null;
 }
 
 export interface GenerateSchemaResult {
@@ -52,11 +57,13 @@ export function generateSchema(
     directiveDefinitions,
     enablePruning,
     sourceRoot,
+    knownTypeNames,
   } = input;
 
   const autoTypeResult = generateAutoTypes({
     extractedTypes,
     resolversResult,
+    knownTypeNames: knownTypeNames ?? new Set(),
   });
 
   const autoTypeErrors = autoTypeResult.diagnostics.filter(
@@ -120,13 +127,103 @@ export function generateSchema(
     },
   };
 
+  const typeMap = new Map(
+    autoTypeResult.updatedExtractedTypes.map((t) => [t.metadata.name, t]),
+  );
+
+  const manualResolveTypeNames = new Set(
+    autoTypeResult.updatedResolversResult.abstractTypeResolvers
+      .filter((r) => r.kind === "resolveType")
+      .map((r) => r.targetTypeName),
+  );
+
+  const typenameResolveTypesResult = collectTypenameResolveTypes({
+    extractedTypes: autoTypeResult.updatedExtractedTypes,
+    typeMap,
+    manualResolveTypeNames,
+  });
+
+  const typenameExtractions = collectTypenameExtractions({
+    extractedTypes: autoTypeResult.updatedExtractedTypes,
+    typeMap,
+  });
+
+  const typenameValidationDiagnostics: Diagnostic[] = [];
+
+  for (const extraction of typenameExtractions) {
+    const abstractType = typeMap.get(extraction.abstractTypeName);
+    if (!abstractType) {
+      continue;
+    }
+    const validationResult = validateTypenames({
+      extractionResult: extraction,
+      sourceLocation: abstractType.metadata.sourceLocation,
+      inlineObjectMembers: abstractType.inlineObjectMembers,
+    });
+    typenameValidationDiagnostics.push(...validationResult.diagnostics);
+  }
+
+  const schemaTypenameValidationResult = validateSchemaTypenames({
+    objectTypes: autoTypeResult.updatedExtractedTypes,
+    typeMap,
+  });
+  typenameValidationDiagnostics.push(
+    ...schemaTypenameValidationResult.diagnostics,
+  );
+
+  if (typenameValidationDiagnostics.length > 0) {
+    return {
+      typeDefsCode: "",
+      sdlContent: "",
+      resolversCode: "",
+      diagnostics: typenameValidationDiagnostics,
+      hasErrors: true,
+      prunedTypes: null,
+    };
+  }
+
+  const generatedInlineObjectTypes =
+    typenameResolveTypesResult.generatedInlineObjectTypes;
+
+  const updatedTypesForIntegration: ExtractTypesResult =
+    generatedInlineObjectTypes.length > 0
+      ? {
+          types: updatedTypesResult.types.map((type) => {
+            if (type.kind !== "Union") {
+              return type;
+            }
+            const inlineTypes = generatedInlineObjectTypes.filter(
+              (g) => g.abstractTypeName === type.name,
+            );
+            if (inlineTypes.length === 0) {
+              return type;
+            }
+            const newMembers = inlineTypes.map((g) => g.typeName);
+            return {
+              ...type,
+              unionMembers: [
+                ...(type.unionMembers ?? []),
+                ...newMembers,
+              ].sort(),
+            };
+          }),
+          diagnostics: updatedTypesResult.diagnostics,
+        }
+      : updatedTypesResult;
+
+  const allAutoGeneratedTypes = [
+    ...autoTypeResult.autoGeneratedTypes,
+    ...typenameResolveTypesResult.generatedObjectTypes,
+  ];
+
   const integratedResult = integrate(
-    updatedTypesResult,
+    updatedTypesForIntegration,
     autoTypeResult.updatedResolversResult,
     customScalarNames,
     customScalars,
     directiveDefinitions,
-    autoTypeResult.autoGeneratedTypes,
+    allAutoGeneratedTypes,
+    typenameResolveTypesResult.autoResolveTypes,
   );
 
   let documentNode = buildDocumentNode(

package/src/schema-generator/integrator/result-integrator.ts

@@ -1,4 +1,9 @@
-import type { AutoGeneratedType } from "../../auto-type-generator/index.js";
+import type {
+  AutoGeneratedType,
+  ResolveTypeFieldPattern,
+} from "../../auto-type-generator/index.js";
+import type { TypenameAutoResolveTypeInfo } from "../../auto-type-generator/typename-resolve-type-generator.js";
+import { createFieldNameSet } from "../../auto-type-generator/typename-types.js";
 import type {
   AbstractResolverInfo,
   ExtractResolversResult,
@@ -121,6 +126,12 @@ export interface StringEnumMappingInfo {
   readonly members: ReadonlyArray<StringEnumMember>;
 }
 
+export interface AutoGeneratedUnionInfo {
+  readonly name: string;
+  readonly fieldPattern: ResolveTypeFieldPattern;
+  readonly hasAutoResolveType: boolean;
+}
+
 export interface IntegratedResult {
   readonly baseTypes: ReadonlyArray<BaseType>;
   readonly inputTypes: ReadonlyArray<InputType>;
@@ -133,6 +144,12 @@ export interface IntegratedResult {
   readonly directiveDefinitions: ReadonlyArray<DirectiveDefinitionInfo> | null;
   /** Abstract type resolvers (resolveType and isTypeOf) */
   readonly abstractTypeResolvers: ReadonlyArray<AbstractResolverInfo>;
+  /** @deprecated Use autoGeneratedUnions instead */
+  readonly autoGeneratedUnionNames: ReadonlyArray<string>;
+  /** Auto-generated Union types that need __resolveType with field pattern info */
+  readonly autoGeneratedUnions: ReadonlyArray<AutoGeneratedUnionInfo>;
+  /** Union/Interface types that have typename-based auto resolveType */
+  readonly typenameAutoResolveTypes: ReadonlyArray<TypenameAutoResolveTypeInfo>;
   /** Numeric enum information for resolver generation */
   readonly numericEnums: ReadonlyArray<NumericEnumInfo>;
   /** String enum mappings for resolver generation */
@@ -257,6 +274,7 @@ export function integrate(
   collectedScalars?: ReadonlyArray<CollectedScalarType> | null,
   directiveDefinitions?: ReadonlyArray<DirectiveDefinitionInfo> | null,
   autoGeneratedTypes?: ReadonlyArray<AutoGeneratedType> | null,
+  typenameAutoResolveTypes?: ReadonlyArray<TypenameAutoResolveTypeInfo>,
 ): IntegratedResult {
   const directiveTypeAliasNames = new Set(
     directiveDefinitions?.map((d) => d.typeAliasName) ?? [],
@@ -281,6 +299,8 @@ export function integrate(
 
   const baseTypes: BaseType[] = [];
   const inputTypes: InputType[] = [];
+  const autoGeneratedUnionNames: string[] = [];
+  const autoGeneratedUnions: AutoGeneratedUnionInfo[] = [];
 
   for (const autoType of autoGeneratedTypes ?? []) {
     if (autoType.kind === "Object") {
@@ -327,6 +347,44 @@ export function integrate(
         sourceFile: autoType.sourceLocation.file,
         directives: null,
       });
+    } else if (autoType.kind === "Union") {
+      baseTypes.push({
+        name: autoType.name,
+        kind: "Union",
+        fields: null,
+        unionMembers: autoType.unionMembers ?? [],
+        enumValues: null,
+        isNumericEnum: false,
+        needsStringEnumMapping: false,
+        implementedInterfaces: null,
+        description: autoType.description,
+        deprecated: null,
+        sourceFile: autoType.sourceLocation.file,
+        directives: null,
+      });
+      autoGeneratedUnionNames.push(autoType.name);
+      autoGeneratedUnions.push({
+        name: autoType.name,
+        fieldPattern: autoType.resolveTypeFieldPattern ?? {
+          usedFieldNames: createFieldNameSet(["__typename"]),
+        },
+        hasAutoResolveType: autoType.resolveTypeFieldPattern !== null,
+      });
+    } else if (autoType.kind === "OneOfInputObject") {
+      inputTypes.push({
+        name: autoType.name,
+        fields: autoType.fields!.map((f) => ({
+          name: f.name,
+          type: f.type,
+          description: f.description,
+          deprecated: f.deprecated,
+          directives: f.directives,
+          defaultValue: f.defaultValue,
+        })),
+        sourceFile: autoType.sourceLocation.file,
+        description: autoType.description,
+        isOneOf: true,
+      });
     } else {
       inputTypes.push({
         name: autoType.name,
@@ -481,9 +539,17 @@ export function integrate(
     });
   }
 
+  const typenameAutoResolveTypeNames = new Set([
+    ...(typenameAutoResolveTypes?.map((t) => t.abstractTypeName) ?? []),
+    ...autoGeneratedUnions
+      .filter((u) => u.hasAutoResolveType)
+      .map((u) => u.name),
+  ]);
+
   const abstractResolverValidation = validateAbstractResolvers({
     abstractResolvers: resolversResult.abstractTypeResolvers,
     baseTypes,
+    typenameAutoResolveTypeNames,
   });
   diagnostics.push(...abstractResolverValidation.diagnostics);
 
@@ -680,6 +746,9 @@ export function integrate(
         ? directiveDefinitions
         : null,
     abstractTypeResolvers: resolversResult.abstractTypeResolvers,
+    autoGeneratedUnionNames,
+    autoGeneratedUnions,
+    typenameAutoResolveTypes: typenameAutoResolveTypes ?? [],
     numericEnums,
     stringEnumMappings,
     hasQuery,

package/src/schema-generator/resolver-collector/resolver-collector.ts

@@ -1,3 +1,4 @@
+import type { AutoGeneratedResolveType } from "../../auto-type-generator/resolve-type-generator.js";
 import type { AbstractResolverInfo } from "../../resolver-extractor/extractor/define-api-extractor.js";
 import type {
   ExtensionField,
@@ -28,6 +29,7 @@ export interface ResolverInfo {
   readonly types: ReadonlyArray<TypeResolvers>;
   readonly sourceFiles: ReadonlyArray<string>;
   readonly abstractTypeResolvers: ReadonlyArray<AbstractTypeResolverInfo>;
+  readonly autoGeneratedResolveTypes: ReadonlyArray<AutoGeneratedResolveType>;
 }
 
 function getResolverValueName(typeName: string): string {
@@ -104,6 +106,37 @@ export function collectResolverInfo(
     sourceFilesSet.add(resolver.sourceFile);
   }
 
+  const manualResolveTypeNames = new Set<string>(
+    abstractTypeResolvers
+      .filter((r) => r.resolverKey === "__resolveType")
+      .map((r) => r.typeName),
+  );
+
+  const inlineUnionResolveTypes: AutoGeneratedResolveType[] =
+    integratedResult.autoGeneratedUnions
+      .filter(
+        (u) => u.hasAutoResolveType && !manualResolveTypeNames.has(u.name),
+      )
+      .map((u) => ({
+        unionTypeName: u.name,
+        fieldPattern: u.fieldPattern,
+      }));
+
+  const typenameResolveTypes: AutoGeneratedResolveType[] =
+    integratedResult.typenameAutoResolveTypes
+      .filter((t) => !manualResolveTypeNames.has(t.abstractTypeName))
+      .map((t) => ({
+        unionTypeName: t.abstractTypeName,
+        fieldPattern: {
+          usedFieldNames: t.resolveTypePattern.usedFieldNames,
+        },
+      }));
+
+  const autoGeneratedResolveTypes = [
+    ...inlineUnionResolveTypes,
+    ...typenameResolveTypes,
+  ].sort((a, b) => a.unionTypeName.localeCompare(b.unionTypeName));
+
   const types: TypeResolvers[] = [...typeMap.entries()]
     .map(([typeName, fields]) => ({
       typeName,
@@ -119,5 +152,6 @@ export function collectResolverInfo(
     types,
     sourceFiles,
     abstractTypeResolvers,
+    autoGeneratedResolveTypes,
   };
 }