refactor: use separate ConstValueRenderer for const exports

Author: Shyam-Raghuwanshi

src/generators/typescript/TypeScriptGenerator.ts

@@ -36,6 +36,7 @@ import { ClassRenderer } from './renderers/ClassRenderer';
 import { InterfaceRenderer } from './renderers/InterfaceRenderer';
 import { EnumRenderer } from './renderers/EnumRenderer';
 import { TypeRenderer } from './renderers/TypeRenderer';
+import { ConstValueRenderer } from './renderers/ConstValueRenderer';
 import {
   TypeScriptDefaultConstraints,
   TypeScriptDefaultTypeMapping
@@ -301,6 +302,15 @@ ${modelCode}`;
       ...options
     });
     const dependencyManagerToUse = this.getDependencyManager(optionsToUse);
+
+    // Render const values first (if any exist)
+    const constValuesOutput = await this.renderConstValue(
+      model,
+      inputModel,
+      optionsToUse
+    );
+
+    // Render the class
     const presets = this.getPresets('class');
     const renderer = new ClassRenderer(
       optionsToUse,
@@ -310,14 +320,53 @@ ${modelCode}`;
       inputModel,
       dependencyManagerToUse
     );
-    const result = await renderer.runSelfPreset();
+    const classResult = await renderer.runSelfPreset();
+
+    // Combine const values and class
+    const result = constValuesOutput
+      ? `${constValuesOutput.result}\n\n${classResult}`
+      : classResult;
+
     return RenderOutput.toRenderOutput({
       result,
       renderedName: model.name,
       dependencies: dependencyManagerToUse.dependencies
     });
   }
 
+  async renderConstValue(
+    model: ConstrainedObjectModel,
+    inputModel: InputMetaModel,
+    options?: DeepPartial<TypeScriptOptions>
+  ): Promise<RenderOutput | null> {
+    const optionsToUse = TypeScriptGenerator.getOptions({
+      ...this.options,
+      ...options
+    });
+    const dependencyManagerToUse = this.getDependencyManager(optionsToUse);
+    const presets = this.getPresets('constValue');
+    const renderer = new ConstValueRenderer(
+      optionsToUse,
+      this,
+      presets,
+      model,
+      inputModel,
+      dependencyManagerToUse
+    );
+
+    // Check if there are any const properties to render
+    if (renderer.getConstProperties().length === 0) {
+      return null;
+    }
+
+    const result = await renderer.runSelfPreset();
+    return RenderOutput.toRenderOutput({
+      result,
+      renderedName: `${model.name}Constants`,
+      dependencies: dependencyManagerToUse.dependencies
+    });
+  }
+
   async renderInterface(
     model: ConstrainedObjectModel,
     inputModel: InputMetaModel,

src/generators/typescript/TypeScriptPreset.ts

@@ -4,7 +4,8 @@ import {
   InterfacePreset,
   EnumPreset,
   CommonPreset,
-  ConstrainedMetaModel
+  ConstrainedMetaModel,
+  ConstValuePreset
 } from '../../models';
 import {
   ClassRenderer,
@@ -16,6 +17,10 @@ import {
 } from './renderers/InterfaceRenderer';
 import { EnumRenderer, TS_DEFAULT_ENUM_PRESET } from './renderers/EnumRenderer';
 import { TypeRenderer, TS_DEFAULT_TYPE_PRESET } from './renderers/TypeRenderer';
+import {
+  ConstValueRenderer,
+  TS_DEFAULT_CONST_VALUE_PRESET
+} from './renderers/ConstValueRenderer';
 import { TypeScriptOptions } from './TypeScriptGenerator';
 
 export type ClassPresetType<O> = ClassPreset<ClassRenderer, O>;
@@ -26,17 +31,20 @@ export type TypePresetType<O> = CommonPreset<
   O,
   ConstrainedMetaModel
 >;
+export type ConstValuePresetType<O> = ConstValuePreset<ConstValueRenderer, O>;
 
 export type TypeScriptPreset<O = any> = Preset<{
   class: ClassPresetType<O>;
   interface: InterfacePresetType<O>;
   enum: EnumPresetType<O>;
   type: TypePresetType<O>;
+  constValue: ConstValuePresetType<O>;
 }>;
 
 export const TS_DEFAULT_PRESET: TypeScriptPreset<TypeScriptOptions> = {
   class: TS_DEFAULT_CLASS_PRESET,
   interface: TS_DEFAULT_INTERFACE_PRESET,
   enum: TS_DEFAULT_ENUM_PRESET,
-  type: TS_DEFAULT_TYPE_PRESET
+  type: TS_DEFAULT_TYPE_PRESET,
+  constValue: TS_DEFAULT_CONST_VALUE_PRESET
 };

src/generators/typescript/index.ts

@@ -3,6 +3,10 @@ export * from './TypeScriptFileGenerator';
 export { TS_DEFAULT_PRESET } from './TypeScriptPreset';
 export type { TypeScriptPreset } from './TypeScriptPreset';
 export * from './presets';
+export {
+  ConstValueRenderer,
+  TS_DEFAULT_CONST_VALUE_PRESET
+} from './renderers/ConstValueRenderer';
 
 export {
   defaultEnumKeyConstraints as typeScriptDefaultEnumKeyConstraints,

src/generators/typescript/renderers/ClassRenderer.ts

@@ -17,43 +17,11 @@ export class ClassRenderer extends TypeScriptObjectRenderer {
       await this.runAdditionalContentPreset()
     ];
 
-    const constExportsBlock = this.renderConstExports();
-
-    return `${constExportsBlock}class ${this.model.name} {
+    return `class ${this.model.name} {
 ${this.indent(this.renderBlock(content, 2))}
 }`;
   }
 
-  /**
-   * Generates exported constants for properties with const values.
-   * Converts camelCase property names to UPPER_SNAKE_CASE.
-   * e.g., eventType with const "EXAMPLE_EVENT" -> export const EVENT_TYPE = 'EXAMPLE_EVENT';
-   */
-  renderConstExports(): string {
-    const constExports = Object.values(this.model.properties)
-      .map((prop) => {
-        const constValue = prop.property.options.const?.value;
-        if (constValue === undefined) {
-          return null;
-        }
-        const constName = prop.propertyName
-          .replaceAll(/([a-z])([A-Z])/g, '$1_$2')
-          .toUpperCase();
-        // Use JSON.stringify for non-string values to avoid [object Object] issues
-        const safeValue = typeof constValue === 'string' 
-          ? constValue 
-          : JSON.stringify(constValue);
-        return `export const ${constName} = ${safeValue};`;
-      })
-      .filter((val): val is string => val !== null);
-
-    if (constExports.length === 0) {
-      return '';
-    }
-
-    return constExports.join('\n') + '\n\n';
-  }
-
   runCtorPreset(): Promise<string> {
     return this.runPreset('ctor');
   }

src/generators/typescript/renderers/ConstValueRenderer.ts

@@ -0,0 +1,80 @@
+import { TypeScriptRenderer } from '../TypeScriptRenderer';
+import {
+  ConstrainedObjectModel,
+  ConstrainedObjectPropertyModel
+} from '../../../models';
+import { ConstValuePresetType } from '../TypeScriptPreset';
+import { TypeScriptOptions } from '../TypeScriptGenerator';
+
+/**
+ * Renderer for TypeScript's exported const values
+ *
+ * This renderer generates exported const declarations for properties
+ * that have const values defined in the schema.
+ *
+ * @extends TypeScriptRenderer
+ */
+export class ConstValueRenderer extends TypeScriptRenderer<ConstrainedObjectModel> {
+  async defaultSelf(): Promise<string> {
+    const content = [
+      await this.renderItems(),
+      await this.runAdditionalContentPreset()
+    ];
+
+    return this.renderBlock(content);
+  }
+
+  /**
+   * Get all properties that have const values defined
+   */
+  getConstProperties(): ConstrainedObjectPropertyModel[] {
+    return Object.values(this.model.properties).filter(
+      (prop) => prop.property.options.const?.value !== undefined
+    );
+  }
+
+  /**
+   * Converts a property name from camelCase to UPPER_SNAKE_CASE
+   */
+  toConstName(propertyName: string): string {
+    return propertyName.replace(/([a-z])([A-Z])/g, '$1_$2').toUpperCase();
+  }
+
+  async renderItems(): Promise<string> {
+    const constProperties = this.getConstProperties();
+    const items: string[] = [];
+
+    for (const property of constProperties) {
+      const renderedItem = await this.runItemPreset(property);
+      if (renderedItem) {
+        items.push(renderedItem);
+      }
+    }
+
+    return this.renderBlock(items);
+  }
+
+  runItemPreset(property: ConstrainedObjectPropertyModel): Promise<string> {
+    return this.runPreset('item', { property });
+  }
+}
+
+export const TS_DEFAULT_CONST_VALUE_PRESET: ConstValuePresetType<TypeScriptOptions> =
+  {
+    self({ renderer }) {
+      return renderer.defaultSelf();
+    },
+    item({ property, renderer }): string {
+      const constValue = property.property.options.const?.value;
+      if (constValue === undefined) {
+        return '';
+      }
+
+      const constName = renderer.toConstName(property.propertyName);
+      // Use proper formatting based on value type
+      const formattedValue =
+        typeof constValue === 'string' ? constValue : JSON.stringify(constValue);
+
+      return `export const ${constName} = ${formattedValue};`;
+    }
+  };

src/models/Preset.ts

@@ -71,6 +71,13 @@ export interface EnumPreset<R extends AbstractRenderer, O>
   item?: (args: PresetArgs<R, O, ConstrainedEnumModel> & EnumArgs) => string;
 }
 
+export interface ConstValuePreset<R extends AbstractRenderer, O>
+  extends CommonPreset<R, O, ConstrainedObjectModel> {
+  item?: (
+    args: PresetArgs<R, O, ConstrainedObjectModel> & PropertyArgs
+  ) => string;
+}
+
 export type Preset<
   C extends Record<string, CommonPreset<any, any, any>> = any
 > = Partial<C>;