@gqlkit-ts/cli 0.5.0 → 0.6.0

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

@@ -35,7 +35,11 @@ import type {
   TSTypeReference,
 } from "../../type-extractor/types/index.js";
 
-export type DefineApiResolverType = "query" | "mutation" | "field";
+export type DefineApiResolverType =
+  | "query"
+  | "mutation"
+  | "field"
+  | "subscription";
 
 export type AbstractResolverKind = "resolveType" | "isTypeOf";
 
@@ -56,6 +60,7 @@ export interface ArgumentDefinition {
 
 export interface DefineApiResolverInfo {
   readonly fieldName: string;
+  readonly resolverExportName: string;
   readonly resolverType: DefineApiResolverType;
   readonly parentTypeName: string | null;
   readonly argsType: TSTypeReference | null;
@@ -222,7 +227,12 @@ function detectResolverFromMetadataType(
   const kindType = checker.getTypeOfSymbol(kindProp);
   if (kindType.isStringLiteral()) {
     const kind = kindType.value;
-    if (kind === "query" || kind === "mutation" || kind === "field") {
+    if (
+      kind === "query" ||
+      kind === "mutation" ||
+      kind === "field" ||
+      kind === "subscription"
+    ) {
       return kind;
     }
   }
@@ -230,6 +240,20 @@ function detectResolverFromMetadataType(
   return null;
 }
 
+function resolveFieldNameFromExportName(exportName: string): string | null {
+  const delimiterIndex = exportName.lastIndexOf("$");
+  if (delimiterIndex === -1) {
+    return exportName;
+  }
+
+  const fieldName = exportName.slice(delimiterIndex + 1);
+  if (fieldName.length === 0) {
+    return null;
+  }
+
+  return fieldName;
+}
+
 function isInlineTypeLiteralDeclaration(declaration: ts.Declaration): boolean {
   if (!ts.isPropertySignature(declaration)) {
     return false;
@@ -633,7 +657,7 @@ export function extractDefineApiResolvers(
           continue;
         }
 
-        const fieldName = declaration.name.getText(sourceFile);
+        const exportName = declaration.name.getText(sourceFile);
         const initializer = declaration.initializer;
 
         if (!initializer) {
@@ -647,11 +671,11 @@ export function extractDefineApiResolvers(
           ) {
             const hasDefineCall = initializer
               .getText(sourceFile)
-              .match(/define(Query|Mutation|Field)/);
+              .match(/define(Query|Mutation|Field|Subscription)/);
             if (hasDefineCall) {
               diagnostics.push({
                 code: "INVALID_DEFINE_CALL",
-                message: `Complex expressions with define* functions are not supported. Use a simple 'export const ${fieldName} = defineXxx(...)' pattern.`,
+                message: `Complex expressions with define* functions are not supported. Use a simple 'export const ${exportName} = defineXxx(...)' pattern.`,
                 severity: "error",
                 location: getSourceLocationFromNode(declaration.name),
               });
@@ -671,7 +695,7 @@ export function extractDefineApiResolvers(
             abstractTypeResolvers.push({
               kind: abstractResolverInfo.kind,
               targetTypeName: abstractResolverInfo.targetTypeName,
-              exportName: fieldName,
+              exportName,
               sourceFile: filePath,
               sourceLocation,
             });
@@ -688,6 +712,17 @@ export function extractDefineApiResolvers(
           continue;
         }
 
+        const fieldName = resolveFieldNameFromExportName(exportName);
+        if (fieldName === null) {
+          diagnostics.push({
+            code: "INVALID_DEFINE_CALL",
+            message: `Resolver export '${exportName}' must have a non-empty field name after '$'.`,
+            severity: "error",
+            location: getSourceLocationFromNode(declaration.name),
+          });
+          continue;
+        }
+
         const funcName = ts.isIdentifier(initializer.expression)
           ? initializer.expression.text
           : undefined;
@@ -702,7 +737,7 @@ export function extractDefineApiResolvers(
         if (!typeInfo) {
           diagnostics.push({
             code: "INVALID_DEFINE_CALL",
-            message: `Failed to extract type arguments from ${funcName ?? "define*"} call for '${fieldName}'`,
+            message: `Failed to extract type arguments from ${funcName ?? "define*"} call for '${exportName}'`,
             severity: "error",
             location: getSourceLocationFromNode(declaration.name),
           });
@@ -720,6 +755,7 @@ export function extractDefineApiResolvers(
 
         resolvers.push({
           fieldName,
+          resolverExportName: exportName,
           resolverType,
           parentTypeName: typeInfo.parentTypeName,
           argsType: typeInfo.argsType,

package/src/resolver-extractor/index.ts

@@ -5,6 +5,7 @@ export type {
   GraphQLInputValue,
   MutationFieldDefinitions,
   QueryFieldDefinitions,
+  SubscriptionFieldDefinitions,
   TypeExtension,
 } from "./extract-resolvers.js";
 export type {

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

@@ -15,6 +15,7 @@ import type {
 } from "../integrator/result-integrator.js";
 import type {
   AbstractTypeResolverInfo,
+  FieldResolver,
   ResolverInfo,
   TypeResolvers,
 } from "../resolver-collector/resolver-collector.js";
@@ -315,21 +316,33 @@ function buildStringEnumResolvers(
   return stringEnumMappings.map(buildStringEnumResolver);
 }
 
+function buildFieldResolverValue(
+  localName: string,
+  field: FieldResolver,
+): string {
+  if (field.isDirectExport) {
+    return localName;
+  }
+  return `${localName}.${field.fieldName}`;
+}
+
 function buildTypeResolverEntry(
   type: TypeResolvers,
   abstractResolverForType: AbstractTypeResolverInfo | null,
 ): string {
   const entries: string[] = [];
+  const isSubscription = type.typeName === "Subscription";
 
   for (const field of type.fields) {
     const localName = makeResolverLocalName(type.typeName, field.fieldName);
+    const resolverValue = buildFieldResolverValue(localName, field);
 
-    if (field.isDirectExport) {
-      entries.push(`      ${field.fieldName}: ${localName},`);
-    } else {
+    if (isSubscription) {
       entries.push(
-        `      ${field.fieldName}: ${localName}.${field.fieldName},`,
+        `      ${field.fieldName}: { subscribe: ${resolverValue}, resolve: (event: unknown) => event },`,
       );
+    } else {
+      entries.push(`      ${field.fieldName}: ${resolverValue},`);
     }
   }
 

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

@@ -145,6 +145,7 @@ export interface IntegratedResult {
   readonly stringEnumMappings: ReadonlyArray<StringEnumMappingInfo>;
   readonly hasQuery: boolean;
   readonly hasMutation: boolean;
+  readonly hasSubscription: boolean;
   readonly hasErrors: boolean;
   readonly diagnostics: ReadonlyArray<Diagnostic>;
 }
@@ -469,8 +470,10 @@ export function integrate(params: IntegrateParams): IntegratedResult {
 
   const hasQuery = resolversResult.queryFields.fields.length > 0;
   const hasMutation = resolversResult.mutationFields.fields.length > 0;
+  const hasSubscription = resolversResult.subscriptionFields.fields.length > 0;
 
-  if (hasQuery) {
+  // GraphQL spec requires Query root type even when only Subscription/Mutation are defined
+  if (hasQuery || hasMutation || hasSubscription) {
     baseTypes.push({
       name: "Query",
       kind: "Object",
@@ -502,6 +505,22 @@ export function integrate(params: IntegrateParams): IntegratedResult {
       directives: null,
     });
   }
+  if (hasSubscription) {
+    baseTypes.push({
+      name: "Subscription",
+      kind: "Object",
+      fields: [],
+      unionMembers: null,
+      enumValues: null,
+      isNumericEnum: false,
+      needsStringEnumMapping: false,
+      implementedInterfaces: null,
+      description: null,
+      deprecated: null,
+      sourceFile: null,
+      directives: null,
+    });
+  }
 
   const typenameAutoResolveTypeNames = new Set([
     ...(typenameAutoResolveTypes?.map((t) => t.abstractTypeName) ?? []),
@@ -540,6 +559,15 @@ export function integrate(params: IntegrateParams): IntegratedResult {
     });
   }
 
+  if (hasSubscription) {
+    typeExtensions.push({
+      targetTypeName: "Subscription",
+      fields: resolversResult.subscriptionFields.fields.map(
+        convertToExtensionField,
+      ),
+    });
+  }
+
   for (const ext of resolversResult.typeExtensions) {
     if (!knownTypeNames.has(ext.targetTypeName)) {
       const firstField = ext.fields[0];
@@ -712,6 +740,7 @@ export function integrate(params: IntegrateParams): IntegratedResult {
     stringEnumMappings,
     hasQuery,
     hasMutation,
+    hasSubscription,
     hasErrors,
     diagnostics,
   };

package/src/type-extractor/extractor/type-name-collector.ts

@@ -1,8 +1,28 @@
 import ts from "typescript";
+import {
+  getSourceLocationFromNode,
+  type SourceLocation,
+} from "../../shared/source-location.js";
 import {
   isExported,
   resolveOriginalSymbol,
 } from "../../shared/typescript-utils.js";
+import type { Diagnostic } from "../types/index.js";
+
+/**
+ * Tracks location and symbol of a type declaration for duplicate detection.
+ */
+interface TypeDeclarationLocation {
+  readonly location: SourceLocation;
+  readonly symbol: ts.Symbol | null;
+}
+
+/**
+ * Formats a source location as a human-readable string.
+ */
+function formatLocation(location: SourceLocation): string {
+  return `${location.file}:${location.line}`;
+}
 
 export interface TypeNameCollectionResult {
   readonly typeNames: ReadonlySet<string>;
@@ -13,6 +33,11 @@ export interface TypeNameCollectionResult {
    * This allows recognizing `ExternalUser` as `User` in field types.
    */
   readonly underlyingSymbolToTypeName: ReadonlyMap<ts.Symbol, string>;
+  /**
+   * Diagnostics collected during type name collection.
+   * Contains errors for duplicate type exports.
+   */
+  readonly diagnostics: ReadonlyArray<Diagnostic>;
 }
 
 /**
@@ -33,8 +58,51 @@ export function collectDeclaredTypeNames(
   const typeNames = new Set<string>();
   const typeSymbols = new Map<string, ts.Symbol>();
   const underlyingSymbolToTypeName = new Map<ts.Symbol, string>();
+  const diagnostics: Diagnostic[] = [];
   const checker = program.getTypeChecker();
 
+  const typeLocations = new Map<string, TypeDeclarationLocation>();
+
+  /**
+   * Registers a type name and checks for duplicates.
+   * Returns true if this is a new type, false if it's a duplicate.
+   */
+  function registerTypeName(
+    name: string,
+    location: SourceLocation,
+    symbol: ts.Symbol | undefined,
+  ): boolean {
+    const resolvedSymbol = symbol
+      ? resolveOriginalSymbol(symbol, checker)
+      : null;
+    const existing = typeLocations.get(name);
+    if (existing) {
+      // Check if both symbols resolve to the same underlying type
+      // (e.g., re-exports of the same type from different files)
+      if (
+        resolvedSymbol &&
+        existing.symbol &&
+        resolvedSymbol === existing.symbol
+      ) {
+        // Same underlying type - not a true duplicate, skip silently
+        return false;
+      }
+      diagnostics.push({
+        code: "DUPLICATE_TYPE_EXPORT",
+        message: `Type '${name}' is exported from multiple files. First defined at ${formatLocation(existing.location)}.`,
+        severity: "error",
+        location,
+      });
+      return false;
+    }
+    typeLocations.set(name, { location, symbol: resolvedSymbol });
+    typeNames.add(name);
+    if (resolvedSymbol) {
+      typeSymbols.set(name, resolvedSymbol);
+    }
+    return true;
+  }
+
   for (const filePath of sourceFiles) {
     const sourceFile = program.getSourceFile(filePath);
     if (!sourceFile) continue;
@@ -43,11 +111,11 @@ export function collectDeclaredTypeNames(
       // Direct type declarations
       if (ts.isTypeAliasDeclaration(node) && isExported(node)) {
         const name = node.name.getText(sourceFile);
-        typeNames.add(name);
+        const location = getSourceLocationFromNode(node)!;
         const symbol = checker.getSymbolAtLocation(node.name);
-        if (symbol) {
-          typeSymbols.set(name, resolveOriginalSymbol(symbol, checker));
+        const isNew = registerTypeName(name, location, symbol);
 
+        if (isNew && symbol) {
           // For type aliases like `type User = ExternalUser;`,
           // also track the underlying type's symbol
           const type = checker.getTypeAtLocation(node.type);
@@ -62,19 +130,15 @@ export function collectDeclaredTypeNames(
       }
       if (ts.isInterfaceDeclaration(node) && isExported(node)) {
         const name = node.name.getText(sourceFile);
-        typeNames.add(name);
+        const location = getSourceLocationFromNode(node)!;
         const symbol = checker.getSymbolAtLocation(node.name);
-        if (symbol) {
-          typeSymbols.set(name, resolveOriginalSymbol(symbol, checker));
-        }
+        registerTypeName(name, location, symbol);
       }
       if (ts.isEnumDeclaration(node) && isExported(node)) {
         const name = node.name.getText(sourceFile);
-        typeNames.add(name);
+        const location = getSourceLocationFromNode(node)!;
         const symbol = checker.getSymbolAtLocation(node.name);
-        if (symbol) {
-          typeSymbols.set(name, resolveOriginalSymbol(symbol, checker));
-        }
+        registerTypeName(name, location, symbol);
       }
 
       // Re-exports: `export type { ... } from "..."` or `export type * from "..."`
@@ -85,11 +149,9 @@ export function collectDeclaredTypeNames(
             for (const element of node.exportClause.elements) {
               // Use the exported name (element.name), not the property name
               const name = element.name.getText(sourceFile);
-              typeNames.add(name);
+              const location = getSourceLocationFromNode(element)!;
               const symbol = checker.getSymbolAtLocation(element.name);
-              if (symbol) {
-                typeSymbols.set(name, resolveOriginalSymbol(symbol, checker));
-              }
+              registerTypeName(name, location, symbol);
             }
           }
         } else if (node.moduleSpecifier) {
@@ -103,8 +165,8 @@ export function collectDeclaredTypeNames(
               const name = exp.getName();
               // Check if the export is a type (not a value)
               if (isTypeExport(exp)) {
-                typeNames.add(name);
-                typeSymbols.set(name, resolveOriginalSymbol(exp, checker));
+                const location = getSourceLocationFromNode(node)!;
+                registerTypeName(name, location, exp);
               }
             }
           }
@@ -113,7 +175,7 @@ export function collectDeclaredTypeNames(
     });
   }
 
-  return { typeNames, typeSymbols, underlyingSymbolToTypeName };
+  return { typeNames, typeSymbols, underlyingSymbolToTypeName, diagnostics };
 }
 
 /**

package/src/type-extractor/types/diagnostics.ts

@@ -96,7 +96,8 @@ export type DiagnosticCode =
   | "TYPENAME_FIELD_STRUCTURE_MISMATCH"
   | "DUPLICATE_TYPENAME_VALUE"
   | "IGNORE_FIELD_NOT_FOUND"
-  | "IGNORE_ALL_FIELDS";
+  | "IGNORE_ALL_FIELDS"
+  | "DUPLICATE_TYPE_EXPORT";
 
 export interface Diagnostic {
   readonly code: DiagnosticCode;