From 41ea26616f744a0429ba701857ea7ee69943e3a2 Mon Sep 17 00:00:00 2001 From: vejrj <77059398+vejrj@users.noreply.github.com> Date: Fri, 29 May 2026 15:03:37 +0200 Subject: [PATCH 1/3] added possible types for unions --- packages/ts-codegen/src/legacyTypes.ts | 74 ++++++++++++++++++++++++++ 1 file changed, 74 insertions(+) diff --git a/packages/ts-codegen/src/legacyTypes.ts b/packages/ts-codegen/src/legacyTypes.ts index 17e1dd710..7010c8c12 100644 --- a/packages/ts-codegen/src/legacyTypes.ts +++ b/packages/ts-codegen/src/legacyTypes.ts @@ -111,6 +111,80 @@ export function generateLegacyTypes(context: TsCodegenContext): ts.SourceFile { ), ); + statements.push( + factory.createInterfaceDeclaration( + [factory.createToken(ts.SyntaxKind.ExportKeyword)], + factory.createIdentifier("PossibleTypesResultData"), + undefined, + undefined, + [ + factory.createPropertySignature( + undefined, + factory.createIdentifier("possibleTypes"), + undefined, + factory.createTypeLiteralNode([ + factory.createIndexSignature( + undefined, + [ + factory.createParameterDeclaration( + undefined, + undefined, + factory.createIdentifier("key"), + undefined, + factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword), + undefined, + ), + ], + factory.createArrayTypeNode( + factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword), + ), + ), + ]), + ), + ], + ), + factory.createVariableStatement( + undefined, + factory.createVariableDeclarationList( + [ + factory.createVariableDeclaration( + factory.createIdentifier("result"), + undefined, + factory.createTypeReferenceNode( + factory.createIdentifier("PossibleTypesResultData"), + undefined, + ), + factory.createObjectLiteralExpression( + [ + factory.createPropertyAssignment( + factory.createStringLiteral("possibleTypes"), + factory.createObjectLiteralExpression( + allTypes + .filter((type) => type.kind === "UNION") + .map((union) => + factory.createPropertyAssignment( + factory.createStringLiteral(union.name), + factory.createArrayLiteralExpression( + union.types.map((type) => { + return factory.createStringLiteral(type); + }), + true, + ), + ), + ), + true, + ), + ), + ], + true, + ), + ), + ], + ts.NodeFlags.Const, + ), + ), + ); + const source = factory.createSourceFile( statements, factory.createToken(ts.SyntaxKind.EndOfFileToken), From 83fc0f25ad5bb59bfc99ae3c0b4c3992d957087d Mon Sep 17 00:00:00 2001 From: vejrj <77059398+vejrj@users.noreply.github.com> Date: Fri, 29 May 2026 15:35:44 +0200 Subject: [PATCH 2/3] added typeMap --- packages/ts-codegen/src/legacyTypes.ts | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/packages/ts-codegen/src/legacyTypes.ts b/packages/ts-codegen/src/legacyTypes.ts index 7010c8c12..3954f8c26 100644 --- a/packages/ts-codegen/src/legacyTypes.ts +++ b/packages/ts-codegen/src/legacyTypes.ts @@ -111,6 +111,29 @@ export function generateLegacyTypes(context: TsCodegenContext): ts.SourceFile { ), ); + statements.push( + factory.createTypeAliasDeclaration( + [factory.createModifier(ts.SyntaxKind.ExportKeyword)], + factory.createIdentifier("TypeMap"), + undefined, + factory.createTypeLiteralNode( + allTypes.map((type) => + factory.createPropertySignature( + undefined, + factory.createStringLiteral(type.name), + undefined, + factory.createTypeReferenceNode( + factory.createQualifiedName( + factory.createIdentifier("Models"), + type.name, + ), + ), + ), + ), + ), + ), + ); + statements.push( factory.createInterfaceDeclaration( [factory.createToken(ts.SyntaxKind.ExportKeyword)], From fa9ba832309751d26911c2563e78728bf44604a8 Mon Sep 17 00:00:00 2001 From: vejrj <77059398+vejrj@users.noreply.github.com> Date: Sun, 31 May 2026 19:55:01 +0200 Subject: [PATCH 3/3] put under parameter --- packages/ts-codegen/src/codegen.ts | 11 +++- packages/ts-codegen/src/legacyTypes.ts | 73 ++++++++++++++++---------- 2 files changed, 55 insertions(+), 29 deletions(-) diff --git a/packages/ts-codegen/src/codegen.ts b/packages/ts-codegen/src/codegen.ts index 581071ad5..a23947292 100644 --- a/packages/ts-codegen/src/codegen.ts +++ b/packages/ts-codegen/src/codegen.ts @@ -61,6 +61,8 @@ export interface GenerateTSOptions { * } */ mandatoryResolverTypes?: boolean; + generateUnionPossibleTypes?: boolean; + generateTypeMap?: boolean; } export function generateTS( @@ -81,6 +83,8 @@ export function generateTS( contextTypeExtensions, generateResolverMap = false, mandatoryResolverTypes = false, + generateUnionPossibleTypes = false, + generateTypeMap = false, }: GenerateTSOptions, ): { files: ts.SourceFile[]; @@ -137,7 +141,12 @@ export function generateTS( } if (legacyCompat) { - result.push(generateLegacyTypes(context)); + result.push( + generateLegacyTypes(context, { + generateUnionPossibleTypes, + generateTypeMap, + }), + ); result.push(generateLegacyResolvers(context)); } } diff --git a/packages/ts-codegen/src/legacyTypes.ts b/packages/ts-codegen/src/legacyTypes.ts index 3954f8c26..94f5ba457 100644 --- a/packages/ts-codegen/src/legacyTypes.ts +++ b/packages/ts-codegen/src/legacyTypes.ts @@ -1,5 +1,5 @@ import ts, { factory } from "typescript"; -import { BUILT_IN_SCALARS, TsCodegenContext } from "./context"; +import { BUILT_IN_SCALARS, TsCodegenContext, Type } from "./context"; const ROOT_OPERATIONS = ["Query", "Mutation", "Subscription"]; const LEGACY_TYPES = [ @@ -12,7 +12,16 @@ const LEGACY_TYPES = [ "ENUM", ]; -export function generateLegacyTypes(context: TsCodegenContext): ts.SourceFile { +export function generateLegacyTypes( + context: TsCodegenContext, + { + generateUnionPossibleTypes = true, + generateTypeMap = true, + }: { + generateUnionPossibleTypes?: boolean; + generateTypeMap?: boolean; + } = {}, +): ts.SourceFile { const statements: ts.Statement[] = []; const allTypes = context .getAllTypes() @@ -111,30 +120,46 @@ export function generateLegacyTypes(context: TsCodegenContext): ts.SourceFile { ), ); - statements.push( - factory.createTypeAliasDeclaration( - [factory.createModifier(ts.SyntaxKind.ExportKeyword)], - factory.createIdentifier("TypeMap"), - undefined, - factory.createTypeLiteralNode( - allTypes.map((type) => - factory.createPropertySignature( - undefined, - factory.createStringLiteral(type.name), - undefined, - factory.createTypeReferenceNode( - factory.createQualifiedName( - factory.createIdentifier("Models"), - type.name, + if (generateTypeMap) { + statements.push( + factory.createTypeAliasDeclaration( + [factory.createModifier(ts.SyntaxKind.ExportKeyword)], + factory.createIdentifier("TypeMap"), + undefined, + factory.createTypeLiteralNode( + allTypes.map((type) => + factory.createPropertySignature( + undefined, + factory.createStringLiteral(type.name), + undefined, + factory.createTypeReferenceNode( + factory.createQualifiedName( + factory.createIdentifier("Models"), + type.name, + ), ), ), ), ), ), - ), + ); + } + + if (generateUnionPossibleTypes) { + statements.push(...createUnionPossibleTypesStatements(allTypes)); + } + + const source = factory.createSourceFile( + statements, + factory.createToken(ts.SyntaxKind.EndOfFileToken), + ts.NodeFlags.None, ); + source.fileName = "legacy-types.interface.ts"; + return source; +} - statements.push( +function createUnionPossibleTypesStatements(allTypes: Type[]): ts.Statement[] { + return [ factory.createInterfaceDeclaration( [factory.createToken(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("PossibleTypesResultData"), @@ -206,13 +231,5 @@ export function generateLegacyTypes(context: TsCodegenContext): ts.SourceFile { ts.NodeFlags.Const, ), ), - ); - - const source = factory.createSourceFile( - statements, - factory.createToken(ts.SyntaxKind.EndOfFileToken), - ts.NodeFlags.None, - ); - source.fileName = "legacy-types.interface.ts"; - return source; + ]; }