@nexusts/cli 0.9.7 → 0.9.8

package/dist/index.js

@@ -45,6 +45,12 @@ function parseArgs(argv) {
     if (longMatch) {
       const [, name, inline] = longMatch;
       const flagName = name;
+      if (flagName.startsWith("no-")) {
+        const key = flagName.slice(3);
+        setFlag(flags, key, false);
+        i++;
+        continue;
+      }
       if (inline !== undefined) {
         setFlag(flags, flagName, inline);
         i++;
@@ -168,7 +174,8 @@ async function loadConfig(cwd = process.cwd()) {
           const mod = await import(path);
           config = mod.default ?? mod;
         } catch (importErr) {
-          console.warn(`[nx] Could not dynamically import ${candidate}: ${importErr instanceof Error ? importErr.message : String(importErr)}. Falling back to defaults.`);
+          process.stderr.write(`[nx] Could not dynamically import ${candidate}: ${importErr instanceof Error ? importErr.message : String(importErr)}. Falling back to defaults.
+`);
           config = {};
         }
       }
@@ -247,6 +254,118 @@ import {
   writeFileSync
 } from "fs";
 import { dirname, isAbsolute, relative, resolve as resolve2 } from "path";
+
+// packages/cli/src/core/template.ts
+var VAR_RE = /\{\{\s*([\w.]+)(?:\s*\|\s*(\w+))?\s*\}\}/;
+var SECTION_RE = /\{\{\s*([#^])\s*([\w.]+)\s*\}\}([\s\S]*?)\{\{\s*\/\s*\2\s*\}\}/g;
+function render(template, context) {
+  let out = template.replace(SECTION_RE, (_, kind, key, body) => {
+    const v = lookup(context, key);
+    const truthy = isTruthy(v);
+    if (kind === "#")
+      return truthy ? body : "";
+    return truthy ? "" : body;
+  });
+  let prev;
+  do {
+    prev = out;
+    out = out.replace(VAR_RE, (_, key, filter) => {
+      const v = lookup(context, key);
+      return applyFilter(v === undefined || v === null ? "" : String(v), filter);
+    });
+  } while (out !== prev);
+  return out;
+}
+function lookup(ctx, dotted) {
+  if (dotted in ctx)
+    return ctx[dotted];
+  const parts = dotted.split(".");
+  let cur = ctx;
+  for (const p of parts) {
+    if (cur == null || typeof cur !== "object")
+      return;
+    cur = cur[p];
+  }
+  return cur === undefined || cur === null ? undefined : cur;
+}
+function isTruthy(v) {
+  if (v === undefined || v === null)
+    return false;
+  if (typeof v === "string")
+    return v.length > 0 && v !== "false" && v !== "0";
+  if (typeof v === "number")
+    return v !== 0;
+  if (typeof v === "boolean")
+    return v;
+  if (Array.isArray(v))
+    return v.length > 0;
+  return Object.keys(v).length > 0;
+}
+function applyFilter(value, filter) {
+  switch (filter) {
+    case undefined:
+    case "raw":
+      return value;
+    case "upper":
+      return value.toUpperCase();
+    case "lower":
+      return value.toLowerCase();
+    case "pascal":
+      return toPascal(value);
+    case "camel":
+      return toCamel(value);
+    case "snake":
+      return toSnake(value);
+    case "kebab":
+      return toKebab(value);
+    case "plural":
+      return pluralize(value);
+    case "singular":
+      return singularize(value);
+    default:
+      throw new Error(`Unknown template filter: ${filter}`);
+  }
+}
+function splitWords(s) {
+  return s.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[\s_-]+/).filter(Boolean);
+}
+function toPascal(s) {
+  return splitWords(s).map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join("");
+}
+function toCamel(s) {
+  const p = toPascal(s);
+  return p.charAt(0).toLowerCase() + p.slice(1);
+}
+function toSnake(s) {
+  return splitWords(s).map((w) => w.toLowerCase()).join("_");
+}
+function toKebab(s) {
+  return splitWords(s).map((w) => w.toLowerCase()).join("-");
+}
+function pluralize(s) {
+  if (!s)
+    return s;
+  if (/(s|x|z|ch|sh)$/i.test(s))
+    return `${s}es`;
+  if (/[^aeiou]y$/i.test(s))
+    return `${s.slice(0, -1)}ies`;
+  if (/y$/i.test(s))
+    return `${s}s`;
+  return `${s}s`;
+}
+function singularize(s) {
+  if (!s)
+    return s;
+  if (/(ses|xes|zes|ches|shes)$/i.test(s))
+    return s.slice(0, -2);
+  if (/ies$/i.test(s))
+    return `${s.slice(0, -3)}y`;
+  if (/s$/i.test(s) && s.length > 1)
+    return s.slice(0, -1);
+  return s;
+}
+
+// packages/cli/src/core/fs.ts
 function writeFile(path, contents, opts = {}) {
   const base = opts.base ?? process.cwd();
   const target = isAbsolute(path) ? path : resolve2(base, path);
@@ -273,17 +392,6 @@ function nameVariants(input) {
     pluralKebab: pluralize(kebab)
   };
 }
-function pluralize(s) {
-  if (!s)
-    return s;
-  if (/(s|x|z|ch|sh)$/i.test(s))
-    return `${s}es`;
-  if (/[^aeiou]y$/i.test(s))
-    return `${s.slice(0, -1)}ies`;
-  if (/y$/i.test(s))
-    return `${s}s`;
-  return `${s}s`;
-}
 // packages/cli/src/core/logger.ts
 var USE_COLOR = process.env.NO_COLOR === undefined && process.env.FORCE_COLOR !== "0" && process.stdout.isTTY === true;
 var wrap = (open, close) => (s) => USE_COLOR ? `\x1B[${open}m${s}\x1B[${close}m` : s;
@@ -384,115 +492,32 @@ async function prompt(message, options = {}) {
 async function select(message, choices, options = {}) {
   return prompt(message, { ...options, choices });
 }
-// packages/cli/src/core/template.ts
-var VAR_RE = /\{\{\s*([\w.]+)(?:\s*\|\s*(\w+))?\s*\}\}/;
-var SECTION_RE = /\{\{\s*([#^])\s*([\w.]+)\s*\}\}([\s\S]*?)\{\{\s*\/\s*\2\s*\}\}/g;
-function render(template, context) {
-  let out = template.replace(SECTION_RE, (_, kind, key, body) => {
-    const v = lookup(context, key);
-    const truthy = isTruthy(v);
-    if (kind === "#")
-      return truthy ? body : "";
-    return truthy ? "" : body;
-  });
-  let prev;
-  do {
-    prev = out;
-    out = out.replace(VAR_RE, (_, key, filter) => {
-      const v = lookup(context, key);
-      return applyFilter(v === undefined || v === null ? "" : String(v), filter);
-    });
-  } while (out !== prev);
-  return out;
-}
-function lookup(ctx, dotted) {
-  if (dotted in ctx)
-    return ctx[dotted];
-  const parts = dotted.split(".");
-  let cur = ctx;
-  for (const p of parts) {
-    if (cur == null || typeof cur !== "object")
-      return;
-    cur = cur[p];
+var VALID_PROJECT_OPTIONS = {
+  style: ["nest", "adonis", "functional"],
+  view: ["rendu", "edge", "eta", "inertia", "none"],
+  orm: ["drizzle", "kysely", "none"],
+  db: ["bun-sqlite", "node-sqlite", "libsql", "postgres", "mysql", "none"],
+  frontend: ["react", "vue", "svelte", "solid"]
+};
+async function resolveProjectOption(flags, key, valid, defaultVal, interactive) {
+  const flagVal = flags[key];
+  if (flagVal) {
+    if (valid.includes(flagVal))
+      return flagVal;
+    if (!interactive) {
+      logger.error(`Invalid --${key} "${flagVal}". Valid values: ${valid.join(", ")}`);
+      process.exit(1);
+    }
+    logger.warn(`"${flagVal}" is not valid for --${key}. Please choose from the list.`);
   }
-  return cur === undefined || cur === null ? undefined : cur;
-}
-function isTruthy(v) {
-  if (v === undefined || v === null)
-    return false;
-  if (typeof v === "string")
-    return v.length > 0 && v !== "false" && v !== "0";
-  if (typeof v === "number")
-    return v !== 0;
-  if (typeof v === "boolean")
-    return v;
-  if (Array.isArray(v))
-    return v.length > 0;
-  return Object.keys(v).length > 0;
-}
-function applyFilter(value, filter) {
-  switch (filter) {
-    case undefined:
-    case "raw":
-      return value;
-    case "upper":
-      return value.toUpperCase();
-    case "lower":
-      return value.toLowerCase();
-    case "pascal":
-      return toPascal(value);
-    case "camel":
-      return toCamel(value);
-    case "snake":
-      return toSnake(value);
-    case "kebab":
-      return toKebab(value);
-    case "plural":
-      return pluralize2(value);
-    case "singular":
-      return singularize(value);
-    default:
-      throw new Error(`Unknown template filter: ${filter}`);
+  const label = key === "style" ? "Routing style" : key === "view" ? "View engine" : key === "orm" ? "ORM driver" : key === "db" ? "Database driver" : "Inertia frontend";
+  for (;; ) {
+    const answer = await select(label, [...valid], { default: defaultVal });
+    if (valid.includes(answer))
+      return answer;
+    logger.warn(`"${answer}" is not valid. Please choose from: ${valid.join(", ")}`);
   }
 }
-function splitWords(s) {
-  return s.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[\s_-]+/).filter(Boolean);
-}
-function toPascal(s) {
-  return splitWords(s).map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join("");
-}
-function toCamel(s) {
-  const p = toPascal(s);
-  return p.charAt(0).toLowerCase() + p.slice(1);
-}
-function toSnake(s) {
-  return splitWords(s).map((w) => w.toLowerCase()).join("_");
-}
-function toKebab(s) {
-  return splitWords(s).map((w) => w.toLowerCase()).join("-");
-}
-function pluralize2(s) {
-  if (!s)
-    return s;
-  if (/(s|x|z|ch|sh)$/i.test(s))
-    return `${s}es`;
-  if (/[^aeiou]y$/i.test(s))
-    return `${s.slice(0, -1)}ies`;
-  if (/y$/i.test(s))
-    return `${s}s`;
-  return `${s}s`;
-}
-function singularize(s) {
-  if (!s)
-    return s;
-  if (/(ses|xes|zes|ches|shes)$/i.test(s))
-    return s.slice(0, -2);
-  if (/ies$/i.test(s))
-    return `${s.slice(0, -3)}y`;
-  if (/s$/i.test(s) && s.length > 1)
-    return s.slice(0, -1);
-  return s;
-}
 // packages/cli/src/core/version.ts
 import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
 import { resolve as resolve3, dirname as dirname2 } from "path";
@@ -517,7 +542,9 @@ import { resolve as resolve4 } from "path";
 
 // packages/cli/src/templates/controller/adonis.ts
 var adonis_default = `
+{{# hasService }}
 import { {{ service }} } from '../services/{{ kebab }}.service.js';
+{{/ hasService }}
 
 export class {{ name }}Controller {
   async index() {
@@ -580,7 +607,9 @@ export const {{ camel }}Routes = {
 var nest_default = `
 import { Controller, Delete, Get, Inject, Post, Put, inputValue } from '@nexusts/core';
 import type { Context } from 'hono';
+{{# hasService }}
 import { {{ service }} } from '../services/{{ kebab }}.service.js';
+{{/ hasService }}
 
 @Controller('/{{ kebab }}s')
 export class {{ name }}Controller {
@@ -993,11 +1022,202 @@ export class {{ repository }} extends KyselyRepository<any, '{{ tableName }}'> {
 }
 `.trimStart();
 
-// packages/cli/src/templates/service/service.ts
-var service_default = `
-import { Injectable, Inject } from '@nexusts/core';
-{{#hasRepo}}import { {{ repository }} } from '../repositories/{{ kebab }}.repository.js';{{/hasRepo}}
-
+// packages/cli/src/templates/auth/auth-instance.ts
+var auth_instance_default = `/**
+ * Better-auth instance \u2014 generated by \`nx make:auth\`.
+ *
+ * Edit \`nx.config.ts\` (\`auth\` section) instead of this file when possible.
+ */
+import { createAuth } from '@nexusts/auth';
+
+export const auth = createAuth({
+{{^jwt}}
+  jwt: { enabled: false },
+{{/jwt}}
+{{#jwt}}
+  jwt: { enabled: true },
+{{/jwt}}
+{{#passkey}}
+  passkey: {
+    enabled: true,
+    rpName: '{{ passkeyRpName }}',
+    rpId:   '{{ passkeyRpId }}',
+    origin: '{{ passkeyOrigin }}',
+  },
+{{/passkey}}
+{{#providers}}
+  socialProviders: {
+{{#entries}}
+    {{ name }}: {
+      clientId:     process.env.{{ envVar }}_CLIENT_ID!,
+      clientSecret: process.env.{{ envVar }}_CLIENT_SECRET!,
+    },
+{{/entries}}
+  },
+{{/providers}}
+});
+`.trimStart();
+
+// packages/cli/src/templates/auth/env-example.ts
+var env_example_default = `# Better Auth \u2014 generated by \`nx make:auth\`.
+# Generate a secret with: openssl rand -base64 32
+BETTER_AUTH_SECRET=
+BETTER_AUTH_URL=http://localhost:3000
+{{#providers}}
+{{#entries}}
+{{ envVar }}_CLIENT_ID=
+{{ envVar }}_CLIENT_SECRET=
+{{/entries}}
+{{/providers}}
+`.trimStart();
+
+// packages/cli/src/templates/listener/listener.ts
+var listener_default = `
+import { Inject, Injectable } from '@nexusts/core';
+import { EventService, OnEvent } from '@nexusts/events';
+
+/**
+ * {{ name }} listener \u2014 generated by \`nx make:listener {{ name }}\`.
+ *
+ * Register handlers below with \`@OnEvent(pattern)\`. Pair with
+ * \`scanForListeners(this, eventService)\` at boot.
+ */
+@Injectable()
+export class {{ name }}Listener {
+  @Inject(EventService.TOKEN) declare private readonly events: EventService;
+
+  // TODO: add @OnEvent('your.event') handlers below.
+
+  // @OnEvent('user.created')
+  // async onUserCreated(payload: { userId: string; email: string }) {
+  //   this.events; // unused \u2014 remove if you don't need it
+  // }
+}
+
+import { scanForListeners } from '@nexusts/events';
+
+/**
+ * Bootstrap helper \u2014 call this from your main.ts (or wherever you
+ * wire up the application) to register every \`@OnEvent\` handler
+ * on this listener class.
+ */
+export async function register{{ name }}(listener: {{ name }}Listener, events: EventService) {
+  return scanForListeners(listener, events);
+}
+`.trimStart();
+
+// packages/cli/src/templates/queue/worker.ts
+var worker_default = `
+import { Inject, Injectable } from '@nexusts/core';
+import { QueueService, OnQueueReady } from '@nexusts/queue';
+
+/**
+ * {{ name }} worker \u2014 generated by \`nx make:queue {{ name }}\`.
+ *
+ * Registers a handler for the \`{{ name }}\` job name on boot.
+ */
+@Injectable()
+export class {{ name }}Worker {
+  @Inject(QueueService.TOKEN) declare private readonly queue: QueueService;
+
+  @OnQueueReady()
+  async register(): Promise<void> {
+    await this.queue.process('{{ name }}', async (data, ctx) => {
+      ctx.prefix; // \u2192 "[queue:{{ name }}]"
+      try {
+        await this.handle(data as {{ name }}Data);
+        return { status: 'completed' };
+      } catch (err) {
+        return {
+          status: 'failed',
+          error: err instanceof Error ? err : new Error(String(err)),
+          willRetry: ctx.attempts < 3,
+        };
+      }
+    });
+  }
+
+  /**
+   * Replace this body with your actual worker logic.
+   */
+  async handle(data: {{ name }}Data): Promise<void> {
+    // TODO: implement
+  }
+}
+
+/**
+ * Typed payload for the \`{{ name }}\` job.
+ */
+export interface {{ name }}Data {
+  // TODO: define fields
+  [key: string]: unknown;
+}
+`.trimStart();
+
+// packages/cli/src/templates/queue/job.ts
+var job_default = `
+import { Inject, Injectable } from '@nexusts/core';
+import { QueueService } from '@nexusts/queue';
+import type { {{ name }}Data } from './{{ kebab }}.worker.js';
+
+/**
+ * Helper for enqueuing \`{{ name }}\` jobs from controllers / services.
+ * Generated by \`nx make:queue {{ name }}\`.
+ */
+@Injectable()
+export class {{ name }}Job {
+  @Inject(QueueService.TOKEN) declare private readonly queue: QueueService;
+
+  /** Enqueue a single {{ name }} job. */
+  async enqueue(data: {{ name }}Data, options?: {
+    delaySeconds?: number;
+    attempts?: number;
+  }) {
+    return this.queue.add('{{ name }}', data, options);
+  }
+
+  /** Enqueue many at once. */
+  async enqueueBatch(items: {{ name }}Data[]) {
+    return this.queue.addBatch(
+      items.map((data) => ({ name: '{{ name }}', data })),
+    );
+  }
+}
+`.trimStart();
+
+// packages/cli/src/templates/schedule/task.ts
+var task_default = `
+import { Injectable } from '@nexusts/core';
+import { Cron, Interval, Timeout } from '@nexusts/schedule';
+
+/**
+ * {{ name }} task \u2014 generated by \`nx make:schedule {{ name }}\`.
+ *
+ * Mark methods with \`@Cron\`, \`@Interval\`, or \`@Timeout\`.
+ * Auto-detected at boot \u2014 no manual registration needed.
+ */
+@Injectable()
+export class {{ name }}Task {
+  constructor() {}
+
+  // TODO: add @Cron, @Interval, or @Timeout handlers below.
+
+  // @Cron('0 * * * *')                          // every hour
+  // async hourly() { /* ... */ }
+
+  // @Interval(60_000)                         // every minute
+  // async tick() { /* ... */ }
+
+  // @Timeout(5_000)                            // 5s after boot
+  // async startup() { /* ... */ }
+}
+`.trimStart();
+
+// packages/cli/src/templates/service/service.ts
+var service_default = `
+import { Injectable, Inject } from '@nexusts/core';
+{{#hasRepo}}import { {{ repository }} } from '../repositories/{{ kebab }}.repository.js';{{/hasRepo}}
+
 @Injectable()
 export class {{ name }}Service {
   {{#hasRepo}}@Inject({{ repository }}) declare {{ repositoryCamel }}: {{ repository }};{{/hasRepo}}
@@ -1029,6 +1249,52 @@ export class {{ name }}Service {
 }
 `.trimStart();
 
+// packages/cli/src/templates/session/session.ts
+var session_default = `
+import { Inject, Injectable } from '@nexusts/core';
+import { SessionService } from '@nexusts/session';
+import type { SessionRecord } from '@nexusts/session';
+
+/**
+ * {{ name }} session helper \u2014 generated by \`nx make:session {{ name }}\`.
+ *
+ * Wraps SessionService with typed accessors for the {{ name }} session's
+ * data. Use from controllers / services.
+ */
+@Injectable()
+export class {{ name }}Session {
+  @Inject(SessionService.TOKEN) declare private readonly sessions: SessionService;
+
+  /** Read the current session record (or null). */
+  async getCurrent(sessionId: string | null | undefined) {
+    if (!sessionId) return null;
+    return this.sessions.read(sessionId);
+  }
+
+  /** Patch the {{ name }} session's data. */
+  async update(sessionId: string, patch: {{ name }}DataPatch) {
+    return this.sessions.update(sessionId, { dataPatch: patch });
+  }
+
+  /** Destroy the session (logout-everywhere equivalent). */
+  async destroy(sessionId: string) {
+    return this.sessions.destroy(sessionId, 'logout');
+  }
+}
+
+/**
+ * Typed payload for the {{ name }} session.
+ *
+ * TODO: define the fields below to match your feature.
+ */
+export interface {{ name }}Data {
+  // userId?: string;
+  // createdAt?: string;
+}
+
+export type {{ name }}DataPatch = Partial<{{ name }}Data>;
+`.trimStart();
+
 // packages/cli/src/templates/validator/validator.ts
 var validator_default = `
 import { z } from 'zod';
@@ -1053,7 +1319,18 @@ var templates = {
     adonis: adonis_default,
     functional: functional_default
   },
+  auth: {
+    instance: auth_instance_default,
+    "env.example": env_example_default
+  },
+  listener: listener_default,
+  queue: {
+    worker: worker_default,
+    job: job_default
+  },
+  schedule: task_default,
   service: service_default,
+  session: session_default,
   repository: {
     drizzle: repository_default,
     kysely: kysely_repository_default
@@ -1445,6 +1722,22 @@ bunx nx make:crud Post
 `);
   return created;
 }
+// packages/cli/src/core/naming.ts
+function inferTableName(input) {
+  if (!input)
+    return "table";
+  const m = /^create_(\w+)_table$/.exec(input);
+  if (m)
+    return m[1] ?? "table";
+  const m2 = /^(?:add|remove|drop|alter)_(\w+)_to_(\w+)$/.exec(input);
+  if (m2)
+    return m2[2] ?? "table";
+  return `${input.toLowerCase().replace(/s$/, "")}s`;
+}
+function formatTimestamp(d) {
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}` + `_${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
+}
 // packages/cli/src/commands/info.ts
 var infoCommand = {
   name: "info",
@@ -1506,32 +1799,6 @@ var info_default = infoCommand;
 // packages/cli/src/commands/init.ts
 import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
 import { resolve as resolve6 } from "path";
-var VALID_OPTIONS = {
-  style: ["nest", "adonis", "functional"],
-  view: ["rendu", "edge", "eta", "inertia", "none"],
-  orm: ["drizzle", "kysely", "none"],
-  db: ["bun-sqlite", "node-sqlite", "libsql", "postgres", "mysql", "none"],
-  frontend: ["react", "vue", "svelte", "solid"]
-};
-async function resolveOpt(flags, key, valid, defaultVal, interactive) {
-  const flagVal = flags[key];
-  if (flagVal) {
-    if (valid.includes(flagVal))
-      return flagVal;
-    if (!interactive) {
-      logger.error(`Invalid --${key} "${flagVal}". Valid values: ${valid.join(", ")}`);
-      process.exit(1);
-    }
-    logger.warn(`"${flagVal}" is not valid for --${key}. Please choose from the list.`);
-  }
-  const label = key === "style" ? "Routing style" : key === "view" ? "View engine" : key === "orm" ? "ORM driver" : key === "db" ? "Database driver" : "Inertia frontend";
-  for (;; ) {
-    const answer = await select(label, [...valid], { default: defaultVal });
-    if (valid.includes(answer))
-      return answer;
-    logger.warn(`"${answer}" is not valid. Please choose from: ${valid.join(", ")}`);
-  }
-}
 var initCommand = {
   name: "init",
   aliases: ["i"],
@@ -1561,11 +1828,11 @@ var initCommand = {
     const interactive = flagBool(ctx.flags, "interaction", true);
     const force = flagBool(ctx.flags, "force", false);
     const target = resolve6(ctx.cwd, ctx.flags.target ?? ".");
-    const routing = await resolveOpt(ctx.flags, "style", VALID_OPTIONS.style, "nest", interactive);
-    const view = await resolveOpt(ctx.flags, "view", VALID_OPTIONS.view, "rendu", interactive);
-    const orm = await resolveOpt(ctx.flags, "orm", VALID_OPTIONS.orm, "drizzle", interactive);
-    const db = await resolveOpt(ctx.flags, "db", VALID_OPTIONS.db, "bun-sqlite", interactive);
-    const frontend = await resolveOpt(ctx.flags, "frontend", VALID_OPTIONS.frontend, "react", interactive);
+    const routing = await resolveProjectOption(ctx.flags, "style", VALID_PROJECT_OPTIONS.style, "nest", interactive);
+    const view = await resolveProjectOption(ctx.flags, "view", VALID_PROJECT_OPTIONS.view, "rendu", interactive);
+    const orm = await resolveProjectOption(ctx.flags, "orm", VALID_PROJECT_OPTIONS.orm, "drizzle", interactive);
+    const db = await resolveProjectOption(ctx.flags, "db", VALID_PROJECT_OPTIONS.db, "bun-sqlite", interactive);
+    const frontend = await resolveProjectOption(ctx.flags, "frontend", VALID_PROJECT_OPTIONS.frontend, "react", interactive);
     const ssr = !flagBool(ctx.flags, "no-ssr", false);
     const name = target.split("/").pop() ?? "nexus-app";
     const dbUrl = db === "bun-sqlite" || db === "node-sqlite" ? "app.db" : "";
@@ -1751,51 +2018,6 @@ var init_default = initCommand;
 
 // packages/cli/src/commands/make-auth.ts
 import { resolve as resolve7 } from "path";
-var AUTH_INSTANCE_TEMPLATE = `/**
- * Better-auth instance \u2014 generated by \`nx make:auth\`.
- *
- * Edit \`nx.config.ts\` (\`auth\` section) instead of this file when possible.
- */
-import { createAuth } from '@nexusts/auth';
-
-export const auth = createAuth({
-{{^jwt}}
-  jwt: { enabled: false },
-{{/jwt}}
-{{#jwt}}
-  jwt: { enabled: true },
-{{/jwt}}
-{{#passkey}}
-  passkey: {
-    enabled: true,
-    rpName: '{{ passkeyRpName }}',
-    rpId:   '{{ passkeyRpId }}',
-    origin: '{{ passkeyOrigin }}',
-  },
-{{/passkey}}
-{{#providers}}
-  socialProviders: {
-{{#entries}}
-    {{ name }}: {
-      clientId:     process.env.{{ envVar }}_CLIENT_ID!,
-      clientSecret: process.env.{{ envVar }}_CLIENT_SECRET!,
-    },
-{{/entries}}
-  },
-{{/providers}}
-});
-`;
-var ENV_EXAMPLE_TEMPLATE = `# Better Auth \u2014 generated by \`nx make:auth\`.
-# Generate a secret with: openssl rand -base64 32
-BETTER_AUTH_SECRET=
-BETTER_AUTH_URL=http://localhost:3000
-{{#providers}}
-{{#entries}}
-{{ envVar }}_CLIENT_ID=
-{{ envVar }}_CLIENT_SECRET=
-{{/entries}}
-{{/providers}}
-`;
 var MODULE_UPDATE_HINT = `import { AuthModule } from '@nexusts/auth';
 // In your AppModule.imports:
 imports: [AuthModule.forRoot({ /* ... */ })],
@@ -1855,7 +2077,7 @@ var makeAuthCommand = {
         envVar: known?.env ?? p.toUpperCase()
       };
     });
-    const authCode = render(AUTH_INSTANCE_TEMPLATE, {
+    const authCode = render(templates.auth.instance, {
       jwt: jwtEnabled,
       passkey: passkeyEnabled,
       providers: providers.length > 0,
@@ -1870,7 +2092,7 @@ var makeAuthCommand = {
     } else {
       logger.warn(`skipped (exists): ${authOut}`);
     }
-    const envCode = render(ENV_EXAMPLE_TEMPLATE, {
+    const envCode = render(templates.auth["env.example"], {
       providers: providers.length > 0,
       entries
     });
@@ -1944,8 +2166,9 @@ var makeControllerCommand = {
       snake: variants.snake,
       pascal: variants.pascal,
       service: serviceName,
-      serviceCamel
-    }).replace(/import .*\n/g, skipService ? (m) => m.includes("services/") ? "" : m : (m) => m);
+      serviceCamel,
+      hasService: !skipService
+    });
     const out = resolve8(ctx.cwd, ctx.config.paths.controllers, `${variants.kebab}.controller.ts`);
     const ok = writeFile(out, code, { skipIfExists: false });
     if (!ok) {
@@ -2078,6 +2301,96 @@ function mapDrizzleType(dialect, type) {
   }
   return "text";
 }
+function mapSqlType(t, dialect) {
+  const type = t.toLowerCase();
+  switch (type) {
+    case "text":
+    case "string":
+    case "varchar":
+      return dialect === "mysql" ? "VARCHAR(255)" : "TEXT";
+    case "int":
+    case "integer":
+      return dialect === "postgres" ? "INTEGER" : dialect === "mysql" ? "INT" : "INTEGER";
+    case "bigint":
+    case "bigintunsigned":
+      return dialect === "postgres" ? "BIGINT" : "BIGINT UNSIGNED";
+    case "serial":
+      return dialect === "postgres" ? "SERIAL" : "INTEGER AUTO_INCREMENT";
+    case "bool":
+    case "boolean":
+      return "BOOLEAN";
+    case "float":
+    case "number":
+    case "real":
+    case "double":
+      return dialect === "mysql" ? "DOUBLE" : "REAL";
+    case "datetime":
+    case "timestamp":
+      return dialect === "postgres" ? "TIMESTAMP" : dialect === "mysql" ? "DATETIME" : "INTEGER";
+    case "date":
+      return dialect === "mysql" ? "DATE" : "TEXT";
+    case "json":
+      return dialect === "postgres" ? "JSONB" : dialect === "mysql" ? "JSON" : "TEXT";
+    case "jsonb":
+      return dialect === "postgres" ? "JSONB" : "TEXT";
+    default:
+      return "TEXT";
+  }
+}
+function mapKyselyType(type) {
+  switch (type.toLowerCase()) {
+    case "text":
+    case "string":
+    case "varchar":
+      return "text";
+    case "int":
+    case "integer":
+      return "integer";
+    case "bigint":
+      return "bigint";
+    case "bool":
+    case "boolean":
+      return "boolean";
+    case "float":
+    case "number":
+    case "real":
+    case "double":
+      return "real";
+    case "datetime":
+    case "timestamp":
+    case "date":
+    case "json":
+    case "jsonb":
+      return "text";
+    default:
+      return "text";
+  }
+}
+function renderSqlColumns(cols, dialect) {
+  return cols.map(([name, type]) => {
+    const sqlType = mapSqlType(type, dialect);
+    const notNull = /NOT NULL/i.test(sqlType) ? "" : " NOT NULL";
+    return `  ${name} ${sqlType}${notNull},`;
+  }).join(`
+`);
+}
+function renderKyselyColumns(cols) {
+  return cols.map(([name, type]) => {
+    const kyselyType = mapKyselyType(type);
+    return `    .addColumn('${name}', '${kyselyType}', (col) => col.notNull())`;
+  }).join(`
+`);
+}
+function renderDrizzleColumns(cols, dialect) {
+  return cols.map(([name, type]) => {
+    const helper = mapDrizzleType(dialect, type);
+    return `  ${name}: ${helper}('${name}'),`;
+  }).join(`
+`);
+}
+function isValidDialect(d) {
+  return ["postgres", "mysql", "sqlite", "bun-sqlite", "d1"].includes(d);
+}
 
 // packages/cli/src/commands/make-crud.ts
 var makeCrudCommand = {
@@ -2173,7 +2486,7 @@ var makeCrudCommand = {
             kebab: variants.kebab,
             snake: variants.snake,
             tableName,
-            columns: renderDrizzleColumns(dialect)
+            columns: renderDrizzleColumns2(dialect)
           });
         } else {
           const tpl = templates.model[orm];
@@ -2281,7 +2594,7 @@ function renderDefaultColumns(orm) {
   }
   return "  title text,";
 }
-function renderDrizzleColumns(dialect) {
+function renderDrizzleColumns2(dialect) {
   const helper = mapDrizzleType(dialect, "text");
   return `  title: ${helper}('title').notNull(),`;
 }
@@ -2289,39 +2602,6 @@ var make_crud_default = makeCrudCommand;
 
 // packages/cli/src/commands/make-listener.ts
 import { resolve as resolve10 } from "path";
-var LISTENER_TEMPLATE = `
-import { Inject, Injectable } from '@nexusts/core';
-import { EventService, OnEvent } from '@nexusts/events';
-
-/**
- * {{ name }} listener \u2014 generated by \`nx make:listener {{ name }}\`.
- *
- * Register handlers below with \`@OnEvent(pattern)\`. Pair with
- * \`scanForListeners(this, eventService)\` at boot.
- */
-@Injectable()
-export class {{ name }}Listener {
-  constructor(@Inject(EventService.TOKEN) private readonly events: EventService) {}
-
-  // TODO: add @OnEvent('your.event') handlers below.
-
-  // @OnEvent('user.created')
-  // async onUserCreated(payload: { userId: string; email: string }) {
-  //   this.events; // unused \u2014 remove if you don't need it
-  // }
-}
-
-import { scanForListeners } from '@nexusts/events';
-
-/**
- * Bootstrap helper \u2014 call this from your main.ts (or wherever you
- * wire up the application) to register every \`@OnEvent\` handler
- * on this listener class.
- */
-export async function register{{ name }}(listener: {{ name }}Listener, events: EventService) {
-  return scanForListeners(listener, events);
-}
-`.trimStart();
 var makeListenerCommand = {
   name: "make:listener",
   aliases: ["ml", "make-listener"],
@@ -2335,7 +2615,7 @@ var makeListenerCommand = {
       return 1;
     }
     const variants = nameVariants(name);
-    const code = render(LISTENER_TEMPLATE, {
+    const code = render(templates.listener, {
       name: variants.pascal,
       kebab: variants.kebab
     });
@@ -2405,192 +2685,87 @@ var makeMigrationCommand = {
     {
       name: "orm",
       description: "Override ORM driver (drizzle|kysely|none)"
-    },
-    {
-      name: "dialect",
-      description: "Drizzle dialect (postgres|mysql|sqlite|bun-sqlite|d1). Default: bun-sqlite"
-    }
-  ],
-  async run(ctx) {
-    const name = ctx.positional[0];
-    if (!name) {
-      logger.error("Usage: nx make:migration <Name> [--dialect ...]");
-      return 1;
-    }
-    const orm = ctx.flags.orm ?? ctx.config.orm;
-    const dialect = ctx.flags.dialect ?? ctx.config.dialect ?? "bun-sqlite";
-    const isDrizzle = orm === "drizzle";
-    const isKysely = orm === "kysely";
-    const useGenericSql = orm === "none";
-    const variants = nameVariants(name);
-    const tableName = inferTableName(name);
-    const colsFlag = ctx.flags.columns;
-    const cols = parseColumns(colsFlag ?? "title:text");
-    const drizzleColumns = renderDrizzleColumns2(cols, dialect);
-    const sqlColumns = renderSqlColumns(cols, dialect);
-    let code;
-    let extension;
-    if (isKysely) {
-      const tpl = templates.migration.kysely;
-      code = render(tpl, {
-        name: variants.pascal,
-        snake: variants.snake,
-        tableName,
-        columns: renderKyselyColumns(cols),
-        timestamp: formatTimestamp(new Date)
-      });
-      extension = "ts";
-    } else if (isDrizzle) {
-      if (!isValidDialect(dialect)) {
-        logger.error(`Unsupported drizzle dialect: ${dialect}. Allowed: postgres, mysql, sqlite, bun-sqlite, d1.`);
-        return 1;
-      }
-      code = renderDrizzleDialect(dialect);
-      code = render(code, {
-        name: variants.pascal,
-        snake: variants.snake,
-        tableName,
-        columns: drizzleColumns,
-        timestamp: formatTimestamp(new Date)
-      });
-      extension = "ts";
-    } else if (useGenericSql) {
-      const tpl = templates.migration.sql;
-      code = render(tpl, {
-        name: variants.pascal,
-        snake: variants.snake,
-        tableName,
-        columns: sqlColumns,
-        timestamp: formatTimestamp(new Date)
-      });
-      extension = "sql";
-    } else {
-      logger.error(`Unsupported ORM for migration: ${orm}. Allowed: drizzle, kysely, none.`);
-      return 1;
-    }
-    const filename = `${formatTimestamp(new Date)}_${variants.snake}.${extension}`;
-    const out = resolve12(ctx.cwd, ctx.config.paths.migrations, filename);
-    writeFile(out, code);
-    logger.success(`created ${out}`);
-    if (isDrizzle || isKysely) {
-      logger.finger(`run \`nx db:migrate\` to apply pending migrations.`);
-    } else {
-      logger.finger(`run \`bun nx db:migrate\` or your migration tool.`);
-    }
-    return 0;
-  }
-};
-function isValidDialect(d) {
-  return ["postgres", "mysql", "sqlite", "bun-sqlite", "d1"].includes(d);
-}
-function inferTableName(input) {
-  const m = /^create_(\w+)_table$/.exec(input);
-  if (m)
-    return m[1] ?? "";
-  const m2 = /^(?:add|remove|drop|alter)_(\w+)_to_(\w+)$/.exec(input);
-  if (m2)
-    return m2[2] ?? "";
-  return `${input.toLowerCase().replace(/s$/, "")}s`;
-}
-function parseColumns(input) {
-  const list = Array.isArray(input) ? input : input.split(",");
-  return list.map((s) => s.trim()).filter(Boolean).map((c2) => {
-    const [name, type = "text"] = c2.split(":");
-    return [name, type];
-  });
-}
-function renderSqlColumns(cols, dialect) {
-  return cols.map(([name, type]) => {
-    const sqlType = mapSqlType(type, dialect);
-    const notNull = /NOT NULL/i.test(sqlType) ? "" : " NOT NULL";
-    return `  ${name} ${sqlType}${notNull},`;
-  }).join(`
-`);
-}
-function renderKyselyColumns(cols) {
-  return cols.map(([name, type]) => {
-    const kyselyType = mapKyselyType(type);
-    return `    .addColumn('${name}', '${kyselyType}', (col) => col.notNull())`;
-  }).join(`
-`);
-}
-function mapKyselyType(type) {
-  switch (type.toLowerCase()) {
-    case "text":
-    case "string":
-    case "varchar":
-      return "text";
-    case "int":
-    case "integer":
-      return "integer";
-    case "bigint":
-      return "bigint";
-    case "bool":
-    case "boolean":
-      return "boolean";
-    case "float":
-    case "number":
-    case "real":
-    case "double":
-      return "real";
-    case "datetime":
-    case "timestamp":
-      return "text";
-    case "date":
-      return "text";
-    case "json":
-    case "jsonb":
-      return "text";
-    default:
-      return "text";
-  }
-}
-function renderDrizzleColumns2(cols, dialect) {
-  return cols.map(([name, type]) => {
-    const helper = mapDrizzleType(dialect, type);
-    return `  ${name}: ${helper}('${name}'),`;
-  }).join(`
-`);
-}
-function mapSqlType(t, dialect) {
-  const type = t.toLowerCase();
-  switch (type) {
-    case "text":
-    case "string":
-    case "varchar":
-      return dialect === "mysql" ? "VARCHAR(255)" : "TEXT";
-    case "int":
-    case "integer":
-      return dialect === "postgres" ? "INTEGER" : dialect === "mysql" ? "INT" : "INTEGER";
-    case "bigint":
-    case "bigintunsigned":
-      return dialect === "postgres" ? "BIGINT" : "BIGINT UNSIGNED";
-    case "serial":
-      return dialect === "postgres" ? "SERIAL" : "INTEGER AUTO_INCREMENT";
-    case "bool":
-    case "boolean":
-      return dialect === "mysql" ? "BOOLEAN" : "BOOLEAN";
-    case "float":
-    case "number":
-    case "real":
-    case "double":
-      return dialect === "mysql" ? "DOUBLE" : "REAL";
-    case "datetime":
-    case "timestamp":
-      return dialect === "postgres" ? "TIMESTAMP" : dialect === "mysql" ? "DATETIME" : "INTEGER";
-    case "date":
-      return dialect === "mysql" ? "DATE" : "TEXT";
-    case "json":
-      return dialect === "postgres" ? "JSONB" : dialect === "mysql" ? "JSON" : "TEXT";
-    case "jsonb":
-      return dialect === "postgres" ? "JSONB" : "TEXT";
-    default:
-      return "TEXT";
+    },
+    {
+      name: "dialect",
+      description: "Drizzle dialect (postgres|mysql|sqlite|bun-sqlite|d1). Default: bun-sqlite"
+    }
+  ],
+  async run(ctx) {
+    const name = ctx.positional[0];
+    if (!name) {
+      logger.error("Usage: nx make:migration <Name> [--dialect ...]");
+      return 1;
+    }
+    const orm = ctx.flags.orm ?? ctx.config.orm;
+    const dialect = ctx.flags.dialect ?? ctx.config.dialect ?? "bun-sqlite";
+    const isDrizzle = orm === "drizzle";
+    const isKysely = orm === "kysely";
+    const useGenericSql = orm === "none";
+    const variants = nameVariants(name);
+    const tableName = inferTableName(name);
+    const colsFlag = ctx.flags.columns;
+    const cols = parseColumns(colsFlag ?? "title:text");
+    const drizzleColumns = renderDrizzleColumns(cols, dialect);
+    const sqlColumns = renderSqlColumns(cols, dialect);
+    let code;
+    let extension;
+    if (isKysely) {
+      const tpl = templates.migration.kysely;
+      code = render(tpl, {
+        name: variants.pascal,
+        snake: variants.snake,
+        tableName,
+        columns: renderKyselyColumns(cols),
+        timestamp: formatTimestamp(new Date)
+      });
+      extension = "ts";
+    } else if (isDrizzle) {
+      if (!isValidDialect(dialect)) {
+        logger.error(`Unsupported drizzle dialect: ${dialect}. Allowed: postgres, mysql, sqlite, bun-sqlite, d1.`);
+        return 1;
+      }
+      code = renderDrizzleDialect(dialect);
+      code = render(code, {
+        name: variants.pascal,
+        snake: variants.snake,
+        tableName,
+        columns: drizzleColumns,
+        timestamp: formatTimestamp(new Date)
+      });
+      extension = "ts";
+    } else if (useGenericSql) {
+      const tpl = templates.migration.sql;
+      code = render(tpl, {
+        name: variants.pascal,
+        snake: variants.snake,
+        tableName,
+        columns: sqlColumns,
+        timestamp: formatTimestamp(new Date)
+      });
+      extension = "sql";
+    } else {
+      logger.error(`Unsupported ORM for migration: ${orm}. Allowed: drizzle, kysely, none.`);
+      return 1;
+    }
+    const filename = `${formatTimestamp(new Date)}_${variants.snake}.${extension}`;
+    const out = resolve12(ctx.cwd, ctx.config.paths.migrations, filename);
+    writeFile(out, code);
+    logger.success(`created ${out}`);
+    if (isDrizzle || isKysely) {
+      logger.finger(`run \`nx db:migrate\` to apply pending migrations.`);
+    } else {
+      logger.finger(`run \`bun nx db:migrate\` or your migration tool.`);
+    }
+    return 0;
   }
-}
-function formatTimestamp(d) {
-  const pad = (n) => String(n).padStart(2, "0");
-  return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}` + `_${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
+};
+function parseColumns(input) {
+  const list = Array.isArray(input) ? input : input.split(",");
+  return list.map((s) => s.trim()).filter(Boolean).map((c2) => {
+    const [name, type = "text"] = c2.split(":");
+    return [name, type];
+  });
 }
 var make_migration_default = makeMigrationCommand;
 
@@ -2640,7 +2815,7 @@ var makeModelCommand = {
     let code;
     if (orm === "drizzle") {
       const dialect = ctx.flags.dialect ?? ctx.config.dialect ?? "bun-sqlite";
-      if (!isValidDialect2(dialect)) {
+      if (!isValidDialect(dialect)) {
         logger.error(`Unsupported drizzle dialect: ${dialect}. Allowed: postgres, mysql, sqlite, bun-sqlite, d1.`);
         return 1;
       }
@@ -2674,9 +2849,6 @@ var makeModelCommand = {
     return 0;
   }
 };
-function isValidDialect2(d) {
-  return ["postgres", "mysql", "sqlite", "bun-sqlite", "d1"].includes(d);
-}
 function renderColumns(cols, orm, dialect) {
   const flat = cols.flatMap((c2) => c2.split(",")).map((c2) => c2.trim()).filter(Boolean);
   return flat.map((col) => {
@@ -2749,81 +2921,6 @@ var make_module_default = makeModuleCommand;
 
 // packages/cli/src/commands/make-queue.ts
 import { resolve as resolve15 } from "path";
-var WORKER_TEMPLATE = `
-import { Inject, Injectable } from '@nexusts/core';
-import { QueueService, OnQueueReady } from '@nexusts/queue';
-
-/**
- * {{ name }} worker \u2014 generated by \`nx make:queue {{ name }}\`.
- *
- * Registers a handler for the \`{{ name }}\` job name on boot.
- */
-@Injectable()
-export class {{ name }}Worker {
-  constructor(@Inject(QueueService.TOKEN) private readonly queue: QueueService) {}
-
-  @OnQueueReady()
-  async register(): Promise<void> {
-    await this.queue.process('{{ name }}', async (data, ctx) => {
-      ctx.prefix; // \u2192 "[queue:{{ name }}]"
-      try {
-        await this.handle(data as {{ name }}Data);
-        return { status: 'completed' };
-      } catch (err) {
-        return {
-          status: 'failed',
-          error: err instanceof Error ? err : new Error(String(err)),
-          willRetry: ctx.attempts < 3,
-        };
-      }
-    });
-  }
-
-  /**
-   * Replace this body with your actual worker logic.
-   */
-  async handle(data: {{ name }}Data): Promise<void> {
-    // TODO: implement
-  }
-}
-
-/**
- * Typed payload for the \`{{ name }}\` job.
- */
-export interface {{ name }}Data {
-  // TODO: define fields
-  [key: string]: unknown;
-}
-`.trimStart();
-var JOB_HELPER_TEMPLATE = `
-import { Inject, Injectable } from '@nexusts/core';
-import { QueueService } from '@nexusts/queue';
-import type { {{ name }}Data } from './{{ kebab }}.worker.js';
-
-/**
- * Helper for enqueuing \`{{ name }}\` jobs from controllers / services.
- * Generated by \`nx make:queue {{ name }}\`.
- */
-@Injectable()
-export class {{ name }}Job {
-  constructor(@Inject(QueueService.TOKEN) private readonly queue: QueueService) {}
-
-  /** Enqueue a single {{ name }} job. */
-  async enqueue(data: {{ name }}Data, options?: {
-    delaySeconds?: number;
-    attempts?: number;
-  }) {
-    return this.queue.add('{{ name }}', data, options);
-  }
-
-  /** Enqueue many at once. */
-  async enqueueBatch(items: {{ name }}Data[]) {
-    return this.queue.addBatch(
-      items.map((data) => ({ name: '{{ name }}', data })),
-    );
-  }
-}
-`.trimStart();
 var WIRE_HINT = `
 import { QueueService } from '@nexusts/queue';
 import { %%NAME%%Job } from './queue/jobs/%%KEBAB%%.job.js';
@@ -2872,11 +2969,11 @@ var makeQueueCommand = {
     }
     logger.heading(`Scaffolding ${variants.pascal} (backend=${backend})`);
     if (!flagBool(ctx.flags, "no-worker", false)) {
-      const code = render(WORKER_TEMPLATE, {
+      const code = render(templates.queue.worker, {
         name: variants.pascal,
         kebab: variants.kebab
       });
-      const out = resolve15(ctx.cwd, "app/queue/workers", `${variants.kebab}.worker.ts`);
+      const out = resolve15(ctx.cwd, `${ctx.config.paths.app}/queue/workers`, `${variants.kebab}.worker.ts`);
       if (writeFile(out, code, { skipIfExists: true })) {
         logger.success(`created ${out}`);
       } else {
@@ -2884,11 +2981,11 @@ var makeQueueCommand = {
       }
     }
     if (!flagBool(ctx.flags, "no-job", false)) {
-      const code = render(JOB_HELPER_TEMPLATE, {
+      const code = render(templates.queue.job, {
         name: variants.pascal,
         kebab: variants.kebab
       });
-      const out = resolve15(ctx.cwd, "app/queue/jobs", `${variants.kebab}.job.ts`);
+      const out = resolve15(ctx.cwd, `${ctx.config.paths.app}/queue/jobs`, `${variants.kebab}.job.ts`);
       if (writeFile(out, code, { skipIfExists: true })) {
         logger.success(`created ${out}`);
       } else {
@@ -2957,32 +3054,6 @@ var make_repository_default = makeRepositoryCommand;
 
 // packages/cli/src/commands/make-schedule.ts
 import { resolve as resolve17 } from "path";
-var TASK_TEMPLATE = `
-import { Injectable } from '@nexusts/core';
-import { Cron, Interval, Timeout } from '@nexusts/schedule';
-
-/**
- * {{ name }} task \u2014 generated by \`nx make:schedule {{ name }}\`.
- *
- * Mark methods with \`@Cron\`, \`@Interval\`, or \`@Timeout\`.
- * Auto-detected at boot \u2014 no manual registration needed.
- */
-@Injectable()
-export class {{ name }}Task {
-  constructor() {}
-
-  // TODO: add @Cron, @Interval, or @Timeout handlers below.
-
-  // @Cron('0 * * * *')                          // every hour
-  // async hourly() { /* ... */ }
-
-  // @Interval(60_000)                         // every minute
-  // async tick() { /* ... */ }
-
-  // @Timeout(5_000)                            // 5s after boot
-  // async startup() { /* ... */ }
-}
-`.trimStart();
 var makeScheduleCommand = {
   name: "make:schedule",
   aliases: ["msk", "make-schedule"],
@@ -2996,11 +3067,11 @@ var makeScheduleCommand = {
       return 1;
     }
     const variants = nameVariants(name);
-    const code = render(TASK_TEMPLATE, {
+    const code = render(templates.schedule, {
       name: variants.pascal,
       kebab: variants.kebab
     });
-    const out = resolve17(ctx.cwd, "app/schedule/tasks", `${variants.kebab}.task.ts`);
+    const out = resolve17(ctx.cwd, `${ctx.config.paths.app}/schedule/tasks`, `${variants.kebab}.task.ts`);
     if (writeFile(out, code, { skipIfExists: true })) {
       logger.success(`created ${out}`);
     } else {
@@ -3060,50 +3131,6 @@ var make_service_default = makeServiceCommand;
 
 // packages/cli/src/commands/make-session.ts
 import { resolve as resolve19 } from "path";
-var SESSION_TEMPLATE = `
-import { Inject, Injectable } from '@nexusts/core';
-import { SessionService } from '@nexusts/session';
-import type { SessionRecord } from '@nexusts/session';
-
-/**
- * {{ name }} session helper \u2014 generated by \`nx make:session {{ name }}\`.
- *
- * Wraps SessionService with typed accessors for the {{ name }} session's
- * data. Use from controllers / services.
- */
-@Injectable()
-export class {{ name }}Session {
-  constructor(@Inject(SessionService.TOKEN) private readonly sessions: SessionService) {}
-
-  /** Read the current session record (or null). */
-  async getCurrent(sessionId: string | null | undefined) {
-    if (!sessionId) return null;
-    return this.sessions.read(sessionId);
-  }
-
-  /** Patch the {{ name }} session's data. */
-  async update(sessionId: string, patch: {{ name }}DataPatch) {
-    return this.sessions.update(sessionId, { dataPatch: patch });
-  }
-
-  /** Destroy the session (logout-everywhere equivalent). */
-  async destroy(sessionId: string) {
-    return this.sessions.destroy(sessionId, 'logout');
-  }
-}
-
-/**
- * Typed payload for the {{ name }} session.
- *
- * TODO: define the fields below to match your feature.
- */
-export interface {{ name }}Data {
-  // userId?: string;
-  // createdAt?: string;
-}
-
-export type {{ name }}DataPatch = Partial<{{ name }}Data>;
-`.trimStart();
 var makeSessionCommand = {
   name: "make:session",
   aliases: ["msess", "make-session"],
@@ -3117,11 +3144,11 @@ var makeSessionCommand = {
       return 1;
     }
     const variants = nameVariants(name);
-    const code = render(SESSION_TEMPLATE, {
+    const code = render(templates.session, {
       name: variants.pascal,
       kebab: variants.kebab
     });
-    const out = resolve19(ctx.cwd, "app/session/services", `${variants.kebab}.session.ts`);
+    const out = resolve19(ctx.cwd, `${ctx.config.paths.app}/session/services`, `${variants.kebab}.session.ts`);
     if (writeFile(out, code, { skipIfExists: true })) {
       logger.success(`created ${out}`);
     } else {
@@ -3468,14 +3495,14 @@ async function runKyselyTemplate(cwd, name, _dialect) {
   const migrationsDir = join(cwd, "app", "database", "migrations");
   mkdirSync5(migrationsDir, { recursive: true });
   const variants = nameVariants(name);
-  const timestamp = formatTimestamp2(new Date);
+  const timestamp = formatTimestamp(new Date);
   const filename = `${timestamp}_${variants.snake}.ts`;
   const filepath = join(migrationsDir, filename);
   const tpl = templates.migration.kysely;
   const code = render(tpl, {
     name: variants.pascal,
     snake: variants.snake,
-    tableName: inferTableName2(name),
+    tableName: inferTableName(name),
     columns: "",
     timestamp
   });
@@ -3489,7 +3516,7 @@ async function runSqlTemplate(cwd, name, dialect) {
   const { join } = await import("path");
   const migrationsDir = join(cwd, "app", "database", "migrations");
   mkdirSync5(migrationsDir, { recursive: true });
-  const timestamp = Date.now();
+  const timestamp = formatTimestamp(new Date);
   const filename = `${timestamp}_${name.replace(/[^a-z0-9_]+/g, "_")}.sql`;
   const filepath = join(migrationsDir, filename);
   const header = dialect === "postgres" || dialect === "mysql" ? `-- Migration: ${name}
@@ -3506,19 +3533,6 @@ async function runSqlTemplate(cwd, name, dialect) {
   logger.info("Edit the SQL file, then run `nx db:migrate` to apply it.");
   return 0;
 }
-function inferTableName2(input) {
-  const m = /^create_(\w+)_table$/.exec(input);
-  if (m)
-    return m[1] ?? "";
-  const m2 = /^(?:add|remove|drop|alter)_(\w+)_to_(\w+)$/.exec(input);
-  if (m2)
-    return m2[2] ?? "";
-  return `${input.toLowerCase().replace(/s$/, "")}s`;
-}
-function formatTimestamp2(d) {
-  const pad = (n) => String(n).padStart(2, "0");
-  return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}_${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
-}
 var db_generate_default = dbGenerateCommand;
 
 // packages/cli/src/commands/db-seed.ts
@@ -3724,32 +3738,6 @@ var db_seed_default = dbSeedCommand;
 // packages/cli/src/commands/new.ts
 import { existsSync as existsSync7, mkdirSync as mkdirSync5, writeFileSync as writeFileSync4 } from "fs";
 import { resolve as resolve24 } from "path";
-var VALID_OPTIONS2 = {
-  style: ["nest", "adonis", "functional"],
-  view: ["rendu", "edge", "eta", "inertia", "none"],
-  orm: ["drizzle", "kysely", "none"],
-  db: ["bun-sqlite", "node-sqlite", "libsql", "postgres", "mysql", "none"],
-  frontend: ["react", "vue", "svelte", "solid"]
-};
-async function resolveOpt2(flags, key, valid, defaultVal, interactive) {
-  const flagVal = flags[key];
-  if (flagVal) {
-    if (valid.includes(flagVal))
-      return flagVal;
-    if (!interactive) {
-      logger.error(`Invalid --${key} "${flagVal}". Valid values: ${valid.join(", ")}`);
-      process.exit(1);
-    }
-    logger.warn(`"${flagVal}" is not valid for --${key}. Please choose from the list.`);
-  }
-  const label = key === "style" ? "Routing style" : key === "view" ? "View engine" : key === "orm" ? "ORM driver" : key === "db" ? "Database driver" : "Inertia frontend";
-  for (;; ) {
-    const answer = await select(label, [...valid], { default: defaultVal });
-    if (valid.includes(answer))
-      return answer;
-    logger.warn(`"${answer}" is not valid. Please choose from: ${valid.join(", ")}`);
-  }
-}
 var newCommand = {
   name: "new",
   aliases: ["n"],
@@ -3779,11 +3767,11 @@ var newCommand = {
       logger.error(`Directory "${name}" already exists.`);
       return 1;
     }
-    const routing = await resolveOpt2(ctx.flags, "style", VALID_OPTIONS2.style, "nest", interactive);
-    const view = await resolveOpt2(ctx.flags, "view", VALID_OPTIONS2.view, "rendu", interactive);
-    const orm = await resolveOpt2(ctx.flags, "orm", VALID_OPTIONS2.orm, "drizzle", interactive);
-    const db = await resolveOpt2(ctx.flags, "db", VALID_OPTIONS2.db, "bun-sqlite", interactive);
-    const frontend = await resolveOpt2(ctx.flags, "frontend", VALID_OPTIONS2.frontend, "react", interactive);
+    const routing = await resolveProjectOption(ctx.flags, "style", VALID_PROJECT_OPTIONS.style, "nest", interactive);
+    const view = await resolveProjectOption(ctx.flags, "view", VALID_PROJECT_OPTIONS.view, "rendu", interactive);
+    const orm = await resolveProjectOption(ctx.flags, "orm", VALID_PROJECT_OPTIONS.orm, "drizzle", interactive);
+    const db = await resolveProjectOption(ctx.flags, "db", VALID_PROJECT_OPTIONS.db, "bun-sqlite", interactive);
+    const frontend = await resolveProjectOption(ctx.flags, "frontend", VALID_PROJECT_OPTIONS.frontend, "react", interactive);
     const ssr = !flagBool(ctx.flags, "no-ssr", false);
     mkdirSync5(target, { recursive: true });
     const dbUrl = db === "bun-sqlite" || db === "node-sqlite" ? "app.db" : "";
@@ -4586,7 +4574,7 @@ async function main() {
   const verbose = flagBool(parsed.flags, "verbose", false);
   logger.setVerbose(verbose);
   if (parsed.flags.version === true) {
-    console.log(PKG_VERSION);
+    console.log(VERSION);
     return 0;
   }
   if (parsed.flags.help === true || parsed.command === "help") {
@@ -4680,7 +4668,6 @@ Examples`));
   }
   console.log();
 }
-var PKG_VERSION = "0.1.0";
 main().then((code) => process.exit(code)).catch((err) => {
   logger.error(err?.message ?? String(err));
   if (process.env.NX_DEBUG === "1" && err?.stack) {
@@ -4689,5 +4676,5 @@ main().then((code) => process.exit(code)).catch((err) => {
   process.exit(1);
 });
 
-//# debugId=B4CDEF95B1BE869264756E2164756E21
+//# debugId=0BB397411F7B54EA64756E2164756E21
 //# sourceMappingURL=index.js.map