@fluojs/cli 1.0.0-beta.3 → 1.0.0-beta.5

package/dist/dev-runner/node-restart-runner.js

@@ -0,0 +1,248 @@
+import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { existsSync, readdirSync, readFileSync, statSync, watch } from 'node:fs';
+import { basename, join, relative, sep } from 'node:path';
+const DEFAULT_DEBOUNCE_MS = 100;
+const DEFAULT_IGNORES = ['.cache', '.fluo', '.git', '.turbo', 'coverage', 'dist', 'node_modules', '*.swp', '*.swo', '*~', '.#*'];
+const WATCH_FILES = ['.env', 'package.json', 'tsconfig.json', 'tsconfig.build.json'];
+function normalizeIgnorePatterns(patterns) {
+  return patterns.map(pattern => pattern.trim()).filter(pattern => pattern.length > 0);
+}
+function parseIgnorePatterns(env) {
+  const configured = env.FLUO_DEV_WATCH_IGNORE?.split(',') ?? [];
+  return normalizeIgnorePatterns([...DEFAULT_IGNORES, ...configured]);
+}
+function matchesSegmentPattern(segment, pattern) {
+  if (pattern.startsWith('*.')) {
+    return segment.endsWith(pattern.slice(1));
+  }
+  if (pattern.endsWith('*')) {
+    return segment.startsWith(pattern.slice(0, -1));
+  }
+  return segment === pattern;
+}
+function shouldIgnorePath(filePath, projectDirectory, ignorePatterns) {
+  const relativePath = relative(projectDirectory, filePath);
+  if (relativePath.startsWith('..')) {
+    return true;
+  }
+  const segments = relativePath.split(sep).filter(Boolean);
+  return segments.some(segment => ignorePatterns.some(pattern => matchesSegmentPattern(segment, pattern)));
+}
+function hashFileContent(filePath) {
+  try {
+    const stats = statSync(filePath);
+    if (!stats.isFile()) {
+      return undefined;
+    }
+    return createHash('sha256').update(readFileSync(filePath)).digest('hex');
+  } catch (_error) {
+    return undefined;
+  }
+}
+function collectContentPaths(filePath, projectDirectory, ignorePatterns, paths) {
+  if (shouldIgnorePath(filePath, projectDirectory, ignorePatterns)) {
+    return;
+  }
+  try {
+    const stats = statSync(filePath);
+    if (stats.isDirectory()) {
+      for (const entry of readdirSync(filePath)) {
+        collectContentPaths(join(filePath, entry), projectDirectory, ignorePatterns, paths);
+      }
+      return;
+    }
+    if (stats.isFile()) {
+      paths.add(filePath);
+    }
+  } catch (_error) {
+    paths.add(filePath);
+  }
+}
+function collectWatchedContentPaths(paths, projectDirectory, ignorePatterns) {
+  const collected = new Set();
+  for (const filePath of paths) {
+    collectContentPaths(filePath, projectDirectory, ignorePatterns, collected);
+  }
+  return collected;
+}
+
+/**
+ * Creates a content-diff gate for fluo-owned dev restarts.
+ *
+ * @param projectDirectory Project root used for ignore matching.
+ * @param ignorePatterns Additional or default ignore patterns to apply before hashing.
+ * @returns A gate that reports whether watched paths changed by content rather than by filesystem event alone.
+ */
+export function createContentChangeGate(projectDirectory, ignorePatterns = DEFAULT_IGNORES) {
+  const normalizedIgnores = normalizeIgnorePatterns(ignorePatterns);
+  const hashes = new Map();
+  return {
+    commitBaseline(paths) {
+      for (const filePath of collectWatchedContentPaths(paths, projectDirectory, normalizedIgnores)) {
+        hashes.set(filePath, hashFileContent(filePath));
+      }
+    },
+    hasMeaningfulChange(paths) {
+      for (const filePath of collectWatchedContentPaths(paths, projectDirectory, normalizedIgnores)) {
+        const nextHash = hashFileContent(filePath);
+        const previousHash = hashes.get(filePath);
+        if (previousHash !== nextHash) {
+          return true;
+        }
+      }
+      return false;
+    }
+  };
+}
+function getWatchTargets(projectDirectory) {
+  return [join(projectDirectory, 'src'), ...WATCH_FILES.map(fileName => join(projectDirectory, fileName))].filter(target => existsSync(target));
+}
+function stopChild(child) {
+  if (child && child.exitCode === null && !child.killed) {
+    child.kill('SIGTERM');
+  }
+}
+
+/**
+ * Runs the Node.js development lifecycle through fluo-owned restart supervision.
+ *
+ * @param options Runner dependencies and project settings.
+ * @returns A promise that resolves with the final child exit code when the runner stops.
+ */
+export async function runNodeRestartRunner(options) {
+  const projectDirectory = options.projectDirectory ?? process.cwd();
+  const env = options.env;
+  const signalTarget = options.signalTarget ?? process;
+  const spawnChild = options.spawnChild ?? spawn;
+  const stdout = options.stdout ?? process.stdout;
+  const stderr = options.stderr ?? process.stderr;
+  const watchTarget = options.watchTarget ?? watch;
+  const appArgs = options.appArgs ?? [];
+  const debounceMs = options.debounceMs ?? Number(env.FLUO_DEV_RELOAD_DEBOUNCE_MS ?? DEFAULT_DEBOUNCE_MS);
+  const gate = createContentChangeGate(projectDirectory, parseIgnorePatterns(env));
+  const watchTargets = getWatchTargets(projectDirectory);
+  let child;
+  const pendingRestartPaths = new Set();
+  const restartAfterClosePaths = new Set();
+  let restartTimer;
+  let restarting = false;
+  let stopping = false;
+  const startChild = (resolveExitCode, cleanup) => {
+    child = spawnChild(process.execPath, ['--env-file=.env', '--import', 'tsx', 'src/main.ts', ...appArgs], {
+      cwd: projectDirectory,
+      env,
+      stdio: 'inherit'
+    });
+    child.once('close', code => {
+      if (restarting) {
+        return;
+      }
+      if (stopping) {
+        cleanup();
+        resolveExitCode(code ?? 0);
+        return;
+      }
+      cleanup();
+      resolveExitCode(code ?? 1);
+    });
+  };
+  const scheduleRestart = (filePath, resolveExitCode, cleanup) => {
+    pendingRestartPaths.add(filePath);
+    if (restartTimer) {
+      clearTimeout(restartTimer);
+    }
+    restartTimer = setTimeout(() => {
+      const restartPaths = [...pendingRestartPaths];
+      pendingRestartPaths.clear();
+      restartTimer = undefined;
+      if (!gate.hasMeaningfulChange(restartPaths)) {
+        return;
+      }
+      stdout.write(`[fluo] restarting after content change: ${relative(projectDirectory, restartPaths[restartPaths.length - 1] ?? projectDirectory)}\n`);
+      const previousChild = child;
+      const startReplacementChild = () => {
+        startChild(resolveExitCode, cleanup);
+        gate.commitBaseline(restartPaths);
+      };
+      if (previousChild) {
+        for (const restartPath of restartPaths) {
+          restartAfterClosePaths.add(restartPath);
+        }
+        if (restarting) {
+          return;
+        }
+        restarting = true;
+        previousChild.once('close', () => {
+          const committedRestartPaths = [...restartAfterClosePaths];
+          restartAfterClosePaths.clear();
+          restarting = false;
+          if (stopping) {
+            return;
+          }
+          startChild(resolveExitCode, cleanup);
+          gate.commitBaseline(committedRestartPaths);
+        });
+        stopChild(previousChild);
+        return;
+      }
+      try {
+        startReplacementChild();
+      } finally {
+        restarting = false;
+      }
+    }, debounceMs);
+  };
+  gate.commitBaseline(watchTargets);
+  return new Promise(resolveExitCode => {
+    const watchers = [];
+    let cleanedUp = false;
+    const stop = () => {
+      stopping = true;
+      cleanup();
+      stopChild(child);
+    };
+    const cleanup = () => {
+      if (cleanedUp) {
+        return;
+      }
+      cleanedUp = true;
+      if (restartTimer) {
+        clearTimeout(restartTimer);
+        restartTimer = undefined;
+      }
+      pendingRestartPaths.clear();
+      restartAfterClosePaths.clear();
+      for (const watcher of watchers.splice(0)) {
+        watcher.close();
+      }
+      signalTarget.off('SIGINT', stop);
+      signalTarget.off('SIGTERM', stop);
+    };
+    startChild(resolveExitCode, cleanup);
+    for (const target of watchTargets) {
+      try {
+        const stats = statSync(target);
+        const watchOptions = {
+          recursive: stats.isDirectory()
+        };
+        const listener = (_event, filename) => {
+          const fileName = filename ? String(filename) : basename(target);
+          scheduleRestart(stats.isDirectory() ? join(target, fileName) : target, resolveExitCode, cleanup);
+        };
+        try {
+          watchers.push(watchTarget(target, watchOptions, listener));
+        } catch (error) {
+          if (!stats.isDirectory()) {
+            throw error;
+          }
+          watchers.push(watchTarget(target, listener));
+        }
+      } catch (error) {
+        stderr.write(`[fluo] unable to watch ${target}: ${error instanceof Error ? error.message : String(error)}\n`);
+      }
+    }
+    signalTarget.once('SIGINT', stop);
+    signalTarget.once('SIGTERM', stop);
+  });
+}

package/dist/generators/manifest.d.ts

@@ -126,6 +126,14 @@ export declare const builtInGeneratorCollection: {
         readonly nextStepHint: "Import the DTO in a controller and add it as a parameter with @FromBody or @FromQuery.";
         readonly schematic: "request-dto";
         readonly wiringBehavior: "files-only";
+    }, {
+        readonly aliases: readonly ["resrc"];
+        readonly description: "Generate a full resource slice with module, controller, service, repository, and DTO stubs.";
+        readonly factory: (name: string, options: import("../generator-types.js").GenerateOptions | undefined) => import("../generator-types.js").GeneratedFile[];
+        readonly kind: "resource";
+        readonly nextStepHint: "Run 'pnpm typecheck' and wire the resource module into a parent module when ready.";
+        readonly schematic: "resource";
+        readonly wiringBehavior: "files-only";
     }, {
         readonly aliases: readonly ["res"];
         readonly description: "Generate a response DTO for typed response payloads (files only — use it as a controller return type).";
@@ -230,6 +238,14 @@ export declare const generatorCollections: readonly [{
         readonly nextStepHint: "Import the DTO in a controller and add it as a parameter with @FromBody or @FromQuery.";
         readonly schematic: "request-dto";
         readonly wiringBehavior: "files-only";
+    }, {
+        readonly aliases: readonly ["resrc"];
+        readonly description: "Generate a full resource slice with module, controller, service, repository, and DTO stubs.";
+        readonly factory: (name: string, options: import("../generator-types.js").GenerateOptions | undefined) => import("../generator-types.js").GeneratedFile[];
+        readonly kind: "resource";
+        readonly nextStepHint: "Run 'pnpm typecheck' and wire the resource module into a parent module when ready.";
+        readonly schematic: "resource";
+        readonly wiringBehavior: "files-only";
     }, {
         readonly aliases: readonly ["res"];
         readonly description: "Generate a response DTO for typed response payloads (files only — use it as a controller return type).";
@@ -332,6 +348,14 @@ export declare const generatorManifest: readonly [{
     readonly nextStepHint: "Import the DTO in a controller and add it as a parameter with @FromBody or @FromQuery.";
     readonly schematic: "request-dto";
     readonly wiringBehavior: "files-only";
+}, {
+    readonly aliases: readonly ["resrc"];
+    readonly description: "Generate a full resource slice with module, controller, service, repository, and DTO stubs.";
+    readonly factory: (name: string, options: import("../generator-types.js").GenerateOptions | undefined) => import("../generator-types.js").GeneratedFile[];
+    readonly kind: "resource";
+    readonly nextStepHint: "Run 'pnpm typecheck' and wire the resource module into a parent module when ready.";
+    readonly schematic: "resource";
+    readonly wiringBehavior: "files-only";
 }, {
     readonly aliases: readonly ["res"];
     readonly description: "Generate a response DTO for typed response payloads (files only — use it as a controller return type).";

package/dist/generators/manifest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../src/generators/manifest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAyB,MAAM,uBAAuB,CAAC;AAYrF,yFAAyF;AACzF,MAAM,MAAM,cAAc,GAAG,aAAa,GAAG,WAAW,GAAG,YAAY,CAAC;AAExE,KAAK,4BAA4B,GAAG;IAClC,QAAQ,EAAE,cAAc,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,8EAA8E;AAC9E,MAAM,MAAM,sBAAsB,GAAG;IACnC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,gBAAgB,CAAC;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,kBAAkB,CAAC,EAAE,4BAA4B,CAAC;IAClD,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,iBAAiB,GAAG,YAAY,CAAC;CAClD,CAAC;AAEF,4FAA4F;AAC5F,MAAM,MAAM,mBAAmB,GAAG;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,SAAS,sBAAsB,EAAE,CAAC;IAC9C,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,UAAU,CAAC;CACpB,CAAC;AAEF,wFAAwF;AACxF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;EAKkB,CAAC;AA6FtD,6EAA6E;AAC7E,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKC,CAAC;AAEzC,2FAA2F;AAC3F,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAiF,CAAC;AAEnH,2FAA2F;AAC3F,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAwC,CAAC;AAEvE,kFAAkF;AAClF,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC;AAEvE,uEAAuE;AACvE,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC;AAcrE;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,aAAa,GAAG,mBAAmB,CAOhF;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,IAAI,SAAS,mBAAmB,EAAE,CAEzE;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,YAAY,GAAE,MAAsC,GAAG,SAAS,mBAAmB,EAAE,CAO7H;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa,GAAG,SAAS,CAMzF"}
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../src/generators/manifest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAyB,MAAM,uBAAuB,CAAC;AAarF,yFAAyF;AACzF,MAAM,MAAM,cAAc,GAAG,aAAa,GAAG,WAAW,GAAG,YAAY,CAAC;AAExE,KAAK,4BAA4B,GAAG;IAClC,QAAQ,EAAE,cAAc,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,8EAA8E;AAC9E,MAAM,MAAM,sBAAsB,GAAG;IACnC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,gBAAgB,CAAC;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,kBAAkB,CAAC,EAAE,4BAA4B,CAAC;IAClD,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,iBAAiB,GAAG,YAAY,CAAC;CAClD,CAAC;AAEF,4FAA4F;AAC5F,MAAM,MAAM,mBAAmB,GAAG;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,SAAS,sBAAsB,EAAE,CAAC;IAC9C,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,UAAU,CAAC;CACpB,CAAC;AAEF,wFAAwF;AACxF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;EAKkB,CAAC;AAsGtD,6EAA6E;AAC7E,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKC,CAAC;AAEzC,2FAA2F;AAC3F,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAiF,CAAC;AAEnH,2FAA2F;AAC3F,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAwC,CAAC;AAEvE,kFAAkF;AAClF,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC;AAEvE,uEAAuE;AACvE,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC;AAcrE;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,aAAa,GAAG,mBAAmB,CAOhF;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,IAAI,SAAS,mBAAmB,EAAE,CAEzE;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,YAAY,GAAE,MAAsC,GAAG,SAAS,mBAAmB,EAAE,CAO7H;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa,GAAG,SAAS,CAMzF"}

package/dist/generators/manifest.js

@@ -5,6 +5,7 @@ import { generateMiddlewareFiles } from './middleware.js';
 import { generateModuleFiles } from './module.js';
 import { generateRepoFiles } from './repository.js';
 import { generateRequestDtoFiles } from './request-dto.js';
+import { generateResourceFiles } from './resource.js';
 import { generateResponseDtoFiles } from './response-dto.js';
 import { generateServiceFiles } from './service.js';
 
@@ -113,6 +114,14 @@ const builtInGeneratorDefinitions = [{
   nextStepHint: 'Import the DTO in a controller and add it as a parameter with @FromBody or @FromQuery.',
   schematic: 'request-dto',
   wiringBehavior: 'files-only'
+}, {
+  aliases: ['resrc'],
+  description: 'Generate a full resource slice with module, controller, service, repository, and DTO stubs.',
+  factory: (name, options) => generateResourceFiles(name, options),
+  kind: 'resource',
+  nextStepHint: "Run 'pnpm typecheck' and wire the resource module into a parent module when ready.",
+  schematic: 'resource',
+  wiringBehavior: 'files-only'
 }, {
   aliases: ['res'],
   description: 'Generate a response DTO for typed response payloads (files only — use it as a controller return type).',

package/dist/generators/resource.d.ts

@@ -0,0 +1,10 @@
+import type { GenerateOptions, GeneratedFile } from '../types.js';
+/**
+ * Generate a complete feature resource slice.
+ *
+ * @param name The resource name.
+ * @param options The generation options.
+ * @returns The generated resource files.
+ */
+export declare function generateResourceFiles(name: string, options?: GenerateOptions): GeneratedFile[];
+//# sourceMappingURL=resource.d.ts.map

package/dist/generators/resource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource.d.ts","sourceRoot":"","sources":["../../src/generators/resource.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AASlE;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,eAAoB,GAAG,aAAa,EAAE,CASlG"}

package/dist/generators/resource.js

@@ -0,0 +1,23 @@
+import { generateControllerFiles } from './controller.js';
+import { generateModuleFiles } from './module.js';
+import { generateRepoFiles } from './repository.js';
+import { generateRequestDtoFiles } from './request-dto.js';
+import { generateResponseDtoFiles } from './response-dto.js';
+import { generateServiceFiles } from './service.js';
+
+/**
+ * Generate a complete feature resource slice.
+ *
+ * @param name The resource name.
+ * @param options The generation options.
+ * @returns The generated resource files.
+ */
+export function generateResourceFiles(name, options = {}) {
+  return [...generateModuleFiles(name), ...generateRepoFiles(name, options), ...generateServiceFiles(name, {
+    ...options,
+    hasRepo: true
+  }), ...generateControllerFiles(name, {
+    ...options,
+    hasService: true
+  }), ...generateRequestDtoFiles(`Create ${name}`), ...generateResponseDtoFiles(name)];
+}

package/dist/generators/templates/controller.ts.ejs

@@ -1,5 +1,7 @@
 <% if (hasService) { %>
-import { Inject } from '@fluojs/core';
+import { ensureMetadataSymbol, Inject } from '@fluojs/core';
+<% } else { %>
+import { ensureMetadataSymbol } from '@fluojs/core';
 <% } %>
 import { Controller, Get } from '@fluojs/http';
 
@@ -7,6 +9,8 @@ import { Controller, Get } from '@fluojs/http';
 import { <%- service %> } from './<%- kebab %>.service';
 <% } %>
 
+ensureMetadataSymbol();
+
 @Controller('/<%- kebab %>')
 <% if (hasService) { %>
 @Inject(<%- service %>)

package/dist/generators/templates/request-dto.ts.ejs

@@ -1,6 +1,9 @@
+import { ensureMetadataSymbol } from '@fluojs/core';
 import { IsString, MinLength } from '@fluojs/validation';
 import { FromBody } from '@fluojs/http';
 
+ensureMetadataSymbol();
+
 export class <%- pascal %> {
   @FromBody('<%- bodyField %>')
   @IsString()

package/dist/new/scaffold.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scaffold.d.ts","sourceRoot":"","sources":["../../src/new/scaffold.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,gBAAgB,EAAkB,MAAM,YAAY,CAAC;AAmkEnE;;;;;;GAMG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,gBAAgB,EACzB,aAAa,SAAkB,GAC9B,OAAO,CAAC,IAAI,CAAC,CA6Bf;AAED;;GAEG;AACH,eAAO,MAAM,eAAe,6BAAuB,CAAC"}
+{"version":3,"file":"scaffold.d.ts","sourceRoot":"","sources":["../../src/new/scaffold.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,gBAAgB,EAAkB,MAAM,YAAY,CAAC;AAqnEnE;;;;;;GAMG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,gBAAgB,EACzB,aAAa,SAAkB,GAC9B,OAAO,CAAC,IAAI,CAAC,CA6Bf;AAED;;GAEG;AACH,eAAO,MAAM,eAAe,6BAAuB,CAAC"}

package/dist/new/scaffold.js

@@ -27,20 +27,21 @@ const PUBLISHED_RUNTIME_DEPENDENCIES = {
   nats: '^2.29.3'
 };
 const PUBLISHED_INTERNAL_DEPENDENCIES = {
-  '@fluojs/cli': '^1.0.0-beta.2',
-  '@fluojs/config': '^1.0.0-beta.1',
-  '@fluojs/core': '^1.0.0-beta.1',
-  '@fluojs/di': '^1.0.0-beta.1',
-  '@fluojs/http': '^1.0.0-beta.1',
-  '@fluojs/microservices': '^1.0.0-beta.1',
-  '@fluojs/platform-bun': '^1.0.0-beta.1',
-  '@fluojs/platform-cloudflare-workers': '^1.0.0-beta.1',
-  '@fluojs/platform-deno': '^1.0.0-beta.1',
-  '@fluojs/platform-express': '^1.0.0-beta.1',
-  '@fluojs/platform-fastify': '^1.0.0-beta.2',
-  '@fluojs/platform-nodejs': '^1.0.0-beta.1',
-  '@fluojs/runtime': '^1.0.0-beta.1',
-  '@fluojs/testing': '^1.0.0-beta.1'
+  '@fluojs/cli': '^1.0.0-beta.3',
+  '@fluojs/config': '^1.0.0-beta.5',
+  '@fluojs/core': '^1.0.0-beta.3',
+  '@fluojs/di': '^1.0.0-beta.6',
+  '@fluojs/http': '^1.0.0-beta.9',
+  '@fluojs/microservices': '^1.0.0-beta.3',
+  '@fluojs/platform-bun': '^1.0.0-beta.6',
+  '@fluojs/platform-cloudflare-workers': '^1.0.0-beta.2',
+  '@fluojs/platform-deno': '^1.0.0-beta.3',
+  '@fluojs/platform-express': '^1.0.0-beta.6',
+  '@fluojs/platform-fastify': '^1.0.0-beta.8',
+  '@fluojs/platform-nodejs': '^1.0.0-beta.4',
+  '@fluojs/runtime': '^1.0.0-beta.9',
+  '@fluojs/testing': '^1.0.0-beta.2',
+  '@fluojs/validation': '^1.0.0-beta.2'
 };
 function describeApplicationStarter(options) {
   if (options.runtime === 'bun') {
@@ -146,32 +147,36 @@ function createProjectScripts(bootstrapPlan) {
   switch (bootstrapPlan.profile.id) {
     case 'application-bun-bun-http':
       return {
-        build: 'bun build ./src/main.ts --outdir ./dist --target bun',
-        dev: 'bun --watch src/main.ts',
+        build: 'fluo build',
+        dev: 'fluo dev',
+        start: 'fluo start',
         test: 'vitest run',
         'test:watch': 'vitest',
         typecheck: 'tsc -p tsconfig.json --noEmit'
       };
     case 'application-deno-deno-http':
       return {
-        build: 'mkdir -p dist && deno compile --allow-env --allow-net --output dist/app src/main.ts',
-        dev: 'deno run --allow-env --allow-net --watch src/main.ts',
+        build: 'fluo build',
+        dev: 'fluo dev',
+        start: 'fluo start',
         test: 'deno test --allow-env --allow-net',
         'test:watch': 'deno test --allow-env --allow-net --watch',
         typecheck: 'deno check src/main.ts src/app.test.ts'
       };
     case 'application-cloudflare-workers-cloudflare-workers-http':
       return {
-        build: 'wrangler deploy --dry-run',
-        dev: 'wrangler dev',
+        build: 'fluo build',
+        dev: 'fluo dev',
+        start: 'fluo start',
         test: 'vitest run',
         'test:watch': 'vitest',
         typecheck: 'tsc -p tsconfig.json --noEmit'
       };
     default:
       return {
-        build: 'babel src --extensions .ts --out-dir dist --config-file ./babel.config.cjs && tsc -p tsconfig.build.json',
-        dev: 'node --env-file=.env --watch --watch-preserve-output --import tsx src/main.ts',
+        build: 'fluo build',
+        dev: 'fluo dev',
+        start: 'fluo start',
         test: 'vitest run',
         'test:watch': 'vitest',
         typecheck: 'tsc -p tsconfig.json --noEmit'
@@ -280,9 +285,49 @@ function createBabelConfig() {
 `;
 }
 function createViteConfig() {
-  return `import { defineConfig } from 'vite';
+  return `import { transformAsync } from '@babel/core';
+import type { Plugin } from 'vite';
+import { defineConfig } from 'vite';
+
+function fluoDecoratorsPlugin(): Plugin {
+  return {
+    name: 'fluo-babel-decorators',
+    async transform(code: string, id: string) {
+      if (!id.endsWith('.ts') || id.includes('.test.')) {
+        return null;
+      }
+
+      const result = await transformAsync(code, {
+        babelrc: false,
+        configFile: false,
+        filename: id,
+        plugins: [['@babel/plugin-proposal-decorators', { version: '2023-11' }]],
+        presets: [['@babel/preset-typescript', { allowDeclareFields: true }]],
+        sourceMaps: true,
+      });
+
+      if (!result?.code) {
+        return null;
+      }
+
+      return { code: result.code, map: result.map };
+    },
+  };
+}
 
 export default defineConfig({
+  plugins: [fluoDecoratorsPlugin()],
+  build: {
+    emptyOutDir: true,
+    outDir: 'dist',
+    rollupOptions: {
+      output: {
+        entryFileNames: 'main.js',
+      },
+    },
+    ssr: 'src/main.ts',
+    target: 'node20',
+  },
   server: {
     port: 5173,
   },
@@ -327,7 +372,7 @@ Generated by @fluojs/cli.
 - Starter contract: ${starterContract}
 - Default baseline: when you omit \`--platform\`, \`fluo new\` still generates the Node.js + Fastify HTTP starter by default
 - Broader runtime/adapter package coverage is documented in the fluo docs and package READMEs; this generated starter intentionally describes only the wired starter path above
-- Package manager: install/run commands can use ${options.packageManager}; runtime choice stays explicit and is independent from the package manager you picked
+- Package manager: install/run commands can use ${options.packageManager}; ${createRunCommand(options.packageManager, 'dev')}, ${createRunCommand(options.packageManager, 'build')}, and ${createRunCommand(options.packageManager, 'start')} delegate to \`fluo dev\`, \`fluo build\`, and \`fluo start\`, which own the generated runtime lifecycle and default \`NODE_ENV\` when unset
 - Runtime dependency set: generated manifest entries match the selected runtime contract instead of inheriting the Node-only starter recipe
 ${corsLine}
 - Observability: /health and /ready endpoints are included by default
@@ -337,6 +382,7 @@ ${corsLine}
 ## Commands
 
 - Dev: ${createRunCommand(options.packageManager, 'dev')}
+- Start: ${createRunCommand(options.packageManager, 'start')}
 - Build: ${createRunCommand(options.packageManager, 'build')}
 - Typecheck: ${createRunCommand(options.packageManager, 'typecheck')}
 - Test: ${createRunCommand(options.packageManager, 'test')}
@@ -451,7 +497,7 @@ Generated by @fluojs/cli.
 - Transport: \`${starter.readmeTransportLabel}\` is the generated runnable starter contract for this project
 - Runtime: \`node\`
 - Platform: \`none\` because the microservice starter boots through \`@fluojs/microservices\`, not an HTTP adapter
-- Package manager: install/run commands can use ${options.packageManager}; ${starter.packageManagerNote}
+- Package manager: install/run commands can use ${options.packageManager}; ${createRunCommand(options.packageManager, 'dev')}, ${createRunCommand(options.packageManager, 'build')}, and ${createRunCommand(options.packageManager, 'start')} delegate to \`fluo dev\`, \`fluo build\`, and \`fluo start\`, which own the generated runtime lifecycle and default \`NODE_ENV\` when unset; ${starter.packageManagerNote}
 - Messaging contract: \`src/math/math.handler.ts\` exposes a \`${starter.pattern}\` message pattern and the generated tests verify it through an in-memory transport so the starter stays testable without external brokers
 - Entrypoint contract: ${starter.entrypointNote}
 - Starter contract note: ${starter.starterNote}
@@ -460,6 +506,7 @@ Generated by @fluojs/cli.
 ## Commands
 
 - Dev: ${createRunCommand(options.packageManager, 'dev')}
+- Start: ${createRunCommand(options.packageManager, 'start')}
 - Build: ${createRunCommand(options.packageManager, 'build')}
 - Typecheck: ${createRunCommand(options.packageManager, 'typecheck')}
 - Test: ${createRunCommand(options.packageManager, 'test')}
@@ -610,12 +657,14 @@ describe('HealthService', () => {
 `;
 }
 function createHealthControllerFile(importSuffix = '') {
-  return `import { Inject } from '@fluojs/core';
+  return `import { ensureMetadataSymbol, Inject } from '@fluojs/core';
 import { Controller, Get } from '@fluojs/http';
 
 import { HealthService } from './health.service${importSuffix}';
 import { HealthResponseDto } from './health.response.dto${importSuffix}';
 
+ensureMetadataSymbol();
+
 @Inject(HealthService)
 @Controller('/health-info')
 export class HealthController {
@@ -1364,12 +1413,13 @@ Generated by @fluojs/cli.
 
 - Shape: \`mixed\`
 - Supported topology: \`single-package\` generates one shared Node.js package where the Fastify HTTP application also starts an attached TCP microservice from the same \`src/main.ts\`
-- Runtime contract: \`src/app.ts\` owns one shared module graph, and \`src/main.ts\` bootstraps the HTTP API before calling \`connectMicroservice()\` and \`startAllMicroservices()\`
+- Runtime contract: \`src/app.ts\` owns one shared module graph, and \`src/main.ts\` bootstraps the HTTP API before calling \`connectMicroservice()\` and \`startAllMicroservices()\`; ${createRunCommand(options.packageManager, 'dev')}, ${createRunCommand(options.packageManager, 'build')}, and ${createRunCommand(options.packageManager, 'start')} delegate to \`fluo dev\`, \`fluo build\`, and \`fluo start\`, which default \`NODE_ENV\` when unset
 - Intentional limitation: the first mixed release supports only the explicit Fastify HTTP + attached TCP microservice contract; other mixed transports or separate multi-entrypoint layouts fail validation instead of generating partial scaffolds
 
 ## Commands
 
 - Dev: ${createRunCommand(options.packageManager, 'dev')}
+- Start: ${createRunCommand(options.packageManager, 'start')}
 - Build: ${createRunCommand(options.packageManager, 'build')}
 - Typecheck: ${createRunCommand(options.packageManager, 'typecheck')}
 - Test: ${createRunCommand(options.packageManager, 'test')}

package/dist/update-check.d.ts

@@ -41,6 +41,7 @@ export type UpdatePrompter = {
  * Describes the cli update check runtime options contract.
  */
 export interface CliUpdateCheckRuntimeOptions {
+    bypassCache?: boolean;
     cacheFile?: string;
     cacheTtlMs?: number;
     ci?: boolean;

package/dist/update-check.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"update-check.d.ts","sourceRoot":"","sources":["../src/update-check.ts"],"names":[],"mappings":"AAOA,KAAK,SAAS,GAAG;IACf,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC;CACjC,CAAC;AAEF,KAAK,iBAAiB,GAAG;IACvB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC;AAcF;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAC5B;IACE,MAAM,EAAE,UAAU,CAAC;CACpB,GACD;IACE,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEN;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,yDAAyD;AACzD,MAAM,MAAM,oBAAoB,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,CAAC;AAEnE;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC;IACvB,MAAM,EAAE,SAAS,CAAC;CACnB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACnE,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,4BAA4B;IAC3C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,EAAE,CAAC,EAAE,OAAO,CAAC;IACb,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,kBAAkB,CAAC,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IAC1E,cAAc,CAAC,EAAE,CAAC,cAAc,EAAE,oBAAoB,EAAE,OAAO,EAAE,oBAAoB,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IAC1G,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,GAAG,CAAC,EAAE,MAAM,IAAI,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,oBAAoB,CAAC;IACtC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,cAAc,CAAC;IACxB,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,oBAAoB,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IAC9E,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB,KAAK,CAAC,EAAE,iBAAiB,CAAC;IAC1B,MAAM,CAAC,EAAE,SAAS,CAAC;CACpB;AAscD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG;IAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,eAAe,EAAE,OAAO,CAAA;CAAE,CAcnG;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,OAAO,GAAE,4BAAiC,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAkEjI"}
+{"version":3,"file":"update-check.d.ts","sourceRoot":"","sources":["../src/update-check.ts"],"names":[],"mappings":"AAOA,KAAK,SAAS,GAAG;IACf,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC;CACjC,CAAC;AAEF,KAAK,iBAAiB,GAAG;IACvB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC;AAcF;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAC5B;IACE,MAAM,EAAE,UAAU,CAAC;CACpB,GACD;IACE,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEN;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,yDAAyD;AACzD,MAAM,MAAM,oBAAoB,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,CAAC;AAEnE;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC;IACvB,MAAM,EAAE,SAAS,CAAC;CACnB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACnE,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,4BAA4B;IAC3C,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,EAAE,CAAC,EAAE,OAAO,CAAC;IACb,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,kBAAkB,CAAC,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IAC1E,cAAc,CAAC,EAAE,CAAC,cAAc,EAAE,oBAAoB,EAAE,OAAO,EAAE,oBAAoB,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IAC1G,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,GAAG,CAAC,EAAE,MAAM,IAAI,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,oBAAoB,CAAC;IACtC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,cAAc,CAAC;IACxB,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,oBAAoB,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IAC9E,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB,KAAK,CAAC,EAAE,iBAAiB,CAAC;IAC1B,MAAM,CAAC,EAAE,SAAS,CAAC;CACpB;AAycD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG;IAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,eAAe,EAAE,OAAO,CAAA;CAAE,CAcnG;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,OAAO,GAAE,4BAAiC,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAmEjI"}

package/dist/update-check.js

@@ -204,10 +204,12 @@ async function fetchLatestDistTag(packageName) {
     clearTimeout(timeout);
   }
 }
-async function resolveLatestVersion(packageName, cacheFile, cacheTtlMs, nowMs, fetchLatestVersion) {
-  const cachedLatestVersion = await readCachedLatestVersion(cacheFile, nowMs, cacheTtlMs);
-  if (cachedLatestVersion) {
-    return cachedLatestVersion;
+async function resolveLatestVersion(packageName, cacheFile, cacheTtlMs, nowMs, fetchLatestVersion, bypassCache) {
+  if (!bypassCache) {
+    const cachedLatestVersion = await readCachedLatestVersion(cacheFile, nowMs, cacheTtlMs);
+    if (cachedLatestVersion) {
+      return cachedLatestVersion;
+    }
   }
   let latestVersion;
   try {
@@ -429,7 +431,7 @@ export async function runCliUpdateCheck(argv, options = {}) {
       action: 'continue'
     };
   }
-  const latestVersion = await resolveLatestVersion(packageName, cacheFile, cacheTtlMs, nowMs, options.fetchLatestVersion ?? fetchLatestDistTag);
+  const latestVersion = await resolveLatestVersion(packageName, cacheFile, cacheTtlMs, nowMs, options.fetchLatestVersion ?? fetchLatestDistTag, options.bypassCache === true);
   if (!latestVersion || !isNewerVersion(latestVersion, currentVersion)) {
     return {
       action: 'continue'