@gqlkit-ts/cli 0.1.0 → 0.3.0

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

@@ -0,0 +1,385 @@
+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 {
+  type BuildDocumentOptions,
+  buildDocumentNode,
+} from "../builder/ast-builder.js";
+import type {
+  IntegratedResult,
+  NumericEnumInfo,
+  StringEnumMappingInfo,
+} from "../integrator/result-integrator.js";
+import type {
+  AbstractTypeResolverInfo,
+  ResolverInfo,
+  TypeResolvers,
+} from "../resolver-collector/resolver-collector.js";
+
+const GENERATED_FILE_HEADER =
+  "// This file is auto-generated by gqlkit. DO NOT EDIT.";
+
+function formatDocumentNodeAsCode(
+  integratedResult: IntegratedResult,
+  options?: BuildDocumentOptions,
+): string {
+  const doc = buildDocumentNode(integratedResult, options);
+
+  return JSON.stringify(doc, null, 2);
+}
+
+export function emitTypeDefsCode(
+  integratedResult: IntegratedResult,
+  options?: BuildDocumentOptions,
+): string {
+  const documentNodeCode = formatDocumentNodeAsCode(integratedResult, options);
+
+  return `${GENERATED_FILE_HEADER}
+
+import type { DocumentNode } from "graphql";
+
+export const typeDefs: DocumentNode = ${documentNodeCode} as DocumentNode;
+`;
+}
+
+function computeRelativeImportPath(fromDir: string, toFile: string): string {
+  const relativePath = toPosixPath(path.relative(fromDir, toFile));
+  const withoutExt = relativePath.replace(/\.ts$/, ".js");
+  if (!withoutExt.startsWith(".")) {
+    return `./${withoutExt}`;
+  }
+  return withoutExt;
+}
+
+interface ScalarTypeImport {
+  readonly typeName: string;
+  readonly sourceFile: string;
+}
+
+function collectScalarTypeImports(
+  customScalars: ReadonlyArray<CollectedScalarType>,
+): ScalarTypeImport[] {
+  const imports: ScalarTypeImport[] = [];
+  const seen = new Set<string>();
+
+  for (const scalar of customScalars) {
+    if (
+      scalar.inputType &&
+      scalar.inputType.sourceFile !== "" &&
+      !seen.has(scalar.inputType.typeName)
+    ) {
+      imports.push({
+        typeName: scalar.inputType.typeName,
+        sourceFile: scalar.inputType.sourceFile,
+      });
+      seen.add(scalar.inputType.typeName);
+    }
+
+    for (const outputType of scalar.outputTypes) {
+      if (outputType.sourceFile !== "" && !seen.has(outputType.typeName)) {
+        imports.push({
+          typeName: outputType.typeName,
+          sourceFile: outputType.sourceFile,
+        });
+        seen.add(outputType.typeName);
+      }
+    }
+  }
+
+  return imports;
+}
+
+function buildScalarTypeImports(
+  scalarTypeImports: ScalarTypeImport[],
+  outputDir: string,
+): string[] {
+  const importsByFile = new Map<string, string[]>();
+
+  for (const imp of scalarTypeImports) {
+    const existing = importsByFile.get(imp.sourceFile) ?? [];
+    existing.push(imp.typeName);
+    importsByFile.set(imp.sourceFile, existing);
+  }
+
+  const imports: string[] = [];
+  const sortedFiles = [...importsByFile.keys()].sort();
+
+  for (const sourceFile of sortedFiles) {
+    const typeNames = importsByFile.get(sourceFile) ?? [];
+    const importPath = computeRelativeImportPath(outputDir, sourceFile);
+    imports.push(
+      `import type { ${typeNames.sort().join(", ")} } from "${importPath}";`,
+    );
+  }
+
+  return imports;
+}
+
+function buildScalarTypeParameter(scalar: CollectedScalarType): string {
+  const inputTypeName = scalar.inputType?.typeName ?? "unknown";
+  const outputTypeNames = scalar.outputTypes.map((t) => t.typeName);
+  const outputTypeUnion =
+    outputTypeNames.length > 0 ? outputTypeNames.join(" | ") : "unknown";
+  return `GraphQLScalarType<${inputTypeName}, ${outputTypeUnion}>`;
+}
+
+function buildScalarsArgumentType(
+  customScalars: ReadonlyArray<CollectedScalarType>,
+): string {
+  const entries = customScalars
+    .map((scalar) => {
+      const typeParam = buildScalarTypeParameter(scalar);
+      return `    ${scalar.scalarName}: ${typeParam};`;
+    })
+    .join("\n");
+
+  return `{\n  scalars: {\n${entries}\n  };\n}`;
+}
+
+function buildScalarResolverEntries(
+  customScalars: ReadonlyArray<CollectedScalarType>,
+): string[] {
+  return customScalars.map(
+    (scalar) => `    ${scalar.scalarName}: scalars.${scalar.scalarName},`,
+  );
+}
+
+function collectResolverImportsByFile(
+  resolverInfo: ResolverInfo,
+): Map<string, Set<string>> {
+  const importsByFile = new Map<string, Set<string>>();
+
+  for (const type of resolverInfo.types) {
+    for (const field of type.fields) {
+      const existing = importsByFile.get(field.sourceFile) ?? new Set<string>();
+      existing.add(field.resolverValueName);
+      importsByFile.set(field.sourceFile, existing);
+    }
+  }
+
+  for (const abstractResolver of resolverInfo.abstractTypeResolvers) {
+    const existing =
+      importsByFile.get(abstractResolver.sourceFile) ?? new Set<string>();
+    existing.add(abstractResolver.exportName);
+    importsByFile.set(abstractResolver.sourceFile, existing);
+  }
+
+  return importsByFile;
+}
+
+function buildResolverImports(
+  importsByFile: Map<string, Set<string>>,
+  outputDir: string,
+): string[] {
+  const imports: string[] = [];
+  const sortedFiles = [...importsByFile.keys()].sort();
+
+  for (const sourceFile of sortedFiles) {
+    const valueNames = importsByFile.get(sourceFile) ?? new Set<string>();
+    const importPath = computeRelativeImportPath(outputDir, sourceFile);
+    const sortedValues = [...valueNames].sort();
+
+    if (sortedValues.length > 0) {
+      imports.push(
+        `import { ${sortedValues.join(", ")} } from "${importPath}";`,
+      );
+    }
+  }
+
+  return imports;
+}
+
+function buildAbstractOnlyTypeEntry(
+  abstractResolver: AbstractTypeResolverInfo,
+): string {
+  return `    ${abstractResolver.typeName}: {\n      ${abstractResolver.resolverKey}: ${abstractResolver.exportName},\n    },`;
+}
+
+function buildNumericEnumResolver(enumInfo: NumericEnumInfo): string {
+  const entries = enumInfo.members
+    .map((member) => `      ${member.name}: ${member.numericValue},`)
+    .join("\n");
+  return `    ${enumInfo.enumName}: {\n${entries}\n    },`;
+}
+
+function buildNumericEnumResolvers(
+  numericEnums: ReadonlyArray<NumericEnumInfo>,
+): string[] {
+  return numericEnums.map(buildNumericEnumResolver);
+}
+
+function buildStringEnumResolver(enumInfo: StringEnumMappingInfo): string {
+  const entries = enumInfo.members
+    .map(
+      (member) => `      ${member.graphqlValue}: "${member.typescriptValue}",`,
+    )
+    .join("\n");
+  return `    ${enumInfo.enumName}: {\n${entries}\n    },`;
+}
+
+function buildStringEnumResolvers(
+  stringEnumMappings: ReadonlyArray<StringEnumMappingInfo>,
+): string[] {
+  return stringEnumMappings.map(buildStringEnumResolver);
+}
+
+function buildTypeResolverEntry(
+  type: TypeResolvers,
+  abstractResolverForType: AbstractTypeResolverInfo | null,
+): string {
+  const entries: string[] = [];
+
+  for (const field of type.fields) {
+    if (field.isDirectExport) {
+      entries.push(`      ${field.fieldName}: ${field.resolverValueName},`);
+    } else {
+      entries.push(
+        `      ${field.fieldName}: ${field.resolverValueName}.${field.fieldName},`,
+      );
+    }
+  }
+
+  if (abstractResolverForType !== null) {
+    entries.push(
+      `      ${abstractResolverForType.resolverKey}: ${abstractResolverForType.exportName},`,
+    );
+  }
+
+  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>,
+): string[] {
+  const typeEntries: string[] = [];
+  const hasCustomScalars = customScalars.length > 0;
+
+  if (hasCustomScalars) {
+    typeEntries.push(...buildScalarResolverEntries(customScalars));
+  }
+
+  const typesWithFields = new Map<string, TypeResolvers>();
+  for (const type of resolverInfo.types) {
+    typesWithFields.set(type.typeName, type);
+  }
+
+  const abstractResolversByType = new Map<string, AbstractTypeResolverInfo>();
+  for (const abstractResolver of resolverInfo.abstractTypeResolvers) {
+    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(
+        buildTypeResolverEntry(typeWithFields, abstractResolver),
+      );
+    } else if (abstractResolver !== null) {
+      typeEntries.push(buildAbstractOnlyTypeEntry(abstractResolver));
+    } else if (autoResolveType !== undefined) {
+      typeEntries.push(buildAutoResolveTypeEntry(autoResolveType));
+    }
+  }
+
+  return typeEntries;
+}
+
+interface EmitResolversCodeParams {
+  readonly resolverInfo: ResolverInfo;
+  readonly outputDir: string;
+  readonly customScalars: ReadonlyArray<CollectedScalarType>;
+  readonly numericEnums: ReadonlyArray<NumericEnumInfo>;
+  readonly stringEnumMappings: ReadonlyArray<StringEnumMappingInfo>;
+}
+
+export function emitResolversCode(params: EmitResolversCodeParams): string {
+  const {
+    resolverInfo,
+    outputDir,
+    customScalars,
+    numericEnums,
+    stringEnumMappings,
+  } = params;
+  const hasCustomScalars = customScalars.length > 0;
+  const imports: string[] = [];
+
+  if (hasCustomScalars) {
+    imports.push('import { GraphQLScalarType } from "graphql";');
+  }
+
+  const importsByFile = collectResolverImportsByFile(resolverInfo);
+  imports.push(...buildResolverImports(importsByFile, outputDir));
+
+  if (hasCustomScalars) {
+    const scalarTypeImports = collectScalarTypeImports(customScalars);
+    const scalarImports = buildScalarTypeImports(scalarTypeImports, outputDir);
+    imports.push(...scalarImports);
+  }
+
+  const numericEnumResolverEntries = buildNumericEnumResolvers(numericEnums);
+  const stringEnumResolverEntries =
+    buildStringEnumResolvers(stringEnumMappings);
+  const typeEntries = buildTypeEntries(resolverInfo, customScalars);
+
+  const allEntries = [
+    ...numericEnumResolverEntries,
+    ...stringEnumResolverEntries,
+    ...typeEntries,
+  ];
+
+  const functionSignature = hasCustomScalars
+    ? `export function createResolvers({ scalars }: ${buildScalarsArgumentType(customScalars)})`
+    : "export function createResolvers()";
+
+  const importSection = imports.length > 0 ? `${imports.join("\n")}\n\n` : "";
+
+  return `${GENERATED_FILE_HEADER}
+
+${importSection}${functionSignature} {
+  return {
+${allEntries.join("\n")}
+  };
+}
+`;
+}

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

@@ -0,0 +1,13 @@
+import { type DocumentNode, print } from "graphql";
+
+const GENERATED_FILE_HEADER =
+  "# This file is auto-generated by gqlkit. DO NOT EDIT.";
+
+/**
+ * DocumentNode を SDL 形式の文字列に変換する。
+ * graphql パッケージの print() 関数を使用して SDL を生成する。
+ */
+export function emitSdlContent(documentNode: DocumentNode): string {
+  const sdl = print(documentNode);
+  return `${GENERATED_FILE_HEADER}\n\n${sdl}`;
+}

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

@@ -0,0 +1,267 @@
+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";
+import type { CollectedScalarType } from "../type-extractor/collector/scalar-collector.js";
+import { convertToGraphQL } from "../type-extractor/converter/graphql-converter.js";
+import type { ExtractTypesResult } from "../type-extractor/index.js";
+import type {
+  Diagnostic,
+  ExtractedTypeInfo,
+} from "../type-extractor/types/index.js";
+import { buildDocumentNode } from "./builder/ast-builder.js";
+import { emitResolversCode, emitTypeDefsCode } from "./emitter/code-emitter.js";
+import { emitSdlContent } from "./emitter/sdl-emitter.js";
+import { integrate } from "./integrator/result-integrator.js";
+import { pruneDocumentNode } from "./pruner/schema-pruner.js";
+import { collectResolverInfo } from "./resolver-collector/resolver-collector.js";
+
+export interface GenerateSchemaInput {
+  readonly typesResult: ExtractTypesResult;
+  readonly extractedTypes: ReadonlyArray<ExtractedTypeInfo>;
+  readonly resolversResult: ExtractResolversResult;
+  readonly outputDir: string;
+  readonly customScalarNames: ReadonlyArray<string> | null;
+  readonly customScalars: ReadonlyArray<CollectedScalarType> | null;
+  readonly directiveDefinitions: ReadonlyArray<DirectiveDefinitionInfo> | null;
+  readonly enablePruning: boolean | null;
+  readonly sourceRoot: string | null;
+  readonly knownTypeNames: ReadonlySet<string> | null;
+}
+
+export interface GenerateSchemaResult {
+  readonly typeDefsCode: string;
+  readonly sdlContent: string;
+  readonly resolversCode: string;
+  readonly diagnostics: ReadonlyArray<Diagnostic>;
+  readonly hasErrors: boolean;
+  readonly prunedTypes: ReadonlyArray<string> | null;
+}
+
+export function generateSchema(
+  input: GenerateSchemaInput,
+): GenerateSchemaResult {
+  const {
+    typesResult,
+    extractedTypes,
+    resolversResult,
+    outputDir,
+    customScalarNames,
+    customScalars,
+    directiveDefinitions,
+    enablePruning,
+    sourceRoot,
+    knownTypeNames,
+  } = input;
+
+  const autoTypeResult = generateAutoTypes({
+    extractedTypes,
+    resolversResult,
+    knownTypeNames: knownTypeNames ?? new Set(),
+  });
+
+  const autoTypeErrors = autoTypeResult.diagnostics.filter(
+    (d) => d.severity === "error",
+  );
+  if (autoTypeErrors.length > 0) {
+    return {
+      typeDefsCode: "",
+      sdlContent: "",
+      resolversCode: "",
+      diagnostics: autoTypeResult.diagnostics,
+      hasErrors: true,
+      prunedTypes: null,
+    };
+  }
+
+  const userDefinedTypes = extractedTypes.map((t) => ({
+    name: t.metadata.name,
+    sourceLocation: t.metadata.sourceLocation,
+  }));
+
+  const collisionResult = validateNameCollisions({
+    userDefinedTypes,
+    autoGeneratedTypes: autoTypeResult.autoGeneratedTypes,
+    sourceRoot,
+  });
+
+  if (collisionResult.hasCollisions) {
+    return {
+      typeDefsCode: "",
+      sdlContent: "",
+      resolversCode: "",
+      diagnostics: collisionResult.diagnostics,
+      hasErrors: true,
+      prunedTypes: null,
+    };
+  }
+
+  // Re-convert to GraphQL types using updated extracted types
+  // This resolves __INLINE_OBJECT__ references to auto-generated type names
+  const updatedConversionResult = convertToGraphQL(
+    autoTypeResult.updatedExtractedTypes,
+  );
+  const updatedTypesResult: ExtractTypesResult = {
+    types: updatedConversionResult.types,
+    diagnostics: {
+      errors: [
+        ...typesResult.diagnostics.errors,
+        ...updatedConversionResult.diagnostics.filter(
+          (d) => d.severity === "error",
+        ),
+        ...autoTypeResult.diagnostics.filter((d) => d.severity === "error"),
+      ],
+      warnings: [
+        ...typesResult.diagnostics.warnings,
+        ...updatedConversionResult.diagnostics.filter(
+          (d) => d.severity === "warning",
+        ),
+        ...autoTypeResult.diagnostics.filter((d) => d.severity === "warning"),
+      ],
+    },
+  };
+
+  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(
+    updatedTypesForIntegration,
+    autoTypeResult.updatedResolversResult,
+    customScalarNames,
+    customScalars,
+    directiveDefinitions,
+    allAutoGeneratedTypes,
+    typenameResolveTypesResult.autoResolveTypes,
+  );
+
+  let documentNode = buildDocumentNode(
+    integratedResult,
+    sourceRoot !== null ? { sourceRoot } : undefined,
+  );
+  let prunedTypes: ReadonlyArray<string> | null = null;
+
+  if (enablePruning) {
+    const pruneResult = pruneDocumentNode({
+      documentNode,
+      customScalarNames,
+    });
+    documentNode = pruneResult.documentNode;
+    prunedTypes = pruneResult.removedTypes;
+  }
+
+  const typeDefsCode = emitTypeDefsCode(
+    integratedResult,
+    sourceRoot !== null ? { sourceRoot } : undefined,
+  );
+  const sdlContent = emitSdlContent(documentNode);
+
+  const resolverInfo = collectResolverInfo(integratedResult);
+  const resolversCode = emitResolversCode({
+    resolverInfo,
+    outputDir,
+    customScalars: customScalars ?? [],
+    numericEnums: integratedResult.numericEnums,
+    stringEnumMappings: integratedResult.stringEnumMappings,
+  });
+
+  return {
+    typeDefsCode,
+    sdlContent,
+    resolversCode,
+    diagnostics: integratedResult.diagnostics,
+    hasErrors: integratedResult.hasErrors,
+    prunedTypes,
+  };
+}

package/src/schema-generator/index.ts

@@ -0,0 +1,19 @@
+export {
+  type GenerateSchemaInput,
+  type GenerateSchemaResult,
+  generateSchema,
+} from "./generate-schema.js";
+export type {
+  BaseField,
+  BaseType,
+  CustomScalarInfo,
+  ExtensionField,
+  IntegratedResult,
+  TypeExtension,
+} from "./integrator/result-integrator.js";
+export type {
+  AbstractTypeResolverInfo,
+  FieldResolver,
+  ResolverInfo,
+  TypeResolvers,
+} from "./resolver-collector/resolver-collector.js";