refactor(codemods): simplify TypeScript output config options

Replace `disableTypescriptSchemas` and `disableMissingTypeAutoGen` with
`forceTypeScript`. JS files now produce plain JS output by default; set
`forceTypeScript: true` to generate TypeScript schemas, types, and
extensions from JavaScript sources. `combineSchemasAndTypes` defaults to
`true` in `runMigration`.

Author: BobrImperator

guides/migrating/codemods.md

@@ -50,6 +50,12 @@ This codemod transforms EmberData models and mixins into WarpDrive's schema form
 
 The codemod is **non-destructive** - original model files are not removed. New files are generated in the `app/data/` by default.
 
+> [!WARNING]
+> On large projects the codemod's AST parsing may exceed the default stack size, causing a segfault. If you hit this, raise the limit before running:
+> ```bash
+> ulimit -s unlimited
+> ```
+
 ### Basic Usage
 
 ```bash
@@ -70,6 +76,7 @@ npx @ember-data/codemods apply migrate-to-schema --project-name my-app --warp-dr
 | `--config <path>` | Path to a JSON configuration file |
 | `--skip-processed` | Skip files that have already been processed |
 | `--force-typescript` | Force all output files to TypeScript (`.ts`) |
+| `--separate-types` | Emit a separate `.type.ts` file alongside each `.schema` file. By default, type interfaces are combined into the `.schema` file |
 | `--model-source-dir <path>` | Directory containing model files (default: `./app/models`) |
 | `--mixin-source-dir <path>` | Directory containing mixin files (default: `./app/mixins`) |
 | `--output-dir <path>` | Output directory for generated schemas (default: `./app/data`) |
@@ -151,6 +158,8 @@ Key configuration options:
 
 - **`projectName`** - The Ember app name, used for resolving classic module imports like `example-app/models/user`.
 - **`emberDataImportSource`** / **`warpDriveImports`** - Tell the codemod where your app imports EmberData and WarpDrive APIs from, when they differ from the defaults (`@ember-data/model`, `@warp-drive/core`, etc.).
+- **`forceTypeScript`** - When `true`, all output is `.ts` with type interfaces, even when source files are JavaScript. When `false` (default), `.js` sources produce plain `.js` output without type annotations.
+- **`combineSchemasAndTypes`** - When `false`, emit a separate `.type.ts` file alongside each `.schema` file. By default (`true`), type interfaces are merged into the `.schema` file.
 - **`typeMapping`** - Maps custom EmberData transform names (e.g., `@attr('uuid')`) to TypeScript types for the generated type files.
 - **`intermediateModelPaths`** - Import paths of base classes between `Model` and your concrete models. The codemod will analyze these and convert them to traits.
 - **`importSubstitutes`** - For base classes whose source can't be analyzed, tells the codemod what trait/extension names to reference.

packages/codemods/src/cli/apply.ts

@@ -59,6 +59,7 @@ function createMigrateToSchemaCommand(applyCommand: Command) {
     )
     .addOption(new Option('--skip-processed', 'Skip files that have already been processed'))
     .addOption(new Option('--force-typescript', 'Force all output files to TypeScript (.ts)'))
+    .addOption(new Option('--separate-types', 'Generate .type.ts files'))
     .addOption(new Option('--model-source-dir <path>', 'Directory containing model files').default('./app/models'))
     .addOption(new Option('--mixin-source-dir <path>', 'Directory containing mixin files').default('./app/mixins'))
     .addOption(new Option('--output-dir <path>', 'Output directory for generated schemas').default('./app/data'))
@@ -134,7 +135,6 @@ async function handleMigrateToSchema(
   }
 
   const cliOptions: ConfigOptions = {
-    ...(options as ConfigOptions),
     inputDir,
     ...(options.dry !== undefined && { dryRun: Boolean(options.dry) }),
     ...(options.verbose !== undefined && { verbose: options.verbose === '1' || options.verbose === '2' }),
@@ -143,6 +143,7 @@ async function handleMigrateToSchema(
     ...(options.mixinsOnly !== undefined && { mixinsOnly: Boolean(options.mixinsOnly) }),
     ...(options.skipProcessed !== undefined && { skipProcessed: Boolean(options.skipProcessed) }),
     ...(options.forceTypescript !== undefined && { forceTypeScript: Boolean(options.forceTypescript) }),
+    ...(options.separateTypes !== undefined && { combineSchemasAndTypes: !options.separateTypes }),
     ...(options.projectName !== undefined && { projectName: String(options.projectName) }),
     ...(options.warpDriveImports !== undefined && {
       warpDriveImports: options.warpDriveImports as 'legacy' | 'modern' | 'mirror',

packages/codemods/src/schema-migration/config-schema.json

@@ -36,6 +36,11 @@
       "description": "Force all output files to be TypeScript (.ts) even when input files are JavaScript (.js).",
       "default": false
     },
+    "combineSchemasAndTypes": {
+      "type": "boolean",
+      "description": "Combine schema and type interface into a single file. When true, each model produces one .schema file. Set to false to emit a separate .type.ts file.",
+      "default": true
+    },
     "mirror": {
       "type": "boolean",
       "description": "Use @warp-drive-mirror instead of @warp-drive for imports",

packages/codemods/src/schema-migration/config.ts

@@ -98,6 +98,12 @@ export function getConfiguredImport(
   } else if (importName === 'AsyncHasMany' || importName === 'HasMany') {
     // typically these imports are from the same source as model
     return { imported: importName, source: packageImports.Model.source, isType: true };
+  } else if (importName === 'LegacyTrait') {
+    const schemaImport = packageImports['LegacyResourceSchema' as keyof typeof packageImports];
+    if (schemaImport) {
+      return { imported: 'LegacyTrait', source: schemaImport.source, isType: true };
+    }
+    return { imported: 'LegacyTrait', source: ModernPackageImports.LegacyTrait.source, isType: true };
   } else {
     return undefined;
   }
@@ -123,20 +129,27 @@ export interface TransformOptions {
    * import paths from other project files. Defaults to false.
    */
   projectImportsUseExtensions?: boolean;
-  /** Combine schemas and types into a single file. By default these will be in separate files */
-  combineSchemasAndTypes?: boolean;
-  /** By default, schemas will be output in TS files even when generated from untyped models. */
-  disableTypescriptSchemas?: boolean;
-  /** Force all output files to be TypeScript (.ts) even when input files are JavaScript (.js). */
-  forceTypeScript?: boolean;
   /**
-   * By default, the codemod will attempt to generate TypeScript types for models that don't
-   * have them by analyzing the model file and various transforms that are in use.
+   * Combine schemas and types into a single file. Defaults to true.
+   *
+   * When true, each model/mixin produces a single `.schema` file containing
+   * both the schema object and the TypeScript type interface.
    *
-   * We heavily discourage turning this off as field level documentation comments are
-   * associated to the type artifact, not the schema.
+   * Set to false to emit a separate `.type.ts` file alongside the `.schema` file.
    */
-  disableMissingTypeAutoGen?: boolean;
+  combineSchemasAndTypes: boolean;
+  /**
+   * Force all output files to be TypeScript (.ts) even when input files are JavaScript (.js).
+   * Defaults to false.
+   *
+   * When false, output file extensions match the source file:
+   * - `.js` source files produce `.schema.js` and `.ext.js` (no type interfaces)
+   * - `.ts` source files produce `.schema.ts` and `.ext.ts` (with type interfaces)
+   *
+   * When true, all output is `.ts` regardless of source language, and type
+   * interfaces are generated even for JavaScript source files.
+   */
+  forceTypeScript?: boolean;
   /**
    * By default, the codemod will insert useful comments
    * to the generated types for inline/editor documentation
@@ -230,7 +243,17 @@ export interface MigrateOptions extends Partial<TransformOptions> {
 
 export type FinalOptions = TransformOptions &
   MigrateOptions &
-  Required<Pick<TransformOptions, 'modelSourceDir' | 'mixinSourceDir' | 'warpDriveImports' | 'projectName'>> &
+  Required<
+    Pick<
+      TransformOptions,
+      | 'modelSourceDir'
+      | 'mixinSourceDir'
+      | 'warpDriveImports'
+      | 'projectName'
+      | 'forceTypeScript'
+      | 'combineSchemasAndTypes'
+    >
+  > &
   Required<Pick<MigrateOptions, 'inputDir'>> & {
     kind: 'finalized';
     outputDir: string;

packages/codemods/src/schema-migration/processors/mixin.ts

@@ -3,7 +3,7 @@ import { join } from 'path';
 
 import { logger } from '../../../utils/logger.js';
 import type { TransformerResult } from '../codemod.js';
-import type { TransformOptions } from '../config.js';
+import type { FinalOptions } from '../config.js';
 import type { SchemaArtifact, SchemaArtifactRegistry } from '../utils/artifact.js';
 import { createTraitArtifactConfig, isConnectedToModel as isConnectedToModelInRegistry } from '../utils/artifact.js';
 import type { PropertyInfo, SchemaField, TransformArtifact } from '../utils/ast-utils.js';
@@ -27,7 +27,7 @@ const log = logger.for('mixin-processor');
  */
 function ensureResourceTypeFileExists(
   modelType: string,
-  options: TransformOptions,
+  options: FinalOptions,
   artifacts: TransformArtifact[]
 ): boolean {
   const pascalCaseType = toPascalCase(modelType);
@@ -81,7 +81,7 @@ export interface ${typeName} {
  */
 export function toArtifacts(
   entity: SchemaArtifact,
-  options: TransformOptions,
+  options: FinalOptions,
   registry: SchemaArtifactRegistry = new Map()
 ): TransformerResult {
   const parsedFile = entity.parsedFile;
@@ -145,7 +145,7 @@ function generateMixinArtifacts(
   traitFields: Array<{ name: string; kind: string; type?: string; options?: Record<string, unknown> }>,
   extensionProperties: PropertyInfo[],
   extendedTraits: string[],
-  options: TransformOptions,
+  options: FinalOptions,
   registry: SchemaArtifactRegistry
 ): TransformArtifact[] {
   const artifacts: TransformArtifact[] = [];

packages/codemods/src/schema-migration/processors/model.ts

@@ -4,7 +4,7 @@ import { dirname, join, resolve } from 'path';
 
 import { logger } from '../../../utils/logger.js';
 import type { TransformerResult } from '../codemod.js';
-import { getConfiguredImport, type TransformOptions } from '../config.js';
+import { getConfiguredImport, type FinalOptions, type TransformOptions } from '../config.js';
 import type { SchemaArtifactRegistry } from '../utils/artifact.js';
 import { createResourceArtifactConfig, createTraitArtifactConfig, SchemaArtifact } from '../utils/artifact.js';
 import type { ExtractedType, SchemaField, TransformArtifact } from '../utils/ast-utils.js';
@@ -308,7 +308,7 @@ export function processIntermediateModelsToTraits(
   intermediateModelPaths: string[],
   additionalModelSources: Array<{ pattern: string; dir: string }> | undefined,
   additionalMixinSources: Array<{ pattern: string; dir: string }> | undefined,
-  options: TransformOptions,
+  options: FinalOptions,
   registry: SchemaArtifactRegistry
 ): { artifacts: TransformArtifact[]; errors: string[] } {
   const artifacts: TransformArtifact[] = [];
@@ -612,7 +612,7 @@ function generateRegularModelArtifacts(
 
 export function toArtifacts(
   entity: SchemaArtifact,
-  options: TransformOptions,
+  options: FinalOptions,
   registry: SchemaArtifactRegistry = new Map()
 ): TransformerResult {
   log.debug(`=== DEBUG: Processing ${entity.path} ===`);

packages/codemods/src/schema-migration/tasks/migrate.ts

@@ -4,7 +4,7 @@ import { basename, dirname, join, resolve } from 'path';
 import { type InstanciatedLogger, logger } from '../../../utils/logger.js';
 import type { SkippedFile, TransformerResult } from '../codemod.js';
 import { Codemod } from '../codemod.js';
-import type { FinalOptions, MigrateOptions, TransformOptions } from '../config.js';
+import type { FinalOptions, MigrateOptions } from '../config.js';
 import {
   DEFAULT_INPUT_DIR,
   DEFAULT_MIXIN_SOURCE_DIR,
@@ -311,7 +311,7 @@ function writeIntermediateArtifacts(
 
 type ArtifactTransformer = (
   entity: SchemaArtifact,
-  options: TransformOptions,
+  options: FinalOptions,
   registry: SchemaArtifactRegistry
 ) => TransformerResult;
 
@@ -384,6 +384,8 @@ export async function runMigration(options: MigrateOptions): Promise<void> {
     mixinSourceDir: options.mixinSourceDir || DEFAULT_MIXIN_SOURCE_DIR,
     projectName: options.projectName || '',
     ...options,
+    combineSchemasAndTypes: options.combineSchemasAndTypes ?? true,
+    forceTypeScript: options.forceTypeScript ?? false,
   };
 
   const log = logger.for('migrate-to-schema');

packages/codemods/src/schema-migration/utils/artifact.ts

@@ -203,31 +203,28 @@ export function createTraitArtifactConfig(
   hasExtensionProperties: boolean,
   isTypeScript: boolean
 ): ArtifactConfig {
-  const hasTypes = isTypeScript || !options.disableMissingTypeAutoGen;
-  const schemaIsTyped = (hasTypes && options.combineSchemasAndTypes) || !options.disableTypescriptSchemas;
-  const extensionIsTyped = isTypeScript;
   const hasExtension = hasExtensionProperties;
 
   return {
     type: 'trait',
     name,
     isFragment: false,
-    hasTypes,
-    schemaIsTyped,
-    extensionIsTyped,
+    hasTypes: isTypeScript,
+    schemaIsTyped: isTypeScript,
+    extensionIsTyped: isTypeScript,
     hasExtension,
     identifiers: {
       schema: deriveTraitSchemaName(name),
-      fieldsInterface: hasTypes ? deriveTraitInterfaceName(name) : null,
-      type: hasTypes ? classified : null,
+      fieldsInterface: isTypeScript ? deriveTraitInterfaceName(name) : null,
+      type: isTypeScript ? classified : null,
       extension: hasExtension ? deriveTraitExtensionName(name) : null,
-      extensionAlias: hasTypes && hasExtension ? `${classified}TraitWithExtensions` : null,
+      extensionAlias: isTypeScript && hasExtension ? `${classified}TraitWithExtensions` : null,
     },
     traits: traits.map((trait) => ({
       name: trait,
       identifiers: {
-        fieldsInterface: hasTypes ? deriveTraitInterfaceName(trait) : null,
-        extension: hasTypes ? deriveTraitExtensionName(trait) : null,
+        fieldsInterface: isTypeScript ? deriveTraitInterfaceName(trait) : null,
+        extension: isTypeScript ? deriveTraitExtensionName(trait) : null,
       },
     })),
   };
@@ -246,43 +243,29 @@ export function createResourceArtifactConfig(
 ): ArtifactConfig {
   const name = analysis.baseName;
   const classified = analysis.modelName;
-
-  /**
-   * types are required IF the model was typed OR
-   * the options don't disable automatic type generation
-   * for untyped models
-   */
-  const hasTypes = modelWasTyped || !options.disableMissingTypeAutoGen;
-  const schemaIsTyped = (hasTypes && options.combineSchemasAndTypes) || !options.disableTypescriptSchemas;
-  const extensionIsTyped = modelWasTyped;
-
-  /**
-   * an extension is required IF
-   * we have a trait OR we have our own extension
-   */
   const hasExtension =
     analysis.mixinTraits.length > 0 || analysis.mixinExtensions.length > 0 || analysis.extensionProperties.length > 0;
 
   return {
     type: 'resource',
     name,
     isFragment: analysis.isFragment ?? false,
-    hasTypes,
-    schemaIsTyped,
-    extensionIsTyped,
+    hasTypes: modelWasTyped,
+    schemaIsTyped: modelWasTyped,
+    extensionIsTyped: modelWasTyped,
     hasExtension,
     identifiers: {
       schema: deriveResourceSchemaName(name),
-      fieldsInterface: hasTypes ? `${classified}Resource` : null,
-      type: hasTypes ? classified : null,
+      fieldsInterface: modelWasTyped ? `${classified}Resource` : null,
+      type: modelWasTyped ? classified : null,
       extension: hasExtension ? deriveResourceExtensionName(name) : null,
-      extensionAlias: hasTypes && hasExtension ? `${classified}WithExtensions` : null,
+      extensionAlias: modelWasTyped && hasExtension ? `${classified}WithExtensions` : null,
     },
     traits: analysis.mixinTraits.map((trait) => ({
       name: trait,
       identifiers: {
-        fieldsInterface: hasTypes ? deriveTraitInterfaceName(trait) : null,
-        extension: hasTypes ? deriveTraitExtensionName(trait) : null,
+        fieldsInterface: modelWasTyped ? deriveTraitInterfaceName(trait) : null,
+        extension: modelWasTyped ? deriveTraitExtensionName(trait) : null,
       },
     })),
   };

packages/codemods/src/schema-migration/utils/config.ts

@@ -6,6 +6,7 @@ export interface ConfigOptions {
   verbose?: boolean;
   debug?: boolean;
   forceTypeScript?: boolean;
+  combineSchemasAndTypes?: boolean;
   mirror?: boolean;
   projectName?: string;
   warpDriveImports?: 'legacy' | 'modern' | 'mirror';

packages/codemods/src/schema-migration/utils/import-utils.ts

@@ -84,9 +84,9 @@ export function generateWarpDriveTypeImport(
  * When `hasTypes` is `false` the trait never produced a `.type` file,
  * so the suffix is always `.schema` regardless of config.
  */
-export function resolveTraitImportPath(baseName: string, options?: TransformOptions, hasTypes = true): string {
-  const suffix = !options?.combineSchemasAndTypes && hasTypes ? 'type' : 'schema';
-  const base = options?.traitsImport ?? '../traits';
+export function resolveTraitImportPath(baseName: string, options: TransformOptions, hasTypes = true): string {
+  const suffix = !options.combineSchemasAndTypes && hasTypes ? 'type' : 'schema';
+  const base = options.traitsImport ?? '../traits';
   return `${base}/${baseName}.${suffix}`;
 }
 
@@ -95,7 +95,7 @@ export function resolveTraitImportPath(baseName: string, options?: TransformOpti
  * e.g., generateTraitImport('shareable', options) returns:
  *   "type { ShareableTrait } from '../traits/shareable.type'"
  */
-export function generateTraitImport(traitName: string, options?: TransformOptions): string {
+export function generateTraitImport(traitName: string, options: TransformOptions): string {
   const traitTypeName = deriveTraitInterfaceName(traitName);
   return `type { ${traitTypeName} } from '${resolveTraitImportPath(traitName, options)}'`;
 }
@@ -188,8 +188,8 @@ export function transformModelToResourceImport(
 
   let useTypeFile = false;
   if (!options.combineSchemasAndTypes) {
-    const isTargetTyped = modelEntity ? modelEntity.parsedFile.isTypeScript : false;
-    useTypeFile = isTargetTyped || !options.disableMissingTypeAutoGen;
+    const isTargetTyped = modelEntity ? modelEntity.parsedFile.isTypeScript : true;
+    useTypeFile = isTargetTyped;
   }
 
   const typeFileName = useTypeFile ? `${relatedType}.type${ext}` : `${relatedType}.schema${ext}`;