@gqlkit-ts/cli 0.2.0 → 0.3.0

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;
+}

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

@@ -0,0 +1,281 @@
+import type {
+  ExtractedTypeInfo,
+  InlineObjectMember,
+  InlineObjectProperty,
+} from "../type-extractor/types/index.js";
+import type {
+  AutoGeneratedField,
+  AutoGeneratedType,
+} from "./auto-type-generator.js";
+import type { ResolveTypeFieldPattern } from "./resolve-type-generator.js";
+import {
+  collectTypenameExtractions,
+  type TypenameExtractionResult,
+} from "./typename-extractor.js";
+import type { TypenameFieldName } from "./typename-types.js";
+
+/**
+ * Pattern for resolveType generation from typename fields.
+ * Uses the common ResolveTypeFieldPattern for usedFieldNames,
+ * with an optional memberFieldMap for mixed patterns.
+ */
+export interface ResolveTypePattern extends ResolveTypeFieldPattern {
+  readonly memberFieldMap: ReadonlyMap<string, TypenameFieldName> | null;
+}
+
+export interface TypenameAutoResolveTypeInfo {
+  readonly abstractTypeName: string;
+  readonly abstractTypeKind: "union" | "interface";
+  readonly resolveTypePattern: ResolveTypePattern;
+}
+
+export interface GeneratedInlineObjectType {
+  readonly typeName: string;
+  readonly abstractTypeName: string;
+  readonly memberIndex: number;
+}
+
+export interface CollectTypenameResolveTypesParams {
+  readonly extractedTypes: ReadonlyArray<ExtractedTypeInfo>;
+  readonly typeMap: ReadonlyMap<string, ExtractedTypeInfo>;
+  readonly manualResolveTypeNames: ReadonlySet<string>;
+}
+
+export interface CollectTypenameResolveTypesResult {
+  readonly autoResolveTypes: ReadonlyArray<TypenameAutoResolveTypeInfo>;
+  readonly autoResolveTypeNames: ReadonlySet<string>;
+  readonly generatedObjectTypes: ReadonlyArray<AutoGeneratedType>;
+  readonly generatedInlineObjectTypes: ReadonlyArray<GeneratedInlineObjectType>;
+}
+
+function determineResolveTypePattern(
+  extraction: TypenameExtractionResult,
+): ResolveTypePattern | null {
+  if (!extraction.allMembersHaveTypename) {
+    return null;
+  }
+
+  const members = extraction.members;
+  if (members.length === 0) {
+    return null;
+  }
+
+  const usedFieldNames = new Set<TypenameFieldName>();
+
+  for (const member of members) {
+    if (member.typenameInfo === null) {
+      return null;
+    }
+    usedFieldNames.add(member.typenameInfo.fieldName);
+  }
+
+  if (usedFieldNames.size === 1) {
+    return { usedFieldNames, memberFieldMap: null };
+  }
+
+  const memberFieldMap = new Map<string, TypenameFieldName>();
+  for (const member of members) {
+    if (member.typenameInfo && member.memberTypeName) {
+      memberFieldMap.set(member.memberTypeName, member.typenameInfo.fieldName);
+    }
+  }
+
+  return { usedFieldNames, memberFieldMap };
+}
+
+function primitiveToGraphQLScalar(primitive: string): string {
+  switch (primitive) {
+    case "string":
+      return "String";
+    case "number":
+      return "Float";
+    case "boolean":
+      return "Boolean";
+    default:
+      return "String";
+  }
+}
+
+function convertInlineObjectPropertyToField(
+  property: InlineObjectProperty,
+): AutoGeneratedField | null {
+  if (
+    property.propertyName === "__typename" ||
+    property.propertyName === "$typeName"
+  ) {
+    return null;
+  }
+
+  const tsType = property.propertyType;
+  let typeName: string;
+  const nullable = tsType.nullable;
+  let list = false;
+  let listItemNullable: boolean | null = null;
+
+  if (tsType.kind === "array" && tsType.elementType) {
+    list = true;
+    listItemNullable = tsType.elementType.nullable;
+    const elementName = tsType.elementType.name ?? "String";
+    typeName =
+      tsType.elementType.kind === "primitive"
+        ? primitiveToGraphQLScalar(elementName)
+        : elementName;
+  } else if (tsType.kind === "reference" && tsType.name) {
+    typeName = tsType.name;
+  } else if (tsType.kind === "primitive" && tsType.name) {
+    typeName = primitiveToGraphQLScalar(tsType.name);
+  } else if (tsType.kind === "scalar" && tsType.scalarInfo) {
+    typeName = tsType.scalarInfo.scalarName;
+  } else {
+    typeName = "String";
+  }
+
+  return {
+    name: property.propertyName,
+    type: {
+      typeName,
+      nullable,
+      list,
+      listItemNullable,
+    },
+    description: property.description,
+    deprecated: property.deprecated,
+    directives: null,
+    defaultValue: null,
+  };
+}
+
+function generateObjectTypeFromInlineObject(
+  inlineObjectMember: InlineObjectMember,
+  typeName: string,
+  abstractTypeName: string,
+  sourceFile: string,
+): AutoGeneratedType {
+  const fields: AutoGeneratedField[] = [];
+
+  for (const property of inlineObjectMember.properties) {
+    const field = convertInlineObjectPropertyToField(property);
+    if (field !== null) {
+      fields.push(field);
+    }
+  }
+
+  return {
+    name: typeName,
+    kind: "Object",
+    fields,
+    enumValues: null,
+    unionMembers: null,
+    needsStringEnumMapping: false,
+    sourceLocation: { file: sourceFile, line: 1, column: 1 },
+    generatedFrom: {
+      parentTypeName: abstractTypeName,
+      fieldPath: [],
+      context: "typeField",
+    },
+    description: null,
+    resolveTypeFieldPattern: null,
+  };
+}
+
+function collectGeneratedObjectTypes(
+  extraction: TypenameExtractionResult,
+  extractedType: ExtractedTypeInfo,
+): {
+  generatedObjectTypes: AutoGeneratedType[];
+  generatedInlineObjectTypes: GeneratedInlineObjectType[];
+} {
+  const generatedObjectTypes: AutoGeneratedType[] = [];
+  const generatedInlineObjectTypes: GeneratedInlineObjectType[] = [];
+
+  if (!extraction.hasInlineObjects) {
+    return { generatedObjectTypes, generatedInlineObjectTypes };
+  }
+
+  const inlineObjectMembers = extractedType.inlineObjectMembers ?? [];
+  const namedMemberCount = extractedType.unionMembers?.length ?? 0;
+
+  for (const member of extraction.members) {
+    if (!member.isInlineObject || member.typenameInfo === null) {
+      continue;
+    }
+
+    const inlineIndex = member.memberIndex - namedMemberCount;
+    const inlineObjectMember = inlineObjectMembers[inlineIndex];
+
+    if (!inlineObjectMember) {
+      continue;
+    }
+
+    const typeName = member.typenameInfo.typeName;
+
+    const objectType = generateObjectTypeFromInlineObject(
+      inlineObjectMember,
+      typeName,
+      extraction.abstractTypeName,
+      extractedType.metadata.sourceFile,
+    );
+
+    generatedObjectTypes.push(objectType);
+    generatedInlineObjectTypes.push({
+      typeName,
+      abstractTypeName: extraction.abstractTypeName,
+      memberIndex: member.memberIndex,
+    });
+  }
+
+  return { generatedObjectTypes, generatedInlineObjectTypes };
+}
+
+export function collectTypenameResolveTypes(
+  params: CollectTypenameResolveTypesParams,
+): CollectTypenameResolveTypesResult {
+  const { extractedTypes, typeMap, manualResolveTypeNames } = params;
+
+  const extractions = collectTypenameExtractions({
+    extractedTypes,
+    typeMap,
+  });
+
+  const autoResolveTypes: TypenameAutoResolveTypeInfo[] = [];
+  const autoResolveTypeNames = new Set<string>();
+  const allGeneratedObjectTypes: AutoGeneratedType[] = [];
+  const allGeneratedInlineObjectTypes: GeneratedInlineObjectType[] = [];
+
+  const typeInfoMap = new Map(extractedTypes.map((t) => [t.metadata.name, t]));
+
+  for (const extraction of extractions) {
+    if (manualResolveTypeNames.has(extraction.abstractTypeName)) {
+      continue;
+    }
+
+    const extractedType = typeInfoMap.get(extraction.abstractTypeName);
+    if (extractedType && extraction.hasInlineObjects) {
+      const { generatedObjectTypes, generatedInlineObjectTypes } =
+        collectGeneratedObjectTypes(extraction, extractedType);
+      allGeneratedObjectTypes.push(...generatedObjectTypes);
+      allGeneratedInlineObjectTypes.push(...generatedInlineObjectTypes);
+    }
+
+    const pattern = determineResolveTypePattern(extraction);
+    if (pattern === null) {
+      continue;
+    }
+
+    autoResolveTypes.push({
+      abstractTypeName: extraction.abstractTypeName,
+      abstractTypeKind: extraction.abstractTypeKind,
+      resolveTypePattern: pattern,
+    });
+    autoResolveTypeNames.add(extraction.abstractTypeName);
+  }
+
+  return {
+    autoResolveTypes: autoResolveTypes.sort((a, b) =>
+      a.abstractTypeName.localeCompare(b.abstractTypeName),
+    ),
+    autoResolveTypeNames,
+    generatedObjectTypes: allGeneratedObjectTypes,
+    generatedInlineObjectTypes: allGeneratedInlineObjectTypes,
+  };
+}

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

@@ -0,0 +1,66 @@
+/**
+ * Common types for typename-related functionality.
+ * These types are shared across typename-extractor, typename-validator,
+ * typename-resolve-type-generator, and inline-union-validator.
+ */
+
+/**
+ * All recognized field names for type discrimination.
+ * - "__typename" is the standard GraphQL introspection field
+ * - "$typeName" is a gqlkit-specific alternative that won't appear in the schema
+ *
+ * To add a new typename field:
+ * 1. Add the field name to this array
+ * 2. Update findTypenameProperty priority if needed
+ */
+export const TYPENAME_FIELD_NAMES = ["__typename", "$typeName"] as const;
+
+/**
+ * The field name used for type discrimination.
+ */
+export type TypenameFieldName = (typeof TYPENAME_FIELD_NAMES)[number];
+
+/**
+ * A set of typename field names used in a resolve type pattern.
+ */
+export type TypenameFieldNameSet = ReadonlySet<TypenameFieldName>;
+
+/**
+ * Create a TypenameFieldNameSet from field names.
+ */
+export function createFieldNameSet(
+  fieldNames: ReadonlyArray<TypenameFieldName>,
+): TypenameFieldNameSet {
+  return new Set(fieldNames);
+}
+
+/**
+ * Information about a typename field extracted from a type definition.
+ */
+export interface TypenameFieldInfo {
+  readonly typeName: string;
+  readonly fieldName: TypenameFieldName;
+}
+
+/**
+ * Find __typename or $typeName property from a list of properties.
+ * __typename takes priority over $typeName.
+ */
+export function findTypenameProperty<T>(
+  properties: ReadonlyArray<T>,
+  getName: (p: T) => string,
+): { property: T; fieldName: TypenameFieldName } | null {
+  const typenameProperty = properties.find((p) => getName(p) === "__typename");
+  if (typenameProperty) {
+    return { property: typenameProperty, fieldName: "__typename" };
+  }
+
+  const dollarTypenameProperty = properties.find(
+    (p) => getName(p) === "$typeName",
+  );
+  if (dollarTypenameProperty) {
+    return { property: dollarTypenameProperty, fieldName: "$typeName" };
+  }
+
+  return null;
+}