@gqlkit-ts/cli 0.1.0 → 0.3.0

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

@@ -0,0 +1,163 @@
+/**
+ * Context for generating auto type names based on different scenarios.
+ */
+export type AutoTypeNameContext =
+  | ObjectFieldContext
+  | InputFieldContext
+  | ResolverArgContext
+  | ResolverPayloadContext;
+
+/**
+ * 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>;
+}
+
+/**
+ * Context for resolver payload inline types.
+ * Query/Mutation: {PascalCaseFieldName}Payload
+ * Field resolver: {ParentTypeName}{PascalCaseFieldName}Payload
+ * Nested: {PayloadTypeName}{PascalCaseFieldPath} (no Input suffix)
+ */
+export interface ResolverPayloadContext {
+  readonly kind: "resolverPayload";
+  readonly resolverType: "query" | "mutation" | "field";
+  readonly fieldName: 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;
+}
+
+/**
+ * Check if a type name follows the Input type naming convention.
+ */
+export function isInputTypeName(name: string): boolean {
+  return name.endsWith("Input");
+}
+
+/**
+ * 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);
+    case "resolverPayload":
+      return generateResolverPayloadTypeName(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`;
+}
+
+function generateResolverPayloadTypeName(
+  context: ResolverPayloadContext,
+): string {
+  const fieldNamePascal = toPascalCase(context.fieldName);
+  const pathParts = context.fieldPath.map(toPascalCase).join("");
+
+  if (context.resolverType === "field" && context.parentTypeName) {
+    return `${context.parentTypeName}${fieldNamePascal}Payload${pathParts}`;
+  }
+
+  return `${fieldNamePascal}Payload${pathParts}`;
+}

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

@@ -0,0 +1,21 @@
+import type { TypenameFieldNameSet } from "./typename-types.js";
+
+/**
+ * Pattern describing which typename fields are used for resolving types.
+ * - Single field: Set contains one field name (e.g., {"__typename"} or {"$typeName"})
+ * - Mixed: Set contains multiple field names (e.g., {"__typename", "$typeName"})
+ */
+export interface ResolveTypeFieldPattern {
+  readonly usedFieldNames: TypenameFieldNameSet;
+}
+
+/**
+ * Information about an auto-generated __resolveType function for a Union type.
+ * The generated function returns `obj.__typename` to resolve the concrete type.
+ */
+export interface AutoGeneratedResolveType {
+  /** The name of the Union type */
+  readonly unionTypeName: string;
+  /** The field pattern used to resolve the type name */
+  readonly fieldPattern: ResolveTypeFieldPattern;
+}

package/src/auto-type-generator/resolver-field-iterator.ts

@@ -0,0 +1,39 @@
+import type {
+  ExtractResolversResult,
+  GraphQLFieldDefinition,
+} from "../resolver-extractor/index.js";
+
+export type ResolverType = "query" | "mutation" | "field";
+
+export interface ResolverFieldInfo {
+  readonly field: GraphQLFieldDefinition;
+  readonly resolverType: ResolverType;
+  readonly parentTypeName: string | null;
+}
+
+/**
+ * Iterates over all resolver fields (query, mutation, field extensions) in a consistent manner.
+ * This eliminates the repeated iteration pattern across multiple collector functions.
+ */
+export function forEachResolverField(
+  resolversResult: ExtractResolversResult,
+  visitor: (info: ResolverFieldInfo) => void,
+): void {
+  for (const field of resolversResult.queryFields.fields) {
+    visitor({ field, resolverType: "query", parentTypeName: null });
+  }
+
+  for (const field of resolversResult.mutationFields.fields) {
+    visitor({ field, resolverType: "mutation", parentTypeName: null });
+  }
+
+  for (const ext of resolversResult.typeExtensions) {
+    for (const field of ext.fields) {
+      visitor({
+        field,
+        resolverType: "field",
+        parentTypeName: ext.targetTypeName,
+      });
+    }
+  }
+}

package/src/auto-type-generator/typename-extractor.ts

@@ -0,0 +1,230 @@
+import type {
+  ExtractedTypeInfo,
+  FieldDefinition,
+  InlineObjectProperty,
+} from "../type-extractor/types/index.js";
+import {
+  findTypenameProperty,
+  type TypenameFieldInfo,
+} from "./typename-types.js";
+
+export type { TypenameFieldInfo } from "./typename-types.js";
+
+export interface MemberTypenameInfo {
+  readonly memberTypeName: string | null;
+  readonly memberIndex: number;
+  readonly typenameInfo: TypenameFieldInfo | null;
+  readonly isInlineObject: boolean;
+}
+
+export interface TypenameExtractionResult {
+  readonly abstractTypeName: string;
+  readonly abstractTypeKind: "union" | "interface";
+  readonly members: ReadonlyArray<MemberTypenameInfo>;
+  readonly allMembersHaveTypename: boolean;
+  readonly hasInlineObjects: boolean;
+}
+
+export interface ExtractTypenamesParams {
+  readonly abstractType: ExtractedTypeInfo;
+  readonly typeMap: ReadonlyMap<string, ExtractedTypeInfo>;
+}
+
+function extractTypenameFromFields(
+  fields: ReadonlyArray<FieldDefinition>,
+): TypenameFieldInfo | null {
+  const found = findTypenameProperty(fields, (f) => f.name);
+  if (!found) {
+    return null;
+  }
+
+  const { property: field, fieldName } = found;
+
+  if (field.optional) {
+    return null;
+  }
+
+  const { tsType } = field;
+  if (tsType.nullable || tsType.kind !== "literal" || tsType.name === null) {
+    return null;
+  }
+
+  return { typeName: tsType.name, fieldName };
+}
+
+function extractTypenameFromInlineObjectProperties(
+  properties: ReadonlyArray<InlineObjectProperty>,
+): TypenameFieldInfo | null {
+  const found = findTypenameProperty(properties, (p) => p.propertyName);
+  if (!found) {
+    return null;
+  }
+
+  const { property, fieldName } = found;
+  const { propertyType: tsType } = property;
+
+  if (tsType.nullable || tsType.kind !== "literal" || tsType.name === null) {
+    return null;
+  }
+
+  return { typeName: tsType.name, fieldName };
+}
+
+function extractUnionMemberTypenames(
+  params: ExtractTypenamesParams,
+): TypenameExtractionResult {
+  const { abstractType, typeMap } = params;
+  const members: MemberTypenameInfo[] = [];
+  let allMembersHaveTypename = true;
+
+  const unionMembers = abstractType.unionMembers ?? [];
+  const inlineObjectMembers = abstractType.inlineObjectMembers ?? [];
+  const hasInlineObjects = inlineObjectMembers.length > 0;
+
+  let memberIndex = 0;
+
+  for (const memberName of unionMembers) {
+    const memberType = typeMap.get(memberName);
+
+    if (!memberType) {
+      members.push({
+        memberTypeName: memberName,
+        memberIndex,
+        typenameInfo: null,
+        isInlineObject: false,
+      });
+      allMembersHaveTypename = false;
+      memberIndex++;
+      continue;
+    }
+
+    const typenameInfo = extractTypenameFromFields(memberType.fields);
+
+    if (typenameInfo === null) {
+      allMembersHaveTypename = false;
+    }
+
+    members.push({
+      memberTypeName: memberName,
+      memberIndex,
+      typenameInfo,
+      isInlineObject: false,
+    });
+    memberIndex++;
+  }
+
+  for (const inlineObjectMember of inlineObjectMembers) {
+    const typenameInfo = extractTypenameFromInlineObjectProperties(
+      inlineObjectMember.properties,
+    );
+
+    if (typenameInfo === null) {
+      allMembersHaveTypename = false;
+    }
+
+    members.push({
+      memberTypeName: null,
+      memberIndex,
+      typenameInfo,
+      isInlineObject: true,
+    });
+    memberIndex++;
+  }
+
+  return {
+    abstractTypeName: abstractType.metadata.name,
+    abstractTypeKind: "union",
+    members,
+    allMembersHaveTypename,
+    hasInlineObjects,
+  };
+}
+
+function extractInterfaceImplementerTypenames(
+  params: ExtractTypenamesParams,
+  implementers: ReadonlyArray<ExtractedTypeInfo>,
+): TypenameExtractionResult {
+  const { abstractType } = params;
+  const members: MemberTypenameInfo[] = [];
+  let allMembersHaveTypename = true;
+  const hasInlineObjects = false;
+
+  for (let i = 0; i < implementers.length; i++) {
+    const implementer = implementers[i]!;
+    const typenameInfo = extractTypenameFromFields(implementer.fields);
+
+    if (typenameInfo === null) {
+      allMembersHaveTypename = false;
+    }
+
+    members.push({
+      memberTypeName: implementer.metadata.name,
+      memberIndex: i,
+      typenameInfo,
+      isInlineObject: false,
+    });
+  }
+
+  return {
+    abstractTypeName: abstractType.metadata.name,
+    abstractTypeKind: "interface",
+    members,
+    allMembersHaveTypename,
+    hasInlineObjects,
+  };
+}
+
+function extractTypenames(
+  params: ExtractTypenamesParams,
+): TypenameExtractionResult | null {
+  const { abstractType, typeMap } = params;
+
+  if (abstractType.metadata.kind === "union") {
+    return extractUnionMemberTypenames(params);
+  }
+
+  if (abstractType.metadata.kind === "graphqlInterface") {
+    const implementers: ExtractedTypeInfo[] = [];
+    for (const typeInfo of typeMap.values()) {
+      if (
+        typeInfo.implementedInterfaces?.includes(abstractType.metadata.name)
+      ) {
+        implementers.push(typeInfo);
+      }
+    }
+
+    if (implementers.length === 0) {
+      return null;
+    }
+
+    return extractInterfaceImplementerTypenames(params, implementers);
+  }
+
+  return null;
+}
+
+export interface CollectTypenameExtractionsParams {
+  readonly extractedTypes: ReadonlyArray<ExtractedTypeInfo>;
+  readonly typeMap: ReadonlyMap<string, ExtractedTypeInfo>;
+}
+
+export function collectTypenameExtractions(
+  params: CollectTypenameExtractionsParams,
+): ReadonlyArray<TypenameExtractionResult> {
+  const { extractedTypes, typeMap } = params;
+  const results: TypenameExtractionResult[] = [];
+
+  for (const typeInfo of extractedTypes) {
+    if (
+      typeInfo.metadata.kind === "union" ||
+      typeInfo.metadata.kind === "graphqlInterface"
+    ) {
+      const result = extractTypenames({ abstractType: typeInfo, typeMap });
+      if (result !== null) {
+        results.push(result);
+      }
+    }
+  }
+
+  return results;
+}