@adonisjs/assembler 8.0.0-next.3 → 8.0.0-next.31

package/build/src/code_transformer/main.js

@@ -1,612 +1,514 @@
-import {
-  debug_default
-} from "../../chunk-RR4HCA4M.js";
+import { t as CodemodException } from "../../codemod_exception-vyN1VXuX.js";
+import { fileURLToPath } from "node:url";
+import { detectPackageManager, installPackage } from "@antfu/install-pkg";
+import { ImportsBag } from "@poppinss/utils";
+import { join } from "node:path";
+import { Node, Project, QuoteKind, SyntaxKind } from "ts-morph";
+const ALLOWED_ENVIRONMENTS = [
+	"web",
+	"console",
+	"test",
+	"repl"
+];
+var RcFileTransformer = class {
+	#cwd;
+	#project;
+	#editorSettings = {
+		indentSize: 2,
+		convertTabsToSpaces: true,
+		trimTrailingWhitespace: true,
+		ensureNewLineAtEndOfFile: true,
+		indentStyle: 2,
+		semicolons: "remove"
+	};
+	constructor(cwd, project) {
+		this.#cwd = cwd;
+		this.#project = project;
+	}
+	#getRcFileOrThrow() {
+		const filePath = "adonisrc.ts";
+		const rcFileUrl = fileURLToPath(new URL(`./${filePath}`, this.#cwd));
+		const file = this.#project.getSourceFile(rcFileUrl);
+		if (!file) throw CodemodException.missingRcFile(filePath, `import { defineConfig } from '@adonisjs/core/app'
 
-// src/code_transformer/main.ts
-import { fileURLToPath as fileURLToPath2 } from "url";
-import string from "@poppinss/utils/string";
-import { isScriptFile } from "@poppinss/utils";
-import { fsReadAll } from "@poppinss/utils/fs";
-import { mkdir, writeFile } from "fs/promises";
-import StringBuilder from "@poppinss/utils/string_builder";
-import { basename, dirname, extname, join, relative } from "path";
-import { installPackage, detectPackageManager } from "@antfu/install-pkg";
-import {
-  Node as Node2,
-  Project,
-  QuoteKind,
-  SyntaxKind as SyntaxKind2
-} from "ts-morph";
+export default defineConfig({
+  // Add your configuration here
+})`);
+		return file;
+	}
+	#isInSpecificEnvironment(environments) {
+		if (!environments) return false;
+		return !!ALLOWED_ENVIRONMENTS.find((env) => !environments.includes(env));
+	}
+	#locateDefineConfigCallOrThrow(file) {
+		const call = file.getDescendantsOfKind(SyntaxKind.CallExpression).find((statement) => statement.getExpression().getText() === "defineConfig");
+		if (!call) throw CodemodException.invalidRcFile("adonisrc.ts", `import { defineConfig } from '@adonisjs/core/app'
 
-// src/code_transformer/rc_file_transformer.ts
-import { fileURLToPath } from "url";
-import {
-  Node,
-  SyntaxKind
-} from "ts-morph";
-var ALLOWED_ENVIRONMENTS = ["web", "console", "test", "repl"];
-var RcFileTransformer = class {
-  #cwd;
-  #project;
-  /**
-   * Settings to use when persisting files
-   */
-  #editorSettings = {
-    indentSize: 2,
-    convertTabsToSpaces: true,
-    trimTrailingWhitespace: true,
-    ensureNewLineAtEndOfFile: true,
-    indentStyle: 2,
-    // @ts-expect-error SemicolonPreference doesn't seem to be re-exported from ts-morph
-    semicolons: "remove"
-  };
-  constructor(cwd, project) {
-    this.#cwd = cwd;
-    this.#project = project;
-  }
-  /**
-   * Get the `adonisrc.ts` source file
-   */
-  #getRcFileOrThrow() {
-    const kernelUrl = fileURLToPath(new URL("./adonisrc.ts", this.#cwd));
-    return this.#project.getSourceFileOrThrow(kernelUrl);
-  }
-  /**
-   * Check if environments array has a subset of available environments
-   */
-  #isInSpecificEnvironment(environments) {
-    if (!environments) {
-      return false;
-    }
-    return !!ALLOWED_ENVIRONMENTS.find((env) => !environments.includes(env));
-  }
-  /**
-   * Locate the `defineConfig` call inside the `adonisrc.ts` file
-   */
-  #locateDefineConfigCallOrThrow(file) {
-    const call = file.getDescendantsOfKind(SyntaxKind.CallExpression).find((statement) => statement.getExpression().getText() === "defineConfig");
-    if (!call) {
-      throw new Error("Could not locate the defineConfig call.");
-    }
-    return call;
-  }
-  /**
-   * Return the ObjectLiteralExpression of the defineConfig call
-   */
-  #getDefineConfigObjectOrThrow(defineConfigCall) {
-    const configObject = defineConfigCall.getArguments()[0].asKindOrThrow(SyntaxKind.ObjectLiteralExpression);
-    return configObject;
-  }
-  /**
-   * Check if the defineConfig() call has the property assignment
-   * inside it or not. If not, it will create one and return it.
-   */
-  #getPropertyAssignmentInDefineConfigCall(propertyName, initializer) {
-    const file = this.#getRcFileOrThrow();
-    const defineConfigCall = this.#locateDefineConfigCallOrThrow(file);
-    const configObject = this.#getDefineConfigObjectOrThrow(defineConfigCall);
-    let property = configObject.getProperty(propertyName);
-    if (!property) {
-      configObject.addPropertyAssignment({ name: propertyName, initializer });
-      property = configObject.getProperty(propertyName);
-    }
-    return property;
-  }
-  /**
-   * Extract list of imported modules from an ArrayLiteralExpression
-   *
-   * It assumes that the array can have two types of elements:
-   *
-   * - Simple lazy imported modules: [() => import('path/to/file')]
-   * - Or an object entry: [{ file: () => import('path/to/file'), environment: ['web', 'console'] }]
-   *   where the `file` property is a lazy imported module.
-   */
-  #extractModulesFromArray(array) {
-    const modules = array.getElements().map((element) => {
-      if (Node.isArrowFunction(element)) {
-        const importExp = element.getFirstDescendantByKindOrThrow(SyntaxKind.CallExpression);
-        const literal = importExp.getFirstDescendantByKindOrThrow(SyntaxKind.StringLiteral);
-        return literal.getLiteralValue();
-      }
-      if (Node.isObjectLiteralExpression(element)) {
-        const fileProp = element.getPropertyOrThrow("file");
-        const arrowFn = fileProp.getFirstDescendantByKindOrThrow(SyntaxKind.ArrowFunction);
-        const importExp = arrowFn.getFirstDescendantByKindOrThrow(SyntaxKind.CallExpression);
-        const literal = importExp.getFirstDescendantByKindOrThrow(SyntaxKind.StringLiteral);
-        return literal.getLiteralValue();
-      }
-    });
-    return modules.filter(Boolean);
-  }
-  /**
-   * Extract a specific property from an ArrayLiteralExpression
-   * that contains object entries.
-   *
-   * This function is mainly used for extractring the `pattern` property
-   * when adding a new meta files entry, or the `name` property when
-   * adding a new test suite.
-   */
-  #extractPropertyFromArray(array, propertyName) {
-    const property = array.getElements().map((el) => {
-      if (!Node.isObjectLiteralExpression(el)) return;
-      const nameProp = el.getPropertyOrThrow(propertyName);
-      if (!Node.isPropertyAssignment(nameProp)) return;
-      const name = nameProp.getInitializerIfKindOrThrow(SyntaxKind.StringLiteral);
-      return name.getLiteralValue();
-    });
-    return property.filter(Boolean);
-  }
-  /**
-   * Build a new module entry for the preloads and providers array
-   * based upon the environments specified
-   */
-  #buildNewModuleEntry(modulePath, environments) {
-    if (!this.#isInSpecificEnvironment(environments)) {
-      return `() => import('${modulePath}')`;
-    }
-    return `{
+export default defineConfig({
+  // Add your configuration here
+})`, "Could not locate the defineConfig call.");
+		return call;
+	}
+	#getDefineConfigObjectOrThrow(defineConfigCall) {
+		return defineConfigCall.getArguments()[0].asKindOrThrow(SyntaxKind.ObjectLiteralExpression);
+	}
+	#getPropertyAssignmentInDefineConfigCall(propertyName, initializer) {
+		const file = this.#getRcFileOrThrow();
+		const defineConfigCall = this.#locateDefineConfigCallOrThrow(file);
+		const configObject = this.#getDefineConfigObjectOrThrow(defineConfigCall);
+		let property = configObject.getProperty(propertyName);
+		if (!property) {
+			configObject.addPropertyAssignment({
+				name: propertyName,
+				initializer
+			});
+			property = configObject.getProperty(propertyName);
+		}
+		return property;
+	}
+	#extractModulesFromArray(array) {
+		return array.getElements().map((element) => {
+			if (Node.isArrowFunction(element)) return element.getFirstDescendantByKindOrThrow(SyntaxKind.CallExpression).getFirstDescendantByKindOrThrow(SyntaxKind.StringLiteral).getLiteralValue();
+			if (Node.isObjectLiteralExpression(element)) return element.getPropertyOrThrow("file").getFirstDescendantByKindOrThrow(SyntaxKind.ArrowFunction).getFirstDescendantByKindOrThrow(SyntaxKind.CallExpression).getFirstDescendantByKindOrThrow(SyntaxKind.StringLiteral).getLiteralValue();
+		}).filter(Boolean);
+	}
+	#extractPropertyFromArray(array, propertyName) {
+		return array.getElements().map((el) => {
+			if (!Node.isObjectLiteralExpression(el)) return;
+			const nameProp = el.getPropertyOrThrow(propertyName);
+			if (!Node.isPropertyAssignment(nameProp)) return;
+			return nameProp.getInitializerIfKindOrThrow(SyntaxKind.StringLiteral).getLiteralValue();
+		}).filter(Boolean);
+	}
+	#buildNewModuleEntry(modulePath, environments) {
+		if (!this.#isInSpecificEnvironment(environments)) return `() => import('${modulePath}')`;
+		return `{
       file: () => import('${modulePath}'),
       environment: [${environments?.map((env) => `'${env}'`).join(", ")}],
     }`;
-  }
-  /**
-   * Add a new command to the rcFile
-   */
-  addCommand(commandPath) {
-    const commandsProperty = this.#getPropertyAssignmentInDefineConfigCall("commands", "[]");
-    const commandsArray = commandsProperty.getInitializerIfKindOrThrow(
-      SyntaxKind.ArrayLiteralExpression
-    );
-    const commandString = `() => import('${commandPath}')`;
-    if (commandsArray.getElements().some((el) => el.getText() === commandString)) {
-      return this;
-    }
-    commandsArray.addElement(commandString);
-    return this;
-  }
-  /**
-   * Add a new preloaded file to the rcFile
-   */
-  addPreloadFile(modulePath, environments) {
-    const preloadsProperty = this.#getPropertyAssignmentInDefineConfigCall("preloads", "[]");
-    const preloadsArray = preloadsProperty.getInitializerIfKindOrThrow(
-      SyntaxKind.ArrayLiteralExpression
-    );
-    const existingPreloadedFiles = this.#extractModulesFromArray(preloadsArray);
-    const isDuplicate = existingPreloadedFiles.includes(modulePath);
-    if (isDuplicate) {
-      return this;
-    }
-    preloadsArray.addElement(this.#buildNewModuleEntry(modulePath, environments));
-    return this;
-  }
-  /**
-   * Add a new provider to the rcFile
-   */
-  addProvider(providerPath, environments) {
-    const property = this.#getPropertyAssignmentInDefineConfigCall("providers", "[]");
-    const providersArray = property.getInitializerIfKindOrThrow(SyntaxKind.ArrayLiteralExpression);
-    const existingProviderPaths = this.#extractModulesFromArray(providersArray);
-    const isDuplicate = existingProviderPaths.includes(providerPath);
-    if (isDuplicate) {
-      return this;
-    }
-    providersArray.addElement(this.#buildNewModuleEntry(providerPath, environments));
-    return this;
-  }
-  /**
-   * Add a new meta file to the rcFile
-   */
-  addMetaFile(globPattern, reloadServer = false) {
-    const property = this.#getPropertyAssignmentInDefineConfigCall("metaFiles", "[]");
-    const metaFilesArray = property.getInitializerIfKindOrThrow(SyntaxKind.ArrayLiteralExpression);
-    const alreadyDefinedPatterns = this.#extractPropertyFromArray(metaFilesArray, "pattern");
-    if (alreadyDefinedPatterns.includes(globPattern)) {
-      return this;
-    }
-    metaFilesArray.addElement(
-      `{
+	}
+	addCommand(commandPath) {
+		const commandsArray = this.#getPropertyAssignmentInDefineConfigCall("commands", "[]").getInitializerIfKindOrThrow(SyntaxKind.ArrayLiteralExpression);
+		const commandString = `() => import('${commandPath}')`;
+		if (commandsArray.getElements().some((el) => el.getText() === commandString)) return this;
+		commandsArray.addElement(commandString);
+		return this;
+	}
+	addPreloadFile(modulePath, environments) {
+		const preloadsArray = this.#getPropertyAssignmentInDefineConfigCall("preloads", "[]").getInitializerIfKindOrThrow(SyntaxKind.ArrayLiteralExpression);
+		if (this.#extractModulesFromArray(preloadsArray).includes(modulePath)) return this;
+		preloadsArray.addElement(this.#buildNewModuleEntry(modulePath, environments));
+		return this;
+	}
+	addProvider(providerPath, environments) {
+		const providersArray = this.#getPropertyAssignmentInDefineConfigCall("providers", "[]").getInitializerIfKindOrThrow(SyntaxKind.ArrayLiteralExpression);
+		if (this.#extractModulesFromArray(providersArray).includes(providerPath)) return this;
+		providersArray.addElement(this.#buildNewModuleEntry(providerPath, environments));
+		return this;
+	}
+	addMetaFile(globPattern, reloadServer = false) {
+		const metaFilesArray = this.#getPropertyAssignmentInDefineConfigCall("metaFiles", "[]").getInitializerIfKindOrThrow(SyntaxKind.ArrayLiteralExpression);
+		if (this.#extractPropertyFromArray(metaFilesArray, "pattern").includes(globPattern)) return this;
+		metaFilesArray.addElement(`{
         pattern: '${globPattern}',
         reloadServer: ${reloadServer},
-      }`
-    );
-    return this;
-  }
-  /**
-   * Set directory name and path
-   */
-  setDirectory(key, value) {
-    const property = this.#getPropertyAssignmentInDefineConfigCall("directories", "{}");
-    const directories = property.getInitializerIfKindOrThrow(SyntaxKind.ObjectLiteralExpression);
-    directories.addPropertyAssignment({ name: key, initializer: `'${value}'` });
-    return this;
-  }
-  /**
-   * Set command alias
-   */
-  setCommandAlias(alias, command) {
-    const aliasProperty = this.#getPropertyAssignmentInDefineConfigCall("commandsAliases", "{}");
-    const aliases = aliasProperty.getInitializerIfKindOrThrow(SyntaxKind.ObjectLiteralExpression);
-    aliases.addPropertyAssignment({ name: alias, initializer: `'${command}'` });
-    return this;
-  }
-  /**
-   * Add a new test suite to the rcFile
-   */
-  addSuite(suiteName, files, timeout) {
-    const testProperty = this.#getPropertyAssignmentInDefineConfigCall(
-      "tests",
-      `{ suites: [], forceExit: true, timeout: 2000 }`
-    );
-    const property = testProperty.getInitializerIfKindOrThrow(SyntaxKind.ObjectLiteralExpression).getPropertyOrThrow("suites");
-    const suitesArray = property.getInitializerIfKindOrThrow(SyntaxKind.ArrayLiteralExpression);
-    const existingSuitesNames = this.#extractPropertyFromArray(suitesArray, "name");
-    if (existingSuitesNames.includes(suiteName)) {
-      return this;
-    }
-    const filesArray = Array.isArray(files) ? files : [files];
-    suitesArray.addElement(
-      `{
+      }`);
+		return this;
+	}
+	setDirectory(key, value) {
+		this.#getPropertyAssignmentInDefineConfigCall("directories", "{}").getInitializerIfKindOrThrow(SyntaxKind.ObjectLiteralExpression).addPropertyAssignment({
+			name: key,
+			initializer: `'${value}'`
+		});
+		return this;
+	}
+	setCommandAlias(alias, command) {
+		this.#getPropertyAssignmentInDefineConfigCall("commandsAliases", "{}").getInitializerIfKindOrThrow(SyntaxKind.ObjectLiteralExpression).addPropertyAssignment({
+			name: alias,
+			initializer: `'${command}'`
+		});
+		return this;
+	}
+	addSuite(suiteName, files, timeout) {
+		const suitesArray = this.#getPropertyAssignmentInDefineConfigCall("tests", `{ suites: [], forceExit: true, timeout: 2000 }`).getInitializerIfKindOrThrow(SyntaxKind.ObjectLiteralExpression).getPropertyOrThrow("suites").getInitializerIfKindOrThrow(SyntaxKind.ArrayLiteralExpression);
+		if (this.#extractPropertyFromArray(suitesArray, "name").includes(suiteName)) return this;
+		const filesArray = Array.isArray(files) ? files : [files];
+		suitesArray.addElement(`{
         name: '${suiteName}',
         files: [${filesArray.map((file) => `'${file}'`).join(", ")}],
         timeout: ${timeout ?? 2e3},
-      }`
-    );
-    return this;
-  }
-  /**
-   * Add a new assembler hook
-   */
-  addAssemblerHook(type, path) {
-    const hooksProperty = this.#getPropertyAssignmentInDefineConfigCall("hooks", "{}");
-    const hooks = hooksProperty.getInitializerIfKindOrThrow(SyntaxKind.ObjectLiteralExpression);
-    let hookArray = hooks.getProperty(type);
-    if (!hookArray) {
-      hooks.addPropertyAssignment({ name: type, initializer: "[]" });
-      hookArray = hooks.getProperty(type);
-    }
-    const hooksArray = hookArray.getInitializerIfKindOrThrow(SyntaxKind.ArrayLiteralExpression);
-    const existingHooks = this.#extractModulesFromArray(hooksArray);
-    if (existingHooks.includes(path)) {
-      return this;
-    }
-    hooksArray.addElement(`() => import('${path}')`);
-    return this;
-  }
-  /**
-   * Save the adonisrc.ts file
-   */
-  save() {
-    const file = this.#getRcFileOrThrow();
-    file.formatText(this.#editorSettings);
-    return file.save();
-  }
+      }`);
+		return this;
+	}
+	addAssemblerHook(type, value, raw = false) {
+		const hooks = this.#getPropertyAssignmentInDefineConfigCall("hooks", "{}").getInitializerIfKindOrThrow(SyntaxKind.ObjectLiteralExpression);
+		let hookArray = hooks.getProperty(type);
+		if (!hookArray) {
+			hooks.addPropertyAssignment({
+				name: type,
+				initializer: "[]"
+			});
+			hookArray = hooks.getProperty(type);
+		}
+		const hooksArray = hookArray.getInitializerIfKindOrThrow(SyntaxKind.ArrayLiteralExpression);
+		if (raw) hooksArray.addElement(value);
+		else {
+			if (this.#extractModulesFromArray(hooksArray).includes(value)) return this;
+			hooksArray.addElement(`() => import('${value}')`);
+		}
+		return this;
+	}
+	addNamedImport(specifier, names) {
+		this.#getRcFileOrThrow().addImportDeclaration({
+			moduleSpecifier: specifier,
+			namedImports: names
+		});
+		return this;
+	}
+	addDefaultImport(specifier, name) {
+		this.#getRcFileOrThrow().addImportDeclaration({
+			moduleSpecifier: specifier,
+			defaultImport: name
+		});
+		return this;
+	}
+	getDirectory(key, defaultValue) {
+		try {
+			const file = this.#getRcFileOrThrow();
+			const defineConfigCall = this.#locateDefineConfigCallOrThrow(file);
+			const directoriesProperty = this.#getDefineConfigObjectOrThrow(defineConfigCall).getProperty("directories");
+			if (!directoriesProperty || !Node.isPropertyAssignment(directoriesProperty)) return defaultValue;
+			const directoriesObject = directoriesProperty.getInitializer();
+			if (!directoriesObject || !Node.isObjectLiteralExpression(directoriesObject)) return defaultValue;
+			const property = directoriesObject.getProperty(key);
+			if (!property || !Node.isPropertyAssignment(property)) return defaultValue;
+			const initializer = property.getInitializer();
+			if (!initializer || !Node.isStringLiteral(initializer)) return defaultValue;
+			return initializer.getLiteralValue();
+		} catch {
+			return defaultValue;
+		}
+	}
+	save() {
+		const file = this.#getRcFileOrThrow();
+		file.formatText(this.#editorSettings);
+		return file.save();
+	}
 };
-
-// src/code_transformer/main.ts
 var CodeTransformer = class {
-  /**
-   * Exporting utilities to install package and detect
-   * the package manager
-   */
-  installPackage = installPackage;
-  detectPackageManager = detectPackageManager;
-  /**
-   * Directory of the adonisjs project
-   */
-  #cwd;
-  #cwdPath;
-  /**
-   * The TsMorph project
-   */
-  project;
-  /**
-   * Settings to use when persisting files
-   */
-  #editorSettings = {
-    indentSize: 2,
-    convertTabsToSpaces: true,
-    trimTrailingWhitespace: true,
-    ensureNewLineAtEndOfFile: true,
-    indentStyle: 2,
-    // @ts-expect-error SemicolonPreference doesn't seem to be re-exported from ts-morph
-    semicolons: "remove"
-  };
-  constructor(cwd) {
-    this.#cwd = cwd;
-    this.#cwdPath = fileURLToPath2(this.#cwd);
-    this.project = new Project({
-      tsConfigFilePath: join(fileURLToPath2(this.#cwd), "tsconfig.json"),
-      manipulationSettings: { quoteKind: QuoteKind.Single }
-    });
-  }
-  /**
-   * Add a new middleware to the middleware array of the
-   * given file
-   */
-  #addToMiddlewareArray(file, target, middlewareEntry) {
-    const callExpressions = file.getDescendantsOfKind(SyntaxKind2.CallExpression).filter((statement) => statement.getExpression().getText() === target);
-    if (!callExpressions.length) {
-      throw new Error(`Cannot find ${target} statement in the file.`);
-    }
-    const arrayLiteralExpression = callExpressions[0].getArguments()[0];
-    if (!arrayLiteralExpression || !Node2.isArrayLiteralExpression(arrayLiteralExpression)) {
-      throw new Error(`Cannot find middleware array in ${target} statement.`);
-    }
-    const middleware = `() => import('${middlewareEntry.path}')`;
-    const existingMiddlewareIndex = arrayLiteralExpression.getElements().findIndex((element) => element.getText() === middleware);
-    if (existingMiddlewareIndex === -1) {
-      if (middlewareEntry.position === "before") {
-        arrayLiteralExpression.insertElement(0, middleware);
-      } else {
-        arrayLiteralExpression.addElement(middleware);
-      }
-    }
-  }
-  /**
-   * Add a new middleware to the named middleware of the given file
-   */
-  #addToNamedMiddleware(file, middlewareEntry) {
-    if (!middlewareEntry.name) {
-      throw new Error("Named middleware requires a name.");
-    }
-    const callArguments = file.getVariableDeclarationOrThrow("middleware").getInitializerIfKindOrThrow(SyntaxKind2.CallExpression).getArguments();
-    if (callArguments.length === 0) {
-      throw new Error("Named middleware call has no arguments.");
-    }
-    const namedMiddlewareObject = callArguments[0];
-    if (!Node2.isObjectLiteralExpression(namedMiddlewareObject)) {
-      throw new Error("The argument of the named middleware call is not an object literal.");
-    }
-    const existingProperty = namedMiddlewareObject.getProperty(middlewareEntry.name);
-    if (!existingProperty) {
-      const middleware = `${middlewareEntry.name}: () => import('${middlewareEntry.path}')`;
-      namedMiddlewareObject.insertProperty(0, middleware);
-    }
-  }
-  /**
-   * Add a policy to the list of pre-registered policy
-   */
-  #addToPoliciesList(file, policyEntry) {
-    const policiesObject = file.getVariableDeclarationOrThrow("policies").getInitializerIfKindOrThrow(SyntaxKind2.ObjectLiteralExpression);
-    const existingProperty = policiesObject.getProperty(policyEntry.name);
-    if (!existingProperty) {
-      const policy = `${policyEntry.name}: () => import('${policyEntry.path}')`;
-      policiesObject.insertProperty(0, policy);
-    }
-  }
-  /**
-   * Add the given import declarations to the source file
-   * and merge named imports with the existing import
-   */
-  #addImportDeclarations(file, importDeclarations) {
-    const existingImports = file.getImportDeclarations();
-    importDeclarations.forEach((importDeclaration) => {
-      const existingImport = existingImports.find(
-        (mod) => mod.getModuleSpecifierValue() === importDeclaration.module
-      );
-      if (existingImport && importDeclaration.isNamed) {
-        if (!existingImport.getNamedImports().find((namedImport) => namedImport.getName() === importDeclaration.identifier)) {
-          existingImport.addNamedImport(importDeclaration.identifier);
-        }
-        return;
-      }
-      if (existingImport) {
-        return;
-      }
-      file.addImportDeclaration({
-        ...importDeclaration.isNamed ? { namedImports: [importDeclaration.identifier] } : { defaultImport: importDeclaration.identifier },
-        moduleSpecifier: importDeclaration.module
-      });
-    });
-  }
-  /**
-   * Write a leading comment
-   */
-  #addLeadingComment(writer, comment) {
-    if (!comment) {
-      return writer.blankLine();
-    }
-    return writer.blankLine().writeLine("/*").writeLine(`|----------------------------------------------------------`).writeLine(`| ${comment}`).writeLine(`|----------------------------------------------------------`).writeLine(`*/`);
-  }
-  /**
-   * Add new env variable validation in the
-   * `env.ts` file
-   */
-  async defineEnvValidations(definition) {
-    const kernelUrl = join(this.#cwdPath, "./start/env.ts");
-    const file = this.project.getSourceFileOrThrow(kernelUrl);
-    const callExpressions = file.getDescendantsOfKind(SyntaxKind2.CallExpression).filter((statement) => statement.getExpression().getText() === "Env.create");
-    if (!callExpressions.length) {
-      throw new Error(`Cannot find Env.create statement in the file.`);
-    }
-    const objectLiteralExpression = callExpressions[0].getArguments()[1];
-    if (!Node2.isObjectLiteralExpression(objectLiteralExpression)) {
-      throw new Error(`The second argument of Env.create is not an object literal.`);
-    }
-    let shouldAddComment = true;
-    for (const [variable, validation] of Object.entries(definition.variables)) {
-      const existingProperty = objectLiteralExpression.getProperty(variable);
-      if (existingProperty) {
-        shouldAddComment = false;
-      }
-      if (!existingProperty) {
-        objectLiteralExpression.addPropertyAssignment({
-          name: variable,
-          initializer: validation,
-          leadingTrivia: (writer) => {
-            if (!shouldAddComment) {
-              return;
-            }
-            shouldAddComment = false;
-            return this.#addLeadingComment(writer, definition.leadingComment);
-          }
-        });
-      }
-    }
-    file.formatText(this.#editorSettings);
-    await file.save();
-  }
-  /**
-   * Define new middlewares inside the `start/kernel.ts`
-   * file
-   *
-   * This function is highly based on some assumptions
-   * and will not work if you significantly tweaked
-   * your `start/kernel.ts` file.
-   */
-  async addMiddlewareToStack(stack, middleware) {
-    const kernelUrl = join(this.#cwdPath, "./start/kernel.ts");
-    const file = this.project.getSourceFileOrThrow(kernelUrl);
-    for (const middlewareEntry of middleware) {
-      if (stack === "named") {
-        this.#addToNamedMiddleware(file, middlewareEntry);
-      } else {
-        this.#addToMiddlewareArray(file, `${stack}.use`, middlewareEntry);
-      }
-    }
-    file.formatText(this.#editorSettings);
-    await file.save();
-  }
-  /**
-   * Update the `adonisrc.ts` file
-   */
-  async updateRcFile(callback) {
-    const rcFileTransformer = new RcFileTransformer(this.#cwd, this.project);
-    callback(rcFileTransformer);
-    await rcFileTransformer.save();
-  }
-  /**
-   * Add a new Japa plugin in the `tests/bootstrap.ts` file
-   */
-  async addJapaPlugin(pluginCall, importDeclarations) {
-    const testBootstrapUrl = join(this.#cwdPath, "./tests/bootstrap.ts");
-    const file = this.project.getSourceFileOrThrow(testBootstrapUrl);
-    this.#addImportDeclarations(file, importDeclarations);
-    const pluginsArray = file.getVariableDeclaration("plugins")?.getInitializerIfKind(SyntaxKind2.ArrayLiteralExpression);
-    if (pluginsArray) {
-      if (!pluginsArray.getElements().find((element) => element.getText() === pluginCall)) {
-        pluginsArray.addElement(pluginCall);
-      }
-    }
-    file.formatText(this.#editorSettings);
-    await file.save();
-  }
-  /**
-   * Add a new Vite plugin
-   */
-  async addVitePlugin(pluginCall, importDeclarations) {
-    const viteConfigTsUrl = join(this.#cwdPath, "./vite.config.ts");
-    const file = this.project.getSourceFile(viteConfigTsUrl);
-    if (!file) {
-      throw new Error(
-        "Cannot find vite.config.ts file. Make sure to rename vite.config.js to vite.config.ts"
-      );
-    }
-    this.#addImportDeclarations(file, importDeclarations);
-    const defaultExport = file.getDefaultExportSymbol();
-    if (!defaultExport) {
-      throw new Error("Cannot find the default export in vite.config.ts");
-    }
-    const declaration = defaultExport.getDeclarations()[0];
-    const options = declaration.getChildrenOfKind(SyntaxKind2.ObjectLiteralExpression)[0] || declaration.getChildrenOfKind(SyntaxKind2.CallExpression)[0].getArguments()[0];
-    const pluginsArray = options.getPropertyOrThrow("plugins").getFirstChildByKindOrThrow(SyntaxKind2.ArrayLiteralExpression);
-    if (!pluginsArray.getElements().find((element) => element.getText() === pluginCall)) {
-      pluginsArray.addElement(pluginCall);
-    }
-    file.formatText(this.#editorSettings);
-    await file.save();
-  }
-  /**
-   * Adds a policy to the list of `policies` object configured
-   * inside the `app/policies/main.ts` file.
-   */
-  async addPolicies(policies) {
-    const kernelUrl = join(this.#cwdPath, "./app/policies/main.ts");
-    const file = this.project.getSourceFileOrThrow(kernelUrl);
-    for (const policy of policies) {
-      this.#addToPoliciesList(file, policy);
-    }
-    file.formatText(this.#editorSettings);
-    await file.save();
-  }
-  /**
-   * Creates an index file that exports an object in which the key is the PascalCase
-   * name of the entity and the value is a dynamic import.
-   *
-   * For example, in case of controllers, the index file will be the list of controller
-   * names pointing a dynamically imported controller file.
-   *
-   * ```ts
-   * export const controllers = {
-   *   LoginController: () => import('#controllers/login_controller'),
-   *   LogoutController: () => import('#controllers/logout_controller'),
-   * }
-   * ```
-   *
-   * @param source
-   * @param outputPath
-   * @param importAlias
-   */
-  async makeEntityIndex(input, output) {
-    const inputs = Array.isArray(input) ? input : [input];
-    const outputPath = join(this.#cwdPath, output.destination);
-    const outputDir = dirname(outputPath);
-    const exportName = output.exportName ?? new StringBuilder(basename(output.destination)).removeExtension().camelCase();
-    debug_default(
-      'creating index for "%s" at destination "%s" using sources %O',
-      exportName,
-      outputPath,
-      inputs
-    );
-    const entries = await Promise.all(
-      inputs.map(async ({ source, importAlias, allowedExtensions }) => {
-        const sourcePath = join(this.#cwdPath, source);
-        const filesList = await fsReadAll(sourcePath, {
-          filter: (filePath) => {
-            if (allowedExtensions) {
-              const ext = extname(filePath);
-              return allowedExtensions.includes(ext);
-            }
-            return isScriptFile(filePath);
-          },
-          pathType: "absolute"
-        });
-        const knownBaseNames = /* @__PURE__ */ new Set();
-        return filesList.map((filePath) => {
-          let baseName = basename(filePath);
-          if (output.computeBaseName) {
-            baseName = output.computeBaseName?.(filePath, sourcePath);
-          } else {
-            if (knownBaseNames.has(baseName)) {
-              baseName = string.toUnixSlash(relative(sourcePath, filePath));
-            }
-            knownBaseNames.add(baseName);
-          }
-          const name = new StringBuilder(baseName).removeExtension().removeSuffix(output.removeNameSuffix ?? "").pascalCase().toString();
-          const baseImportPath = importAlias ? string.toUnixSlash(relative(sourcePath, filePath)) : string.toUnixSlash(relative(outputDir, filePath));
-          const importPath = importAlias ? `${importAlias}/${new StringBuilder(baseImportPath).removeExtension().toString()}` : baseImportPath;
-          return {
-            name,
-            importPath
-          };
-        });
-      })
-    );
-    const computeOutput = output.computeOutput ?? ((list) => {
-      return list.reduce(
-        (result, entry) => {
-          debug_default('adding "%O" to the index', entry);
-          result.push(`  ${entry.name}: () => import('${entry.importPath}'),`);
-          return result;
-        },
-        [`export const ${exportName} = {`]
-      ).concat("}").join("\n");
-    });
-    await mkdir(outputDir, { recursive: true });
-    await writeFile(outputPath, computeOutput(entries.flat(2)));
-  }
-};
-export {
-  CodeTransformer
+	installPackage = installPackage;
+	detectPackageManager = detectPackageManager;
+	#cwd;
+	#cwdPath;
+	project;
+	#editorSettings = {
+		indentSize: 2,
+		convertTabsToSpaces: true,
+		trimTrailingWhitespace: true,
+		ensureNewLineAtEndOfFile: true,
+		indentStyle: 2,
+		semicolons: "remove"
+	};
+	constructor(cwd) {
+		this.#cwd = cwd;
+		this.#cwdPath = fileURLToPath(this.#cwd);
+		this.project = new Project({
+			tsConfigFilePath: join(fileURLToPath(this.#cwd), "tsconfig.json"),
+			manipulationSettings: { quoteKind: QuoteKind.Single }
+		});
+	}
+	getDirectories() {
+		const rcFileTransformer = new RcFileTransformer(this.#cwd, this.project);
+		return {
+			start: rcFileTransformer.getDirectory("start", "start"),
+			tests: rcFileTransformer.getDirectory("tests", "tests"),
+			policies: rcFileTransformer.getDirectory("policies", "app/policies"),
+			validators: rcFileTransformer.getDirectory("validators", "app/validators"),
+			models: rcFileTransformer.getDirectory("models", "app/models"),
+			controllers: rcFileTransformer.getDirectory("controllers", "app/controllers")
+		};
+	}
+	#addToMiddlewareArray(file, target, middlewareEntry) {
+		const callExpressions = file.getDescendantsOfKind(SyntaxKind.CallExpression).filter((statement) => statement.getExpression().getText() === target);
+		if (!callExpressions.length) throw new Error(`Cannot find ${target} statement in the file.`);
+		const arrayLiteralExpression = callExpressions[0].getArguments()[0];
+		if (!arrayLiteralExpression || !Node.isArrayLiteralExpression(arrayLiteralExpression)) throw new Error(`Cannot find middleware array in ${target} statement.`);
+		const middleware = `() => import('${middlewareEntry.path}')`;
+		if (arrayLiteralExpression.getElements().findIndex((element) => element.getText() === middleware) === -1) if (middlewareEntry.position === "before") arrayLiteralExpression.insertElement(0, middleware);
+		else arrayLiteralExpression.addElement(middleware);
+	}
+	#addToNamedMiddleware(file, middlewareEntry) {
+		if (!middlewareEntry.name) throw new Error("Named middleware requires a name.");
+		const callArguments = file.getVariableDeclarationOrThrow("middleware").getInitializerIfKindOrThrow(SyntaxKind.CallExpression).getArguments();
+		if (callArguments.length === 0) throw new Error("Named middleware call has no arguments.");
+		const namedMiddlewareObject = callArguments[0];
+		if (!Node.isObjectLiteralExpression(namedMiddlewareObject)) throw new Error("The argument of the named middleware call is not an object literal.");
+		if (!namedMiddlewareObject.getProperty(middlewareEntry.name)) {
+			const middleware = `${middlewareEntry.name}: () => import('${middlewareEntry.path}')`;
+			namedMiddlewareObject.insertProperty(0, middleware);
+		}
+	}
+	#addToPoliciesList(file, policyEntry) {
+		const policiesObject = file.getVariableDeclarationOrThrow("policies").getInitializerIfKindOrThrow(SyntaxKind.ObjectLiteralExpression);
+		if (!policiesObject.getProperty(policyEntry.name)) {
+			const policy = `${policyEntry.name}: () => import('${policyEntry.path}')`;
+			policiesObject.insertProperty(0, policy);
+		}
+	}
+	#addImportDeclarations(file, importDeclarations) {
+		importDeclarations.forEach((importDeclaration) => {
+			const existingImport = file.getImportDeclarations().find((mod) => mod.getModuleSpecifierValue() === importDeclaration.module);
+			if (existingImport && importDeclaration.isNamed) {
+				if (!existingImport.getNamedImports().find((namedImport) => namedImport.getName() === importDeclaration.identifier)) existingImport.addNamedImport(importDeclaration.identifier);
+				return;
+			}
+			if (existingImport) return;
+			file.addImportDeclaration({
+				...importDeclaration.isNamed ? { namedImports: [importDeclaration.identifier] } : { defaultImport: importDeclaration.identifier },
+				moduleSpecifier: importDeclaration.module
+			});
+		});
+	}
+	#addImportsFromImportInfo(file, imports) {
+		const importsBag = new ImportsBag();
+		for (const importInfo of imports) importsBag.add(importInfo);
+		const importDeclarations = importsBag.toArray().flatMap((moduleImport) => {
+			return (moduleImport.namedImports ?? []).map((symbol) => {
+				return {
+					isNamed: true,
+					module: moduleImport.source,
+					identifier: symbol
+				};
+			}).concat(moduleImport.defaultImport ? [{
+				isNamed: false,
+				module: moduleImport.source,
+				identifier: moduleImport.defaultImport
+			}] : []);
+		});
+		this.#addImportDeclarations(file, importDeclarations);
+	}
+	#addLeadingComment(writer, comment) {
+		if (!comment) return writer.blankLine();
+		return writer.blankLine().writeLine("/*").writeLine(`|----------------------------------------------------------`).writeLine(`| ${comment}`).writeLine(`|----------------------------------------------------------`).writeLine(`*/`);
+	}
+	async defineEnvValidations(definition) {
+		const filePath = `${this.getDirectories().start}/env.ts`;
+		const envUrl = join(this.#cwdPath, `./${filePath}`);
+		const file = this.project.getSourceFile(envUrl);
+		if (!file) throw CodemodException.missingEnvFile(filePath, definition);
+		const callExpressions = file.getDescendantsOfKind(SyntaxKind.CallExpression).filter((statement) => statement.getExpression().getText() === "Env.create");
+		if (!callExpressions.length) throw CodemodException.missingEnvCreate(filePath, definition);
+		const objectLiteralExpression = callExpressions[0].getArguments()[1];
+		if (!Node.isObjectLiteralExpression(objectLiteralExpression)) throw CodemodException.invalidEnvCreate(filePath, definition);
+		let shouldAddComment = true;
+		for (const [variable, validation] of Object.entries(definition.variables)) {
+			const existingProperty = objectLiteralExpression.getProperty(variable);
+			if (existingProperty) shouldAddComment = false;
+			if (!existingProperty) objectLiteralExpression.addPropertyAssignment({
+				name: variable,
+				initializer: validation,
+				leadingTrivia: (writer) => {
+					if (!shouldAddComment) return;
+					shouldAddComment = false;
+					return this.#addLeadingComment(writer, definition.leadingComment);
+				}
+			});
+		}
+		file.formatText(this.#editorSettings);
+		await file.save();
+	}
+	async addMiddlewareToStack(stack, middleware) {
+		const filePath = `${this.getDirectories().start}/kernel.ts`;
+		const kernelUrl = join(this.#cwdPath, `./${filePath}`);
+		const file = this.project.getSourceFile(kernelUrl);
+		if (!file) throw CodemodException.missingKernelFile(filePath, stack, middleware);
+		try {
+			for (const middlewareEntry of middleware) if (stack === "named") this.#addToNamedMiddleware(file, middlewareEntry);
+			else this.#addToMiddlewareArray(file, `${stack}.use`, middlewareEntry);
+		} catch (error) {
+			if (error instanceof Error) throw CodemodException.invalidMiddlewareStack(filePath, stack, middleware, error.message);
+			throw error;
+		}
+		file.formatText(this.#editorSettings);
+		await file.save();
+	}
+	async updateRcFile(callback) {
+		const rcFileTransformer = new RcFileTransformer(this.#cwd, this.project);
+		callback(rcFileTransformer);
+		await rcFileTransformer.save();
+	}
+	async addJapaPlugin(pluginCall, importDeclarations) {
+		const filePath = `${this.getDirectories().tests}/bootstrap.ts`;
+		const testBootstrapUrl = join(this.#cwdPath, `./${filePath}`);
+		const file = this.project.getSourceFile(testBootstrapUrl);
+		if (!file) throw CodemodException.missingJapaBootstrap(filePath, pluginCall, importDeclarations);
+		this.#addImportDeclarations(file, importDeclarations);
+		const pluginsArray = file.getVariableDeclaration("plugins")?.getInitializerIfKind(SyntaxKind.ArrayLiteralExpression);
+		if (pluginsArray) {
+			if (!pluginsArray.getElements().find((element) => element.getText() === pluginCall)) pluginsArray.addElement(pluginCall);
+		}
+		file.formatText(this.#editorSettings);
+		await file.save();
+	}
+	async addVitePlugin(pluginCall, importDeclarations) {
+		const filePath = "vite.config.ts";
+		const viteConfigTsUrl = join(this.#cwdPath, `./${filePath}`);
+		const file = this.project.getSourceFile(viteConfigTsUrl);
+		if (!file) throw CodemodException.missingViteConfig(filePath, pluginCall, importDeclarations);
+		try {
+			this.#addImportDeclarations(file, importDeclarations);
+			const defaultExport = file.getDefaultExportSymbol();
+			if (!defaultExport) throw new Error("Cannot find the default export in vite.config.ts");
+			const declaration = defaultExport.getDeclarations()[0];
+			const pluginsArray = (declaration.getChildrenOfKind(SyntaxKind.ObjectLiteralExpression)[0] || declaration.getChildrenOfKind(SyntaxKind.CallExpression)[0].getArguments()[0]).getPropertyOrThrow("plugins").getFirstChildByKindOrThrow(SyntaxKind.ArrayLiteralExpression);
+			if (!pluginsArray.getElements().find((element) => element.getText() === pluginCall)) pluginsArray.addElement(pluginCall);
+		} catch (error) {
+			if (error instanceof CodemodException) throw error;
+			if (error instanceof Error) throw CodemodException.invalidViteConfig(filePath, pluginCall, importDeclarations, error.message);
+			throw error;
+		}
+		file.formatText(this.#editorSettings);
+		await file.save();
+	}
+	async addPolicies(policies) {
+		const filePath = `${this.getDirectories().policies}/main.ts`;
+		const policiesUrl = join(this.#cwdPath, `./${filePath}`);
+		const file = this.project.getSourceFile(policiesUrl);
+		if (!file) throw CodemodException.missingPoliciesFile(filePath, policies);
+		try {
+			for (const policy of policies) this.#addToPoliciesList(file, policy);
+		} catch (error) {
+			if (error instanceof Error) throw CodemodException.invalidPoliciesFile(filePath, policies, error.message);
+			throw error;
+		}
+		file.formatText(this.#editorSettings);
+		await file.save();
+	}
+	async addValidator(definition) {
+		const filePath = `${this.getDirectories().validators}/${definition.validatorFileName}`;
+		const validatorFileUrl = join(this.#cwdPath, `./${filePath}`);
+		let file = this.project.getSourceFile(validatorFileUrl);
+		if (!file) try {
+			file = this.project.addSourceFileAtPath(validatorFileUrl);
+		} catch {}
+		if (!file) {
+			file = this.project.createSourceFile(validatorFileUrl, definition.contents);
+			file.formatText(this.#editorSettings);
+			await file.save();
+			return;
+		}
+		if (file.getVariableDeclaration(definition.exportName)) return;
+		file.addStatements(`\n${definition.contents}`);
+		file.formatText(this.#editorSettings);
+		await file.save();
+	}
+	async addLimiter(definition) {
+		const filePath = `${this.getDirectories().start}/${definition.limiterFileName}`;
+		const limiterFileUrl = join(this.#cwdPath, `./${filePath}`);
+		let file = this.project.getSourceFile(limiterFileUrl);
+		if (!file) try {
+			file = this.project.addSourceFileAtPath(limiterFileUrl);
+		} catch {}
+		if (!file) {
+			file = this.project.createSourceFile(limiterFileUrl, definition.contents);
+			file.formatText(this.#editorSettings);
+			await file.save();
+			return;
+		}
+		if (file.getVariableDeclaration(definition.exportName)) return;
+		file.addStatements(`\n${definition.contents}`);
+		file.formatText(this.#editorSettings);
+		await file.save();
+	}
+	async addModelMixins(modelFileName, mixins) {
+		const filePath = `${this.getDirectories().models}/${modelFileName}`;
+		const modelFileUrl = join(this.#cwdPath, `./${filePath}`);
+		let file = this.project.getSourceFile(modelFileUrl);
+		if (!file) try {
+			file = this.project.addSourceFileAtPath(modelFileUrl);
+		} catch {
+			throw new Error(`Could not find source file at path: "${filePath}"`);
+		}
+		const defaultExportSymbol = file.getDefaultExportSymbol();
+		if (!defaultExportSymbol) throw new Error(`Could not find default export in "${filePath}". The model must have a default export class.`);
+		const declarations = defaultExportSymbol.getDeclarations();
+		if (declarations.length === 0) throw new Error(`Could not find default export declaration in "${filePath}".`);
+		const declaration = declarations[0];
+		if (!Node.isClassDeclaration(declaration)) throw new Error(`Default export in "${filePath}" is not a class. The model must be exported as a class.`);
+		const mixinImports = mixins.map((mixin) => {
+			if (mixin.importType === "named") return {
+				source: mixin.importPath,
+				namedImports: [mixin.name]
+			};
+			else return {
+				source: mixin.importPath,
+				defaultImport: mixin.name
+			};
+		});
+		this.#addImportsFromImportInfo(file, mixinImports);
+		const heritageClause = declaration.getHeritageClauseByKind(SyntaxKind.ExtendsKeyword);
+		if (!heritageClause) throw new Error(`Could not find extends clause in "${filePath}".`);
+		const extendsExpression = heritageClause.getTypeNodes()[0];
+		if (!extendsExpression) throw new Error(`Could not find extends expression in "${filePath}".`);
+		const extendsExpressionNode = extendsExpression.getExpression();
+		let composeCall;
+		if (Node.isCallExpression(extendsExpressionNode)) {
+			if (extendsExpressionNode.getExpression().getText() === "compose") composeCall = extendsExpressionNode;
+		}
+		const mixinCalls = mixins.map((mixin) => {
+			const args = mixin.args && mixin.args.length > 0 ? mixin.args.join(", ") : "";
+			return `${mixin.name}(${args})`;
+		});
+		if (composeCall && Node.isCallExpression(composeCall)) {
+			const existingArgsText = composeCall.getArguments().map((arg) => arg.getText());
+			const newMixinCalls = mixinCalls.filter((mixinCall) => {
+				const mixinFunctionName = mixinCall.split("(")[0];
+				return !existingArgsText.some((existingArg) => {
+					return existingArg.includes(`${mixinFunctionName}(`);
+				});
+			});
+			const newArgs = [...existingArgsText, ...newMixinCalls];
+			composeCall.replaceWithText(`compose(${newArgs.join(", ")})`);
+		} else {
+			this.#addImportDeclarations(file, [{
+				isNamed: true,
+				module: "@adonisjs/core/helpers",
+				identifier: "compose"
+			}]);
+			const newExtends = `compose(${extendsExpressionNode.getText()}, ${mixinCalls.join(", ")})`;
+			extendsExpression.replaceWithText(newExtends);
+		}
+		file.formatText(this.#editorSettings);
+		await file.save();
+	}
+	async addControllerMethod(definition) {
+		const filePath = `${this.getDirectories().controllers}/${definition.controllerFileName}`;
+		const controllerFileUrl = join(this.#cwdPath, `./${filePath}`);
+		let file = this.project.getSourceFile(controllerFileUrl);
+		if (!file) try {
+			file = this.project.addSourceFileAtPath(controllerFileUrl);
+		} catch {}
+		if (!file) {
+			const contents = `export default class ${definition.className} {
+  ${definition.contents}
+}`;
+			file = this.project.createSourceFile(controllerFileUrl, contents);
+			if (definition.imports) this.#addImportsFromImportInfo(file, definition.imports);
+			file.formatText(this.#editorSettings);
+			await file.save();
+			return;
+		}
+		const defaultExportSymbol = file.getDefaultExportSymbol();
+		if (!defaultExportSymbol) throw new Error(`Could not find default export in "${filePath}". The controller must have a default export class.`);
+		const declarations = defaultExportSymbol.getDeclarations();
+		if (declarations.length === 0) throw new Error(`Could not find default export declaration in "${filePath}".`);
+		const declaration = declarations[0];
+		if (!Node.isClassDeclaration(declaration)) throw new Error(`Default export in "${filePath}" is not a class. The controller must be exported as a class.`);
+		if (declaration.getMethod(definition.name)) return;
+		if (definition.imports) this.#addImportsFromImportInfo(file, definition.imports);
+		declaration.addMember(definition.contents);
+		file.formatText(this.#editorSettings);
+		await file.save();
+	}
 };
+export { CodeTransformer };