@gqlkit-ts/cli 0.0.1 → 0.2.0

package/src/auto-type-generator/index.ts

@@ -0,0 +1,21 @@
+export {
+  type AutoGeneratedEnumValue,
+  type AutoGeneratedField,
+  type AutoGeneratedType,
+  type AutoTypeGeneratorInput,
+  type AutoTypeGeneratorResult,
+  type GeneratedFromInfo,
+  generateAutoTypes,
+} from "./auto-type-generator.js";
+export {
+  type NameCollisionValidatorInput,
+  type NameCollisionValidatorResult,
+  type UserDefinedTypeInfo,
+  validateNameCollisions,
+} from "./name-collision-validator.js";
+export type {
+  AutoTypeNameContext,
+  InputFieldContext,
+  ObjectFieldContext,
+  ResolverArgContext,
+} from "./naming-convention.js";

package/src/auto-type-generator/inline-enum-collector.ts

@@ -0,0 +1,290 @@
+import type ts from "typescript";
+import type {
+  ExtractResolversResult,
+  GraphQLFieldDefinition,
+} from "../resolver-extractor/index.js";
+import type { DeprecationInfo } from "../shared/tsdoc-parser.js";
+import type {
+  ExtractedTypeInfo,
+  FieldDefinition,
+  InlineEnumMemberInfo,
+  InlineObjectPropertyDef,
+  SourceLocation,
+} from "../type-extractor/types/index.js";
+import {
+  type AutoTypeNameContext,
+  buildFieldContext,
+} from "./naming-convention.js";
+
+/**
+ * Inline enum with context information for naming and generation.
+ */
+export interface InlineEnumWithContext {
+  readonly members: ReadonlyArray<InlineEnumMemberInfo>;
+  readonly context: AutoTypeNameContext;
+  readonly sourceLocation: SourceLocation;
+  readonly nullable: boolean;
+  /** External TypeScript enum symbol for deduplication (null for string literal unions) */
+  readonly externalEnumSymbol: ts.Symbol | null;
+  /** TSDoc description from the external enum type itself (null for string literal unions) */
+  readonly externalEnumDescription: string | null;
+  /** @deprecated tag from the external enum type itself (null for string literal unions) */
+  readonly externalEnumDeprecated: DeprecationInfo | null;
+}
+
+function isInputTypeName(name: string): boolean {
+  return name.endsWith("Input");
+}
+
+/**
+ * Collect inline enums from ExtractedTypeInfo.
+ * Task 4.1: Traverse type fields to find inline enums with context.
+ */
+export function collectInlineEnumsFromTypes(
+  extractedTypes: ReadonlyArray<ExtractedTypeInfo>,
+): InlineEnumWithContext[] {
+  const results: InlineEnumWithContext[] = [];
+
+  for (const typeInfo of extractedTypes) {
+    const isInput = isInputTypeName(typeInfo.metadata.name);
+
+    for (const field of typeInfo.fields) {
+      collectInlineEnumsFromField(
+        field,
+        typeInfo.metadata.name,
+        [],
+        isInput,
+        typeInfo.metadata.sourceFile,
+        results,
+      );
+    }
+  }
+
+  return results;
+}
+
+function collectInlineEnumsFromField(
+  field: FieldDefinition,
+  parentTypeName: string,
+  parentPath: ReadonlyArray<string>,
+  isInput: boolean,
+  sourceFile: string,
+  results: InlineEnumWithContext[],
+): void {
+  const tsType = field.tsType;
+  const fieldPath = [...parentPath, field.name];
+
+  if (tsType.kind === "inlineEnum" && tsType.inlineEnumMembers) {
+    results.push({
+      members: tsType.inlineEnumMembers,
+      context: buildFieldContext(parentTypeName, fieldPath, isInput),
+      sourceLocation: field.sourceLocation ?? {
+        file: sourceFile,
+        line: 1,
+        column: 1,
+      },
+      nullable: tsType.nullable,
+      externalEnumSymbol: tsType.externalEnumSymbol,
+      externalEnumDescription: tsType.externalEnumDescription,
+      externalEnumDeprecated: tsType.externalEnumDeprecated,
+    });
+  }
+
+  if (
+    tsType.kind === "array" &&
+    tsType.elementType?.kind === "inlineEnum" &&
+    tsType.elementType.inlineEnumMembers
+  ) {
+    results.push({
+      members: tsType.elementType.inlineEnumMembers,
+      context: buildFieldContext(parentTypeName, fieldPath, isInput),
+      sourceLocation: field.sourceLocation ?? {
+        file: sourceFile,
+        line: 1,
+        column: 1,
+      },
+      nullable: tsType.elementType.nullable,
+      externalEnumSymbol: tsType.elementType.externalEnumSymbol,
+      externalEnumDescription: tsType.elementType.externalEnumDescription,
+      externalEnumDeprecated: tsType.elementType.externalEnumDeprecated,
+    });
+  }
+
+  if (tsType.kind === "inlineObject" && tsType.inlineObjectProperties) {
+    collectInlineEnumsFromInlineObjectProperties(
+      tsType.inlineObjectProperties,
+      parentTypeName,
+      fieldPath,
+      isInput,
+      sourceFile,
+      results,
+    );
+  }
+}
+
+function collectInlineEnumsFromInlineObjectProperties(
+  properties: ReadonlyArray<InlineObjectPropertyDef>,
+  parentTypeName: string,
+  parentPath: ReadonlyArray<string>,
+  isInput: boolean,
+  sourceFile: string,
+  results: InlineEnumWithContext[],
+): void {
+  for (const prop of properties) {
+    const propPath = [...parentPath, prop.name];
+    const tsType = prop.tsType;
+
+    if (tsType.kind === "inlineEnum" && tsType.inlineEnumMembers) {
+      results.push({
+        members: tsType.inlineEnumMembers,
+        context: buildFieldContext(parentTypeName, propPath, isInput),
+        sourceLocation: prop.sourceLocation ?? {
+          file: sourceFile,
+          line: 1,
+          column: 1,
+        },
+        nullable: tsType.nullable,
+        externalEnumSymbol: tsType.externalEnumSymbol,
+        externalEnumDescription: tsType.externalEnumDescription,
+        externalEnumDeprecated: tsType.externalEnumDeprecated,
+      });
+    }
+
+    if (tsType.kind === "inlineObject" && tsType.inlineObjectProperties) {
+      collectInlineEnumsFromInlineObjectProperties(
+        tsType.inlineObjectProperties,
+        parentTypeName,
+        propPath,
+        isInput,
+        sourceFile,
+        results,
+      );
+    }
+  }
+}
+
+/**
+ * Collect inline enums from ExtractResolversResult.
+ * Task 4.2: Traverse resolver args to find inline enums with context.
+ */
+export function collectInlineEnumsFromResolvers(
+  resolversResult: ExtractResolversResult,
+): InlineEnumWithContext[] {
+  const results: InlineEnumWithContext[] = [];
+
+  for (const field of resolversResult.queryFields.fields) {
+    collectInlineEnumsFromResolverArgs(field, "query", null, results);
+  }
+
+  for (const field of resolversResult.mutationFields.fields) {
+    collectInlineEnumsFromResolverArgs(field, "mutation", null, results);
+  }
+
+  for (const ext of resolversResult.typeExtensions) {
+    for (const field of ext.fields) {
+      collectInlineEnumsFromResolverArgs(
+        field,
+        "field",
+        ext.targetTypeName,
+        results,
+      );
+    }
+  }
+
+  return results;
+}
+
+function collectInlineEnumsFromResolverArgs(
+  field: GraphQLFieldDefinition,
+  resolverType: "query" | "mutation" | "field",
+  parentTypeName: string | null,
+  results: InlineEnumWithContext[],
+): void {
+  if (!field.args) return;
+
+  for (const arg of field.args) {
+    if (arg.inlineEnumMembers) {
+      const context: AutoTypeNameContext = {
+        kind: "resolverArg",
+        resolverType,
+        fieldName: field.name,
+        argName: arg.name,
+        parentTypeName,
+        fieldPath: [],
+      };
+
+      results.push({
+        members: arg.inlineEnumMembers,
+        context,
+        sourceLocation: field.sourceLocation,
+        nullable: arg.type.nullable,
+        externalEnumSymbol: arg.externalEnumSymbol,
+        externalEnumDescription: arg.externalEnumDescription,
+        externalEnumDeprecated: arg.externalEnumDeprecated,
+      });
+    }
+
+    if (arg.inlineObjectProperties) {
+      collectInlineEnumsFromInlineObjectArg(
+        arg.inlineObjectProperties,
+        resolverType,
+        field.name,
+        arg.name,
+        parentTypeName,
+        [],
+        field.sourceLocation,
+        results,
+      );
+    }
+  }
+}
+
+function collectInlineEnumsFromInlineObjectArg(
+  properties: ReadonlyArray<InlineObjectPropertyDef>,
+  resolverType: "query" | "mutation" | "field",
+  fieldName: string,
+  argName: string,
+  parentTypeName: string | null,
+  parentPath: ReadonlyArray<string>,
+  sourceLocation: SourceLocation,
+  results: InlineEnumWithContext[],
+): void {
+  for (const prop of properties) {
+    const propPath = [...parentPath, prop.name];
+    const tsType = prop.tsType;
+
+    if (tsType.kind === "inlineEnum" && tsType.inlineEnumMembers) {
+      const context: AutoTypeNameContext = {
+        kind: "resolverArg",
+        resolverType,
+        fieldName,
+        argName,
+        parentTypeName,
+        fieldPath: propPath,
+      };
+
+      results.push({
+        members: tsType.inlineEnumMembers,
+        context,
+        sourceLocation: prop.sourceLocation ?? sourceLocation,
+        nullable: tsType.nullable,
+        externalEnumSymbol: tsType.externalEnumSymbol,
+        externalEnumDescription: tsType.externalEnumDescription,
+        externalEnumDeprecated: tsType.externalEnumDeprecated,
+      });
+    }
+
+    if (tsType.kind === "inlineObject" && tsType.inlineObjectProperties) {
+      collectInlineEnumsFromInlineObjectArg(
+        tsType.inlineObjectProperties,
+        resolverType,
+        fieldName,
+        argName,
+        parentTypeName,
+        propPath,
+        sourceLocation,
+        results,
+      );
+    }
+  }
+}

package/src/auto-type-generator/name-collision-validator.ts

@@ -0,0 +1,119 @@
+import { relative } from "node:path";
+import type {
+  Diagnostic,
+  SourceLocation,
+} from "../type-extractor/types/index.js";
+import type { AutoGeneratedType } from "./auto-type-generator.js";
+
+export interface UserDefinedTypeInfo {
+  readonly name: string;
+  readonly sourceLocation: SourceLocation;
+}
+
+export interface NameCollisionValidatorInput {
+  readonly userDefinedTypes: ReadonlyArray<UserDefinedTypeInfo>;
+  readonly autoGeneratedTypes: ReadonlyArray<AutoGeneratedType>;
+  readonly sourceRoot: string | null;
+}
+
+export interface NameCollisionValidatorResult {
+  readonly hasCollisions: boolean;
+  readonly diagnostics: ReadonlyArray<Diagnostic>;
+}
+
+function formatLocation(
+  loc: SourceLocation,
+  sourceRoot: string | null,
+): string {
+  let filePath = loc.file;
+  if (sourceRoot !== null) {
+    filePath = relative(sourceRoot, filePath);
+  }
+  const normalizedPath = filePath.replaceAll("\\", "/");
+  return `${normalizedPath}:${loc.line}`;
+}
+
+function findUserDefinedCollisions(
+  userDefinedTypes: ReadonlyArray<UserDefinedTypeInfo>,
+  autoGeneratedTypes: ReadonlyArray<AutoGeneratedType>,
+  sourceRoot: string | null,
+): Diagnostic[] {
+  const diagnostics: Diagnostic[] = [];
+
+  const userTypeMap = new Map<string, UserDefinedTypeInfo>();
+  for (const userType of userDefinedTypes) {
+    userTypeMap.set(userType.name, userType);
+  }
+
+  for (const autoType of autoGeneratedTypes) {
+    const userType = userTypeMap.get(autoType.name);
+    if (userType) {
+      diagnostics.push({
+        code: "AUTO_TYPE_NAME_COLLISION_USER",
+        message: `Auto-generated type '${autoType.name}' conflicts with user-defined type at ${formatLocation(userType.sourceLocation, sourceRoot)}. Consider renaming the field or using an explicit type definition.`,
+        severity: "error",
+        location: autoType.sourceLocation,
+      });
+    }
+  }
+
+  return diagnostics;
+}
+
+function findAutoGeneratedCollisions(
+  autoGeneratedTypes: ReadonlyArray<AutoGeneratedType>,
+  sourceRoot: string | null,
+): Diagnostic[] {
+  const diagnostics: Diagnostic[] = [];
+
+  const typesByName = new Map<string, AutoGeneratedType[]>();
+  for (const autoType of autoGeneratedTypes) {
+    const existing = typesByName.get(autoType.name);
+    if (existing) {
+      existing.push(autoType);
+    } else {
+      typesByName.set(autoType.name, [autoType]);
+    }
+  }
+
+  for (const [name, types] of typesByName) {
+    if (types.length > 1) {
+      const locations = types
+        .map((t) => formatLocation(t.sourceLocation, sourceRoot))
+        .join(", ");
+      const firstType = types[0];
+      if (firstType) {
+        diagnostics.push({
+          code: "AUTO_TYPE_NAME_COLLISION_AUTO",
+          message: `Auto-generated type name '${name}' is generated from multiple sources: ${locations}. Use explicit type definitions to resolve the conflict.`,
+          severity: "error",
+          location: firstType.sourceLocation,
+        });
+      }
+    }
+  }
+
+  return diagnostics;
+}
+
+export function validateNameCollisions(
+  input: NameCollisionValidatorInput,
+): NameCollisionValidatorResult {
+  const userCollisions = findUserDefinedCollisions(
+    input.userDefinedTypes,
+    input.autoGeneratedTypes,
+    input.sourceRoot,
+  );
+
+  const autoCollisions = findAutoGeneratedCollisions(
+    input.autoGeneratedTypes,
+    input.sourceRoot,
+  );
+
+  const diagnostics = [...userCollisions, ...autoCollisions];
+
+  return {
+    hasCollisions: diagnostics.length > 0,
+    diagnostics,
+  };
+}

package/src/auto-type-generator/naming-convention.ts

@@ -0,0 +1,126 @@
+/**
+ * Context for generating auto type names based on different scenarios.
+ */
+export type AutoTypeNameContext =
+  | ObjectFieldContext
+  | InputFieldContext
+  | ResolverArgContext;
+
+/**
+ * Context for Object type field inline objects.
+ * Generated name: {ParentTypeName}{PascalCaseFieldPath}
+ */
+export interface ObjectFieldContext {
+  readonly kind: "objectField";
+  readonly parentTypeName: string;
+  readonly fieldPath: ReadonlyArray<string>;
+}
+
+/**
+ * Context for Input type field inline objects.
+ * Generated name: {ParentTypeNameWithoutInputSuffix}{PascalCaseFieldPath}Input
+ */
+export interface InputFieldContext {
+  readonly kind: "inputField";
+  readonly parentTypeName: string;
+  readonly fieldPath: ReadonlyArray<string>;
+}
+
+/**
+ * Context for resolver argument inline objects.
+ * Query/Mutation: {PascalCaseFieldName}{PascalCaseArgName}{NestedPath}Input
+ * Field resolver: {ParentTypeName}{PascalCaseFieldName}{PascalCaseArgName}{NestedPath}Input
+ */
+export interface ResolverArgContext {
+  readonly kind: "resolverArg";
+  readonly resolverType: "query" | "mutation" | "field";
+  readonly fieldName: string;
+  readonly argName: string;
+  readonly parentTypeName: string | null;
+  readonly fieldPath: ReadonlyArray<string>;
+}
+
+/**
+ * Convert a string to PascalCase.
+ * Handles camelCase, snake_case, and kebab-case inputs.
+ */
+function toPascalCase(str: string): string {
+  if (str.length === 0) return str;
+
+  return str
+    .split(/[-_\s]+/)
+    .map((part) =>
+      part
+        .split(/(?=[A-Z])/)
+        .map(
+          (segment) =>
+            segment.charAt(0).toUpperCase() + segment.slice(1).toLowerCase(),
+        )
+        .join(""),
+    )
+    .join("");
+}
+
+/**
+ * Remove Input suffix from type name if present.
+ */
+function removeInputSuffix(typeName: string): string {
+  if (typeName.endsWith("Input")) {
+    return typeName.slice(0, -5);
+  }
+  return typeName;
+}
+
+/**
+ * Build a field context (object or input) based on the parent type name.
+ */
+export function buildFieldContext(
+  parentTypeName: string,
+  fieldPath: ReadonlyArray<string>,
+  isInput: boolean,
+): ObjectFieldContext | InputFieldContext {
+  return isInput
+    ? { kind: "inputField", parentTypeName, fieldPath }
+    : { kind: "objectField", parentTypeName, fieldPath };
+}
+
+/**
+ * Generate auto type name based on context.
+ */
+export function generateAutoTypeName(context: AutoTypeNameContext): string {
+  switch (context.kind) {
+    case "objectField":
+      return generateObjectFieldTypeName(context);
+    case "inputField":
+      return generateInputFieldTypeName(context);
+    case "resolverArg":
+      return generateResolverArgTypeName(context);
+  }
+}
+
+function generateObjectFieldTypeName(context: ObjectFieldContext): string {
+  const pathParts = context.fieldPath.map(toPascalCase).join("");
+  return `${context.parentTypeName}${pathParts}`;
+}
+
+function generateInputFieldTypeName(context: InputFieldContext): string {
+  const baseName = removeInputSuffix(context.parentTypeName);
+  const pathParts = context.fieldPath.map(toPascalCase).join("");
+  return `${baseName}${pathParts}Input`;
+}
+
+function generateResolverArgTypeName(context: ResolverArgContext): string {
+  const fieldNamePascal = toPascalCase(context.fieldName);
+  // Avoid "InputInput" duplication when argName is "input"
+  const argNamePascal =
+    context.argName.toLowerCase() === "input"
+      ? ""
+      : toPascalCase(context.argName);
+  const pathParts = context.fieldPath.map(toPascalCase).join("");
+
+  if (context.resolverType === "field" && context.parentTypeName) {
+    return `${context.parentTypeName}${fieldNamePascal}${argNamePascal}${pathParts}Input`;
+  }
+
+  return `${fieldNamePascal}${argNamePascal}${pathParts}Input`;
+}

package/src/cli.ts

@@ -0,0 +1,11 @@
+import { cli } from "gunshi";
+import { genCommand } from "./commands/gen.js";
+import { mainCommand } from "./commands/main.js";
+
+await cli(process.argv.slice(2), mainCommand, {
+  name: "gqlkit",
+  version: "0.0.0",
+  subCommands: {
+    gen: genCommand,
+  },
+});

package/src/commands/gen.ts

@@ -0,0 +1,141 @@
+import { dirname } from "node:path";
+import { define } from "gunshi";
+import { loadConfig } from "../config-loader/index.js";
+import { executeHooks } from "../gen-orchestrator/hook-executor/hook-executor.js";
+import {
+  executeGeneration,
+  type GenerationConfig,
+  writeGeneratedFiles,
+} from "../gen-orchestrator/orchestrator.js";
+import { createDiagnosticReporter } from "../gen-orchestrator/reporter/diagnostic-reporter.js";
+import { createProgressReporter } from "../gen-orchestrator/reporter/progress-reporter.js";
+
+export interface RunGenCommandOptions {
+  readonly cwd: string;
+}
+
+export interface RunGenCommandResult {
+  readonly exitCode: number;
+}
+
+export async function runGenCommand(
+  options: RunGenCommandOptions,
+): Promise<RunGenCommandResult> {
+  const writer = {
+    stdout: (msg: string) => console.log(msg),
+    stderr: (msg: string) => console.error(msg),
+  };
+
+  const progressReporter = createProgressReporter(writer);
+  const diagnosticReporter = createDiagnosticReporter(writer);
+
+  const configResult = await loadConfig({ cwd: options.cwd });
+
+  if (configResult.diagnostics.length > 0) {
+    diagnosticReporter.reportDiagnostics(configResult.diagnostics);
+    diagnosticReporter.reportError("Config load failed");
+    return { exitCode: 1 };
+  }
+
+  const configDir = configResult.configPath
+    ? dirname(configResult.configPath)
+    : options.cwd;
+
+  const { sourceDir, sourceIgnoreGlobs, output, scalars, tsconfigPath } =
+    configResult.config;
+
+  const config: GenerationConfig = {
+    cwd: options.cwd,
+    sourceDir,
+    sourceIgnoreGlobs,
+    output,
+    configDir,
+    customScalars: scalars,
+    tsconfigPath,
+  };
+
+  progressReporter.startPhase("Extracting types");
+  progressReporter.startPhase("Extracting resolvers");
+  progressReporter.startPhase("Generating schema");
+
+  const result = await executeGeneration(config);
+
+  if (result.diagnostics.length > 0) {
+    diagnosticReporter.reportDiagnostics(result.diagnostics);
+  }
+
+  if (!result.success) {
+    diagnosticReporter.reportError("Generation failed");
+    return { exitCode: 1 };
+  }
+
+  const writeResult = await writeGeneratedFiles({
+    files: result.files,
+  });
+
+  if (!writeResult.success) {
+    diagnosticReporter.reportError("Failed to write output files");
+    return { exitCode: 1 };
+  }
+
+  for (const filePath of writeResult.filesWritten) {
+    progressReporter.fileWritten(filePath);
+  }
+  progressReporter.complete();
+
+  const { hooks } = configResult.config;
+  let hookFailed = false;
+
+  if (
+    writeResult.filesWritten.length > 0 &&
+    hooks.afterAllFileWrite.length > 0
+  ) {
+    progressReporter.startHookPhase();
+
+    const hookResult = await executeHooks({
+      commands: hooks.afterAllFileWrite,
+      filePaths: writeResult.filesWritten,
+      cwd: options.cwd,
+      onHookComplete: (result) => {
+        if (result.success) {
+          progressReporter.hookCompleted(result.command);
+        } else {
+          progressReporter.hookFailed(
+            result.command,
+            result.exitCode,
+            result.stderr,
+          );
+        }
+      },
+    });
+
+    hookFailed = !hookResult.success;
+    const failedCount = hookResult.results.filter((r) => !r.success).length;
+    progressReporter.hookPhaseSummary(hookResult.results.length, failedCount);
+  }
+
+  if (hookFailed) {
+    diagnosticReporter.reportError("Hook execution failed");
+    return { exitCode: 1 };
+  }
+
+  diagnosticReporter.reportSuccess("Generation complete!");
+  return { exitCode: 0 };
+}
+
+export const genCommand = define({
+  name: "gen",
+  args: {
+    cwd: {
+      type: "string",
+      description: "Working directory for code generation",
+    },
+  },
+  run: async (ctx) => {
+    const cwd = ctx.values.cwd ?? process.cwd();
+    const result = await runGenCommand({ cwd });
+    if (result.exitCode !== 0) {
+      process.exitCode = result.exitCode;
+    }
+  },
+});