Merge pull request #1 from hyperweb-io/dev/test-watch

add test command with nodemon support

Author: Jovonni

packages/makage/README.md

@@ -92,6 +92,18 @@ Or with recursive patterns:
 "copy:all-sql": "makage copy src/**/*.sql dist/sql --flat"
 ```
 
+### Watching Tests
+
+**Before:**
+```json
+"test:watch": "nodemon --watch deploy --watch revert --ext sql --exec 'jest'"
+```
+
+**After:**
+```json
+"test:watch": "makage test --watch deploy,revert --ext sql"
+```
+
 > **Note:** For convenience, `makage assets` combines copy + footer functionality and is kept for backwards compatibility.
 
 ## Assumptions
@@ -242,6 +254,41 @@ Run from the monorepo root:
 makage update-workspace
 ```
 
+makage update-workspace
+```
+
+### `makage test [--runner <cmd>] [--watch <dirs>] [--ext <exts>] [-- <args...>]`
+
+Runs tests using a specified runner (defaults to `jest`). Automatically switches to `nodemon` if watch directories or extensions are specified.
+
+- Use `--runner` to specify a custom test runner (e.g., `vitest`, `node --test`)
+- Use `--watch` to enable watch mode. If followed by directories (comma-separated), it uses `nodemon` to watch those directories.
+- Use `--ext` to specify file extensions to watch (comma-separated). Implies `nodemon`.
+- Use `--` to pass additional arguments to the runner.
+
+```bash
+# Default (runs jest)
+makage test
+
+# Watch mode (runs jest --watch)
+makage test --watch
+
+# Custom runner
+makage test --runner vitest
+
+# Watch specific directories (uses nodemon)
+makage test --watch dir1,dir2
+
+# Watch specific extensions (uses nodemon)
+makage test --ext js,sql,ts
+
+# Complex example: Watch dirs and extensions, run custom command
+# Runs: nodemon --watch dir1 --watch dir2 --ext sql,js --exec "vitest --runInBand"
+makage test --watch dir1,dir2 --ext sql,js --runner vitest -- --runInBand
+```
+
+### `makage update-workspace`
+
 This will:
 1. Scan all packages in the `packages/` directory
 2. Identify internal package names

packages/makage/package.json

@@ -39,5 +39,8 @@
     "lint": "eslint . --fix",
     "test": "jest",
     "test:watch": "jest --watch"
+  },
+  "dependencies": {
+    "nodemon": "^3.1.11"
   }
 }

packages/makage/src/cli.ts

@@ -6,6 +6,7 @@ import { runAssets } from './commands/assets';
 import { runBuild } from './commands/build';
 import { runBuildTs } from './commands/buildTs';
 import { runUpdateWorkspace } from './commands/updateWorkspace';
+import { runTest } from './commands/testCommand';
 
 const [, , cmd, ...rest] = process.argv;
 
@@ -33,6 +34,9 @@ async function main() {
       case 'update-workspace':
         await runUpdateWorkspace(rest);
         break;
+      case 'test':
+        await runTest(rest);
+        break;
       case '-h':
       case '--help':
       default:
@@ -57,6 +61,7 @@ Usage:
   makage assets
   makage build-ts [--dev]
   makage update-workspace
+  makage test [--runner <cmd>] [--watch] [-- <args...>]
 `);
 }
 

packages/makage/src/commands/testCommand.ts

@@ -0,0 +1,112 @@
+import { spawn } from 'node:child_process';
+
+interface TestOptions {
+    runner: string;
+    watchMode: boolean;
+    watchDirs: string[];
+    extensions: string[];
+    passThrough: string[];
+}
+
+export async function runTest(args: string[]) {
+    const opts: TestOptions = {
+        runner: 'jest',
+        watchMode: false,
+        watchDirs: [],
+        extensions: [],
+        passThrough: []
+    };
+
+    // Parse args
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+
+        if (arg === '--runner') {
+            if (i + 1 < args.length) {
+                opts.runner = args[i + 1];
+                i++;
+            }
+        } else if (arg === '--watch') {
+            // Check if next arg is a value (not starting with -)
+            const nextArg = args[i + 1];
+            if (nextArg && !nextArg.startsWith('-')) {
+                opts.watchDirs.push(...nextArg.split(','));
+                i++;
+            } else {
+                opts.watchMode = true;
+            }
+        } else if (arg === '--ext') {
+            const nextArg = args[i + 1];
+            if (nextArg && !nextArg.startsWith('-')) {
+                opts.extensions.push(...nextArg.split(','));
+                i++;
+            }
+        } else if (arg === '--') {
+            opts.passThrough = args.slice(i + 1);
+            break;
+        } else if (arg.startsWith('-')) {
+            // Unknown flag, ignore or assume it's part of pass-through if we wanted to support mixed args,
+            // but for now we stick to strict parsing and assume user puts runner args after --
+        }
+    }
+
+    // Determine mode
+    const useNodemon = opts.watchDirs.length > 0 || opts.extensions.length > 0;
+
+    let command: string;
+    let commandArgs: string[];
+
+    if (useNodemon) {
+        // Nodemon mode
+        command = 'nodemon';
+        commandArgs = [];
+
+        // Add watch dirs
+        for (const dir of opts.watchDirs) {
+            commandArgs.push('--watch', dir);
+        }
+
+        // Add extensions
+        for (const ext of opts.extensions) {
+            commandArgs.push('--ext', ext);
+        }
+
+        // Add exec command
+        // We need to combine runner and passThrough into a single string for --exec
+        const runnerCmd = [opts.runner, ...opts.passThrough].join(' ');
+        commandArgs.push('--exec', runnerCmd);
+
+    } else {
+        // Standard mode
+        const runnerParts = opts.runner.split(' ');
+        command = runnerParts[0];
+        commandArgs = runnerParts.slice(1);
+
+        if (opts.watchMode) {
+            commandArgs.push('--watch');
+        }
+
+        commandArgs.push(...opts.passThrough);
+    }
+
+    console.log(`[makage] running tests with: ${command} ${commandArgs.join(' ')}`);
+
+    const child = spawn(command, commandArgs, {
+        stdio: 'inherit',
+        shell: true
+    });
+
+    return new Promise<void>((resolve, reject) => {
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            } else {
+                process.exit(code ?? 1);
+            }
+        });
+        child.on('error', (err) => {
+            console.error(`[makage] failed to start runner: ${err.message}`);
+            process.exit(1);
+        });
+    });
+}