@gqlkit-ts/cli 0.1.0 → 0.2.0

package/src/resolver-extractor/index.ts

@@ -0,0 +1,19 @@
+export type { ScanResult } from "../shared/index.js";
+export type {
+  ExtractResolversResult,
+  GraphQLFieldDefinition,
+  GraphQLInputValue,
+  MutationFieldDefinitions,
+  QueryFieldDefinitions,
+  TypeExtension,
+} from "./extract-resolvers.js";
+export type {
+  AbstractResolverInfo,
+  AbstractResolverKind,
+} from "./extractor/define-api-extractor.js";
+export type {
+  OnlyConstraintViolation,
+  OnlyConstraintViolationCode,
+  ValidateOnlyConstraintsOptions,
+  ValidationContext,
+} from "./validator/only-validator.js";

package/src/resolver-extractor/validator/abstract-resolver-validator.ts

@@ -0,0 +1,251 @@
+/**
+ * AbstractResolverValidator validates that abstract type resolvers
+ * reference valid types in the schema.
+ *
+ * - resolveType must reference union or interface types
+ * - isTypeOf must reference object types
+ */
+
+import type { BaseType } from "../../schema-generator/integrator/result-integrator.js";
+import type {
+  Diagnostic,
+  DiagnosticCode,
+} from "../../type-extractor/types/index.js";
+import type { AbstractResolverInfo } from "../extractor/define-api-extractor.js";
+
+export interface ValidateAbstractResolversOptions {
+  readonly abstractResolvers: ReadonlyArray<AbstractResolverInfo>;
+  readonly baseTypes: ReadonlyArray<BaseType>;
+}
+
+export interface ValidateAbstractResolversResult {
+  readonly diagnostics: ReadonlyArray<Diagnostic>;
+}
+
+function formatTypeKindForDisplay(kind: BaseType["kind"]): string {
+  return kind.toLowerCase();
+}
+
+/**
+ * Formats a list of resolver definitions for error messages.
+ */
+function formatResolverLocations(
+  resolvers: ReadonlyArray<AbstractResolverInfo>,
+): string {
+  return resolvers
+    .map(
+      (r) =>
+        `  - ${r.exportName} at ${r.sourceLocation.file}:${r.sourceLocation.line}:${r.sourceLocation.column}`,
+    )
+    .join("\n");
+}
+
+function reportDuplicates(
+  resolverMap: Map<string, AbstractResolverInfo[]>,
+  code: DiagnosticCode,
+  kind: string,
+): Diagnostic[] {
+  const diagnostics: Diagnostic[] = [];
+  for (const [typeName, duplicates] of resolverMap) {
+    if (duplicates.length > 1) {
+      const firstResolver = duplicates[0];
+      if (firstResolver) {
+        diagnostics.push({
+          code,
+          message: `Multiple ${kind} definitions found for type '${typeName}':\n${formatResolverLocations(duplicates)}`,
+          severity: "error",
+          location: firstResolver.sourceLocation,
+        });
+      }
+    }
+  }
+  return diagnostics;
+}
+
+/**
+ * Detects duplicate abstract type resolver definitions.
+ * Groups resolvers by kind and target type, then reports all duplicates.
+ *
+ * @param resolvers - All abstract resolvers to check
+ * @param typeMap - Map of type names to their definitions (for existence checking)
+ * @returns Array of diagnostics for duplicate definitions
+ */
+function detectDuplicateResolvers(
+  resolvers: ReadonlyArray<AbstractResolverInfo>,
+  typeMap: Map<string, BaseType>,
+): Diagnostic[] {
+  const resolveTypeMap = new Map<string, AbstractResolverInfo[]>();
+  const isTypeOfMap = new Map<string, AbstractResolverInfo[]>();
+
+  for (const resolver of resolvers) {
+    if (!typeMap.has(resolver.targetTypeName)) {
+      continue;
+    }
+
+    const targetMap =
+      resolver.kind === "resolveType" ? resolveTypeMap : isTypeOfMap;
+    const existing = targetMap.get(resolver.targetTypeName) ?? [];
+    existing.push(resolver);
+    targetMap.set(resolver.targetTypeName, existing);
+  }
+
+  return [
+    ...reportDuplicates(
+      resolveTypeMap,
+      "DUPLICATE_RESOLVE_TYPE",
+      "resolveType",
+    ),
+    ...reportDuplicates(isTypeOfMap, "DUPLICATE_IS_TYPE_OF", "isTypeOf"),
+  ];
+}
+
+function createMissingResolverDiagnostic(
+  typeName: string,
+  typeKind: "Union" | "Interface",
+  sourceFile: string | null,
+): Diagnostic {
+  const memberLabel = typeKind === "Union" ? "member" : "implementing";
+  return {
+    code: "MISSING_ABSTRACT_TYPE_RESOLVER",
+    message: `${typeKind} type '${typeName}' has no resolveType defined, and not all ${memberLabel} types have isTypeOf defined. To prevent runtime errors, either define a resolveType for '${typeName}' or define isTypeOf for each ${memberLabel} type.`,
+    severity: "error",
+    location: sourceFile ? { file: sourceFile, line: 1, column: 1 } : null,
+  };
+}
+
+/**
+ * Detects abstract types (union/interface) that have no resolveType defined
+ * and whose member/implementing types don't all have isTypeOf defined.
+ *
+ * @param resolvers - All abstract resolvers to check
+ * @param typeMap - Map of type names to their definitions
+ * @returns Array of warning diagnostics for missing resolvers
+ */
+function detectMissingAbstractTypeResolvers(
+  resolvers: ReadonlyArray<AbstractResolverInfo>,
+  typeMap: Map<string, BaseType>,
+): Diagnostic[] {
+  const diagnostics: Diagnostic[] = [];
+
+  const resolveTypeSet = new Set<string>();
+  const isTypeOfSet = new Set<string>();
+
+  for (const resolver of resolvers) {
+    if (resolver.kind === "resolveType") {
+      resolveTypeSet.add(resolver.targetTypeName);
+    } else if (resolver.kind === "isTypeOf") {
+      isTypeOfSet.add(resolver.targetTypeName);
+    }
+  }
+
+  const implementingTypesMap = new Map<string, string[]>();
+  for (const [typeName, baseType] of typeMap) {
+    if (
+      baseType.kind === "Object" &&
+      baseType.implementedInterfaces &&
+      baseType.implementedInterfaces.length > 0
+    ) {
+      for (const interfaceName of baseType.implementedInterfaces) {
+        const existing = implementingTypesMap.get(interfaceName) ?? [];
+        existing.push(typeName);
+        implementingTypesMap.set(interfaceName, existing);
+      }
+    }
+  }
+
+  for (const [typeName, baseType] of typeMap) {
+    if (baseType.kind !== "Union" && baseType.kind !== "Interface") {
+      continue;
+    }
+    if (resolveTypeSet.has(typeName)) {
+      continue;
+    }
+
+    const members =
+      baseType.kind === "Union"
+        ? (baseType.unionMembers ?? [])
+        : (implementingTypesMap.get(typeName) ?? []);
+
+    if (members.length === 0) {
+      continue;
+    }
+
+    const allMembersHaveIsTypeOf = members.every((m) => isTypeOfSet.has(m));
+    if (!allMembersHaveIsTypeOf) {
+      diagnostics.push(
+        createMissingResolverDiagnostic(
+          typeName,
+          baseType.kind,
+          baseType.sourceFile ?? null,
+        ),
+      );
+    }
+  }
+
+  return diagnostics;
+}
+
+/**
+ * Validates abstract type resolvers.
+ *
+ * @param options - Validation options including abstract resolvers and base types
+ * @returns Validation result with diagnostics
+ */
+export function validateAbstractResolvers(
+  options: ValidateAbstractResolversOptions,
+): ValidateAbstractResolversResult {
+  const diagnostics: Diagnostic[] = [];
+  const typeMap = new Map<string, BaseType>();
+
+  for (const baseType of options.baseTypes) {
+    typeMap.set(baseType.name, baseType);
+  }
+
+  for (const resolver of options.abstractResolvers) {
+    const targetType = typeMap.get(resolver.targetTypeName);
+
+    if (!targetType) {
+      diagnostics.push({
+        code: "UNKNOWN_ABSTRACT_TYPE",
+        message: `Type '${resolver.targetTypeName}' does not exist in the schema. The ${resolver.kind} resolver '${resolver.exportName}' references a type that has not been defined.`,
+        severity: "error",
+        location: resolver.sourceLocation,
+      });
+      continue;
+    }
+
+    if (resolver.kind === "resolveType") {
+      if (targetType.kind !== "Union" && targetType.kind !== "Interface") {
+        diagnostics.push({
+          code: "INVALID_ABSTRACT_TYPE_KIND",
+          message: `Type '${resolver.targetTypeName}' is ${formatTypeKindForDisplay(targetType.kind)} type, but resolveType can only be used with union or interface types. The resolver '${resolver.exportName}' must reference an abstract type.`,
+          severity: "error",
+          location: resolver.sourceLocation,
+        });
+      }
+    } else if (resolver.kind === "isTypeOf") {
+      if (targetType.kind !== "Object") {
+        diagnostics.push({
+          code: "INVALID_OBJECT_TYPE_KIND",
+          message: `Type '${resolver.targetTypeName}' is ${formatTypeKindForDisplay(targetType.kind)} type, but isTypeOf can only be used with object types. The resolver '${resolver.exportName}' must reference an object type.`,
+          severity: "error",
+          location: resolver.sourceLocation,
+        });
+      }
+    }
+  }
+
+  const duplicateDiagnostics = detectDuplicateResolvers(
+    options.abstractResolvers,
+    typeMap,
+  );
+  diagnostics.push(...duplicateDiagnostics);
+
+  const missingResolverWarnings = detectMissingAbstractTypeResolvers(
+    options.abstractResolvers,
+    typeMap,
+  );
+  diagnostics.push(...missingResolverWarnings);
+
+  return { diagnostics };
+}

package/src/resolver-extractor/validator/only-validator.ts

@@ -0,0 +1,158 @@
+/**
+ * OnlyValidator validates that scalar types with only constraints
+ * are used in the correct position (input or output).
+ *
+ * - Scalars with only: "output" can only be used in output positions
+ * - Scalars with only: "input" can only be used in input positions
+ * - Scalars without only constraint can be used in both positions
+ */
+
+import type { TSTypeReference } from "../../type-extractor/types/index.js";
+
+export type OnlyConstraintViolationCode =
+  | "OUTPUT_ONLY_IN_INPUT_POSITION"
+  | "INPUT_ONLY_IN_OUTPUT_POSITION";
+
+export interface OnlyConstraintViolation {
+  readonly code: OnlyConstraintViolationCode;
+  readonly message: string;
+  readonly scalarName: string;
+  readonly only: "input" | "output";
+  readonly position: "input" | "output";
+  readonly context: ValidationContext;
+}
+
+interface InputTypeFieldContext {
+  readonly kind: "inputTypeField";
+  readonly typeName: string;
+  readonly fieldName: string;
+  readonly sourceFile: string;
+  readonly line: number;
+}
+
+interface ObjectTypeFieldContext {
+  readonly kind: "objectTypeField";
+  readonly typeName: string;
+  readonly fieldName: string;
+  readonly sourceFile: string;
+  readonly line: number;
+}
+
+interface ResolverArgumentContext {
+  readonly kind: "resolverArgument";
+  readonly resolverName: string;
+  readonly argumentName: string;
+  readonly sourceFile: string;
+  readonly line: number;
+}
+
+interface ResolverReturnTypeContext {
+  readonly kind: "resolverReturnType";
+  readonly resolverName: string;
+  readonly sourceFile: string;
+  readonly line: number;
+}
+
+export type ValidationContext =
+  | InputTypeFieldContext
+  | ObjectTypeFieldContext
+  | ResolverArgumentContext
+  | ResolverReturnTypeContext;
+
+export interface ValidateOnlyConstraintsOptions {
+  readonly typeRef: TSTypeReference;
+  readonly position: "input" | "output";
+  readonly context: ValidationContext;
+}
+
+function formatContextLocation(context: ValidationContext): string {
+  switch (context.kind) {
+    case "inputTypeField":
+      return `field '${context.fieldName}' of input type '${context.typeName}'`;
+    case "objectTypeField":
+      return `field '${context.fieldName}' of type '${context.typeName}'`;
+    case "resolverArgument":
+      return `argument '${context.argumentName}' of resolver '${context.resolverName}'`;
+    case "resolverReturnType":
+      return `return type of resolver '${context.resolverName}'`;
+  }
+}
+
+function createViolationMessage(
+  scalarName: string,
+  only: "input" | "output",
+  position: "input" | "output",
+  context: ValidationContext,
+): string {
+  const locationDesc = formatContextLocation(context);
+  const oppositePosition = only === "output" ? "input" : "output";
+  const hint =
+    position === "input"
+      ? "Use a type without 'only' constraint or with 'only: \"input\"' instead."
+      : "Use a type without 'only' constraint or with 'only: \"output\"' instead.";
+
+  return `Scalar type '${scalarName}' is ${only}-only but is used in ${position} position (${locationDesc}). ${oppositePosition.charAt(0).toUpperCase() + oppositePosition.slice(1)}-only scalars cannot be used in ${position} positions. ${hint}`;
+}
+
+function collectScalarViolations(
+  typeRef: TSTypeReference,
+  position: "input" | "output",
+  context: ValidationContext,
+  violations: OnlyConstraintViolation[],
+): void {
+  if (typeRef.scalarInfo) {
+    const { scalarName, only } = typeRef.scalarInfo;
+
+    if (only !== null) {
+      if (position === "input" && only === "output") {
+        violations.push({
+          code: "OUTPUT_ONLY_IN_INPUT_POSITION",
+          message: createViolationMessage(scalarName, only, position, context),
+          scalarName,
+          only,
+          position,
+          context,
+        });
+      } else if (position === "output" && only === "input") {
+        violations.push({
+          code: "INPUT_ONLY_IN_OUTPUT_POSITION",
+          message: createViolationMessage(scalarName, only, position, context),
+          scalarName,
+          only,
+          position,
+          context,
+        });
+      }
+    }
+  }
+
+  if (typeRef.elementType) {
+    collectScalarViolations(typeRef.elementType, position, context, violations);
+  }
+
+  if (typeRef.members) {
+    for (const member of typeRef.members) {
+      collectScalarViolations(member, position, context, violations);
+    }
+  }
+}
+
+/**
+ * Validates that only constraints are not violated.
+ * Returns diagnostics for each violation.
+ *
+ * @param options - Validation options including type reference, position, and context
+ * @returns Array of constraint violations (empty if no violations)
+ */
+export function validateOnlyConstraints(
+  options: ValidateOnlyConstraintsOptions,
+): ReadonlyArray<OnlyConstraintViolation> {
+  const violations: OnlyConstraintViolation[] = [];
+  collectScalarViolations(
+    options.typeRef,
+    options.position,
+    options.context,
+    violations,
+  );
+  return violations;
+}