@fluojs/cli 1.0.0-beta.4 → 1.0.0-beta.6

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

@@ -0,0 +1,317 @@
+import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { existsSync, readdirSync, readFileSync, statSync, watch } from 'node:fs';
+import { basename, dirname, join, relative, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+/** Runtime target handled by the fluo-owned development restart runner. */
+
+/** Options used to configure the fluo-owned Node restart-on-watch process boundary. */
+
+const DEFAULT_DEBOUNCE_MS = 100;
+const PRETTY_TTY_COLOR_ENV = 'FLUO_DEV_PRETTY_TTY_COLOR';
+const DEFAULT_IGNORES = ['.cache', '.fluo', '.git', '.turbo', 'coverage', 'dist', 'node_modules', '*.swp', '*.swo', '*~', '.#*'];
+const WATCH_FILES = ['.env', 'package.json', 'tsconfig.json', 'tsconfig.build.json'];
+const SHOW_NODE_RESTART_NOTICE_ENV = 'FLUO_DEV_SHOW_RESTART_NOTICE';
+const CLEAR_SCREEN = '\u001B[2J\u001B[3J\u001B[H';
+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');
+  }
+}
+function getPreserveColorTtyImport() {
+  return join(dirname(dirname(fileURLToPath(import.meta.url))), 'dev-runner', 'preserve-color-tty.js');
+}
+function buildNodeAppArgs(env, appArgs) {
+  const colorTtyImport = env[PRETTY_TTY_COLOR_ENV] === '1' ? ['--import', getPreserveColorTtyImport()] : [];
+  return ['--env-file=.env', ...colorTtyImport, '--import', 'tsx', 'src/main.ts', ...appArgs];
+}
+function buildBunAppArgs(env, appArgs) {
+  const colorTtyPreload = env[PRETTY_TTY_COLOR_ENV] === '1' ? ['--preload', getPreserveColorTtyImport()] : [];
+  return [...colorTtyPreload, 'src/main.ts', ...appArgs];
+}
+function buildAppCommand(runtime, env, appArgs) {
+  switch (runtime) {
+    case 'bun':
+      return {
+        command: 'bun',
+        args: buildBunAppArgs(env, appArgs)
+      };
+    case 'cloudflare-workers':
+      return {
+        command: 'wrangler',
+        args: ['dev', '--show-interactive-dev-session=false', ...appArgs]
+      };
+    case 'deno':
+      return {
+        command: 'deno',
+        args: ['run', '--allow-env', '--allow-net', 'src/main.ts', ...appArgs]
+      };
+    default:
+      return {
+        command: process.execPath,
+        args: buildNodeAppArgs(env, appArgs)
+      };
+  }
+}
+function readDevScriptHeader(projectDirectory) {
+  const fallbackName = basename(projectDirectory);
+  try {
+    const manifest = JSON.parse(readFileSync(join(projectDirectory, 'package.json'), 'utf8'));
+    const name = typeof manifest.name === 'string' && manifest.name.length > 0 ? manifest.name : fallbackName;
+    const version = typeof manifest.version === 'string' && manifest.version.length > 0 ? `@${manifest.version}` : '';
+    const devScript = typeof manifest.scripts?.dev === 'string' && manifest.scripts.dev.length > 0 ? manifest.scripts.dev : 'fluo dev';
+    return `> ${name}${version} dev ${projectDirectory}\n> ${devScript}\n\n`;
+  } catch (_error) {
+    return `> ${fallbackName} dev ${projectDirectory}\n> fluo dev\n\n`;
+  }
+}
+function redrawDevScriptHeader(stdout, projectDirectory, env) {
+  if (env[SHOW_NODE_RESTART_NOTICE_ENV] !== '1') {
+    return;
+  }
+  stdout.write(CLEAR_SCREEN);
+  stdout.write(readDevScriptHeader(projectDirectory));
+}
+
+/**
+ * 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 runnerRuntime = options.runtime ?? 'node';
+  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) => {
+    const appCommand = buildAppCommand(runnerRuntime, env, appArgs);
+    child = spawnChild(appCommand.command, appCommand.args, {
+      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;
+      }
+      if (env[SHOW_NODE_RESTART_NOTICE_ENV] === '1') {
+        stdout.write(`[fluo] restarting after content change: ${relative(projectDirectory, restartPaths[restartPaths.length - 1] ?? projectDirectory)}\n`);
+      }
+      const previousChild = child;
+      const startReplacementChild = () => {
+        redrawDevScriptHeader(stdout, projectDirectory, env);
+        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;
+          }
+          redrawDevScriptHeader(stdout, projectDirectory, env);
+          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/dev-runner/preserve-color-tty.d.ts

@@ -0,0 +1,2 @@
+declare function preserveTtyColorDetection(stream: NodeJS.WriteStream): void;
+//# sourceMappingURL=preserve-color-tty.d.ts.map

package/dist/dev-runner/preserve-color-tty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preserve-color-tty.d.ts","sourceRoot":"","sources":["../../src/dev-runner/preserve-color-tty.ts"],"names":[],"mappings":"AAAA,iBAAS,yBAAyB,CAAC,MAAM,EAAE,MAAM,CAAC,WAAW,GAAG,IAAI,CASnE"}

package/dist/dev-runner/preserve-color-tty.js

@@ -0,0 +1,12 @@
+function preserveTtyColorDetection(stream) {
+  try {
+    Object.defineProperty(stream, 'isTTY', {
+      configurable: true,
+      value: true
+    });
+  } catch (_error) {
+    return;
+  }
+}
+preserveTtyColorDetection(process.stdout);
+preserveTtyColorDetection(process.stderr);

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;AAokEnE;;;;;;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;AAkoEnE;;;;;;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"}