@gqlkit-ts/cli 0.1.0 → 0.3.0

package/src/gen-orchestrator/reporter/diagnostic-reporter.ts

@@ -0,0 +1,44 @@
+import type { Diagnostic } from "../../type-extractor/index.js";
+import type { OutputWriter } from "./progress-reporter.js";
+
+export interface DiagnosticReporter {
+  reportDiagnostics(diagnostics: ReadonlyArray<Diagnostic>): void;
+  reportError(message: string): void;
+  reportSuccess(message: string): void;
+}
+
+function formatDiagnostic(diagnostic: Diagnostic): string {
+  const severity = diagnostic.severity;
+  const code = diagnostic.code;
+  const message = diagnostic.message;
+
+  if (diagnostic.location) {
+    const { file, line, column } = diagnostic.location;
+    return `${file}:${line}:${column} - ${severity}[${code}]: ${message}`;
+  }
+
+  return `${severity}[${code}]: ${message}`;
+}
+
+export function createDiagnosticReporter(
+  writer: OutputWriter,
+): DiagnosticReporter {
+  return {
+    reportDiagnostics(diagnostics: ReadonlyArray<Diagnostic>): void {
+      for (const diagnostic of diagnostics) {
+        const formatted = formatDiagnostic(diagnostic);
+        if (diagnostic.severity === "error") {
+          writer.stderr(formatted);
+        } else {
+          writer.stdout(formatted);
+        }
+      }
+    },
+    reportError(message: string): void {
+      writer.stderr(`error: ${message}`);
+    },
+    reportSuccess(message: string): void {
+      writer.stdout(message);
+    },
+  };
+}

package/src/gen-orchestrator/reporter/progress-reporter.ts

@@ -0,0 +1,61 @@
+export interface OutputWriter {
+  readonly stdout: (message: string) => void;
+  readonly stderr: (message: string) => void;
+}
+
+export interface ProgressReporter {
+  startPhase(phaseName: string): void;
+  fileWritten(filePath: string): void;
+  complete(): void;
+
+  /** Display hook execution start message */
+  startHookPhase(): void;
+
+  /** Display successful hook completion */
+  hookCompleted(command: string): void;
+
+  /** Display hook failure with error details */
+  hookFailed(command: string, exitCode: number | null, stderr: string): void;
+
+  /** Display hook phase summary */
+  hookPhaseSummary(totalCount: number, failedCount: number): void;
+}
+
+export function createProgressReporter(writer: OutputWriter): ProgressReporter {
+  return {
+    startPhase(phaseName: string): void {
+      writer.stdout(`  ${phaseName}...`);
+    },
+    fileWritten(filePath: string): void {
+      writer.stdout(`    wrote ${filePath}`);
+    },
+    complete(): void {
+      writer.stdout("  Done!");
+    },
+    startHookPhase(): void {
+      writer.stdout("  Running hooks...");
+    },
+    hookCompleted(command: string): void {
+      writer.stdout(`    hook completed: ${command}`);
+    },
+    hookFailed(command: string, exitCode: number | null, stderr: string): void {
+      const exitCodeStr = exitCode !== null ? ` (exit code: ${exitCode})` : "";
+      writer.stderr(`    hook failed: ${command}${exitCodeStr}`);
+      const trimmedStderr = stderr.trim();
+      if (trimmedStderr) {
+        for (const line of trimmedStderr.split("\n")) {
+          writer.stderr(`      ${line}`);
+        }
+      }
+    },
+    hookPhaseSummary(totalCount: number, failedCount: number): void {
+      if (failedCount === 0) {
+        writer.stdout(`  Hooks completed: ${totalCount} succeeded`);
+      } else {
+        writer.stderr(
+          `  Hooks completed: ${totalCount - failedCount} succeeded, ${failedCount} failed`,
+        );
+      }
+    },
+  };
+}

package/src/gen-orchestrator/writer/file-writer.ts

@@ -0,0 +1,38 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+
+export interface WriteFileOptions {
+  readonly files: ReadonlyArray<{
+    readonly filePath: string;
+    readonly content: string;
+  }>;
+}
+
+export interface WriteResult {
+  readonly success: boolean;
+  readonly writtenPaths: ReadonlyArray<string>;
+  readonly error: Error | null;
+}
+
+export async function writeFiles(
+  options: WriteFileOptions,
+): Promise<WriteResult> {
+  const { files } = options;
+  const writtenPaths: string[] = [];
+
+  try {
+    for (const file of files) {
+      await mkdir(dirname(file.filePath), { recursive: true });
+      await writeFile(file.filePath, file.content, "utf-8");
+      writtenPaths.push(file.filePath);
+    }
+
+    return { success: true, writtenPaths, error: null };
+  } catch (error) {
+    return {
+      success: false,
+      writtenPaths,
+      error: error instanceof Error ? error : new Error(String(error)),
+    };
+  }
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export type { GqlkitConfig, ScalarMappingConfig } from "./config/index.js";
+export { defineConfig } from "./config/index.js";

package/src/resolver-extractor/extract-resolvers.ts

@@ -0,0 +1,82 @@
+import type ts from "typescript";
+import type {
+  DirectiveArgumentValue,
+  DirectiveInfo,
+} from "../shared/directive-detector.js";
+import type { DeprecationInfo } from "../shared/tsdoc-parser.js";
+import type {
+  Diagnostics,
+  GraphQLFieldType,
+  InlineEnumMemberInfo,
+  InlineObjectPropertyDef,
+  SourceLocation,
+  TSTypeReference,
+} from "../type-extractor/types/index.js";
+import type { AbstractResolverInfo } from "./extractor/define-api-extractor.js";
+
+export interface GraphQLInputValue {
+  readonly name: string;
+  readonly type: GraphQLFieldType;
+  readonly description: string | null;
+  readonly deprecated: DeprecationInfo | null;
+  readonly defaultValue: DirectiveArgumentValue | null;
+  readonly inlineObjectProperties: ReadonlyArray<InlineObjectPropertyDef> | null;
+  /** Inline enum members when arg type is an inline enum (string literal union or external TypeScript enum) */
+  readonly inlineEnumMembers: ReadonlyArray<InlineEnumMemberInfo> | null;
+  /** External TypeScript enum symbol for deduplication across multiple references */
+  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;
+  /** Inline union members when arg type is a union type (for @oneOf input objects) */
+  readonly inlineUnionMembers: ReadonlyArray<TSTypeReference> | null;
+}
+
+export interface GraphQLFieldDefinition {
+  readonly name: string;
+  readonly type: GraphQLFieldType;
+  readonly args: ReadonlyArray<GraphQLInputValue> | null;
+  readonly sourceLocation: SourceLocation;
+  readonly resolverExportName: string | null;
+  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 {
+  readonly fields: ReadonlyArray<GraphQLFieldDefinition>;
+}
+
+export interface MutationFieldDefinitions {
+  readonly fields: ReadonlyArray<GraphQLFieldDefinition>;
+}
+
+export interface TypeExtension {
+  readonly targetTypeName: string;
+  readonly fields: ReadonlyArray<GraphQLFieldDefinition>;
+}
+
+export interface ExtractResolversResult {
+  readonly queryFields: QueryFieldDefinitions;
+  readonly mutationFields: MutationFieldDefinitions;
+  readonly typeExtensions: ReadonlyArray<TypeExtension>;
+  readonly abstractTypeResolvers: ReadonlyArray<AbstractResolverInfo>;
+  readonly diagnostics: Diagnostics;
+}