fix(typescript): Use serialization layer to convert types to JSON str…

…ings when enabled.

fix(typescript): Use serialization layer to convert types to JSON strings when enabled.

generators/browser-compatible-base/src/dynamic-snippets/test-utils/DynamicSnippetsTestRunner.ts

@@ -361,7 +361,7 @@ export class DynamicSnippetsTestRunner {
                         headers: undefined,
                         requestBody: {
                             file: "Hello, world!",
-                            fileList: ["First", "Second"]
+                            file_list: ["First", "Second"]
                         }
                     }
                 },

generators/typescript/express/generator/src/ExpressGenerator.ts

@@ -564,7 +564,9 @@ export class ExpressGenerator {
             includeSerdeLayer: this.config.includeSerdeLayer,
             retainOriginalCasing: this.config.retainOriginalCasing,
             useBigInt: this.config.useBigInt,
-            enableInlineTypes: false
+            enableInlineTypes: false,
+            allowExtraFields: this.config.allowExtraFields,
+            omitUndefined: false
         });
     }
 }

generators/typescript/express/generator/src/contexts/ExpressContextImpl.ts

@@ -84,6 +84,8 @@ export declare namespace ExpressContextImpl {
         retainOriginalCasing: boolean;
         useBigInt: boolean;
         enableInlineTypes: boolean;
+        allowExtraFields: boolean;
+        omitUndefined: boolean;
     }
 }
 
@@ -141,6 +143,8 @@ export class ExpressContextImpl implements ExpressContext {
         includeSerdeLayer,
         retainOriginalCasing,
         enableInlineTypes,
+        allowExtraFields,
+        omitUndefined,
         useBigInt
     }: ExpressContextImpl.Init) {
         this.logger = logger;
@@ -168,13 +172,15 @@ export class ExpressContextImpl implements ExpressContext {
             retainOriginalCasing,
             useBigInt,
             enableInlineTypes,
+            allowExtraFields,
+            omitUndefined,
             context: this
         });
         this.typeSchema = new TypeSchemaContextImpl({
             sourceFile,
             coreUtilities: this.coreUtilities,
             importsManager,
-            typeResolver,
+            context: this,
             typeSchemaDeclarationReferencer,
             typeDeclarationReferencer,
             typeGenerator,
@@ -183,7 +189,9 @@ export class ExpressContextImpl implements ExpressContext {
             includeSerdeLayer,
             retainOriginalCasing,
             useBigInt,
-            enableInlineTypes
+            enableInlineTypes,
+            allowExtraFields,
+            omitUndefined
         });
 
         this.expressInlinedRequestBody = new ExpressInlinedRequestBodyContextImpl({

generators/typescript/express/generator/src/contexts/type-schema/TypeSchemaContextImpl.ts

@@ -1,6 +1,6 @@
 import { ImportsManager, Reference, TypeReferenceNode, Zurg } from "@fern-typescript/commons";
 import { CoreUtilities } from "@fern-typescript/commons/src/core-utilities/CoreUtilities";
-import { GeneratedTypeSchema, TypeSchemaContext } from "@fern-typescript/contexts";
+import { BaseContext, GeneratedTypeSchema, TypeSchemaContext } from "@fern-typescript/contexts";
 import { TypeResolver } from "@fern-typescript/resolvers";
 import { TypeGenerator } from "@fern-typescript/type-generator";
 import {
@@ -20,7 +20,7 @@ export declare namespace TypeSchemaContextImpl {
         sourceFile: SourceFile;
         coreUtilities: CoreUtilities;
         importsManager: ImportsManager;
-        typeResolver: TypeResolver;
+        context: BaseContext;
         typeDeclarationReferencer: TypeDeclarationReferencer;
         typeSchemaDeclarationReferencer: TypeDeclarationReferencer;
         typeGenerator: TypeGenerator;
@@ -30,6 +30,8 @@ export declare namespace TypeSchemaContextImpl {
         retainOriginalCasing: boolean;
         useBigInt: boolean;
         enableInlineTypes: boolean;
+        allowExtraFields: boolean;
+        omitUndefined: boolean;
     }
 }
 
@@ -41,7 +43,7 @@ export class TypeSchemaContextImpl implements TypeSchemaContext {
     private typeSchemaDeclarationReferencer: TypeDeclarationReferencer;
     private typeReferenceToRawTypeNodeConverter: TypeReferenceToRawTypeNodeConverter;
     private typeReferenceToSchemaConverter: TypeReferenceToSchemaConverter;
-    private typeResolver: TypeResolver;
+    private context: BaseContext;
     private typeGenerator: TypeGenerator;
     private typeSchemaGenerator: TypeSchemaGenerator;
     private includeSerdeLayer: boolean;
@@ -51,7 +53,7 @@ export class TypeSchemaContextImpl implements TypeSchemaContext {
         sourceFile,
         coreUtilities,
         importsManager,
-        typeResolver,
+        context,
         typeDeclarationReferencer,
         typeGenerator,
         typeSchemaDeclarationReferencer,
@@ -60,40 +62,46 @@ export class TypeSchemaContextImpl implements TypeSchemaContext {
         includeSerdeLayer,
         retainOriginalCasing,
         useBigInt,
-        enableInlineTypes
+        enableInlineTypes,
+        allowExtraFields,
+        omitUndefined
     }: TypeSchemaContextImpl.Init) {
         this.sourceFile = sourceFile;
         this.coreUtilities = coreUtilities;
         this.importsManager = importsManager;
         this.typeReferenceToRawTypeNodeConverter = new TypeReferenceToRawTypeNodeConverter({
             getReferenceToNamedType: (typeName) => this.getReferenceToRawNamedType(typeName).getEntityName(),
             generateForInlineUnion: (typeName) => this.generateForInlineUnion(typeName),
-            typeResolver,
+            context,
             treatUnknownAsAny,
             includeSerdeLayer,
             useBigInt,
-            enableInlineTypes
+            enableInlineTypes,
+            allowExtraFields,
+            omitUndefined
         });
         this.typeReferenceToSchemaConverter = new TypeReferenceToSchemaConverter({
             getSchemaOfNamedType: (typeName) => this.getSchemaOfNamedType(typeName, { isGeneratingSchema: true }),
             zurg: this.coreUtilities.zurg,
-            typeResolver,
+            context,
             treatUnknownAsAny,
             includeSerdeLayer,
             useBigInt,
-            enableInlineTypes
+            enableInlineTypes,
+            allowExtraFields,
+            omitUndefined
         });
         this.typeDeclarationReferencer = typeDeclarationReferencer;
         this.typeSchemaDeclarationReferencer = typeSchemaDeclarationReferencer;
-        this.typeResolver = typeResolver;
+        this.context = context;
         this.typeGenerator = typeGenerator;
         this.typeSchemaGenerator = typeSchemaGenerator;
         this.includeSerdeLayer = includeSerdeLayer;
         this.retainOriginalCasing = retainOriginalCasing;
     }
 
     public getGeneratedTypeSchema(typeName: DeclaredTypeName): GeneratedTypeSchema {
-        const typeDeclaration = this.typeResolver.getTypeDeclarationFromName(typeName);
+        const typeDeclaration = this.context.type.getTypeDeclaration(typeName);
         const examples = typeDeclaration.userProvidedExamples;
         if (examples.length === 0) {
             examples.push(...typeDeclaration.autogeneratedExamples);
@@ -188,7 +196,7 @@ export class TypeSchemaContextImpl implements TypeSchemaContext {
     }
 
     private wrapSchemaWithLazy(schema: Zurg.Schema, typeName: DeclaredTypeName): Zurg.Schema {
-        const resolvedType = this.typeResolver.resolveTypeName(typeName);
+        const resolvedType = this.context.type.resolveTypeName(typeName);
         return resolvedType.type === "named" && resolvedType.shape === ShapeType.Object
             ? this.coreUtilities.zurg.lazyObject(schema)
             : this.coreUtilities.zurg.lazy(schema);

generators/typescript/express/generator/src/contexts/type/TypeContextImpl.ts

@@ -1,5 +1,11 @@
 import { ImportsManager, Reference, TypeReferenceNode } from "@fern-typescript/commons";
-import { BaseContext, GeneratedType, GeneratedTypeReferenceExample, TypeContext } from "@fern-typescript/contexts";
+import {
+    BaseContext,
+    GeneratedType,
+    GeneratedTypeReferenceExample,
+    TypeContext,
+    TypeSchemaContext
+} from "@fern-typescript/contexts";
 import { TypeResolver } from "@fern-typescript/resolvers";
 import { TypeGenerator } from "@fern-typescript/type-generator";
 import {
@@ -12,7 +18,6 @@ import { SourceFile, ts } from "ts-morph";
 import {
     DeclaredTypeName,
     ExampleTypeReference,
-    ObjectProperty,
     ResolvedTypeReference,
     TypeDeclaration,
     TypeReference
@@ -34,6 +39,8 @@ export declare namespace TypeContextImpl {
         useBigInt: boolean;
         context: BaseContext;
         enableInlineTypes: boolean;
+        allowExtraFields: boolean;
+        omitUndefined: boolean;
     }
 }
 
@@ -62,6 +69,8 @@ export class TypeContextImpl implements TypeContext {
         retainOriginalCasing,
         useBigInt,
         enableInlineTypes,
+        allowExtraFields,
+        omitUndefined,
         context
     }: TypeContextImpl.Init) {
         this.sourceFile = sourceFile;
@@ -77,18 +86,22 @@ export class TypeContextImpl implements TypeContext {
         this.typeReferenceToParsedTypeNodeConverter = new TypeReferenceToParsedTypeNodeConverter({
             getReferenceToNamedType: (typeName) => this.getReferenceToNamedType(typeName).getEntityName(),
             generateForInlineUnion: (typeName) => this.generateForInlineUnion(typeName),
-            typeResolver,
+            context,
             treatUnknownAsAny,
             includeSerdeLayer,
             useBigInt,
-            enableInlineTypes
+            enableInlineTypes,
+            allowExtraFields,
+            omitUndefined
         });
         this.typeReferenceToStringExpressionConverter = new TypeReferenceToStringExpressionConverter({
-            typeResolver,
+            context,
             treatUnknownAsAny,
             includeSerdeLayer,
             useBigInt,
-            enableInlineTypes
+            enableInlineTypes,
+            allowExtraFields,
+            omitUndefined
         });
     }
 

generators/typescript/model/type-reference-converters/package.json

@@ -29,7 +29,7 @@
     "@fern-fern/ir-sdk": "53.23.0",
     "@fern-api/core-utils": "workspace:*",
     "@fern-typescript/commons": "workspace:*",
-    "@fern-typescript/resolvers": "workspace:*",
+    "@fern-typescript/contexts": "workspace:*",
     "ts-morph": "^15.1.0"
   },
   "devDependencies": {

generators/typescript/model/type-reference-converters/src/AbstractTypeReferenceConverter.ts

@@ -1,5 +1,5 @@
 import { TypeReferenceNode } from "@fern-typescript/commons";
-import { TypeResolver } from "@fern-typescript/resolvers";
+import { BaseContext } from "@fern-typescript/contexts";
 import { ts } from "ts-morph";
 
 import {
@@ -15,11 +15,13 @@ import {
 
 export declare namespace AbstractTypeReferenceConverter {
     export interface Init {
-        typeResolver: TypeResolver;
+        context: BaseContext;
         treatUnknownAsAny: boolean;
         includeSerdeLayer: boolean;
         useBigInt: boolean;
         enableInlineTypes: boolean;
+        allowExtraFields: boolean;
+        omitUndefined: boolean;
     }
 }
 
@@ -86,24 +88,30 @@ export namespace ConvertTypeReferenceParams {
 const genericIn = ConvertTypeReferenceParams.GenericIn;
 
 export abstract class AbstractTypeReferenceConverter<T> {
-    protected typeResolver: TypeResolver;
+    protected context: BaseContext;
     protected treatUnknownAsAny: boolean;
     protected includeSerdeLayer: boolean;
     protected useBigInt: boolean;
     protected enableInlineTypes: boolean;
+    protected allowExtraFields: boolean;
+    protected omitUndefined: boolean;
 
     constructor({
-        typeResolver,
+        context,
         treatUnknownAsAny,
         includeSerdeLayer,
         useBigInt,
-        enableInlineTypes
+        enableInlineTypes,
+        allowExtraFields,
+        omitUndefined
     }: AbstractTypeReferenceConverter.Init) {
-        this.typeResolver = typeResolver;
+        this.context = context;
         this.treatUnknownAsAny = treatUnknownAsAny;
         this.includeSerdeLayer = includeSerdeLayer;
         this.useBigInt = useBigInt;
         this.enableInlineTypes = enableInlineTypes;
+        this.allowExtraFields = allowExtraFields;
+        this.omitUndefined = omitUndefined;
     }
 
     public convert(params: ConvertTypeReferenceParams): T {
@@ -167,7 +175,7 @@ export abstract class AbstractTypeReferenceConverter<T> {
     }
 
     protected map(mapType: MapType, params: ConvertTypeReferenceParams): T {
-        const resolvdKeyType = this.typeResolver.resolveTypeReference(mapType.keyType);
+        const resolvdKeyType = this.context.type.resolveTypeReference(mapType.keyType);
         if (resolvdKeyType.type === "named" && resolvdKeyType.shape === ShapeType.Enum) {
             return this.mapWithEnumKeys(mapType, params);
         } else {
@@ -179,7 +187,7 @@ export abstract class AbstractTypeReferenceConverter<T> {
     protected abstract mapWithNonEnumKeys(mapType: MapType, params: ConvertTypeReferenceParams): T;
 
     protected isTypeReferencePrimitive(typeReference: TypeReference): boolean {
-        const resolvedType = this.typeResolver.resolveTypeReference(typeReference);
+        const resolvedType = this.context.type.resolveTypeReference(typeReference);
         if (resolvedType.type === "primitive") {
             return true;
         }

generators/typescript/model/type-reference-converters/src/AbstractTypeReferenceToTypeNodeConverter.ts

@@ -33,7 +33,7 @@ export abstract class AbstractTypeReferenceToTypeNodeConverter extends AbstractT
     }
 
     protected override named(typeName: DeclaredTypeName, params: ConvertTypeReferenceParams): TypeReferenceNode {
-        const resolvedType = this.typeResolver.resolveTypeName(typeName);
+        const resolvedType = this.context.type.resolveTypeName(typeName);
         const isOptional = ResolvedTypeReference._visit<boolean>(resolvedType, {
             container: (container) => this.container(container, params).isOptional,
             primitive: (primitive) => this.primitive(primitive).isOptional,
@@ -45,7 +45,7 @@ export abstract class AbstractTypeReferenceToTypeNodeConverter extends AbstractT
         });
 
         let typeNodeWithoutUndefined: ts.TypeNode;
-        const typeDeclaration = this.typeResolver.getTypeDeclarationFromName(typeName);
+        const typeDeclaration = this.context.type.getTypeDeclaration(typeName);
         if (this.enableInlineTypes && typeDeclaration.inline) {
             if (ConvertTypeReferenceParams.isInlinePropertyParams(params)) {
                 typeNodeWithoutUndefined = this.createTypeRefenceForInlinePropertyNamedType(params);