domain-driver 0.4.0 → 0.4.1

package/README.md

@@ -23,12 +23,12 @@ npx domain-driver make:feature <feature>[/<Entity>]
 Every command reads your `package.json` once and prints the stack it found before writing anything:
 
 ```
-Stack: next-fullstack (detected)
+Stack: next-fullstack (detected), root: src/app
 ```
 
 | Stack | Detected when | Features live in |
 |---|---|---|
-| `nest` | `@nestjs/core` is a dependency | `src/<feature>` |
+| `nest` | `@nestjs/core` is a dependency | `src/features/<feature>` if `src/features` exists, otherwise `src/<feature>` |
 | `tanstack-start` | `@tanstack/react-start` is a dependency | `src/routes/<feature>` or `routes/<feature>` |
 | `next-fullstack` | `next` is a dependency and `app/api`, `src/app/api`, `pages/api`, or `src/pages/api` exists | `app/<feature>` or `src/app/<feature>` |
 | `next-frontend` | `next` is a dependency, no api directory | `app/<feature>` or `src/app/<feature>` |
@@ -43,6 +43,34 @@ Override detection with `--stack`:
 domain-driver --stack nest make:feature cat -a
 ```
 
+### Choosing where features live
+
+The "Features live in" column is a convention, not a rule. Two overrides take precedence over it, in this order.
+
+`--root` wins over everything, and suits one-off scaffolding:
+
+```bash
+domain-driver --root src/modules make:feature billing/Billing -a
+```
+
+For a project you work in daily, set it once in `package.json` instead of retyping the flag on every command:
+
+```json
+{
+  "domainDriver": {
+    "featureRoot": "src/modules"
+  }
+}
+```
+
+Either way the stack line tells you which one won, so you can see where files will land before they land:
+
+```
+Stack: nest (detected), root: src/modules (package.json)
+```
+
+The root must be a relative path inside the project. An absolute path or one containing `..` is rejected rather than quietly normalised.
+
 ---
 
 ## What each stack generates
@@ -277,6 +305,16 @@ The cache lives in `~/.cache/domain-driver` (or `$XDG_CACHE_HOME/domain-driver`)
 
 ---
 
+## Upgrading from 0.4.0
+
+Two changes affect existing projects.
+
+On NestJS, a project that already has a `src/features` directory now scaffolds into it instead of directly into `src`. If you keep features in `src` you are unaffected, since the behaviour is opt-in by that directory existing. To pin either choice explicitly, set `domainDriver.featureRoot` in `package.json`.
+
+The entity half of a `<feature>/<Entity>` target must now be PascalCase. `make:schema users/user` previously produced `Listuser.service.ts` exporting `ListuserService`; it now fails with a message telling you to pass `User`.
+
+---
+
 ## Upgrading from 0.3.x
 
 Hooks are now one file per action — `<Action><Entity>.hook.ts` exporting `use<Action><Entity>` (`useListCat`, `useCreateCat`, ...) — instead of a single combined `use<Entity>.ts`, which is no longer generated. `make:hook` now takes `<feature>/<Entity>`, not `<feature>/use<Entity>`. `make:action` writes a matching hook alongside the service and repository on any stack that has a hook layer.

package/dist/cli.js

@@ -78,7 +78,8 @@ function createProgram(deps) {
         .name('domain-driver')
         .description('CLI scaffolding tool for domain-driven feature folders in Next.js, React, Node, and NestJS projects')
         .version(deps.current)
-        .option('--stack <name>', `Override stack detection (${types_2.STACK_NAMES.join(', ')})`);
+        .option('--stack <name>', `Override stack detection (${types_2.STACK_NAMES.join(', ')})`)
+        .option('--root <dir>', 'Override where feature folders are created, for example src/features');
     let pendingNotice = Promise.resolve(null);
     program.hook('preAction', (_thisCommand, actionCommand) => {
         const name = actionCommand.name();
@@ -93,8 +94,8 @@ function createProgram(deps) {
         }
         if (SKIP_DETECTION.has(name))
             return;
-        const { stack } = program.opts();
-        deps.log((0, detect_1.describeStack)((0, detect_1.detectStack)(stack)));
+        const { stack, root } = program.opts();
+        deps.log((0, detect_1.describeStack)((0, detect_1.detectStack)(stack, root)));
     });
     program.hook('postAction', async () => {
         const notice = await pendingNotice;

package/dist/commands/target.js

@@ -3,11 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseTarget = parseTarget;
 exports.parseFeatureTarget = parseFeatureTarget;
 const naming_1 = require("../utils/naming");
-const NAME_PATTERN = /^[A-Za-z][A-Za-z0-9]*$/;
+const NAME_PATTERN = /^[A-Z][A-Za-z0-9]*$/;
+const HOOK_NAME_PATTERN = /^use[A-Z]/;
 function validateName(name) {
-    if (!NAME_PATTERN.test(name)) {
-        throw new Error(`Name "${name}" must be letters and digits only, for example User.`);
+    if (NAME_PATTERN.test(name))
+        return;
+    if (HOOK_NAME_PATTERN.test(name)) {
+        throw new Error(`Name "${name}" is a hook name. Pass the entity instead, for example ${name.slice(3)}.`);
     }
+    throw new Error(`Name "${name}" must be PascalCase, for example User.`);
 }
 function parseTarget(value) {
     const parts = value.split('/');

package/dist/init/content.js

@@ -35,7 +35,8 @@ const SKILL_LINES = [
     '',
     '## Detect the stack',
     '',
-    'The tool reads `package.json` and prints `Stack: <stack> (detected)` before every command. Stacks: `next-fullstack`, `next-frontend`, `react`, `node` (Express, Fastify, Hono, or none), `nest`, `tanstack-start`. Override with `--stack <name>` if detection is wrong.',
+    'The tool reads `package.json` and prints `Stack: <stack> (detected), root: <dir>` before every command. Stacks: `next-fullstack`, `next-frontend`, `react`, `node` (Express, Fastify, Hono, or none), `nest`, `tanstack-start`. Override with `--stack <name>` if detection is wrong.',
+    'Where features are written can be overridden too: `--root <dir>` for one command, or a `domainDriver.featureRoot` key in `package.json` for the project. Read the root off the stack line rather than assuming the convention.',
     '',
     '## Commands',
     '',
@@ -70,7 +71,7 @@ const SKILL_LINES = [
     '',
     '- Next.js: `app/<feature>` or `src/app/<feature>`; route handlers under `app/api/<feature>`.',
     '- React and Node: `src/features/<feature>` or `features/<feature>`.',
-    '- Nest: `src/<feature>` with a `<feature>.module.ts`.',
+    '- Nest: `src/features/<feature>` when `src/features` exists, otherwise `src/<feature>`, with a `<feature>.module.ts`.',
     '- TanStack Start: `src/routes/<feature>` or `routes/<feature>`; every layer folder is prefixed with `-` so the router ignores it, and the entry file is `index.tsx`, not `page.tsx`.',
 ];
 exports.AGENTS_SECTION = AGENTS_LINES.join('\n');

package/dist/stack/detect.js

@@ -41,22 +41,30 @@ const path = __importStar(require("path"));
 const fs_1 = require("../utils/fs");
 const types_1 = require("./types");
 const API_DIRS = ['app/api', 'src/app/api', 'pages/api', 'src/pages/api'];
+const ROOT_LABELS = Object.freeze({
+    detected: '',
+    flag: ' (--root)',
+    config: ' (package.json)',
+});
 let cached;
 function resetStackCache() {
     cached = undefined;
 }
-function detectStack(override) {
+function detectStack(override, rootOverride) {
     if (cached)
         return cached;
     const cwd = process.cwd();
     const overridden = override !== undefined;
-    const deps = readDependencies(cwd, overridden);
+    const pkg = readPackageJson(cwd, overridden);
+    const deps = dependencyNames(pkg);
     const stack = overridden ? parseOverride(override) : inferStack(cwd, deps);
+    const root = resolveRoot(cwd, stack, pkg, rootOverride);
     const result = Object.freeze({
         stack,
         source: overridden ? 'override' : 'detected',
         httpFramework: stack === 'node' ? detectHttpFramework(deps) : null,
-        featureRoot: resolveFeatureRoot(cwd, stack),
+        featureRoot: root.featureRoot,
+        featureRootSource: root.source,
         hasNestjsZod: deps.has('nestjs-zod'),
     });
     cached = result;
@@ -64,18 +72,19 @@ function detectStack(override) {
 }
 function describeStack(stack) {
     const base = `Stack: ${stack.stack} (${stack.source})`;
-    if (stack.stack !== 'node')
-        return base;
-    return `${base}, http: ${stack.httpFramework ?? 'none'}`;
+    const http = stack.stack === 'node' ? `, http: ${stack.httpFramework ?? 'none'}` : '';
+    return `${base}${http}, root: ${stack.featureRoot}${ROOT_LABELS[stack.featureRootSource]}`;
 }
-function readDependencies(cwd, optional) {
+function readPackageJson(cwd, optional) {
     const pkgPath = path.join(cwd, 'package.json');
     if (!fs.existsSync(pkgPath)) {
         if (optional)
-            return new Set();
+            return {};
         throw new Error(`No package.json found in ${cwd}. Run domain-driver from your project root, or pass --stack <name>.`);
     }
-    const pkg = parsePackageJson(pkgPath);
+    return parsePackageJson(pkgPath);
+}
+function dependencyNames(pkg) {
     return new Set([
         ...Object.keys(pkg.dependencies ?? {}),
         ...Object.keys(pkg.devDependencies ?? {}),
@@ -113,7 +122,38 @@ function hasApiDir(cwd) {
 function detectHttpFramework(deps) {
     return types_1.HTTP_FRAMEWORKS.find((name) => deps.has(name)) ?? null;
 }
-function resolveFeatureRoot(cwd, stack) {
+function resolveRoot(cwd, stack, pkg, flag) {
+    if (flag !== undefined) {
+        return { featureRoot: validateRoot(flag, '--root'), source: 'flag' };
+    }
+    const configured = configuredRoot(pkg);
+    if (configured !== null) {
+        return { featureRoot: configured, source: 'config' };
+    }
+    return { featureRoot: conventionalRoot(cwd, stack), source: 'detected' };
+}
+function configuredRoot(pkg) {
+    const value = pkg.domainDriver?.featureRoot;
+    if (value === undefined)
+        return null;
+    if (typeof value !== 'string') {
+        throw new Error('package.json "domainDriver.featureRoot" must be a string, for example "src/features".');
+    }
+    return validateRoot(value, 'package.json');
+}
+/**
+ * The root becomes a filesystem path under the project, so an absolute path or any
+ * `..` segment would write outside it. Both are rejected rather than normalised away.
+ */
+function validateRoot(value, source) {
+    const normalized = value.replace(/\\/g, '/').replace(/\/+$/, '');
+    const escapes = normalized === '' || path.isAbsolute(value) || normalized.split('/').includes('..');
+    if (escapes) {
+        throw new Error(`Feature root "${value}" from ${source} must be a relative path inside the project, for example src/features.`);
+    }
+    return normalized;
+}
+function conventionalRoot(cwd, stack) {
     switch (stack) {
         case 'next-fullstack':
         case 'next-frontend':
@@ -122,7 +162,7 @@ function resolveFeatureRoot(cwd, stack) {
         case 'node':
             return (0, fs_1.isDirectory)(path.join(cwd, 'src')) ? 'src/features' : 'features';
         case 'nest':
-            return 'src';
+            return (0, fs_1.isDirectory)(path.join(cwd, 'src', 'features')) ? 'src/features' : 'src';
         case 'tanstack-start':
             if ((0, fs_1.isDirectory)(path.join(cwd, 'src', 'routes')))
                 return 'src/routes';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "domain-driver",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "CLI scaffolding tool for domain-driven feature folders in Next.js, React, Node, NestJS, and TanStack Start projects, with per-action files, bespoke actions, and agent guidance",
   "main": "dist/index.js",
   "bin": {