@adonisjs/assembler 8.0.0-next.1 → 8.0.0-next.2

package/README.md

@@ -444,6 +444,85 @@ export const policies = {
 }
 ```
 
+### makeEntityIndex
+The method is used to create an index file for a collection of entities discovered from one or more root folders. We use this method to create an index file for controllers or generate types for Inertia pages.
+
+```ts
+const transformer = new CodeTransformer(appRoot)
+
+const output = await transformer.makeEntityIndex({
+  source: 'app/controllers',
+  importAlias: '#controllers'
+}, {
+  destination: '.adonisjs/backend/controllers',
+  exportName: 'controllers'
+})
+
+/**
+  export const controllers = {
+    SignupController: () => import('#controllers/auth/signup_controller'),
+    PostsController: () => import('#controllers/posts_controller'),
+    HomePage: () => import('#controllers/public/home_page'),
+    UserPostsController: () => import('#controllers/user/posts_controller'),
+  }
+ */
+```
+
+If you would like to remove the `Controller` suffix from the key (which we do in our official generator), then you can specify the `removeNameSuffix` option.
+
+```ts
+const output = await transformer.makeEntityIndex({
+  source: 'app/controllers',
+  importAlias: '#controllers'
+}, {
+  destination: '.adonisjs/backend/controllers',
+  exportName: 'controllers',
+  removeNameSuffix: 'controller'
+})
+```
+
+For more advanced use-cases, you can specify the `computeBaseName` method to self compute the key name for the collection.
+
+```ts
+import StringBuilder from '@poppinss/utils/string_builder'
+
+const output = await transformer.makeEntityIndex({
+  source: 'app/controllers',
+  importAlias: '#controllers'
+}, {
+  destination: '.adonisjs/backend/controllers',
+  exportName: 'controllers',
+  computeBaseName(filePath, sourcePath) {
+    const baseName = relative(sourcePath, filePath)
+    return new StringBuilder(baseName).toUnixSlash().removeExtension().removeSuffix('Controller').toString()
+  },
+})
+```
+
+#### Controlling the output
+The output is an object with key-value pair in which the value is a lazily imported module. However, you can customize the output to generate a TypeScript type using the `computeOutput` method.
+
+```ts
+const output = await transformer.makeEntityIndex(
+  { source: './inertia/pages', allowedExtensions: ['.tsx'] },
+  {
+    destination: outputPath,
+    computeOutput(entries) {
+      return entries
+        .reduce<string[]>(
+          (result, entry) => {
+            result.push(`${entry.name}: typeof import('${entry.importPath}')`)
+            return result
+          },
+          [`declare module '@adonisjs/inertia' {`, 'export interface Pages {']
+        )
+        .concat('}', '}')
+        .join('\n')
+    },
+  }
+)
+```
+
 ## Contributing
 One of the primary goals of AdonisJS is to have a vibrant community of users and contributors who believe in the framework's principles.
 

package/build/index.js

@@ -560,6 +560,96 @@ var FileSystem = class {
   }
 };
 
+// src/shortcuts_manager.ts
+var ShortcutsManager = class {
+  #logger;
+  #callbacks;
+  #serverUrl;
+  #keyPressHandler;
+  #shortcuts = [
+    {
+      key: "r",
+      description: "restart server",
+      handler: () => {
+        this.#logger.log("");
+        this.#logger.info("Manual restart triggered...");
+        this.#callbacks.onRestart();
+      }
+    },
+    {
+      key: "c",
+      description: "clear console",
+      handler: () => {
+        this.#callbacks.onClear();
+        this.#logger.info("Console cleared");
+      }
+    },
+    {
+      key: "o",
+      description: "open in browser",
+      handler: () => this.#handleOpenBrowser()
+    },
+    {
+      key: "h",
+      description: "show this help",
+      handler: () => this.showHelp()
+    }
+  ];
+  constructor(options) {
+    this.#logger = options.logger;
+    this.#callbacks = options.callbacks;
+  }
+  /**
+   * Set server url for opening in browser
+   */
+  setServerUrl(url) {
+    this.#serverUrl = url;
+  }
+  /**
+   * Initialize keyboard shortcuts
+   */
+  setup() {
+    if (!process.stdin.isTTY) return;
+    process.stdin.setRawMode(true);
+    this.#keyPressHandler = (data) => this.#handleKeyPress(data.toString());
+    process.stdin.on("data", this.#keyPressHandler);
+  }
+  /**
+   * Handle key press events
+   */
+  #handleKeyPress(key) {
+    if (key === "" || key === "") return this.#callbacks.onQuit();
+    const shortcut = this.#shortcuts.find((s) => s.key === key);
+    if (shortcut) shortcut.handler();
+  }
+  /**
+   * Handle opening browser
+   */
+  async #handleOpenBrowser() {
+    this.#logger.log("");
+    this.#logger.info(`Opening ${this.#serverUrl}...`);
+    const { default: open } = await import("open");
+    open(this.#serverUrl);
+  }
+  /**
+   * Show available keyboard shortcuts
+   */
+  showHelp() {
+    this.#logger.log("");
+    this.#logger.log("Available shortcuts:");
+    this.#shortcuts.forEach(({ key, description }) => this.#logger.log(`\xB7 ${key}: ${description}`));
+  }
+  /**
+   * Cleanup keyboard shortcuts
+   */
+  cleanup() {
+    if (!process.stdin.isTTY) return;
+    process.stdin.setRawMode(false);
+    process.stdin.removeListener("data", this.#keyPressHandler);
+    this.#keyPressHandler = void 0;
+  }
+};
+
 // src/dev_server.ts
 var DevServer = class {
   constructor(cwd, options) {
@@ -594,6 +684,10 @@ var DevServer = class {
    * Reference to the child process
    */
   #httpServer;
+  /**
+   * Keyboard shortcuts manager
+   */
+  #shortcutsManager;
   /**
    * Filesystem is used to decide which files to watch or entertain when
    * using hot-hook
@@ -614,6 +708,26 @@ var DevServer = class {
     }
     await this.#startHTTPServer(this.#stickyPort);
   }, "restartHTTPServer");
+  /**
+   * Sets up keyboard shortcuts
+   */
+  #setupKeyboardShortcuts() {
+    this.#shortcutsManager = new ShortcutsManager({
+      logger: this.ui.logger,
+      callbacks: {
+        onRestart: () => this.#restartHTTPServer(),
+        onClear: () => this.#clearScreen(),
+        onQuit: () => this.close()
+      }
+    });
+    this.#shortcutsManager.setup();
+  }
+  /**
+   * Cleanup keyboard shortcuts
+   */
+  #cleanupKeyboardShortcuts() {
+    this.#shortcutsManager?.cleanup();
+  }
   /**
    * CLI UI to log colorful messages
    */
@@ -640,10 +754,13 @@ var DevServer = class {
    */
   async #postServerReady(message) {
     const host = message.host === "0.0.0.0" ? "127.0.0.1" : message.host;
-    const displayMessage = this.ui.sticker().add(`Server address: ${this.ui.colors.cyan(`http://${host}:${message.port}`)}`).add(`Mode: ${this.ui.colors.cyan(this.mode)}`);
+    const serverUrl = `http://${host}:${message.port}`;
+    this.#shortcutsManager?.setServerUrl(serverUrl);
+    const displayMessage = this.ui.sticker().add(`Server address: ${this.ui.colors.cyan(serverUrl)}`).add(`Mode: ${this.ui.colors.cyan(this.mode)}`);
     if (message.duration) {
       displayMessage.add(`Ready in: ${this.ui.colors.cyan(prettyHrtime(message.duration))}`);
     }
+    displayMessage.add(`Press ${this.ui.colors.dim("h")} to show help`);
     try {
       await this.#hooks.runner("devServerStarted").run(this, displayMessage);
     } catch (error) {
@@ -807,6 +924,7 @@ var DevServer = class {
    * Close watchers and the running child process
    */
   async close() {
+    this.#cleanupKeyboardShortcuts();
     await this.#watcher?.close();
     if (this.#httpServer) {
       this.#httpServer.removeAllListeners();
@@ -842,6 +960,7 @@ var DevServer = class {
       };
     }
     this.#clearScreen();
+    this.#setupKeyboardShortcuts();
     this.ui.logger.info("starting HTTP server...");
     await this.#startHTTPServer(this.#stickyPort);
   }
@@ -865,6 +984,7 @@ var DevServer = class {
     ]);
     this.#registerServerRestartHooks();
     this.#clearScreen();
+    this.#setupKeyboardShortcuts();
     this.ui.logger.info("starting HTTP server...");
     await this.#startHTTPServer(this.#stickyPort);
     this.#watcher = watch({

package/build/src/code_transformer/main.d.ts

@@ -67,8 +67,8 @@ export declare class CodeTransformer {
      *
      * ```ts
      * export const controllers = {
-     *   Login: () => import('#controllers/login_controller'),
-     *   Login: () => import('#controllers/login_controller'),
+     *   LoginController: () => import('#controllers/login_controller'),
+     *   LogoutController: () => import('#controllers/logout_controller'),
      * }
      * ```
      *
@@ -79,10 +79,15 @@ export declare class CodeTransformer {
     makeEntityIndex(input: OneOrMore<{
         source: string;
         importAlias?: string;
+        allowedExtensions?: string[];
     }>, output: {
         destination: string;
         exportName?: string;
-        transformName?: (name: string) => string;
-        transformImport?: (modulePath: string) => string;
+        removeNameSuffix?: string;
+        computeBaseName?: (filePath: string, sourcePath: string) => string;
+        computeOutput?: (entries: {
+            name: string;
+            importPath: string;
+        }[]) => string;
     }): Promise<void>;
 }

package/build/src/code_transformer/main.js

@@ -9,7 +9,7 @@ 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, join, relative } from "path";
+import { basename, dirname, extname, join, relative } from "path";
 import { installPackage, detectPackageManager } from "@antfu/install-pkg";
 import {
   Node as Node2,
@@ -539,8 +539,8 @@ var CodeTransformer = class {
    *
    * ```ts
    * export const controllers = {
-   *   Login: () => import('#controllers/login_controller'),
-   *   Login: () => import('#controllers/login_controller'),
+   *   LoginController: () => import('#controllers/login_controller'),
+   *   LogoutController: () => import('#controllers/logout_controller'),
    * }
    * ```
    *
@@ -560,32 +560,51 @@ var CodeTransformer = class {
       inputs
     );
     const entries = await Promise.all(
-      inputs.map(async ({ source, importAlias }) => {
+      inputs.map(async ({ source, importAlias, allowedExtensions }) => {
         const sourcePath = join(this.#cwdPath, source);
         const filesList = await fsReadAll(sourcePath, {
-          filter: isScriptFile,
+          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) => {
-          const name = new StringBuilder(string.toUnixSlash(relative(sourcePath, filePath))).removeExtension().pascalCase().toString();
-          const importPath = importAlias ? `${importAlias}/${new StringBuilder(string.toUnixSlash(relative(sourcePath, filePath))).removeExtension().toString()}` : string.toUnixSlash(relative(outputDir, 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: output.transformName?.(name) ?? name,
-            importPath: output.transformImport?.(importPath) ?? importPath
+            name,
+            importPath
           };
         });
       })
     );
-    const outputContents = entries.flat(2).reduce(
-      (result, entry) => {
-        debug_default('adding "%O" to the index', entry);
-        result.push(`  ${entry.name}: () => import('${entry.importPath}'),`);
-        return result;
-      },
-      [`export const ${exportName} = {`]
-    ).concat("}");
+    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, outputContents.join("\n"));
+    await writeFile(outputPath, computeOutput(entries.flat(2)));
   }
 };
 export {

package/build/src/shortcuts_manager.d.ts

@@ -0,0 +1,47 @@
+import type { Logger } from '@poppinss/cliui';
+/**
+ * Keyboard shortcut definition
+ */
+export interface KeyboardShortcut {
+    key: string;
+    description: string;
+    handler: () => void;
+}
+/**
+ * Callbacks for keyboard shortcuts actions
+ */
+export interface KeyboardShortcutsCallbacks {
+    onRestart: () => void;
+    onClear: () => void;
+    onQuit: () => void;
+}
+/**
+ * Shortcuts manager options
+ */
+export interface ShortcutsManagerOptions {
+    logger: Logger;
+    callbacks: KeyboardShortcutsCallbacks;
+}
+/**
+ * Manages keyboard shortcuts for development server
+ */
+export declare class ShortcutsManager {
+    #private;
+    constructor(options: ShortcutsManagerOptions);
+    /**
+     * Set server url for opening in browser
+     */
+    setServerUrl(url: string): void;
+    /**
+     * Initialize keyboard shortcuts
+     */
+    setup(): void;
+    /**
+     * Show available keyboard shortcuts
+     */
+    showHelp(): void;
+    /**
+     * Cleanup keyboard shortcuts
+     */
+    cleanup(): void;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@adonisjs/assembler",
   "description": "Provides utilities to run AdonisJS development server and build project for production",
-  "version": "8.0.0-next.1",
+  "version": "8.0.0-next.2",
   "engines": {
     "node": ">=24.0.0"
   },
@@ -40,18 +40,18 @@
     "@japa/file-system": "^2.3.2",
     "@japa/runner": "^4.2.0",
     "@japa/snapshot": "^2.0.8",
-    "@poppinss/ts-exec": "^1.2.1",
+    "@poppinss/ts-exec": "^1.4.0",
     "@release-it/conventional-changelog": "^10.0.1",
-    "@types/node": "^22.15.29",
+    "@types/node": "^24.0.10",
     "@types/picomatch": "^4.0.0",
     "@types/pretty-hrtime": "^1.0.3",
     "c8": "^10.1.3",
     "cross-env": "^7.0.3",
     "del-cli": "^6.0.0",
-    "eslint": "^9.28.0",
+    "eslint": "^9.30.1",
     "hot-hook": "^0.4.1-next.0",
     "p-event": "^6.0.1",
-    "prettier": "^3.5.3",
+    "prettier": "^3.6.2",
     "release-it": "^19.0.3",
     "tsup": "^8.5.0",
     "typescript": "^5.8.3"
@@ -59,15 +59,16 @@
   "dependencies": {
     "@adonisjs/env": "^6.2.0",
     "@antfu/install-pkg": "^1.1.0",
-    "@poppinss/cliui": "^6.4.3",
-    "@poppinss/hooks": "^7.2.5",
-    "@poppinss/utils": "^7.0.0-next.1",
+    "@poppinss/cliui": "^6.4.4",
+    "@poppinss/hooks": "^7.2.6",
+    "@poppinss/utils": "^7.0.0-next.3",
     "chokidar": "^4.0.3",
     "dedent": "^1.6.0",
     "execa": "^9.6.0",
     "fast-glob": "^3.3.3",
     "get-port": "^7.1.0",
     "junk": "^4.0.1",
+    "open": "^10.1.2",
     "picomatch": "^4.0.2",
     "pretty-hrtime": "^1.0.3",
     "tmp-cache": "^1.1.0",