@gqlkit-ts/cli 0.5.1 → 0.7.0

package/src/schema-generator/emitter/discriminator-resolve-type-emitter.ts

@@ -0,0 +1,125 @@
+import type {
+  DiscriminatorResolveTypeInfo,
+  DiscriminatorValueMapping,
+} from "../../auto-type-generator/discriminator-resolve-type-generator.js";
+
+/**
+ * Groups value mappings by their value at a given field index.
+ * Null values at the field index mean the member doesn't have that field,
+ * so the member should be resolved directly at the current switch level.
+ */
+function groupMappingsByFieldValue(
+  mappings: ReadonlyArray<DiscriminatorValueMapping>,
+  fieldIndex: number,
+): Map<string | null, DiscriminatorValueMapping[]> {
+  const groups = new Map<string | null, DiscriminatorValueMapping[]>();
+  for (const mapping of mappings) {
+    const value = mapping.values[fieldIndex] ?? null;
+    const group = groups.get(value) ?? [];
+    group.push(mapping);
+    groups.set(value, group);
+  }
+  return groups;
+}
+
+/**
+ * Builds a switch statement body for a given field level, recursing for nested fields.
+ * Returns an array of code lines (without leading indentation for the switch itself).
+ */
+function buildSwitchBody(
+  mappings: ReadonlyArray<DiscriminatorValueMapping>,
+  fieldNames: ReadonlyArray<string>,
+  fieldIndex: number,
+  indent: string,
+): string[] {
+  const fieldName = fieldNames[fieldIndex]!;
+  const groups = groupMappingsByFieldValue(mappings, fieldIndex);
+  const lines: string[] = [];
+
+  lines.push(`${indent}switch (obj.${fieldName}) {`);
+
+  for (const [value, groupMappings] of groups) {
+    // Null value means the member doesn't have this field — resolved at the parent level
+    if (value === null) {
+      for (const mapping of groupMappings) {
+        lines.push(
+          `${indent}  case "${mapping.values[fieldIndex - 1]!}": return "${mapping.memberGraphQLTypeName}";`,
+        );
+      }
+      continue;
+    }
+
+    const nextFieldIndex = fieldIndex + 1;
+    const hasMoreFields = nextFieldIndex < fieldNames.length;
+
+    // Check if all mappings in this group can be resolved directly
+    // (either no more fields, or only one mapping, or all remaining values are null)
+    const canResolveDirectly =
+      groupMappings.length === 1 &&
+      (!hasMoreFields || groupMappings[0]!.values[nextFieldIndex] === null);
+
+    if (!hasMoreFields || canResolveDirectly) {
+      // Single mapping or no more fields: emit direct return
+      if (groupMappings.length === 1) {
+        lines.push(
+          `${indent}  case "${value}": return "${groupMappings[0]!.memberGraphQLTypeName}";`,
+        );
+      } else {
+        // Multiple mappings at the leaf level — shouldn't happen with unique tuples
+        for (const mapping of groupMappings) {
+          lines.push(
+            `${indent}  case "${value}": return "${mapping.memberGraphQLTypeName}";`,
+          );
+        }
+      }
+    } else {
+      // Need nested switch for remaining fields
+      lines.push(`${indent}  case "${value}":`);
+      const nestedLines = buildSwitchBody(
+        groupMappings,
+        fieldNames,
+        nextFieldIndex,
+        `${indent}    `,
+      );
+      lines.push(...nestedLines);
+    }
+  }
+
+  lines.push(`${indent}  default: return undefined;`);
+  lines.push(`${indent}}`);
+
+  return lines;
+}
+
+function buildObjTypeAnnotation(fieldNames: ReadonlyArray<string>): string {
+  const fields = fieldNames.map((name) => `${name}: string`);
+  return `{ ${fields.join("; ")} }`;
+}
+
+/**
+ * Builds a resolver map entry for a discriminator-based __resolveType.
+ *
+ * For single discriminator field:
+ *   TypeName: {
+ *     __resolveType: (obj: { field: string }) => {
+ *       switch (obj.field) {
+ *         case "val": return "MemberType";
+ *         default: return undefined;
+ *       }
+ *     },
+ *   },
+ *
+ * For multiple discriminator fields, generates nested switch statements.
+ */
+export function buildDiscriminatorResolveTypeEntry(
+  info: DiscriminatorResolveTypeInfo,
+): string {
+  const { unionTypeName, fieldNames, valueMappings } = info;
+  const objType = buildObjTypeAnnotation(fieldNames);
+  const baseIndent = "        ";
+
+  const switchLines = buildSwitchBody(valueMappings, fieldNames, 0, baseIndent);
+  const switchBody = switchLines.join("\n");
+
+  return `    ${unionTypeName}: {\n      __resolveType: (obj: ${objType}) => {\n${switchBody}\n      },\n    },`;
+}

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

@@ -1,12 +1,16 @@
 import {
+  collectDiscriminatorResolveTypes,
   collectTypenameExtractions,
   collectTypenameResolveTypes,
+  flattenIntersectionMembers,
   generateAutoTypes,
+  validateDiscriminatorFields,
   validateNameCollisions,
   validateSchemaTypenames,
   validateTypenames,
 } from "../auto-type-generator/index.js";
 import type { ImportExtension } from "../config/types.js";
+import type { ResolvedDiscriminatorFieldsMap } from "../config-loader/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";
@@ -35,6 +39,7 @@ export interface GenerateSchemaInput {
   readonly sourceRoot: string | null;
   readonly knownTypeNames: ReadonlySet<string> | null;
   readonly importExtension: ImportExtension;
+  readonly discriminatorFields: ResolvedDiscriminatorFieldsMap;
 }
 
 export interface GenerateSchemaResult {
@@ -67,6 +72,7 @@ export function generateSchema(
     extractedTypes,
     resolversResult,
     knownTypeNames: knownTypeNames ?? new Set(),
+    discriminatorFields: input.discriminatorFields,
   });
 
   const autoTypeErrors = autoTypeResult.diagnostics.filter(
@@ -105,11 +111,52 @@ export function generateSchema(
     };
   }
 
+  // Flatten intersection-expanded inline object members for discriminator unions.
+  // TypeScript distributes intersections over unions, creating duplicate members
+  // that must be merged before discriminator field validation.
+  const flattenedExtractedTypes = flattenIntersectionMembers({
+    extractedTypes: autoTypeResult.updatedExtractedTypes,
+    discriminatorFields: input.discriminatorFields,
+  });
+
   // 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 updatedConversionResult = convertToGraphQL(flattenedExtractedTypes);
+  const typeMap = new Map(
+    flattenedExtractedTypes.map((t) => [t.metadata.name, t]),
   );
+
+  // Validate discriminator fields against extracted types
+  const inlineDiscriminatorUnionNames = new Set(
+    autoTypeResult.inlineDiscriminatorResolveTypes.map(
+      (rt) => rt.unionTypeName,
+    ),
+  );
+  const discriminatorValidationResult = validateDiscriminatorFields({
+    discriminatorFields: input.discriminatorFields,
+    extractedTypes: flattenedExtractedTypes,
+    typeMap,
+    inlineDiscriminatorUnionNames,
+  });
+  const discriminatorErrors = discriminatorValidationResult.diagnostics.filter(
+    (d) => d.severity === "error",
+  );
+  if (discriminatorErrors.length > 0) {
+    return {
+      typeDefsCode: "",
+      sdlContent: "",
+      resolversCode: "",
+      diagnostics: discriminatorValidationResult.diagnostics,
+      hasErrors: true,
+      prunedTypes: null,
+    };
+  }
+
+  const discriminatorWarnings =
+    discriminatorValidationResult.diagnostics.filter(
+      (d) => d.severity === "warning",
+    );
+
   const updatedTypesResult: ExtractTypesResult = {
     types: updatedConversionResult.types,
     diagnostics: {
@@ -126,29 +173,48 @@ export function generateSchema(
           (d) => d.severity === "warning",
         ),
         ...autoTypeResult.diagnostics.filter((d) => d.severity === "warning"),
+        ...discriminatorWarnings,
       ],
     },
   };
 
-  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),
   );
 
+  // Collect discriminator resolve types from validated entries
+  const discriminatorResolveTypesResult = collectDiscriminatorResolveTypes({
+    validatedEntries: discriminatorValidationResult.validatedEntries,
+    manualResolveTypeNames,
+    extractedTypes: flattenedExtractedTypes,
+    typeMap,
+  });
+
+  // Merge inline discriminator resolveTypes from auto-type generation
+  // (for inline unions flattened by discriminator fields, e.g. UIMessagePart<...>[])
+  const mergedDiscriminatorResolveTypes = [
+    ...discriminatorResolveTypesResult.discriminatorResolveTypes,
+    ...autoTypeResult.inlineDiscriminatorResolveTypes,
+  ];
+  // discriminatorResolveTypeNames are derived by integrate() from the merged list
+
+  const discriminatorFieldUnionNames = new Set(
+    input.discriminatorFields.keys(),
+  );
+
   const typenameResolveTypesResult = collectTypenameResolveTypes({
-    extractedTypes: autoTypeResult.updatedExtractedTypes,
+    extractedTypes: flattenedExtractedTypes,
     typeMap,
     manualResolveTypeNames,
+    discriminatorFieldUnionNames,
   });
 
   const typenameExtractions = collectTypenameExtractions({
-    extractedTypes: autoTypeResult.updatedExtractedTypes,
+    extractedTypes: flattenedExtractedTypes,
     typeMap,
+    discriminatorFieldUnionNames,
   });
 
   const typenameValidationDiagnostics: Diagnostic[] = [];
@@ -167,7 +233,7 @@ export function generateSchema(
   }
 
   const schemaTypenameValidationResult = validateSchemaTypenames({
-    objectTypes: autoTypeResult.updatedExtractedTypes,
+    objectTypes: flattenedExtractedTypes,
     typeMap,
   });
   typenameValidationDiagnostics.push(
@@ -188,20 +254,38 @@ export function generateSchema(
   const generatedInlineObjectTypes =
     typenameResolveTypesResult.generatedInlineObjectTypes;
 
+  // Collect all generated object types that need to be added as union members
+  // (both typename-based and discriminator-based inline objects)
+  const discriminatorGeneratedObjectTypes =
+    discriminatorResolveTypesResult.generatedObjectTypes;
+
   const updatedTypesForIntegration: ExtractTypesResult =
-    generatedInlineObjectTypes.length > 0
+    generatedInlineObjectTypes.length > 0 ||
+    discriminatorGeneratedObjectTypes.length > 0
       ? {
           types: updatedTypesResult.types.map((type) => {
             if (type.kind !== "Union") {
               return type;
             }
-            const inlineTypes = generatedInlineObjectTypes.filter(
+            const typenameInlineTypes = generatedInlineObjectTypes.filter(
               (g) => g.abstractTypeName === type.name,
             );
-            if (inlineTypes.length === 0) {
+            const discriminatorInlineTypes =
+              discriminatorGeneratedObjectTypes.filter(
+                (g) =>
+                  g.generatedFrom !== null &&
+                  g.generatedFrom.parentTypeName === type.name,
+              );
+            if (
+              typenameInlineTypes.length === 0 &&
+              discriminatorInlineTypes.length === 0
+            ) {
               return type;
             }
-            const newMembers = inlineTypes.map((g) => g.typeName);
+            const newMembers = [
+              ...typenameInlineTypes.map((g) => g.typeName),
+              ...discriminatorInlineTypes.map((g) => g.name),
+            ];
             return {
               ...type,
               unionMembers: [
@@ -217,6 +301,7 @@ export function generateSchema(
   const allAutoGeneratedTypes = [
     ...autoTypeResult.autoGeneratedTypes,
     ...typenameResolveTypesResult.generatedObjectTypes,
+    ...discriminatorGeneratedObjectTypes,
   ];
 
   const integratedResult = integrate({
@@ -227,6 +312,8 @@ export function generateSchema(
     directiveDefinitions,
     autoGeneratedTypes: allAutoGeneratedTypes,
     typenameAutoResolveTypes: typenameResolveTypesResult.autoResolveTypes,
+    discriminatorResolveTypes: mergedDiscriminatorResolveTypes,
+    tsAliasToGraphQLNameMap: autoTypeResult.tsAliasToGraphQLNameMap,
   });
 
   let documentNode = buildDocumentNode(integratedResult, { sourceRoot });

package/src/schema-generator/integrator/result-integrator.ts

@@ -1,3 +1,4 @@
+import type { DiscriminatorResolveTypeInfo } from "../../auto-type-generator/discriminator-resolve-type-generator.js";
 import type {
   AutoGeneratedType,
   ResolveTypeFieldPattern,
@@ -141,10 +142,12 @@ export interface IntegratedResult {
   readonly abstractTypeResolvers: ReadonlyArray<AbstractResolverInfo>;
   readonly autoGeneratedUnions: ReadonlyArray<AutoGeneratedUnionInfo>;
   readonly typenameAutoResolveTypes: ReadonlyArray<TypenameAutoResolveTypeInfo>;
+  readonly discriminatorResolveTypes: ReadonlyArray<DiscriminatorResolveTypeInfo>;
   readonly numericEnums: ReadonlyArray<NumericEnumInfo>;
   readonly stringEnumMappings: ReadonlyArray<StringEnumMappingInfo>;
   readonly hasQuery: boolean;
   readonly hasMutation: boolean;
+  readonly hasSubscription: boolean;
   readonly hasErrors: boolean;
   readonly diagnostics: ReadonlyArray<Diagnostic>;
 }
@@ -275,6 +278,8 @@ export interface IntegrateParams {
   readonly directiveDefinitions: ReadonlyArray<DirectiveDefinitionInfo> | null;
   readonly autoGeneratedTypes: ReadonlyArray<AutoGeneratedType> | null;
   readonly typenameAutoResolveTypes: ReadonlyArray<TypenameAutoResolveTypeInfo> | null;
+  readonly discriminatorResolveTypes: ReadonlyArray<DiscriminatorResolveTypeInfo> | null;
+  readonly tsAliasToGraphQLNameMap: ReadonlyMap<string, string> | null;
 }
 
 export function integrate(params: IntegrateParams): IntegratedResult {
@@ -286,6 +291,8 @@ export function integrate(params: IntegrateParams): IntegratedResult {
     directiveDefinitions,
     autoGeneratedTypes,
     typenameAutoResolveTypes,
+    discriminatorResolveTypes,
+    tsAliasToGraphQLNameMap,
   } = params;
   const directiveTypeAliasNames = new Set(
     directiveDefinitions?.map((d) => d.typeAliasName) ?? [],
@@ -469,8 +476,10 @@ export function integrate(params: IntegrateParams): IntegratedResult {
 
   const hasQuery = resolversResult.queryFields.fields.length > 0;
   const hasMutation = resolversResult.mutationFields.fields.length > 0;
+  const hasSubscription = resolversResult.subscriptionFields.fields.length > 0;
 
-  if (hasQuery) {
+  // GraphQL spec requires Query root type even when only Subscription/Mutation are defined
+  if (hasQuery || hasMutation || hasSubscription) {
     baseTypes.push({
       name: "Query",
       kind: "Object",
@@ -502,21 +511,54 @@ export function integrate(params: IntegrateParams): IntegratedResult {
       directives: null,
     });
   }
+  if (hasSubscription) {
+    baseTypes.push({
+      name: "Subscription",
+      kind: "Object",
+      fields: [],
+      unionMembers: null,
+      enumValues: null,
+      isNumericEnum: false,
+      needsStringEnumMapping: false,
+      implementedInterfaces: null,
+      description: null,
+      deprecated: null,
+      sourceFile: null,
+      directives: null,
+    });
+  }
 
   const typenameAutoResolveTypeNames = new Set([
     ...(typenameAutoResolveTypes?.map((t) => t.abstractTypeName) ?? []),
     ...autoGeneratedUnions
       .filter((u) => u.hasAutoResolveType)
       .map((u) => u.name),
+    ...(discriminatorResolveTypes?.map((t) => t.unionTypeName) ?? []),
   ]);
 
+  const aliasMap = tsAliasToGraphQLNameMap ?? new Map<string, string>();
+
   const abstractResolverValidation = validateAbstractResolvers({
     abstractResolvers: resolversResult.abstractTypeResolvers,
     baseTypes,
     typenameAutoResolveTypeNames,
+    tsAliasToGraphQLNameMap: aliasMap,
   });
   diagnostics.push(...abstractResolverValidation.diagnostics);
 
+  // Remap abstract resolver target type names from TS aliases to GraphQL names
+  // Only remap resolveType resolvers — isTypeOf targets object types, not unions
+  const remappedAbstractResolvers =
+    aliasMap.size > 0
+      ? resolversResult.abstractTypeResolvers.map((resolver) => {
+          if (resolver.kind !== "resolveType") return resolver;
+          const mappedName = aliasMap.get(resolver.targetTypeName);
+          return mappedName !== undefined
+            ? { ...resolver, targetTypeName: mappedName }
+            : resolver;
+        })
+      : resolversResult.abstractTypeResolvers;
+
   const knownTypeNames = new Set([
     ...baseTypes.map((t) => t.name),
     ...inputTypes.map((t) => t.name),
@@ -540,6 +582,15 @@ export function integrate(params: IntegrateParams): IntegratedResult {
     });
   }
 
+  if (hasSubscription) {
+    typeExtensions.push({
+      targetTypeName: "Subscription",
+      fields: resolversResult.subscriptionFields.fields.map(
+        convertToExtensionField,
+      ),
+    });
+  }
+
   for (const ext of resolversResult.typeExtensions) {
     if (!knownTypeNames.has(ext.targetTypeName)) {
       const firstField = ext.fields[0];
@@ -705,13 +756,15 @@ export function integrate(params: IntegrateParams): IntegratedResult {
       directiveDefinitions && directiveDefinitions.length > 0
         ? directiveDefinitions
         : null,
-    abstractTypeResolvers: resolversResult.abstractTypeResolvers,
+    abstractTypeResolvers: remappedAbstractResolvers,
     autoGeneratedUnions,
     typenameAutoResolveTypes: typenameAutoResolveTypes ?? [],
+    discriminatorResolveTypes: discriminatorResolveTypes ?? [],
     numericEnums,
     stringEnumMappings,
     hasQuery,
     hasMutation,
+    hasSubscription,
     hasErrors,
     diagnostics,
   };

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

@@ -1,3 +1,4 @@
+import type { DiscriminatorResolveTypeInfo } from "../../auto-type-generator/discriminator-resolve-type-generator.js";
 import type { AutoGeneratedResolveType } from "../../auto-type-generator/resolve-type-generator.js";
 import type { AbstractResolverInfo } from "../../resolver-extractor/extractor/define-api-extractor.js";
 import type {
@@ -30,6 +31,7 @@ export interface ResolverInfo {
   readonly sourceFiles: ReadonlyArray<string>;
   readonly abstractTypeResolvers: ReadonlyArray<AbstractTypeResolverInfo>;
   readonly autoGeneratedResolveTypes: ReadonlyArray<AutoGeneratedResolveType>;
+  readonly discriminatorResolveTypes: ReadonlyArray<DiscriminatorResolveTypeInfo>;
 }
 
 function getResolverValueName(typeName: string): string {
@@ -148,10 +150,15 @@ export function collectResolverInfo(
 
   const sourceFiles = [...sourceFilesSet].sort((a, b) => a.localeCompare(b));
 
+  const discriminatorResolveTypes = [
+    ...integratedResult.discriminatorResolveTypes,
+  ].sort((a, b) => a.unionTypeName.localeCompare(b.unionTypeName));
+
   return {
     types,
     sourceFiles,
     abstractTypeResolvers,
     autoGeneratedResolveTypes,
+    discriminatorResolveTypes,
   };
 }

package/src/shared/constants.ts

@@ -39,6 +39,19 @@ const TS_ANONYMOUS_TYPE_SYMBOL = "__type";
  */
 const TS_ARRAY_TYPE_SYMBOL = "Array";
 
+/**
+ * Object literal type symbol name.
+ *
+ * TypeScript uses `__object` as the internal symbol name for object literal
+ * expressions (value-space). This differs from `__type` which is used for
+ * anonymous object types in type-space.
+ *
+ * This commonly occurs when a type is derived via `typeof` from a variable
+ * initialized with an object literal, especially when the value comes from
+ * an external library.
+ */
+const TS_OBJECT_LITERAL_TYPE_SYMBOL = "__object";
+
 /**
  * Checks if a symbol name represents a TypeScript internal/anonymous type
  * that should not be used directly as a GraphQL type name.
@@ -49,7 +62,8 @@ const TS_ARRAY_TYPE_SYMBOL = "Array";
 export function isInternalTypeSymbol(symbolName: string): boolean {
   return (
     symbolName === TS_ANONYMOUS_TYPE_SYMBOL ||
-    symbolName === TS_ARRAY_TYPE_SYMBOL
+    symbolName === TS_ARRAY_TYPE_SYMBOL ||
+    symbolName === TS_OBJECT_LITERAL_TYPE_SYMBOL
   );
 }
 

package/src/shared/enum-prefix-detector.ts

@@ -32,6 +32,86 @@ export function buildEnumPrefixCandidate(enumName: string): string {
   return `${toUpperSnakeCase(enumName)}_`;
 }
 
+const IRREGULAR_PLURAL_SEGMENTS = new Map([
+  ["ALIAS", "ALIASES"],
+  ["ANALYSIS", "ANALYSES"],
+  ["CHILD", "CHILDREN"],
+  ["COOKIE", "COOKIES"],
+  ["CRISIS", "CRISES"],
+  ["DIAGNOSIS", "DIAGNOSES"],
+  ["FOOT", "FEET"],
+  ["GOOSE", "GEESE"],
+  ["MAN", "MEN"],
+  ["MOUSE", "MICE"],
+  ["MOVIE", "MOVIES"],
+  ["PERSON", "PEOPLE"],
+  ["THESIS", "THESES"],
+  ["TOOTH", "TEETH"],
+  ["WOMAN", "WOMEN"],
+]);
+
+function isConsonant(char: string): boolean {
+  return /^[BCDFGHJKLMNPQRSTVWXYZ]$/.test(char);
+}
+
+function pluralizeUpperSnakeSegment(segment: string): string {
+  const irregularPlural = IRREGULAR_PLURAL_SEGMENTS.get(segment);
+  if (irregularPlural) {
+    return irregularPlural;
+  }
+
+  if (
+    segment.endsWith("Y") &&
+    segment.length > 1 &&
+    isConsonant(segment.at(-2) ?? "")
+  ) {
+    return `${segment.slice(0, -1)}IES`;
+  }
+
+  if (
+    segment.endsWith("S") ||
+    segment.endsWith("SH") ||
+    segment.endsWith("CH") ||
+    segment.endsWith("X") ||
+    segment.endsWith("Z")
+  ) {
+    return `${segment}ES`;
+  }
+
+  return `${segment}S`;
+}
+
+function buildEnumPrefixCandidates(enumName: string): string[] {
+  const upperSnakeName = toUpperSnakeCase(enumName);
+  const baseCandidate = `${upperSnakeName}_`;
+  const segments = upperSnakeName.split("_");
+  const candidateSegmentSets: string[][] = [segments];
+
+  if (segments.length === 0) {
+    return [baseCandidate];
+  }
+
+  for (const [index, segment] of segments.entries()) {
+    const pluralizedSegment = pluralizeUpperSnakeSegment(segment);
+    if (pluralizedSegment === segment) {
+      continue;
+    }
+
+    const existingCandidates = [...candidateSegmentSets];
+    for (const candidateSegments of existingCandidates) {
+      const nextCandidateSegments = [...candidateSegments];
+      nextCandidateSegments[index] = pluralizedSegment;
+      candidateSegmentSets.push(nextCandidateSegments);
+    }
+  }
+
+  return [
+    ...new Set(
+      candidateSegmentSets.map((candidate) => `${candidate.join("_")}_`),
+    ),
+  ];
+}
+
 export interface DetectEnumPrefixParams {
   readonly enumName: string;
   readonly memberValues: ReadonlyArray<string>;
@@ -71,20 +151,28 @@ export function detectEnumPrefix(
     return { shouldStrip: false, prefix: null };
   }
 
-  const prefixCandidate = buildEnumPrefixCandidate(enumName);
+  for (const prefixCandidate of buildEnumPrefixCandidates(enumName)) {
+    let matches = true;
+
+    for (const value of memberValues) {
+      if (!value.startsWith(prefixCandidate)) {
+        matches = false;
+        break;
+      }
 
-  for (const value of memberValues) {
-    if (!value.startsWith(prefixCandidate)) {
-      return { shouldStrip: false, prefix: null };
+      const stripped = value.slice(prefixCandidate.length);
+      if (stripped === "") {
+        matches = false;
+        break;
+      }
     }
 
-    const stripped = value.slice(prefixCandidate.length);
-    if (stripped === "") {
-      return { shouldStrip: false, prefix: null };
+    if (matches) {
+      return { shouldStrip: true, prefix: prefixCandidate };
     }
   }
 
-  return { shouldStrip: true, prefix: prefixCandidate };
+  return { shouldStrip: false, prefix: null };
 }
 
 /**

package/src/shared/inline-object-utils.ts

@@ -12,7 +12,7 @@ export function isInlineObjectType(type: ts.Type): boolean {
     return false;
   }
   const symbolName = type.symbol.getName();
-  if (symbolName !== "__type") {
+  if (symbolName !== "__type" && symbolName !== "__object") {
     return false;
   }
   if (!(type.flags & ts.TypeFlags.Object)) {