@adonisjs/assembler 8.0.0-next.21 → 8.0.0-next.23

package/build/src/code_transformer/main.js

@@ -1,634 +1,288 @@
-// src/code_transformer/main.ts
-import { join } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { installPackage, detectPackageManager } from "@antfu/install-pkg";
-import {
-  Node as Node2,
-  Project,
-  QuoteKind,
-  SyntaxKind as SyntaxKind2
-} from "ts-morph";
-
-// src/code_transformer/rc_file_transformer.ts
-import { fileURLToPath } from "url";
-import {
-  Node,
-  SyntaxKind
-} from "ts-morph";
-var ALLOWED_ENVIRONMENTS = ["web", "console", "test", "repl"];
+import { fileURLToPath } from "node:url";
+import { detectPackageManager, installPackage } from "@antfu/install-pkg";
+import { join } from "node:path";
+import { Node, Project, QuoteKind, SyntaxKind } from "ts-morph";
+const ALLOWED_ENVIRONMENTS = [
+	"web",
+	"console",
+	"test",
+	"repl"
+];
 var RcFileTransformer = class {
-  /**
-   * The current working directory URL
-   */
-  #cwd;
-  /**
-   * The TsMorph project instance
-   */
-  #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"
-  };
-  /**
-   * Create a new RcFileTransformer instance
-   *
-   * @param cwd - The current working directory URL
-   * @param project - The TsMorph project instance
-   */
-  constructor(cwd, project) {
-    this.#cwd = cwd;
-    this.#project = project;
-  }
-  /**
-   * Get the `adonisrc.ts` source file
-   *
-   * @returns The adonisrc.ts source file
-   * @throws Error if the file cannot be found
-   */
-  #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
-   *
-   * @param environments - Optional array of environment names
-   * @returns True if the provided environments are a subset of available ones
-   */
-  #isInSpecificEnvironment(environments) {
-    if (!environments) {
-      return false;
-    }
-    return !!ALLOWED_ENVIRONMENTS.find((env) => !environments.includes(env));
-  }
-  /**
-   * Locate the `defineConfig` call inside the `adonisrc.ts` file
-   *
-   * @param file - The source file to search in
-   * @returns The defineConfig call expression
-   * @throws Error if defineConfig call cannot be found
-   */
-  #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
-   *
-   * @param defineConfigCall - The defineConfig call expression
-   * @returns The configuration object literal expression
-   * @throws Error if the object literal cannot be found
-   */
-  #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.
-   *
-   * @param propertyName - The name of the property to find or create
-   * @param initializer - The initial value if the property needs to be created
-   * @returns The property assignment node
-   */
-  #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 `{
+	#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 kernelUrl = fileURLToPath(new URL("./adonisrc.ts", this.#cwd));
+		return this.#project.getSourceFileOrThrow(kernelUrl);
+	}
+	#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 new Error("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
-   *
-   * @param commandPath - The path to the command file
-   * @returns This RcFileTransformer instance for method chaining
-   */
-  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
-   *
-   * @param modulePath - The path to the preload file
-   * @param environments - Optional array of environments where this preload should run
-   * @returns This RcFileTransformer instance for method chaining
-   */
-  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
-   *
-   * @param providerPath - The path to the provider file
-   * @param environments - Optional array of environments where this provider should run
-   * @returns This RcFileTransformer instance for method chaining
-   */
-  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
-   *
-   * @param globPattern - The glob pattern for the meta file
-   * @param reloadServer - Whether the server should reload when this file changes
-   * @returns This RcFileTransformer instance for method chaining
-   */
-  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 in the directories configuration
-   *
-   * @param key - The directory key (e.g., 'controllers', 'models')
-   * @param value - The directory path
-   * @returns This RcFileTransformer instance for method chaining
-   */
-  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 in the command aliases configuration
-   *
-   * @param alias - The alias name
-   * @param command - The full command name
-   * @returns This RcFileTransformer instance for method chaining
-   */
-  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
-   *
-   * @param suiteName - The name of the test suite
-   * @param files - File patterns for the test suite (string or array)
-   * @param timeout - Optional timeout in milliseconds (defaults to 2000)
-   * @returns This RcFileTransformer instance for method chaining
-   */
-  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
-   *
-   * @param type - The type of hook to add
-   * @param path - The path to the hook file
-   * @returns This RcFileTransformer instance for method chaining
-   */
-  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 with all applied transformations
-   *
-   * Formats the file according to editor settings and saves it to disk.
-   *
-   * @returns Promise that resolves when the file is saved
-   */
-  save() {
-    const file = this.#getRcFileOrThrow();
-    file.formatText(this.#editorSettings);
-    return file.save();
-  }
+      }`);
+		return this;
+	}
+	addAssemblerHook(type, path) {
+		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 (this.#extractModulesFromArray(hooksArray).includes(path)) return this;
+		hooksArray.addElement(`() => import('${path}')`);
+		return this;
+	}
+	save() {
+		const file = this.#getRcFileOrThrow();
+		file.formatText(this.#editorSettings);
+		return file.save();
+	}
 };
-
-// src/code_transformer/main.ts
 var CodeTransformer = class {
-  /**
-   * Utility function for installing packages
-   */
-  installPackage = installPackage;
-  /**
-   * Utility function for detecting the package manager
-   */
-  detectPackageManager = detectPackageManager;
-  /**
-   * Directory of the adonisjs project
-   */
-  #cwd;
-  /**
-   * String path version of the current working directory
-   */
-  #cwdPath;
-  /**
-   * The TsMorph project instance for AST manipulation
-   */
-  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"
-  };
-  /**
-   * Create a new CodeTransformer instance
-   *
-   * @param cwd - The current working directory URL
-   */
-  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
-   *
-   * This method locates middleware stack calls (like server.use or router.use)
-   * and adds the middleware entry to the appropriate position in the array.
-   *
-   * @param file - The source file to modify
-   * @param target - The target method call (e.g., 'server.use', 'router.use')
-   * @param middlewareEntry - The middleware entry to add
-   */
-  #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
-   *
-   * This method adds middleware entries to the named middleware object,
-   * typically used for route-specific middleware registration.
-   *
-   * @param file - The source file to modify
-   * @param middlewareEntry - The middleware entry to add (must have a name)
-   */
-  #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 policies
-   *
-   * This method adds bouncer policy entries to the policies object,
-   * allowing them to be used in route authorization.
-   *
-   * @param file - The source file to modify
-   * @param policyEntry - The policy entry to add
-   */
-  #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
-   *
-   * @param definition - Environment validation definition containing variables and comment
-   */
-  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.
-   *
-   * @param stack - The middleware stack to add to ('server', 'router', or 'named')
-   * @param middleware - Array of middleware entries to add
-   */
-  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 using the provided callback
-   *
-   * @param callback - Function that receives the RcFileTransformer for modifications
-   */
-  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
-   *
-   * @param pluginCall - The plugin function call to add
-   * @param importDeclarations - Import declarations needed for the plugin
-   */
-  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 to the `vite.config.ts` file
-   *
-   * @param pluginCall - The plugin function call to add
-   * @param importDeclarations - Import declarations needed for the 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.
-   *
-   * @param policies - Array of bouncer policy entries to add
-   */
-  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();
-  }
-};
-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 }
+		});
+	}
+	#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) {
+		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
+			});
+		});
+	}
+	#addLeadingComment(writer, comment) {
+		if (!comment) return writer.blankLine();
+		return writer.blankLine().writeLine("/*").writeLine(`|----------------------------------------------------------`).writeLine(`| ${comment}`).writeLine(`|----------------------------------------------------------`).writeLine(`*/`);
+	}
+	async defineEnvValidations(definition) {
+		const kernelUrl = join(this.#cwdPath, "./start/env.ts");
+		const file = this.project.getSourceFileOrThrow(kernelUrl);
+		const callExpressions = file.getDescendantsOfKind(SyntaxKind.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 (!Node.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();
+	}
+	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();
+	}
+	async updateRcFile(callback) {
+		const rcFileTransformer = new RcFileTransformer(this.#cwd, this.project);
+		callback(rcFileTransformer);
+		await rcFileTransformer.save();
+	}
+	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(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 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 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);
+		file.formatText(this.#editorSettings);
+		await file.save();
+	}
+	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();
+	}
 };
+export { CodeTransformer };