@gqlkit-ts/cli 0.1.0 → 0.3.0

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

@@ -0,0 +1,112 @@
+import { pruneSchema } from "@graphql-tools/utils";
+import {
+  buildASTSchema,
+  type DocumentNode,
+  type GraphQLSchema,
+  Kind,
+  parse,
+  print,
+  printSchema,
+} from "graphql";
+
+export interface PruneDocumentNodeInput {
+  readonly documentNode: DocumentNode;
+  readonly customScalarNames: ReadonlyArray<string> | null;
+}
+
+export interface PruneDocumentNodeResult {
+  readonly documentNode: DocumentNode;
+  readonly removedTypes: ReadonlyArray<string>;
+}
+
+function getTypeNamesFromDocument(documentNode: DocumentNode): Set<string> {
+  const typeNames = new Set<string>();
+
+  for (const definition of documentNode.definitions) {
+    if (
+      definition.kind === Kind.OBJECT_TYPE_DEFINITION ||
+      definition.kind === Kind.INPUT_OBJECT_TYPE_DEFINITION ||
+      definition.kind === Kind.ENUM_TYPE_DEFINITION ||
+      definition.kind === Kind.UNION_TYPE_DEFINITION ||
+      definition.kind === Kind.SCALAR_TYPE_DEFINITION ||
+      definition.kind === Kind.INTERFACE_TYPE_DEFINITION
+    ) {
+      typeNames.add(definition.name.value);
+    }
+  }
+
+  return typeNames;
+}
+
+function getTypeNamesFromSchema(schema: GraphQLSchema): Set<string> {
+  const typeNames = new Set<string>();
+  const typeMap = schema.getTypeMap();
+
+  for (const typeName of Object.keys(typeMap)) {
+    if (!typeName.startsWith("__")) {
+      typeNames.add(typeName);
+    }
+  }
+
+  return typeNames;
+}
+
+function extractCustomScalarDefinitions(
+  documentNode: DocumentNode,
+  customScalarNames: ReadonlyArray<string>,
+): DocumentNode["definitions"] {
+  const customScalarSet = new Set(customScalarNames);
+  return documentNode.definitions.filter(
+    (def) =>
+      def.kind === Kind.SCALAR_TYPE_DEFINITION &&
+      customScalarSet.has(def.name.value),
+  );
+}
+
+/**
+ * Remove unused types from DocumentNode.
+ * Types not referenced from Query, Mutation, or Subscription are removed.
+ * Custom scalars are preserved and excluded from pruning.
+ */
+export function pruneDocumentNode(
+  input: PruneDocumentNodeInput,
+): PruneDocumentNodeResult {
+  const { documentNode } = input;
+  const customScalarNames = input.customScalarNames ?? [];
+
+  const originalTypeNames = getTypeNamesFromDocument(documentNode);
+  const customScalarSet = new Set(customScalarNames);
+
+  const customScalarDefinitions = extractCustomScalarDefinitions(
+    documentNode,
+    customScalarNames,
+  );
+
+  const sdl = print(documentNode);
+  const schema = buildASTSchema(parse(sdl));
+
+  const prunedSchema = pruneSchema(schema, {
+    skipPruning: (type) => customScalarSet.has(type.name),
+  });
+
+  const prunedSdl = printSchema(prunedSchema);
+  const prunedDocument = parse(prunedSdl);
+  const prunedTypeNames = getTypeNamesFromSchema(prunedSchema);
+
+  const finalDocument: DocumentNode = {
+    kind: Kind.DOCUMENT,
+    definitions: [...customScalarDefinitions, ...prunedDocument.definitions],
+  };
+
+  const removedTypes: string[] = [];
+  for (const typeName of originalTypeNames) {
+    if (!prunedTypeNames.has(typeName) && !customScalarSet.has(typeName)) {
+      removedTypes.push(typeName);
+    }
+  }
+
+  return {
+    documentNode: finalDocument,
+    removedTypes: removedTypes.sort(),
+  };
+}

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

@@ -0,0 +1,157 @@
+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,
+  IntegratedResult,
+  TypeExtension,
+} from "../integrator/result-integrator.js";
+
+export interface FieldResolver {
+  readonly fieldName: string;
+  readonly sourceFile: string;
+  readonly resolverValueName: string;
+  readonly isDirectExport: boolean;
+}
+
+export interface TypeResolvers {
+  readonly typeName: string;
+  readonly fields: ReadonlyArray<FieldResolver>;
+}
+
+export interface AbstractTypeResolverInfo {
+  readonly typeName: string;
+  readonly resolverKey: "__resolveType" | "__isTypeOf";
+  readonly sourceFile: string;
+  readonly exportName: string;
+}
+
+export interface ResolverInfo {
+  readonly types: ReadonlyArray<TypeResolvers>;
+  readonly sourceFiles: ReadonlyArray<string>;
+  readonly abstractTypeResolvers: ReadonlyArray<AbstractTypeResolverInfo>;
+  readonly autoGeneratedResolveTypes: ReadonlyArray<AutoGeneratedResolveType>;
+}
+
+function getResolverValueName(typeName: string): string {
+  return `${typeName.charAt(0).toLowerCase()}${typeName.slice(1)}Resolver`;
+}
+
+function collectFieldResolver(
+  field: ExtensionField,
+  fallbackResolverValueName: string,
+): FieldResolver {
+  const isDirectExport = field.resolverExportName !== null;
+  const resolverValueName = isDirectExport
+    ? field.resolverExportName!
+    : fallbackResolverValueName;
+
+  return {
+    fieldName: field.name,
+    sourceFile: field.resolverSourceFile,
+    resolverValueName,
+    isDirectExport,
+  };
+}
+
+function collectFieldResolvers(ext: TypeExtension): FieldResolver[] {
+  const fallbackResolverValueName = getResolverValueName(ext.targetTypeName);
+
+  return ext.fields.map((field) =>
+    collectFieldResolver(field, fallbackResolverValueName),
+  );
+}
+
+function convertToAbstractTypeResolverInfo(
+  resolver: AbstractResolverInfo,
+): AbstractTypeResolverInfo {
+  return {
+    typeName: resolver.targetTypeName,
+    resolverKey:
+      resolver.kind === "resolveType" ? "__resolveType" : "__isTypeOf",
+    sourceFile: resolver.sourceFile,
+    exportName: resolver.exportName,
+  };
+}
+
+function collectAbstractTypeResolvers(
+  abstractResolvers: ReadonlyArray<AbstractResolverInfo>,
+): AbstractTypeResolverInfo[] {
+  return abstractResolvers
+    .map(convertToAbstractTypeResolverInfo)
+    .sort((a, b) => a.typeName.localeCompare(b.typeName));
+}
+
+export function collectResolverInfo(
+  integratedResult: IntegratedResult,
+): ResolverInfo {
+  const typeMap = new Map<string, FieldResolver[]>();
+  const sourceFilesSet = new Set<string>();
+
+  for (const ext of integratedResult.typeExtensions) {
+    const fieldResolvers = collectFieldResolvers(ext);
+
+    for (const resolver of fieldResolvers) {
+      sourceFilesSet.add(resolver.sourceFile);
+    }
+
+    const existing = typeMap.get(ext.targetTypeName) ?? [];
+    typeMap.set(ext.targetTypeName, [...existing, ...fieldResolvers]);
+  }
+
+  const abstractTypeResolvers = collectAbstractTypeResolvers(
+    integratedResult.abstractTypeResolvers,
+  );
+
+  for (const resolver of abstractTypeResolvers) {
+    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,
+      fields: [...fields].sort((a, b) =>
+        a.fieldName.localeCompare(b.fieldName),
+      ),
+    }))
+    .sort((a, b) => a.typeName.localeCompare(b.typeName));
+
+  const sourceFiles = [...sourceFilesSet].sort((a, b) => a.localeCompare(b));
+
+  return {
+    types,
+    sourceFiles,
+    abstractTypeResolvers,
+    autoGeneratedResolveTypes,
+  };
+}

package/src/shared/constants.ts

@@ -0,0 +1,122 @@
+/**
+ * TypeScript internal symbol names.
+ *
+ * These are internal names used by the TypeScript compiler to represent
+ * certain types. They should be treated as implementation details and
+ * filtered out when converting TypeScript types to GraphQL types.
+ */
+
+/**
+ * Anonymous object type symbol name.
+ *
+ * When TypeScript encounters an anonymous object type (e.g., `{ name: string }`
+ * without a type alias), it uses `__type` as the internal symbol name.
+ *
+ * This commonly occurs when:
+ * 1. A type is defined inline without a name
+ * 2. A type reference is resolved through complex type operations
+ *    (e.g., extracting from optional properties, intersection types)
+ * 3. The original type name is lost during TypeScript's internal type resolution
+ *
+ * In the context of GqlField<T, Meta>, when we extract T from the
+ * `$gqlkitOriginalType` property, TypeScript may return the type with
+ * `__type` as its symbol name instead of the original type name (e.g., "NestedConfig").
+ * This happens because:
+ * - The property is optional (`T | undefined`)
+ * - TypeScript's type resolution doesn't always preserve the original type alias
+ *
+ * When we encounter `__type`, we should fall back to using `checker.typeToString()`
+ * which preserves the human-readable type name.
+ */
+const TS_ANONYMOUS_TYPE_SYMBOL = "__type";
+
+/**
+ * Array type symbol name.
+ *
+ * TypeScript uses `Array` as the symbol name for array types.
+ * This should be handled separately using `checker.isArrayType()` rather than
+ * treating it as a named type reference.
+ */
+const TS_ARRAY_TYPE_SYMBOL = "Array";
+
+/**
+ * Checks if a symbol name represents a TypeScript internal/anonymous type
+ * that should not be used directly as a GraphQL type name.
+ *
+ * @param symbolName - The symbol name from `type.symbol.getName()`
+ * @returns true if the symbol name is internal and should be filtered out
+ */
+export function isInternalTypeSymbol(symbolName: string): boolean {
+  return (
+    symbolName === TS_ANONYMOUS_TYPE_SYMBOL ||
+    symbolName === TS_ARRAY_TYPE_SYMBOL
+  );
+}
+
+// ============================================================
+// gqlkit Metadata Property Names
+// ============================================================
+
+/**
+ * Property names used internally by gqlkit types for metadata.
+ * These start with " $" (space + dollar sign) to avoid conflicts.
+ */
+export const METADATA_PROPERTIES = {
+  /** Field metadata (GqlField) */
+  FIELD_META: " $gqlkitFieldMeta",
+  /** Type metadata (GqlObject) */
+  TYPE_META: " $gqlkitTypeMeta",
+  /** Directive name */
+  DIRECTIVE_NAME: " $directiveName",
+  /** Directive arguments */
+  DIRECTIVE_ARGS: " $directiveArgs",
+  /** Directive location */
+  DIRECTIVE_LOCATION: " $directiveLocation",
+  /** Original unwrapped type */
+  ORIGINAL_TYPE: " $gqlkitOriginalType",
+  /** Scalar metadata */
+  SCALAR: " $gqlkitScalar",
+  /** Resolver metadata */
+  RESOLVER: " $gqlkitResolver",
+  /** Abstract resolver metadata (resolveType, isTypeOf) */
+  ABSTRACT_RESOLVER: " $gqlkitAbstractResolver",
+  /** Interface metadata */
+  INTERFACE_META: " $gqlkitInterfaceMeta",
+} as const;
+
+// ============================================================
+// GraphQL Built-in Types
+// ============================================================
+
+/**
+ * GraphQL built-in scalar type names.
+ */
+export const BUILT_IN_SCALARS = new Set([
+  "ID",
+  "Int",
+  "Float",
+  "String",
+  "Boolean",
+] as const);
+
+/**
+ * Checks if a type name is a GraphQL built-in scalar.
+ */
+export function isBuiltInScalar(typeName: string): boolean {
+  return BUILT_IN_SCALARS.has(
+    typeName as typeof BUILT_IN_SCALARS extends Set<infer T> ? T : never,
+  );
+}
+
+// ============================================================
+// TypeScript to GraphQL Type Mapping
+// ============================================================
+
+/**
+ * Maps TypeScript primitive type names to GraphQL scalar names.
+ */
+export const PRIMITIVE_TYPE_MAP: Record<string, string> = {
+  string: "String",
+  number: "Float",
+  boolean: "Boolean",
+} as const;

package/src/shared/default-value-detector.ts

@@ -0,0 +1,172 @@
+/**
+ * Default value metadata detector.
+ *
+ * This module provides functions to detect default value metadata embedded
+ * in TypeScript intersection types using the $gqlkitFieldMeta property.
+ */
+
+import ts from "typescript";
+import { METADATA_PROPERTIES } from "./constants.js";
+import type { DirectiveArgumentValue } from "./directive-detector.js";
+import { resolveArgumentValue } from "./directive-detector.js";
+import { getActualMetadataType } from "./metadata-detector.js";
+
+const FIELD_META_PROPERTY = METADATA_PROPERTIES.FIELD_META;
+const DEFAULT_VALUE_PROPERTY = "defaultValue";
+
+/**
+ * Error codes for default value detection.
+ */
+export type DefaultValueDetectionErrorCode = "UNRESOLVABLE_DEFAULT_VALUE";
+
+/**
+ * Error information for default value detection.
+ */
+export interface DefaultValueDetectionError {
+  readonly code: DefaultValueDetectionErrorCode;
+  readonly message: string;
+}
+
+/**
+ * Result of default value detection.
+ */
+export interface DefaultValueDetectionResult {
+  readonly defaultValue: DirectiveArgumentValue | null;
+  readonly errors: ReadonlyArray<DefaultValueDetectionError>;
+}
+
+function createEmptyResult(): DefaultValueDetectionResult {
+  return {
+    defaultValue: null,
+    errors: [],
+  };
+}
+
+/**
+ * Gets the field meta property from a type, checking various type structures.
+ */
+function getFieldMetaProperty(type: ts.Type): ts.Symbol | undefined {
+  const prop = type.getProperty(FIELD_META_PROPERTY);
+  if (prop) {
+    return prop;
+  }
+
+  if (type.isIntersection()) {
+    for (const member of type.types) {
+      const memberProp = member.getProperty(FIELD_META_PROPERTY);
+      if (memberProp) {
+        return memberProp;
+      }
+    }
+  }
+
+  if (type.isUnion()) {
+    for (const member of type.types) {
+      if (
+        member.flags & ts.TypeFlags.Null ||
+        member.flags & ts.TypeFlags.Undefined
+      ) {
+        continue;
+      }
+      const result = getFieldMetaProperty(member);
+      if (result) {
+        return result;
+      }
+    }
+  }
+
+  return undefined;
+}
+
+/**
+ * Detects default value metadata from a TypeScript type.
+ *
+ * This function analyzes TypeScript types to detect default value metadata:
+ * - Intersection types with " $gqlkitFieldMeta" property containing "defaultValue"
+ * - Literal types are resolved to their values
+ * - Non-literal types result in an error
+ *
+ * @param type - The TypeScript type to analyze
+ * @param checker - The TypeScript type checker
+ * @returns Detection result with default value and any errors
+ */
+export function detectDefaultValueMetadata(
+  type: ts.Type,
+  checker: ts.TypeChecker,
+): DefaultValueDetectionResult {
+  const metaProp = getFieldMetaProperty(type);
+  if (!metaProp) {
+    return createEmptyResult();
+  }
+
+  const rawMetaType = checker.getTypeOfSymbol(metaProp);
+  const metaType = getActualMetadataType(rawMetaType);
+  if (!metaType) {
+    return createEmptyResult();
+  }
+
+  const defaultValueProp = metaType.getProperty(DEFAULT_VALUE_PROPERTY);
+  if (!defaultValueProp) {
+    return createEmptyResult();
+  }
+
+  const rawDefaultValueType = checker.getTypeOfSymbol(defaultValueProp);
+  const typeString = checker.typeToString(rawDefaultValueType);
+
+  // If defaultValue is undefined (not specified in Meta), return empty result
+  // Check raw type first before unwrapping
+  if (rawDefaultValueType.flags & ts.TypeFlags.Undefined) {
+    return createEmptyResult();
+  }
+
+  // Check if the type is a union that only contains undefined
+  // This handles cases where Meta["defaultValue"] resolves to undefined
+  if (rawDefaultValueType.isUnion()) {
+    const nonUndefinedTypes = rawDefaultValueType.types.filter(
+      (t) => !(t.flags & ts.TypeFlags.Undefined),
+    );
+    if (nonUndefinedTypes.length === 0) {
+      return createEmptyResult();
+    }
+  }
+
+  // If the type string is "undefined", skip (handles edge cases)
+  if (typeString === "undefined") {
+    return createEmptyResult();
+  }
+
+  // If the type is unknown, it means Meta["defaultValue"] was not explicitly specified
+  // and TypeScript inferred it from the constraint (defaultValue?: unknown)
+  if (rawDefaultValueType.flags & ts.TypeFlags.Unknown) {
+    return createEmptyResult();
+  }
+
+  const defaultValueType = getActualMetadataType(rawDefaultValueType);
+  if (!defaultValueType) {
+    return createEmptyResult();
+  }
+
+  // Also check the unwrapped type for undefined
+  if (defaultValueType.flags & ts.TypeFlags.Undefined) {
+    return createEmptyResult();
+  }
+
+  const resolved = resolveArgumentValue(defaultValueType, checker);
+  if (resolved) {
+    return {
+      defaultValue: resolved,
+      errors: [],
+    };
+  }
+
+  return {
+    defaultValue: null,
+    errors: [
+      {
+        code: "UNRESOLVABLE_DEFAULT_VALUE",
+        message:
+          "Default value must be a literal type (string, number, boolean, null, array, object, or enum)",
+      },
+    ],
+  };
+}

package/src/shared/diagnostics.ts

@@ -0,0 +1,35 @@
+import type { Diagnostic, Diagnostics } from "../type-extractor/types/index.js";
+
+function getDiagnosticKey(d: Diagnostic): string {
+  const locationKey = d.location
+    ? `${d.location.file}:${d.location.line}:${d.location.column}`
+    : "";
+  return `${d.code}:${d.message}:${d.severity}:${locationKey}`;
+}
+
+export function deduplicateDiagnostics(
+  diagnostics: ReadonlyArray<Diagnostic>,
+): Diagnostic[] {
+  const seen = new Set<string>();
+  const result: Diagnostic[] = [];
+
+  for (const d of diagnostics) {
+    const key = getDiagnosticKey(d);
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(d);
+    }
+  }
+
+  return result;
+}
+
+export function collectDiagnostics(
+  allDiagnostics: ReadonlyArray<Diagnostic>,
+): Diagnostics {
+  const uniqueDiagnostics = deduplicateDiagnostics(allDiagnostics);
+  const errors = uniqueDiagnostics.filter((d) => d.severity === "error");
+  const warnings = uniqueDiagnostics.filter((d) => d.severity === "warning");
+
+  return { errors, warnings };
+}