@tactical-ddd/nx 0.0.2-alpha.0 → 0.0.2-alpha.1

package/README.md

@@ -4,9 +4,80 @@
 
 The suite is being built out incrementally. Generators currently available:
 
+- [`init`](#init-generator) — the recommended starting point: bootstraps the whole workspace (generator defaults, module-boundary lint rules, the Shared Kernel, and an optional framework preset such as React) in one step.
 - [`shared-kernel`](#shared-kernel-generator) — scaffolds the Shared Kernel, the agnostic foundation reused by every other module.
+- [`domain`](#domain-generator) — scaffolds a bounded business domain (its `contracts`/`core`/`ui`/`features` layers) and wires up cross-domain isolation.
 
-> More generators (e.g. `domain`) are planned. This document covers the generators shipped today.
+## Init Generator
+
+The `init` generator is the **one-shot bootstrap** for a Tactical DDD workspace. Run it once, right after creating your Nx workspace, and it wires up everything the rest of the ecosystem relies on. It is a composing generator — it does not duplicate logic, but orchestrates the lower-level pieces:
+
+1. **Workspace generator defaults** — persists shared options into `nx.json` so they are configured **once** and Nx injects them automatically into later generator invocations, so you never have to retype them. Two groups are written: the organization `prefix` plus `linter`/`unitTestRunner` for our own `@tactical-ddd/nx` generators, and the same `bundler`/`linter`/`unitTestRunner` choices for the built-in `@nx/js:library` generator — so even a hand-rolled `nx g @nx/js:library` already matches the conventions. The matching `@nx/react:library` defaults are added only under the `react` preset:
+
+   ```jsonc
+   // nx.json
+   {
+     "generators": {
+       "@tactical-ddd/nx": {
+         "shared-kernel": {
+           "prefix": "@my-org",
+           "linter": "eslint",
+           "unitTestRunner": "jest",
+         },
+       },
+       "@nx/js:library": {
+         "bundler": "none",
+         "linter": "eslint",
+         "unitTestRunner": "jest",
+       },
+       // Added only with `--preset=react`:
+       "@nx/react:library": {
+         "bundler": "none",
+         "linter": "eslint",
+         "unitTestRunner": "jest",
+       },
+     },
+   }
+   ```
+
+2. **Module-boundary lint rules** — populates `@nx/enforce-module-boundaries` in the root ESLint config with the full Tactical DDD dependency graph (`depConstraints`). This enforces the allowed dependency directions between scopes/layers _and_ the absence of circular dependencies. Both flat config (`eslint.config.*`) and legacy `.eslintrc.*` are detected and updated via AST manipulation. See [Module Boundaries & Isolation Rules](#module-boundaries--isolation-rules).
+
+3. **Shared Kernel** — invokes the [`shared-kernel`](#shared-kernel-generator) generator to scaffold `libs/shared/{contracts,utils,infrastructure}`.
+
+4. **Framework preset** _(optional)_ — with `--preset=react`, the workspace is additionally set up for React: the `@nx/react:library` generator defaults above are written, the `@nx/react` generator plugin is added, and the React runtime — `react`, `react-dom` and the [`@tactical-ddd/react`](https://www.npmjs.com/package/@tactical-ddd/react) bindings — is installed as a production dependency. With the default `--preset=none` the workspace stays framework-agnostic and none of the React tooling is pulled in.
+
+5. **Dependency check & install** — ensures the packages the configured and invoked generators rely on are present in the workspace `package.json`, installing any that are missing (via `addDependenciesToPackageJson`). Nx plugin versions are pinned to the workspace's Nx version. The set is scoped to your choices: `@nx/js` always; `@nx/eslint` + `@nx/eslint-plugin` when `linter: eslint`; `@nx/jest` or `@nx/vite` to match `unitTestRunner`; and the React packages above when `preset: react`. Already-installed packages are left untouched (never downgraded).
+
+> Order matters and is handled for you: the Shared Kernel is generated first (in a fresh workspace the root ESLint config only exists after the first library is created), then the module-boundary rules are applied to it.
+
+### Usage
+
+```bash
+nx g @tactical-ddd/nx:init --prefix=@my-org --linter=eslint --unitTestRunner=jest
+```
+
+For a React workspace, add the preset to also install `@tactical-ddd/react` and the React tooling:
+
+```bash
+nx g @tactical-ddd/nx:init --prefix=@my-org --linter=eslint --unitTestRunner=jest --preset=react
+```
+
+When run interactively (or via Nx Console), the generator prompts for any required option that is not passed on the command line.
+
+### Options
+
+| Option            | Type     | Default       | Required | Description                                                                                                                             |
+| ----------------- | -------- | ------------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------- |
+| `prefix`          | `string` | —             | Yes      | Organization prefix used for the generated library names, e.g. `@my-org`. Set once, reused by all generators.                           |
+| `sharedDirectory` | `string` | `libs/shared` | No       | Root folder the Shared Kernel libraries are generated into.                                                                             |
+| `linter`          | `string` | —             | Yes      | Linter to configure for the generated libraries. One of `eslint`, `none`.                                                               |
+| `unitTestRunner`  | `string` | —             | Yes      | Unit test runner to set up. One of `jest`, `vitest`, `none`.                                                                            |
+| `bundler`         | `string` | `none`        | No       | Bundler used to build the libraries. One of `none`, `swc`, `tsc`, `rollup`, `vite`, `esbuild`.                                          |
+| `preset`          | `string` | `none`        | No       | Framework preset. `react` also installs `@tactical-ddd/react`, the React runtime, and React generator defaults. One of `none`, `react`. |
+
+> The generator is idempotent: re-running it refreshes the `nx.json` defaults and module-boundary rules and safely skips Shared Kernel libraries that already exist.
+>
+> If the linter is set to `none` (no ESLint config in the workspace), the module-boundary step is skipped with a warning — there is no linter to enforce the graph.
 
 ## Shared Kernel Generator
 
@@ -164,3 +235,68 @@ The generator automatically tags these projects with `scope:shared`. In your roo
    - `contracts` knows about no one.
    - `utils` only knows about `contracts`.
    - `infrastructure` knows about both `contracts` and `utils`.
+
+## Domain Generator
+
+The `domain` generator scaffolds a single **bounded business domain** (e.g. `auth`, `payments`, `beneficiaries`) under `libs/[domain-name]/`. Each domain is isolated from every other domain and depends only on the Shared Kernel and — for collaboration — the **public contracts** of other domains.
+
+It generates one library per selected layer, tags each with `scope:domain` plus its layer type and a domain tag (`domain:<name>`), and registers a per-domain module-boundary constraint that enforces the isolation described below.
+
+### Layers
+
+The `--layers` option selects which layers to generate (default: `contracts,core`):
+
+| Layer       | Tags                             | Purpose                                                                                   |
+| ----------- | -------------------------------- | ----------------------------------------------------------------------------------------- |
+| `contracts` | `scope:domain`, `type:contracts` | Domain-specific types, events, and ports/API boundaries. The domain's **public surface**. |
+| `core`      | `scope:domain`, `type:core`      | Pure business logic — entities, value objects, use cases, repository interfaces.          |
+| `ui`        | `scope:domain`, `type:ui`        | Presentational components (a DOM lib is added to `tsconfig` for browser globals).         |
+| `features`  | `scope:domain`, `type:features`  | UI + state, framework bindings, DI containers — the topmost layer.                        |
+
+> Under `--preset=react`, the `ui` and `features` layers are generated as React libraries (via `@nx/react`, loaded only when the preset is set); otherwise they are framework-agnostic `@nx/js` libraries.
+
+### Cross-domain isolation (published-language)
+
+The generator injects a per-domain `@nx/enforce-module-boundaries` constraint so that a `domain:<name>` library may depend only on:
+
+- its **own** domain (`domain:<name>`),
+- the **Shared Kernel** (`scope:shared`),
+- and the **public contracts of any other domain** (`type:contracts`).
+
+This is the **published-language** pattern: a domain may depend on another domain's _abstraction_ (its contracts), but never on its _implementation_ (`core`/`ui`/`features`/`infrastructure`). The implementation stays hidden inside the domain and is provided across boundaries via dependency injection wired up in the composition root. Importing another domain's `core` fails the lint boundary check.
+
+### Usage
+
+```bash
+nx g @tactical-ddd/nx:domain payments --directory=libs/payments
+```
+
+`prefix`, `linter`, `unitTestRunner` and `preset` are inherited from the `nx.json` defaults written by [`init`](#init-generator), so in a bootstrapped workspace only the domain name (and directory) are needed. Example with explicit flags:
+
+```bash
+nx g @tactical-ddd/nx:domain payments \
+  --directory=libs/payments \
+  --prefix=@my-org \
+  --layers=contracts,core,features \
+  --preset=react \
+  --linter=eslint \
+  --unitTestRunner=jest \
+  --bundler=tsc
+```
+
+### Options
+
+| Option           | Type       | Default          | Required | Description                                                                                                 |
+| ---------------- | ---------- | ---------------- | -------- | ----------------------------------------------------------------------------------------------------------- |
+| `name`           | `string`   | —                | Yes      | Domain name, also the `domain:<name>` tag. Passed as the first positional argument.                         |
+| `directory`      | `string`   | —                | Yes      | Root folder the domain libraries are generated into, e.g. `libs/payments`.                                  |
+| `layers`         | `string[]` | `contracts,core` | Yes      | Architectural layers to generate. Any of `contracts`, `core`, `ui`, `features`.                             |
+| `prefix`         | `string`   | —                | No       | Organization prefix used for the generated library names, e.g. `@my-org`.                                   |
+| `preset`         | `string`   | `none`           | No       | Framework preset for the `ui`/`features` layers. One of `none`, `react`.                                    |
+| `linter`         | `string`   | —                | Yes      | Linter to configure for the generated libraries. One of `eslint`, `none`.                                   |
+| `unitTestRunner` | `string`   | —                | No       | Unit test runner to set up. One of `jest`, `vitest`, `none`. (`contracts` is always generated without one.) |
+| `bundler`        | `string`   | `tsc`            | No       | Bundler used to build the libraries. One of `none`, `swc`, `tsc`, `rollup`, `vite`, `esbuild`.              |
+
+> The generator is idempotent: it checks for each layer's library before creating it, so re-running it safely fills in only the layers that are missing.
+>
+> If `libs/shared/contracts` does not exist yet, the generator warns you to run [`init`](#init-generator) (or [`shared-kernel`](#shared-kernel-generator)) first, since domain libraries depend on the Shared Kernel.

package/generators/domain/domain.d.ts

@@ -0,0 +1,5 @@
+import { type GeneratorCallback, type Tree } from '@nx/devkit';
+import type { DomainGeneratorSchema } from './schema';
+export declare function domainGenerator(tree: Tree, options: DomainGeneratorSchema): Promise<GeneratorCallback>;
+export default domainGenerator;
+//# sourceMappingURL=domain.d.ts.map

package/generators/domain/domain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/generators/domain/domain.ts"],"names":[],"mappings":"AAAA,OAAO,EASL,KAAK,iBAAiB,EACtB,KAAK,IAAI,EAEV,MAAM,YAAY,CAAC;AAIpB,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAatD,wBAAsB,eAAe,CACnC,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC,iBAAiB,CAAC,CAmK5B;AAqED,eAAe,eAAe,CAAC"}

package/generators/domain/domain.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get default () {
+        return _default;
+    },
+    get domainGenerator () {
+        return domainGenerator;
+    }
+});
+const _extends = require("@swc/helpers/_/_extends");
+const _devkit = require("@nx/devkit");
+const _js = require("@nx/js");
+const _path = require("path");
+const _libraryexist = require("../../utils/library-exist");
+const _eslintmoduleboundaries = require("../../utils/eslint-module-boundaries");
+const _logger = require("../../utils/logger");
+const _types = require("../../types");
+const _resolvemoduleformat = require("../../utils/resolve-module-format");
+/** Conventional location of the shared kernel's contracts library. */ const SHARED_CONTRACTS_ROOT = 'libs/shared/contracts';
+async function domainGenerator(tree, options) {
+    // Implicit existence check (CLAUDE.md 7.3.1): domain libraries depend on the
+    // shared kernel, so warn if it has not been generated yet rather than
+    // producing libraries whose boundary constraints reference tags nothing
+    // carries.
+    if (!(0, _libraryexist.libraryExists)(tree, SHARED_CONTRACTS_ROOT)) {
+        (0, _logger.warning)(`Shared kernel not found at ${SHARED_CONTRACTS_ROOT}. Run \`nx g @tactical-ddd/nx:init\` (or the \`shared-kernel\` generator) first so domain libraries can depend on the shared contracts.`);
+    }
+    const contractsRoot = `${options.directory}/contracts`;
+    const coreRoot = `${options.directory}/core`;
+    const uiRoot = `${options.directory}/ui`;
+    const featuresRoot = `${options.directory}/features`;
+    const domainTag = `domain:${options.name}`;
+    const facadeDomainInterfaceVariants = (0, _devkit.names)(`${options.name}Facade`);
+    // Install callbacks from the delegated library generators — returned to Nx so
+    // the packages backing the inferred plugins (`@nx/eslint`, `@nx/jest`) the
+    // libraries register via `addPlugin` get installed.
+    const tasks = [];
+    if (!(0, _libraryexist.libraryExists)(tree, contractsRoot) && options.layers.includes('contracts')) {
+        tasks.push(await (0, _js.libraryGenerator)(tree, {
+            name: layerName(options, 'contracts'),
+            directory: contractsRoot,
+            useProjectJson: false,
+            addPlugin: true,
+            unitTestRunner: 'none',
+            bundler: options.bundler,
+            linter: options.linter,
+            tags: `${_types.LibraryScope.Domain},${domainTag},${_types.LibraryType.Contracts}`
+        }));
+        const type = (0, _resolvemoduleformat.resolveLibraryModuleFormat)(tree, contractsRoot);
+        tree.delete(`${contractsRoot}/src/lib/${options.name}-contracts.ts`);
+        tree.write(`${contractsRoot}/src/index.ts`, '');
+        (0, _devkit.generateFiles)(tree, (0, _path.resolve)(__dirname, 'files/contracts'), contractsRoot, {
+            name: options.name,
+            interfaceName: facadeDomainInterfaceVariants.className,
+            esm: type === _types.ModuleFormat.EsModule
+        }, {
+            overwriteStrategy: _devkit.OverwriteStrategy.Overwrite
+        });
+    }
+    if (!(0, _libraryexist.libraryExists)(tree, coreRoot) && options.layers.includes('core')) {
+        tasks.push(await (0, _js.libraryGenerator)(tree, {
+            name: layerName(options, 'core'),
+            directory: coreRoot,
+            useProjectJson: false,
+            addPlugin: true,
+            unitTestRunner: options.unitTestRunner,
+            bundler: options.bundler,
+            linter: options.linter,
+            tags: `${_types.LibraryScope.Domain},${domainTag},${_types.LibraryType.Core}`
+        }));
+        const type = (0, _resolvemoduleformat.resolveLibraryModuleFormat)(tree, coreRoot);
+        const contractsPackage = layerName(options, 'contracts');
+        tree.delete(`${coreRoot}/src/lib/${options.name}-core.ts`);
+        tree.delete(`${coreRoot}/src/lib/${options.name}-core.spec.ts`);
+        tree.write(`${coreRoot}/src/index.ts`, '');
+        // Scaffold the default Clean Architecture layer folders (domain,
+        // application, infrastructure — each kept in git via a `.gitkeep`) and lock
+        // down imports between them: domain ⊀ application/infrastructure, and
+        // application ⊀ infrastructure (the implementation is wired via DI at the
+        // composition root, not imported across layers).
+        (0, _devkit.generateFiles)(tree, (0, _path.resolve)(__dirname, 'files/core'), coreRoot, {
+            name: options.name,
+            interfaceName: facadeDomainInterfaceVariants.className,
+            // Full package name of this domain's contracts library, so the facade's
+            // import resolves with or without an organization prefix.
+            contractsPackage,
+            esm: type === _types.ModuleFormat.EsModule
+        }, {
+            overwriteStrategy: _devkit.OverwriteStrategy.Overwrite
+        });
+        // The generated facade imports the domain's contracts package, so declare it
+        // as a dependency — otherwise `@nx/dependency-checks` flags the core library
+        // for using a package missing from its `package.json`.
+        if (tree.exists(`${contractsRoot}/package.json`)) {
+            var _readJson_version;
+            const contractsVersion = (_readJson_version = (0, _devkit.readJson)(tree, `${contractsRoot}/package.json`).version) != null ? _readJson_version : '*';
+            (0, _devkit.updateJson)(tree, `${coreRoot}/package.json`, (pkg)=>{
+                pkg.dependencies = _extends._({}, pkg.dependencies, {
+                    [contractsPackage]: contractsVersion
+                });
+                return pkg;
+            });
+        }
+        (0, _eslintmoduleboundaries.applyCleanArchitectureBoundaries)(tree, coreRoot, options.prefix);
+    }
+    if (!(0, _libraryexist.libraryExists)(tree, uiRoot) && options.layers.includes('ui')) {
+        tasks.push(await generateLayerLibrary(tree, options, {
+            root: uiRoot,
+            name: layerName(options, 'ui'),
+            tags: `${_types.LibraryScope.Domain},${domainTag},${_types.LibraryType.Ui}`
+        }));
+    }
+    if (!(0, _libraryexist.libraryExists)(tree, featuresRoot) && options.layers.includes('features')) {
+        tasks.push(await generateLayerLibrary(tree, options, {
+            root: featuresRoot,
+            name: layerName(options, 'features'),
+            tags: `${_types.LibraryScope.Domain},${domainTag},${_types.LibraryType.Features}`
+        }));
+    }
+    // Silo this domain: per-domain constraints are what actually prevent
+    // cross-domain imports (a static `domain:*` rule cannot — Nx glob-matches the
+    // target tags, so it would let `domain:auth` import `domain:payments`).
+    //
+    // A `domain:<name>` library may depend on its own domain, the shared kernel,
+    // and the *public contracts* of any other domain (`type:contracts`) — the
+    // published-language pattern: a domain depends on another domain's
+    // abstraction, never its implementation (`core`/`ui`/`features`/
+    // `infrastructure`), which stays hidden behind DI wired up in the composition
+    // root. No-op (with a warning) when there is no ESLint config.
+    (0, _eslintmoduleboundaries.applyDepConstraints)(tree, [
+        {
+            sourceTag: domainTag,
+            onlyDependOnLibsWithTags: [
+                domainTag,
+                _types.LibraryScope.Shared,
+                _types.LibraryType.Contracts
+            ]
+        }
+    ]);
+    await (0, _devkit.formatFiles)(tree);
+    return (0, _devkit.runTasksInSerial)(...tasks);
+}
+/** Composes a layer library name, applying the optional organization prefix. */ function layerName(options, layer) {
+    const base = `${options.name}-${layer}`;
+    return options.prefix ? `${options.prefix}/${base}` : base;
+}
+/**
+ * Generates a presentational/feature layer library and returns its install
+ * callback. Under the `react` preset it uses `@nx/react`'s generator (loaded
+ * lazily via `ensurePackage` so the domain generator never hard-depends on
+ * `@nx/react` in non-React workspaces); under `none` it uses `@nx/js` and adds
+ * the DOM lib to the library `tsconfig` so browser globals type-check.
+ *
+ * Both pass `addPlugin: true` so the library gets inferred tasks (Project
+ * Crystal) rather than the deprecated executor targets the generators' public
+ * wrappers default to.
+ */ async function generateLayerLibrary(tree, options, layer) {
+    if (options.preset === 'react') {
+        const { libraryGenerator: reactLibraryGenerator } = (0, _devkit.ensurePackage)('@nx/react', _devkit.NX_VERSION);
+        return await reactLibraryGenerator(tree, {
+            name: layer.name,
+            directory: layer.root,
+            useProjectJson: false,
+            addPlugin: true,
+            unitTestRunner: options.unitTestRunner,
+            bundler: options.bundler,
+            linter: options.linter,
+            style: 'none',
+            tags: layer.tags
+        });
+    }
+    const task = await (0, _js.libraryGenerator)(tree, {
+        name: layer.name,
+        directory: layer.root,
+        useProjectJson: false,
+        addPlugin: true,
+        unitTestRunner: options.unitTestRunner,
+        bundler: options.bundler,
+        linter: options.linter,
+        tags: layer.tags
+    });
+    addDomLibToTsConfig(tree, layer.root);
+    return task;
+}
+/** Adds the `DOM` lib to a library's `tsconfig.lib.json` (idempotent). */ function addDomLibToTsConfig(tree, root) {
+    (0, _devkit.updateJson)(tree, `${root}/tsconfig.lib.json`, (json)=>{
+        var _json, _compilerOptions;
+        (_compilerOptions = (_json = json).compilerOptions) != null ? _compilerOptions : _json.compilerOptions = {};
+        if (!json.compilerOptions.lib) {
+            json.compilerOptions.lib = [
+                'ESNext',
+                'DOM'
+            ];
+        } else if (!json.compilerOptions.lib.includes('DOM')) {
+            json.compilerOptions.lib.push('DOM');
+        }
+        return json;
+    });
+}
+const _default = domainGenerator;
+
+//# sourceMappingURL=domain.js.map

package/generators/domain/domain.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../packages/nx/src/generators/domain/domain.ts"],"sourcesContent":["import {\n  ensurePackage,\n  formatFiles,\n  generateFiles,\n  names,\n  NX_VERSION,\n  OverwriteStrategy,\n  readJson,\n  runTasksInSerial,\n  type GeneratorCallback,\n  type Tree,\n  updateJson,\n} from '@nx/devkit';\nimport { libraryGenerator as jsLibraryGenerator } from '@nx/js';\nimport { resolve } from 'path';\n\nimport type { DomainGeneratorSchema } from './schema';\nimport { libraryExists } from '../../utils/library-exist';\nimport {\n  applyCleanArchitectureBoundaries,\n  applyDepConstraints,\n} from '../../utils/eslint-module-boundaries';\nimport { warning } from '../../utils/logger';\nimport { LibraryScope, LibraryType, ModuleFormat } from '../../types';\nimport { resolveLibraryModuleFormat } from '../../utils/resolve-module-format';\n\n/** Conventional location of the shared kernel's contracts library. */\nconst SHARED_CONTRACTS_ROOT = 'libs/shared/contracts';\n\nexport async function domainGenerator(\n  tree: Tree,\n  options: DomainGeneratorSchema,\n): Promise<GeneratorCallback> {\n  // Implicit existence check (CLAUDE.md 7.3.1): domain libraries depend on the\n  // shared kernel, so warn if it has not been generated yet rather than\n  // producing libraries whose boundary constraints reference tags nothing\n  // carries.\n  if (!libraryExists(tree, SHARED_CONTRACTS_ROOT)) {\n    warning(\n      `Shared kernel not found at ${SHARED_CONTRACTS_ROOT}. Run \\`nx g @tactical-ddd/nx:init\\` (or the \\`shared-kernel\\` generator) first so domain libraries can depend on the shared contracts.`,\n    );\n  }\n\n  const contractsRoot = `${options.directory}/contracts`;\n  const coreRoot = `${options.directory}/core`;\n  const uiRoot = `${options.directory}/ui`;\n  const featuresRoot = `${options.directory}/features`;\n  const domainTag = `domain:${options.name}`;\n  const facadeDomainInterfaceVariants = names(`${options.name}Facade`);\n\n  // Install callbacks from the delegated library generators — returned to Nx so\n  // the packages backing the inferred plugins (`@nx/eslint`, `@nx/jest`) the\n  // libraries register via `addPlugin` get installed.\n  const tasks: GeneratorCallback[] = [];\n\n  if (\n    !libraryExists(tree, contractsRoot) &&\n    options.layers.includes('contracts')\n  ) {\n    tasks.push(\n      await jsLibraryGenerator(tree, {\n        name: layerName(options, 'contracts'),\n        directory: contractsRoot,\n        useProjectJson: false,\n        addPlugin: true,\n        unitTestRunner: 'none',\n        bundler: options.bundler,\n        linter: options.linter,\n        tags: `${LibraryScope.Domain},${domainTag},${LibraryType.Contracts}`,\n      }),\n    );\n\n    const type = resolveLibraryModuleFormat(tree, contractsRoot);\n\n    tree.delete(`${contractsRoot}/src/lib/${options.name}-contracts.ts`);\n    tree.write(`${contractsRoot}/src/index.ts`, '');\n    generateFiles(\n      tree,\n      resolve(__dirname, 'files/contracts'),\n      contractsRoot,\n      {\n        name: options.name,\n        interfaceName: facadeDomainInterfaceVariants.className,\n        esm: type === ModuleFormat.EsModule,\n      },\n      { overwriteStrategy: OverwriteStrategy.Overwrite },\n    );\n  }\n\n  if (!libraryExists(tree, coreRoot) && options.layers.includes('core')) {\n    tasks.push(\n      await jsLibraryGenerator(tree, {\n        name: layerName(options, 'core'),\n        directory: coreRoot,\n        useProjectJson: false,\n        addPlugin: true,\n        unitTestRunner: options.unitTestRunner,\n        bundler: options.bundler,\n        linter: options.linter,\n        tags: `${LibraryScope.Domain},${domainTag},${LibraryType.Core}`,\n      }),\n    );\n\n    const type = resolveLibraryModuleFormat(tree, coreRoot);\n    const contractsPackage = layerName(options, 'contracts');\n\n    tree.delete(`${coreRoot}/src/lib/${options.name}-core.ts`);\n    tree.delete(`${coreRoot}/src/lib/${options.name}-core.spec.ts`);\n    tree.write(`${coreRoot}/src/index.ts`, '');\n\n    // Scaffold the default Clean Architecture layer folders (domain,\n    // application, infrastructure — each kept in git via a `.gitkeep`) and lock\n    // down imports between them: domain ⊀ application/infrastructure, and\n    // application ⊀ infrastructure (the implementation is wired via DI at the\n    // composition root, not imported across layers).\n    generateFiles(\n      tree,\n      resolve(__dirname, 'files/core'),\n      coreRoot,\n      {\n        name: options.name,\n        interfaceName: facadeDomainInterfaceVariants.className,\n        // Full package name of this domain's contracts library, so the facade's\n        // import resolves with or without an organization prefix.\n        contractsPackage,\n        esm: type === ModuleFormat.EsModule,\n      },\n      { overwriteStrategy: OverwriteStrategy.Overwrite },\n    );\n\n    // The generated facade imports the domain's contracts package, so declare it\n    // as a dependency — otherwise `@nx/dependency-checks` flags the core library\n    // for using a package missing from its `package.json`.\n    if (tree.exists(`${contractsRoot}/package.json`)) {\n      const contractsVersion =\n        readJson(tree, `${contractsRoot}/package.json`).version ?? '*';\n      updateJson(tree, `${coreRoot}/package.json`, (pkg) => {\n        pkg.dependencies = {\n          ...pkg.dependencies,\n          [contractsPackage]: contractsVersion,\n        };\n        return pkg;\n      });\n    }\n\n    applyCleanArchitectureBoundaries(tree, coreRoot, options.prefix);\n  }\n\n  if (!libraryExists(tree, uiRoot) && options.layers.includes('ui')) {\n    tasks.push(\n      await generateLayerLibrary(tree, options, {\n        root: uiRoot,\n        name: layerName(options, 'ui'),\n        tags: `${LibraryScope.Domain},${domainTag},${LibraryType.Ui}`,\n      }),\n    );\n  }\n\n  if (\n    !libraryExists(tree, featuresRoot) &&\n    options.layers.includes('features')\n  ) {\n    tasks.push(\n      await generateLayerLibrary(tree, options, {\n        root: featuresRoot,\n        name: layerName(options, 'features'),\n        tags: `${LibraryScope.Domain},${domainTag},${LibraryType.Features}`,\n      }),\n    );\n  }\n\n  // Silo this domain: per-domain constraints are what actually prevent\n  // cross-domain imports (a static `domain:*` rule cannot — Nx glob-matches the\n  // target tags, so it would let `domain:auth` import `domain:payments`).\n  //\n  // A `domain:<name>` library may depend on its own domain, the shared kernel,\n  // and the *public contracts* of any other domain (`type:contracts`) — the\n  // published-language pattern: a domain depends on another domain's\n  // abstraction, never its implementation (`core`/`ui`/`features`/\n  // `infrastructure`), which stays hidden behind DI wired up in the composition\n  // root. No-op (with a warning) when there is no ESLint config.\n  applyDepConstraints(tree, [\n    {\n      sourceTag: domainTag,\n      onlyDependOnLibsWithTags: [\n        domainTag,\n        LibraryScope.Shared,\n        LibraryType.Contracts,\n      ],\n    },\n  ]);\n\n  await formatFiles(tree);\n\n  return runTasksInSerial(...tasks);\n}\n\n/** Composes a layer library name, applying the optional organization prefix. */\nfunction layerName(options: DomainGeneratorSchema, layer: string): string {\n  const base = `${options.name}-${layer}`;\n  return options.prefix ? `${options.prefix}/${base}` : base;\n}\n\n/**\n * Generates a presentational/feature layer library and returns its install\n * callback. Under the `react` preset it uses `@nx/react`'s generator (loaded\n * lazily via `ensurePackage` so the domain generator never hard-depends on\n * `@nx/react` in non-React workspaces); under `none` it uses `@nx/js` and adds\n * the DOM lib to the library `tsconfig` so browser globals type-check.\n *\n * Both pass `addPlugin: true` so the library gets inferred tasks (Project\n * Crystal) rather than the deprecated executor targets the generators' public\n * wrappers default to.\n */\nasync function generateLayerLibrary(\n  tree: Tree,\n  options: DomainGeneratorSchema,\n  layer: { root: string; name: string; tags: string },\n): Promise<GeneratorCallback> {\n  if (options.preset === 'react') {\n    const { libraryGenerator: reactLibraryGenerator } = ensurePackage<\n      typeof import('@nx/react')\n    >('@nx/react', NX_VERSION);\n\n    return await reactLibraryGenerator(tree, {\n      name: layer.name,\n      directory: layer.root,\n      useProjectJson: false,\n      addPlugin: true,\n      unitTestRunner: options.unitTestRunner,\n      bundler: options.bundler,\n      linter: options.linter,\n      style: 'none',\n      tags: layer.tags,\n    });\n  }\n\n  const task = await jsLibraryGenerator(tree, {\n    name: layer.name,\n    directory: layer.root,\n    useProjectJson: false,\n    addPlugin: true,\n    unitTestRunner: options.unitTestRunner,\n    bundler: options.bundler,\n    linter: options.linter,\n    tags: layer.tags,\n  });\n  addDomLibToTsConfig(tree, layer.root);\n  return task;\n}\n\n/** Adds the `DOM` lib to a library's `tsconfig.lib.json` (idempotent). */\nfunction addDomLibToTsConfig(tree: Tree, root: string) {\n  updateJson(tree, `${root}/tsconfig.lib.json`, (json) => {\n    json.compilerOptions ??= {};\n    if (!json.compilerOptions.lib) {\n      json.compilerOptions.lib = ['ESNext', 'DOM'];\n    } else if (!json.compilerOptions.lib.includes('DOM')) {\n      json.compilerOptions.lib.push('DOM');\n    }\n    return json;\n  });\n}\n\nexport default domainGenerator;\n"],"names":["domainGenerator","SHARED_CONTRACTS_ROOT","tree","options","libraryExists","warning","contractsRoot","directory","coreRoot","uiRoot","featuresRoot","domainTag","name","facadeDomainInterfaceVariants","names","tasks","layers","includes","push","jsLibraryGenerator","layerName","useProjectJson","addPlugin","unitTestRunner","bundler","linter","tags","LibraryScope","Domain","LibraryType","Contracts","type","resolveLibraryModuleFormat","delete","write","generateFiles","resolve","__dirname","interfaceName","className","esm","ModuleFormat","EsModule","overwriteStrategy","OverwriteStrategy","Overwrite","Core","contractsPackage","exists","readJson","contractsVersion","version","updateJson","pkg","dependencies","applyCleanArchitectureBoundaries","prefix","generateLayerLibrary","root","Ui","Features","applyDepConstraints","sourceTag","onlyDependOnLibsWithTags","Shared","formatFiles","runTasksInSerial","layer","base","preset","libraryGenerator","reactLibraryGenerator","ensurePackage","NX_VERSION","style","task","addDomLibToTsConfig","json","compilerOptions","lib"],"mappings":"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"}

package/generators/domain/files/contracts/src/index.ts

@@ -0,0 +1 @@
+export * from './lib/interfaces/<%= name %>-facade.interface<% if (esm) { %>.js<% } %>';

package/generators/domain/files/contracts/src/lib/interfaces/__name__-facade.interface.ts

@@ -0,0 +1,7 @@
+export interface <%= interfaceName %> {
+  method(): void
+}
+
+export const <%= interfaceName %> = {
+  $: Symbol.for('<%= interfaceName %>')
+}

package/generators/domain/files/core/src/index.ts

@@ -0,0 +1 @@
+export * from './lib/application/<%= name %>.facade<% if (esm) { %>.js<% } %>';

package/generators/domain/files/core/src/lib/application/__name__.facade.ts

@@ -0,0 +1,7 @@
+import { <%= interfaceName %> } from '<%= contractsPackage %>';
+
+export class Core<%= interfaceName %> implements <%= interfaceName %> {
+  method(): void {
+    throw new Error('Method not implemented.');
+  }
+}

package/generators/domain/schema.d.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=schema.d.js.map

package/generators/domain/schema.d.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../packages/nx/src/generators/domain/schema.d.ts"],"names":[],"mappings":""}

package/generators/domain/schema.d.ts

@@ -0,0 +1,12 @@
+import type { Bundler } from '@nx/devkit';
+
+export interface DomainGeneratorSchema {
+  directory: string;
+  name: string;
+  layers: string[];
+  prefix?: string;
+  preset?: string;
+  linter: 'eslint' | 'none';
+  unitTestRunner?: 'jest' | 'vitest' | 'none';
+  bundler?: Bundler;
+}

package/generators/domain/schema.json

@@ -0,0 +1,73 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "DomainGenerator",
+  "title": "Tactical DDD: Domain Generator",
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "Domain ",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": "What name would you like to use?"
+    },
+    "directory": {
+      "type": "string",
+      "description": "Root folder for domain libraries",
+      "x-prompt": "Which directory should the domain be generated into?"
+    },
+    "prefix": {
+      "type": "string",
+      "description": "Organization prefix for the generated libraries, e.g. '@my-org'",
+      "x-prompt": "Which organization prefix should be used (e.g. @my-org)?"
+    },
+    "layers": {
+      "type": "array",
+      "description": "Select the architectural layers to generate for this domain",
+      "items": {
+        "type": "string",
+        "enum": ["contracts", "core", "ui", "features"]
+      },
+      "default": ["contracts", "core"],
+      "x-prompt": "Select the architectural layers to generate for this domain"
+    },
+    "preset": {
+      "type": "string",
+      "enum": ["none", "react"],
+      "default": "none",
+      "description": "Framework preset. 'react' also installs @tactical-ddd/react, the React runtime and React generator defaults.",
+      "x-prompt": {
+        "message": "Which framework preset should be configured?",
+        "type": "list",
+        "items": [
+          { "value": "none", "label": "None (framework-agnostic)" },
+          {
+            "value": "react",
+            "label": "React (@tactical-ddd/react + React tooling)"
+          }
+        ]
+      }
+    },
+    "linter": {
+      "type": "string",
+      "enum": ["eslint", "none"],
+      "description": "Which linter to use?",
+      "x-prompt": "Which linter should be configured?"
+    },
+    "unitTestRunner": {
+      "type": "string",
+      "enum": ["jest", "vitest", "none"],
+      "description": "Which test runner to use?",
+      "x-prompt": "Which unit test runner should be used?"
+    },
+    "bundler": {
+      "type": "string",
+      "enum": ["none", "swc", "tsc", "rollup", "vite", "esbuild"],
+      "default": "tsc",
+      "description": "Which bundler to use? Defaults to 'tsc' per the Tactical DDD standard (all generated libraries are tsc-built)."
+    }
+  },
+  "required": ["name", "directory", "layers", "linter", "prefix"]
+}

package/generators/init/init.d.ts

@@ -0,0 +1,5 @@
+import { type GeneratorCallback, type Tree } from '@nx/devkit';
+import type { InitGeneratorSchema } from './schema';
+export declare function initGenerator(tree: Tree, options: InitGeneratorSchema): Promise<GeneratorCallback>;
+export default initGenerator;
+//# sourceMappingURL=init.d.ts.map

package/generators/init/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/generators/init/init.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,iBAAiB,EAEtB,KAAK,IAAI,EACV,MAAM,YAAY,CAAC;AAEpB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAuDpD,wBAAsB,aAAa,CACjC,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,iBAAiB,CAAC,CA8B5B;AA4HD,eAAe,aAAa,CAAC"}