@tactical-ddd/nx 0.0.1-alpha.3 → 0.0.2-alpha.1

package/generators/init/init.js

@@ -0,0 +1,193 @@
+"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 initGenerator () {
+        return initGenerator;
+    }
+});
+const _extends = require("@swc/helpers/_/_extends");
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _devkit = require("@nx/devkit");
+const _moduleboundaries = require("./module-boundaries");
+const _eslintmoduleboundaries = require("../../utils/eslint-module-boundaries");
+const _sharedkernel = /*#__PURE__*/ _interop_require_default._(require("../shared-kernel/shared-kernel"));
+/**
+ * Collection name this plugin publishes its generators under. Used as the key
+ * in `nx.json`'s `generators` map so defaults apply to every generator we ship.
+ */ const COLLECTION = '@tactical-ddd/nx';
+/**
+ * Generators that accept (and should inherit) the workspace-wide `prefix`.
+ * Extend this list as new generators are added — for now only `shared-kernel`
+ * consumes the prefix.
+ */ const PREFIXED_GENERATORS = [
+    'shared-kernel',
+    'domain'
+];
+/**
+ * Built-in Nx library generators that should inherit the workspace-wide
+ * build/lint/test defaults so hand-rolled libraries match the conventions.
+ * `@nx/js:library` always applies; `@nx/react:library` is layered on only for
+ * the `react` preset (see {@link setGeneratorDefaults}).
+ */ const BASE_LIBRARY_GENERATORS = [
+    '@nx/js:library'
+];
+const REACT_LIBRARY_GENERATORS = [
+    '@nx/react:library'
+];
+/** The Tactical DDD React runtime bindings package. */ const TACTICAL_DDD_REACT = '@tactical-ddd/react';
+/**
+ * React runtime versions added to the *user's* workspace under the `react`
+ * preset. Kept in step with the React version `@nx/react`'s own generators
+ * install so the two never disagree.
+ */ const REACT_VERSION = '^19.0.0';
+const REACT_DOM_VERSION = '^19.0.0';
+/**
+ * Version specifier to install `@tactical-ddd/react` at. The React bindings are
+ * released in lockstep with this plugin, so we mirror the running plugin's own
+ * version. This also makes the e2e suite resolve the locally-published build:
+ * both packages are published to the local registry under the same e2e version.
+ */ function tacticalDddReactVersion() {
+    try {
+        // Resolves from the workspace the generator runs in, where the plugin is
+        // installed (real usage and e2e).
+        return require('@tactical-ddd/nx/package.json').version;
+    } catch (unused) {
+        // Source / unit-test fallback: this package's own manifest.
+        return require('../../../package.json').version;
+    }
+}
+async function initGenerator(tree, options) {
+    setGeneratorDefaults(tree, options);
+    // Make sure every Nx plugin the configured/invoked generators rely on is
+    // present; the returned task installs whatever was missing once the generator
+    // finishes writing to the tree.
+    const installDependencies = ensureGeneratorDependencies(tree, options);
+    // Generate the shared kernel first: in a fresh workspace the root ESLint
+    // config does not exist until the first library is generated, so this is what
+    // establishes the config that `applyDepConstraints` then tunes.
+    const installKernel = await (0, _sharedkernel.default)(tree, {
+        directory: options.sharedDirectory,
+        prefix: options.prefix,
+        linter: options.linter,
+        unitTestRunner: options.unitTestRunner,
+        bundler: options.bundler
+    });
+    // Populate the root ESLint config with the Tactical DDD dependency graph so
+    // the architecture is enforced at lint time. Skipped (with a warning) when
+    // the workspace has no ESLint config — e.g. `linter: none`.
+    (0, _eslintmoduleboundaries.applyDepConstraints)(tree, _moduleboundaries.DEP_CONSTRAINTS);
+    await (0, _devkit.formatFiles)(tree);
+    // Run both the plugin-dependency install and the shared kernel's own install
+    // callbacks (the latter installs the packages backing the inferred ESLint/Jest
+    // plugins the generated libraries registered).
+    return (0, _devkit.runTasksInSerial)(installDependencies, installKernel);
+}
+/**
+ * Ensures the Nx plugin packages the configured/invoked generators depend on are
+ * declared in the workspace `package.json`, installing any that are missing.
+ *
+ * `addDependenciesToPackageJson` is itself the presence check: it only adds (or
+ * bumps) entries that are absent or older, leaving existing versions untouched,
+ * and returns a task that runs the package manager install for whatever changed.
+ * All versions are pinned to `NX_VERSION` — the Nx version this plugin runs
+ * against — so the added plugins stay in lockstep with the workspace's Nx core.
+ *
+ * Dependencies are scoped to the chosen options: the ESLint tooling is only
+ * required when `linter: 'eslint'`, and the test-runner plugin follows
+ * `unitTestRunner`. The `react` preset additionally pulls in the `@nx/react`
+ * generator plugin (dev-time) plus the React runtime — `react`, `react-dom`
+ * and the `@tactical-ddd/react` bindings — as production dependencies.
+ */ function ensureGeneratorDependencies(tree, options) {
+    const dependencies = {};
+    const devDependencies = {
+        // Powers the shared-kernel generator (`@nx/js:library`) and the
+        // `@nx/js:library` defaults written above.
+        '@nx/js': _devkit.NX_VERSION
+    };
+    if (options.linter === 'eslint') {
+        // `@nx/eslint` provides the flat-config AST utilities and lint target;
+        // `@nx/eslint-plugin` provides the `@nx/enforce-module-boundaries` rule.
+        devDependencies['@nx/eslint'] = _devkit.NX_VERSION;
+        devDependencies['@nx/eslint-plugin'] = _devkit.NX_VERSION;
+    }
+    if (options.unitTestRunner === 'jest') {
+        devDependencies['@nx/jest'] = _devkit.NX_VERSION;
+    } else if (options.unitTestRunner === 'vitest') {
+        devDependencies['@nx/vite'] = _devkit.NX_VERSION;
+    }
+    if (options.preset === 'react') {
+        // Dev-time: powers the `@nx/react:library` defaults and React generators.
+        devDependencies['@nx/react'] = _devkit.NX_VERSION;
+        // Run-time: the React framework and our React bindings ship in the app.
+        dependencies['react'] = REACT_VERSION;
+        dependencies['react-dom'] = REACT_DOM_VERSION;
+        dependencies[TACTICAL_DDD_REACT] = tacticalDddReactVersion();
+    }
+    return (0, _devkit.addDependenciesToPackageJson)(tree, dependencies, devDependencies);
+}
+/**
+ * Persists workspace-wide generator defaults into `nx.json` so choices like the
+ * organization `prefix`, linter and test runner are configured once during
+ * `init` and then transparently injected by Nx into every subsequent generator
+ * invocation (e.g. `nx g @tactical-ddd/nx:shared-kernel`, or even the built-in
+ * `nx g @nx/js:library`) without the user re-typing them.
+ *
+ * Two groups of defaults are written:
+ *
+ *   "generators": {
+ *     // 1. Our own collection — inherit the prefix and linting/testing choices.
+ *     "@tactical-ddd/nx": {
+ *       "shared-kernel": { "prefix": "@my-org", "linter": "eslint", "unitTestRunner": "jest" }
+ *     },
+ *     // 2. The built-in library generators — so hand-rolled libs match conventions.
+ *     "@nx/js:library":    { "bundler": "none", "linter": "eslint", "unitTestRunner": "jest" },
+ *     // `@nx/react:library` is added only under the `react` preset.
+ *     "@nx/react:library": { "bundler": "none", "linter": "eslint", "unitTestRunner": "jest" }
+ *   }
+ */ function setGeneratorDefaults(tree, options) {
+    var _readNxJson, _nxJson, _generators, _generators1, _COLLECTION, _, _options_bundler;
+    const nxJson = (_readNxJson = (0, _devkit.readNxJson)(tree)) != null ? _readNxJson : {};
+    const generators = (_generators = (_nxJson = nxJson).generators) != null ? _generators : _nxJson.generators = {};
+    // 1. Our own collection's generators inherit the prefix + linting/testing.
+    const collectionDefaults = (_ = (_generators1 = generators)[_COLLECTION = COLLECTION]) != null ? _ : _generators1[_COLLECTION] = {};
+    for (const generator of PREFIXED_GENERATORS){
+        collectionDefaults[generator] = _extends._({}, collectionDefaults[generator], {
+            prefix: options.prefix,
+            linter: options.linter,
+            unitTestRunner: options.unitTestRunner,
+            preset: options.preset
+        });
+    }
+    // 2. The built-in library generators get the same workspace-wide build/lint/
+    // test defaults, so a plain `nx g @nx/js:library` (or `@nx/react:library`)
+    // produces a library that already matches the Tactical DDD conventions.
+    // `@nx/react:library` defaults are written only under the `react` preset, so
+    // we don't advertise React tooling a non-React workspace never installed.
+    const libraryDefaults = {
+        bundler: (_options_bundler = options.bundler) != null ? _options_bundler : 'none',
+        linter: options.linter,
+        unitTestRunner: options.unitTestRunner
+    };
+    const libraryGenerators = options.preset === 'react' ? [
+        ...BASE_LIBRARY_GENERATORS,
+        ...REACT_LIBRARY_GENERATORS
+    ] : BASE_LIBRARY_GENERATORS;
+    for (const generator of libraryGenerators){
+        generators[generator] = _extends._({}, generators[generator], libraryDefaults);
+    }
+    (0, _devkit.updateNxJson)(tree, nxJson);
+}
+const _default = initGenerator;
+
+//# sourceMappingURL=init.js.map

package/generators/init/init.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../packages/nx/src/generators/init/init.ts"],"sourcesContent":["import {\n  addDependenciesToPackageJson,\n  formatFiles,\n  NX_VERSION,\n  readNxJson,\n  runTasksInSerial,\n  updateNxJson,\n  type GeneratorCallback,\n  type NxJsonConfiguration,\n  type Tree,\n} from '@nx/devkit';\n\nimport type { InitGeneratorSchema } from './schema';\nimport { DEP_CONSTRAINTS } from './module-boundaries';\nimport { applyDepConstraints } from '../../utils/eslint-module-boundaries';\nimport sharedKernelGenerator from '../shared-kernel/shared-kernel';\n\n/**\n * Collection name this plugin publishes its generators under. Used as the key\n * in `nx.json`'s `generators` map so defaults apply to every generator we ship.\n */\nconst COLLECTION = '@tactical-ddd/nx';\n\n/**\n * Generators that accept (and should inherit) the workspace-wide `prefix`.\n * Extend this list as new generators are added — for now only `shared-kernel`\n * consumes the prefix.\n */\nconst PREFIXED_GENERATORS = ['shared-kernel', 'domain'] as const;\n\n/**\n * Built-in Nx library generators that should inherit the workspace-wide\n * build/lint/test defaults so hand-rolled libraries match the conventions.\n * `@nx/js:library` always applies; `@nx/react:library` is layered on only for\n * the `react` preset (see {@link setGeneratorDefaults}).\n */\nconst BASE_LIBRARY_GENERATORS = ['@nx/js:library'] as const;\nconst REACT_LIBRARY_GENERATORS = ['@nx/react:library'] as const;\n\n/** The Tactical DDD React runtime bindings package. */\nconst TACTICAL_DDD_REACT = '@tactical-ddd/react';\n\n/**\n * React runtime versions added to the *user's* workspace under the `react`\n * preset. Kept in step with the React version `@nx/react`'s own generators\n * install so the two never disagree.\n */\nconst REACT_VERSION = '^19.0.0';\nconst REACT_DOM_VERSION = '^19.0.0';\n\n/**\n * Version specifier to install `@tactical-ddd/react` at. The React bindings are\n * released in lockstep with this plugin, so we mirror the running plugin's own\n * version. This also makes the e2e suite resolve the locally-published build:\n * both packages are published to the local registry under the same e2e version.\n */\nfunction tacticalDddReactVersion(): string {\n  try {\n    // Resolves from the workspace the generator runs in, where the plugin is\n    // installed (real usage and e2e).\n    return require('@tactical-ddd/nx/package.json').version as string;\n  } catch {\n    // Source / unit-test fallback: this package's own manifest.\n    return require('../../../package.json').version as string;\n  }\n}\n\nexport async function initGenerator(\n  tree: Tree,\n  options: InitGeneratorSchema,\n): Promise<GeneratorCallback> {\n  setGeneratorDefaults(tree, options);\n\n  // Make sure every Nx plugin the configured/invoked generators rely on is\n  // present; the returned task installs whatever was missing once the generator\n  // finishes writing to the tree.\n  const installDependencies = ensureGeneratorDependencies(tree, options);\n\n  // Generate the shared kernel first: in a fresh workspace the root ESLint\n  // config does not exist until the first library is generated, so this is what\n  // establishes the config that `applyDepConstraints` then tunes.\n  const installKernel = await sharedKernelGenerator(tree, {\n    directory: options.sharedDirectory,\n    prefix: options.prefix,\n    linter: options.linter,\n    unitTestRunner: options.unitTestRunner,\n    bundler: options.bundler,\n  });\n\n  // Populate the root ESLint config with the Tactical DDD dependency graph so\n  // the architecture is enforced at lint time. Skipped (with a warning) when\n  // the workspace has no ESLint config — e.g. `linter: none`.\n  applyDepConstraints(tree, DEP_CONSTRAINTS);\n\n  await formatFiles(tree);\n\n  // Run both the plugin-dependency install and the shared kernel's own install\n  // callbacks (the latter installs the packages backing the inferred ESLint/Jest\n  // plugins the generated libraries registered).\n  return runTasksInSerial(installDependencies, installKernel);\n}\n\n/**\n * Ensures the Nx plugin packages the configured/invoked generators depend on are\n * declared in the workspace `package.json`, installing any that are missing.\n *\n * `addDependenciesToPackageJson` is itself the presence check: it only adds (or\n * bumps) entries that are absent or older, leaving existing versions untouched,\n * and returns a task that runs the package manager install for whatever changed.\n * All versions are pinned to `NX_VERSION` — the Nx version this plugin runs\n * against — so the added plugins stay in lockstep with the workspace's Nx core.\n *\n * Dependencies are scoped to the chosen options: the ESLint tooling is only\n * required when `linter: 'eslint'`, and the test-runner plugin follows\n * `unitTestRunner`. The `react` preset additionally pulls in the `@nx/react`\n * generator plugin (dev-time) plus the React runtime — `react`, `react-dom`\n * and the `@tactical-ddd/react` bindings — as production dependencies.\n */\nfunction ensureGeneratorDependencies(\n  tree: Tree,\n  options: InitGeneratorSchema,\n): GeneratorCallback {\n  const dependencies: Record<string, string> = {};\n  const devDependencies: Record<string, string> = {\n    // Powers the shared-kernel generator (`@nx/js:library`) and the\n    // `@nx/js:library` defaults written above.\n    '@nx/js': NX_VERSION,\n  };\n\n  if (options.linter === 'eslint') {\n    // `@nx/eslint` provides the flat-config AST utilities and lint target;\n    // `@nx/eslint-plugin` provides the `@nx/enforce-module-boundaries` rule.\n    devDependencies['@nx/eslint'] = NX_VERSION;\n    devDependencies['@nx/eslint-plugin'] = NX_VERSION;\n  }\n\n  if (options.unitTestRunner === 'jest') {\n    devDependencies['@nx/jest'] = NX_VERSION;\n  } else if (options.unitTestRunner === 'vitest') {\n    devDependencies['@nx/vite'] = NX_VERSION;\n  }\n\n  if (options.preset === 'react') {\n    // Dev-time: powers the `@nx/react:library` defaults and React generators.\n    devDependencies['@nx/react'] = NX_VERSION;\n    // Run-time: the React framework and our React bindings ship in the app.\n    dependencies['react'] = REACT_VERSION;\n    dependencies['react-dom'] = REACT_DOM_VERSION;\n    dependencies[TACTICAL_DDD_REACT] = tacticalDddReactVersion();\n  }\n\n  return addDependenciesToPackageJson(tree, dependencies, devDependencies);\n}\n\n/**\n * Persists workspace-wide generator defaults into `nx.json` so choices like the\n * organization `prefix`, linter and test runner are configured once during\n * `init` and then transparently injected by Nx into every subsequent generator\n * invocation (e.g. `nx g @tactical-ddd/nx:shared-kernel`, or even the built-in\n * `nx g @nx/js:library`) without the user re-typing them.\n *\n * Two groups of defaults are written:\n *\n *   \"generators\": {\n *     // 1. Our own collection — inherit the prefix and linting/testing choices.\n *     \"@tactical-ddd/nx\": {\n *       \"shared-kernel\": { \"prefix\": \"@my-org\", \"linter\": \"eslint\", \"unitTestRunner\": \"jest\" }\n *     },\n *     // 2. The built-in library generators — so hand-rolled libs match conventions.\n *     \"@nx/js:library\":    { \"bundler\": \"none\", \"linter\": \"eslint\", \"unitTestRunner\": \"jest\" },\n *     // `@nx/react:library` is added only under the `react` preset.\n *     \"@nx/react:library\": { \"bundler\": \"none\", \"linter\": \"eslint\", \"unitTestRunner\": \"jest\" }\n *   }\n */\nfunction setGeneratorDefaults(tree: Tree, options: InitGeneratorSchema) {\n  const nxJson = readNxJson(tree) ?? ({} as NxJsonConfiguration);\n\n  const generators = (nxJson.generators ??= {}) as Record<\n    string,\n    Record<string, unknown>\n  >;\n\n  // 1. Our own collection's generators inherit the prefix + linting/testing.\n  const collectionDefaults = (generators[COLLECTION] ??= {}) as Record<\n    string,\n    Record<string, unknown>\n  >;\n\n  for (const generator of PREFIXED_GENERATORS) {\n    collectionDefaults[generator] = {\n      ...collectionDefaults[generator],\n      prefix: options.prefix,\n      linter: options.linter,\n      unitTestRunner: options.unitTestRunner,\n      preset: options.preset,\n    };\n  }\n\n  // 2. The built-in library generators get the same workspace-wide build/lint/\n  // test defaults, so a plain `nx g @nx/js:library` (or `@nx/react:library`)\n  // produces a library that already matches the Tactical DDD conventions.\n  // `@nx/react:library` defaults are written only under the `react` preset, so\n  // we don't advertise React tooling a non-React workspace never installed.\n  const libraryDefaults: Record<string, unknown> = {\n    bundler: options.bundler ?? 'none',\n    linter: options.linter,\n    unitTestRunner: options.unitTestRunner,\n  };\n\n  const libraryGenerators =\n    options.preset === 'react'\n      ? [...BASE_LIBRARY_GENERATORS, ...REACT_LIBRARY_GENERATORS]\n      : BASE_LIBRARY_GENERATORS;\n\n  for (const generator of libraryGenerators) {\n    generators[generator] = {\n      ...generators[generator],\n      ...libraryDefaults,\n    };\n  }\n\n  updateNxJson(tree, nxJson);\n}\n\nexport default initGenerator;\n"],"names":["initGenerator","COLLECTION","PREFIXED_GENERATORS","BASE_LIBRARY_GENERATORS","REACT_LIBRARY_GENERATORS","TACTICAL_DDD_REACT","REACT_VERSION","REACT_DOM_VERSION","tacticalDddReactVersion","require","version","tree","options","setGeneratorDefaults","installDependencies","ensureGeneratorDependencies","installKernel","sharedKernelGenerator","directory","sharedDirectory","prefix","linter","unitTestRunner","bundler","applyDepConstraints","DEP_CONSTRAINTS","formatFiles","runTasksInSerial","dependencies","devDependencies","NX_VERSION","preset","addDependenciesToPackageJson","readNxJson","nxJson","generators","collectionDefaults","generator","libraryDefaults","libraryGenerators","updateNxJson"],"mappings":"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"}

package/generators/init/module-boundaries.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `depConstraints` for `@nx/enforce-module-boundaries`, encoding the dependency
+ * graph of the Tactical DDD architecture.
+ *
+ * The rule enforces two things at once:
+ *   1. The allowed dependency directions described below (a library may only
+ *      depend on libraries whose tags are listed in `onlyDependOnLibsWithTags`).
+ *   2. The absence of circular dependencies between projects — this is built
+ *      into `@nx/enforce-module-boundaries` and needs no extra option.
+ */
+import type { DepConstraint } from '../../utils/eslint-module-boundaries';
+export type { DepConstraint };
+export declare const DEP_CONSTRAINTS: DepConstraint[];
+//# sourceMappingURL=module-boundaries.d.ts.map

package/generators/init/module-boundaries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-boundaries.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/generators/init/module-boundaries.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AAE1E,YAAY,EAAE,aAAa,EAAE,CAAC;AAE9B,eAAO,MAAM,eAAe,EAAE,aAAa,EAkH1C,CAAC"}

package/generators/init/module-boundaries.js

@@ -0,0 +1,140 @@
+/**
+ * `depConstraints` for `@nx/enforce-module-boundaries`, encoding the dependency
+ * graph of the Tactical DDD architecture.
+ *
+ * The rule enforces two things at once:
+ *   1. The allowed dependency directions described below (a library may only
+ *      depend on libraries whose tags are listed in `onlyDependOnLibsWithTags`).
+ *   2. The absence of circular dependencies between projects — this is built
+ *      into `@nx/enforce-module-boundaries` and needs no extra option.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "DEP_CONSTRAINTS", {
+    enumerable: true,
+    get: function() {
+        return DEP_CONSTRAINTS;
+    }
+});
+const _types = require("../../types");
+const DEP_CONSTRAINTS = [
+    // ==========================================
+    // 1. SCOPE RULES
+    // ==========================================
+    // Shared knows about nothing but itself.
+    {
+        sourceTag: _types.LibraryScope.Shared,
+        onlyDependOnLibsWithTags: [
+            _types.LibraryScope.Shared
+        ]
+    },
+    // A domain may use shared libraries and other libraries of its own scope.
+    {
+        sourceTag: _types.LibraryScope.Domain,
+        onlyDependOnLibsWithTags: [
+            _types.LibraryScope.Domain,
+            _types.LibraryScope.Shared
+        ]
+    },
+    // ==========================================
+    // 2. CROSS-DOMAIN IMPORT PROTECTION
+    // ==========================================
+    // Per-domain isolation cannot be expressed by a single static constraint:
+    // `@nx/enforce-module-boundaries` glob-matches the target tags too, so a
+    // `domain:*` → `domain:*` rule would let `domain:auth` import `domain:payments`.
+    // The actual silo is enforced by a per-domain constraint
+    // (`domain:<name>` → [`domain:<name>`, `scope:shared`, `type:contracts`]) that
+    // the `domain` generator injects for each domain it creates — confining a
+    // domain to itself, the shared kernel, and the *public contracts* of other
+    // domains (the published-language pattern), never their implementation. This
+    // baseline entry only scopes any domain library to domains + shared
+    // (mirroring the `scope:domain` rule above); the injected per-domain
+    // constraints add the real restriction (Nx requires *every* matching
+    // constraint to permit a dependency).
+    {
+        sourceTag: _types.LibraryScope.CrossDomain,
+        onlyDependOnLibsWithTags: [
+            _types.LibraryScope.CrossDomain,
+            _types.LibraryScope.Shared
+        ]
+    },
+    // ==========================================
+    // 3. TYPE RULES (ARCHITECTURE LAYERS)
+    // ==========================================
+    // Contracts: the foundation. May import nothing.
+    {
+        sourceTag: _types.LibraryType.Contracts,
+        onlyDependOnLibsWithTags: [
+            _types.LibraryType.Contracts
+        ]
+    },
+    // Utils: pure functions. Know only contracts and other utils.
+    {
+        sourceTag: _types.LibraryType.Utils,
+        onlyDependOnLibsWithTags: [
+            _types.LibraryType.Contracts,
+            _types.LibraryType.Utils
+        ]
+    },
+    // Infrastructure: I/O, API clients. Know types and helpers.
+    {
+        sourceTag: _types.LibraryType.Infrastructure,
+        onlyDependOnLibsWithTags: [
+            _types.LibraryType.Contracts,
+            _types.LibraryType.Utils,
+            _types.LibraryType.Infrastructure
+        ]
+    },
+    // Core: business logic. May use everything below it plus its own domain core.
+    {
+        sourceTag: _types.LibraryType.Core,
+        onlyDependOnLibsWithTags: [
+            _types.LibraryType.Contracts,
+            _types.LibraryType.Utils,
+            _types.LibraryType.Infrastructure,
+            _types.LibraryType.Core
+        ]
+    },
+    // ------------------------------------------
+    // UI (presentational components)
+    // ------------------------------------------
+    // Dumb components (buttons, cards, forms). Know only props interfaces
+    // (contracts) and formatting helpers (utils). Importing core (entities) or
+    // infrastructure is strictly forbidden.
+    {
+        sourceTag: _types.LibraryType.Ui,
+        onlyDependOnLibsWithTags: [
+            _types.LibraryType.Contracts,
+            _types.LibraryType.Utils,
+            _types.LibraryType.Ui
+        ]
+    },
+    // Testing: mocks and fixtures. May import the core for mocking.
+    {
+        sourceTag: _types.LibraryType.Testing,
+        onlyDependOnLibsWithTags: [
+            _types.LibraryType.Contracts,
+            _types.LibraryType.Utils,
+            _types.LibraryType.Infrastructure,
+            _types.LibraryType.Core,
+            _types.LibraryType.Ui,
+            _types.LibraryType.Testing
+        ]
+    },
+    // Features: UI and state. The topmost layer, may import everything.
+    {
+        sourceTag: _types.LibraryType.Features,
+        onlyDependOnLibsWithTags: [
+            _types.LibraryType.Contracts,
+            _types.LibraryType.Utils,
+            _types.LibraryType.Infrastructure,
+            _types.LibraryType.Core,
+            _types.LibraryType.Ui,
+            _types.LibraryType.Testing,
+            _types.LibraryType.Features
+        ]
+    }
+];
+
+//# sourceMappingURL=module-boundaries.js.map

package/generators/init/module-boundaries.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../packages/nx/src/generators/init/module-boundaries.ts"],"sourcesContent":["/**\n * `depConstraints` for `@nx/enforce-module-boundaries`, encoding the dependency\n * graph of the Tactical DDD architecture.\n *\n * The rule enforces two things at once:\n *   1. The allowed dependency directions described below (a library may only\n *      depend on libraries whose tags are listed in `onlyDependOnLibsWithTags`).\n *   2. The absence of circular dependencies between projects — this is built\n *      into `@nx/enforce-module-boundaries` and needs no extra option.\n */\n\nimport { LibraryScope, LibraryType } from '../../types';\nimport type { DepConstraint } from '../../utils/eslint-module-boundaries';\n\nexport type { DepConstraint };\n\nexport const DEP_CONSTRAINTS: DepConstraint[] = [\n  // ==========================================\n  // 1. SCOPE RULES\n  // ==========================================\n\n  // Shared knows about nothing but itself.\n  {\n    sourceTag: LibraryScope.Shared,\n    onlyDependOnLibsWithTags: [LibraryScope.Shared],\n  },\n  // A domain may use shared libraries and other libraries of its own scope.\n  {\n    sourceTag: LibraryScope.Domain,\n    onlyDependOnLibsWithTags: [LibraryScope.Domain, LibraryScope.Shared],\n  },\n\n  // ==========================================\n  // 2. CROSS-DOMAIN IMPORT PROTECTION\n  // ==========================================\n  // Per-domain isolation cannot be expressed by a single static constraint:\n  // `@nx/enforce-module-boundaries` glob-matches the target tags too, so a\n  // `domain:*` → `domain:*` rule would let `domain:auth` import `domain:payments`.\n  // The actual silo is enforced by a per-domain constraint\n  // (`domain:<name>` → [`domain:<name>`, `scope:shared`, `type:contracts`]) that\n  // the `domain` generator injects for each domain it creates — confining a\n  // domain to itself, the shared kernel, and the *public contracts* of other\n  // domains (the published-language pattern), never their implementation. This\n  // baseline entry only scopes any domain library to domains + shared\n  // (mirroring the `scope:domain` rule above); the injected per-domain\n  // constraints add the real restriction (Nx requires *every* matching\n  // constraint to permit a dependency).\n  {\n    sourceTag: LibraryScope.CrossDomain,\n    onlyDependOnLibsWithTags: [LibraryScope.CrossDomain, LibraryScope.Shared],\n  },\n\n  // ==========================================\n  // 3. TYPE RULES (ARCHITECTURE LAYERS)\n  // ==========================================\n\n  // Contracts: the foundation. May import nothing.\n  {\n    sourceTag: LibraryType.Contracts,\n    onlyDependOnLibsWithTags: [LibraryType.Contracts],\n  },\n\n  // Utils: pure functions. Know only contracts and other utils.\n  {\n    sourceTag: LibraryType.Utils,\n    onlyDependOnLibsWithTags: [LibraryType.Contracts, LibraryType.Utils],\n  },\n\n  // Infrastructure: I/O, API clients. Know types and helpers.\n  {\n    sourceTag: LibraryType.Infrastructure,\n    onlyDependOnLibsWithTags: [\n      LibraryType.Contracts,\n      LibraryType.Utils,\n      LibraryType.Infrastructure,\n    ],\n  },\n\n  // Core: business logic. May use everything below it plus its own domain core.\n  {\n    sourceTag: LibraryType.Core,\n    onlyDependOnLibsWithTags: [\n      LibraryType.Contracts,\n      LibraryType.Utils,\n      LibraryType.Infrastructure,\n      LibraryType.Core,\n    ],\n  },\n\n  // ------------------------------------------\n  // UI (presentational components)\n  // ------------------------------------------\n  // Dumb components (buttons, cards, forms). Know only props interfaces\n  // (contracts) and formatting helpers (utils). Importing core (entities) or\n  // infrastructure is strictly forbidden.\n  {\n    sourceTag: LibraryType.Ui,\n    onlyDependOnLibsWithTags: [\n      LibraryType.Contracts,\n      LibraryType.Utils,\n      LibraryType.Ui,\n    ],\n  },\n\n  // Testing: mocks and fixtures. May import the core for mocking.\n  {\n    sourceTag: LibraryType.Testing,\n    onlyDependOnLibsWithTags: [\n      LibraryType.Contracts,\n      LibraryType.Utils,\n      LibraryType.Infrastructure,\n      LibraryType.Core,\n      LibraryType.Ui,\n      LibraryType.Testing,\n    ],\n  },\n\n  // Features: UI and state. The topmost layer, may import everything.\n  {\n    sourceTag: LibraryType.Features,\n    onlyDependOnLibsWithTags: [\n      LibraryType.Contracts,\n      LibraryType.Utils,\n      LibraryType.Infrastructure,\n      LibraryType.Core,\n      LibraryType.Ui,\n      LibraryType.Testing,\n      LibraryType.Features,\n    ],\n  },\n];\n"],"names":["DEP_CONSTRAINTS","sourceTag","LibraryScope","Shared","onlyDependOnLibsWithTags","Domain","CrossDomain","LibraryType","Contracts","Utils","Infrastructure","Core","Ui","Testing","Features"],"mappings":"AAAA;;;;;;;;;CASC;;;;+BAOYA;;;eAAAA;;;uBAL6B;AAKnC,MAAMA,kBAAmC;IAC9C,6CAA6C;IAC7C,iBAAiB;IACjB,6CAA6C;IAE7C,yCAAyC;IACzC;QACEC,WAAWC,mBAAY,CAACC,MAAM;QAC9BC,0BAA0B;YAACF,mBAAY,CAACC,MAAM;SAAC;IACjD;IACA,0EAA0E;IAC1E;QACEF,WAAWC,mBAAY,CAACG,MAAM;QAC9BD,0BAA0B;YAACF,mBAAY,CAACG,MAAM;YAAEH,mBAAY,CAACC,MAAM;SAAC;IACtE;IAEA,6CAA6C;IAC7C,oCAAoC;IACpC,6CAA6C;IAC7C,0EAA0E;IAC1E,yEAAyE;IACzE,iFAAiF;IACjF,yDAAyD;IACzD,+EAA+E;IAC/E,0EAA0E;IAC1E,2EAA2E;IAC3E,6EAA6E;IAC7E,oEAAoE;IACpE,qEAAqE;IACrE,qEAAqE;IACrE,sCAAsC;IACtC;QACEF,WAAWC,mBAAY,CAACI,WAAW;QACnCF,0BAA0B;YAACF,mBAAY,CAACI,WAAW;YAAEJ,mBAAY,CAACC,MAAM;SAAC;IAC3E;IAEA,6CAA6C;IAC7C,sCAAsC;IACtC,6CAA6C;IAE7C,iDAAiD;IACjD;QACEF,WAAWM,kBAAW,CAACC,SAAS;QAChCJ,0BAA0B;YAACG,kBAAW,CAACC,SAAS;SAAC;IACnD;IAEA,8DAA8D;IAC9D;QACEP,WAAWM,kBAAW,CAACE,KAAK;QAC5BL,0BAA0B;YAACG,kBAAW,CAACC,SAAS;YAAED,kBAAW,CAACE,KAAK;SAAC;IACtE;IAEA,4DAA4D;IAC5D;QACER,WAAWM,kBAAW,CAACG,cAAc;QACrCN,0BAA0B;YACxBG,kBAAW,CAACC,SAAS;YACrBD,kBAAW,CAACE,KAAK;YACjBF,kBAAW,CAACG,cAAc;SAC3B;IACH;IAEA,8EAA8E;IAC9E;QACET,WAAWM,kBAAW,CAACI,IAAI;QAC3BP,0BAA0B;YACxBG,kBAAW,CAACC,SAAS;YACrBD,kBAAW,CAACE,KAAK;YACjBF,kBAAW,CAACG,cAAc;YAC1BH,kBAAW,CAACI,IAAI;SACjB;IACH;IAEA,6CAA6C;IAC7C,iCAAiC;IACjC,6CAA6C;IAC7C,sEAAsE;IACtE,2EAA2E;IAC3E,wCAAwC;IACxC;QACEV,WAAWM,kBAAW,CAACK,EAAE;QACzBR,0BAA0B;YACxBG,kBAAW,CAACC,SAAS;YACrBD,kBAAW,CAACE,KAAK;YACjBF,kBAAW,CAACK,EAAE;SACf;IACH;IAEA,gEAAgE;IAChE;QACEX,WAAWM,kBAAW,CAACM,OAAO;QAC9BT,0BAA0B;YACxBG,kBAAW,CAACC,SAAS;YACrBD,kBAAW,CAACE,KAAK;YACjBF,kBAAW,CAACG,cAAc;YAC1BH,kBAAW,CAACI,IAAI;YAChBJ,kBAAW,CAACK,EAAE;YACdL,kBAAW,CAACM,OAAO;SACpB;IACH;IAEA,oEAAoE;IACpE;QACEZ,WAAWM,kBAAW,CAACO,QAAQ;QAC/BV,0BAA0B;YACxBG,kBAAW,CAACC,SAAS;YACrBD,kBAAW,CAACE,KAAK;YACjBF,kBAAW,CAACG,cAAc;YAC1BH,kBAAW,CAACI,IAAI;YAChBJ,kBAAW,CAACK,EAAE;YACdL,kBAAW,CAACM,OAAO;YACnBN,kBAAW,CAACO,QAAQ;SACrB;IACH;CACD"}

package/generators/init/schema.d.js

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

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

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

package/generators/init/schema.d.ts

@@ -0,0 +1,10 @@
+import type { Bundler } from '@nx/devkit';
+
+export interface InitGeneratorSchema {
+  sharedDirectory: string;
+  prefix: string;
+  linter?: 'eslint' | 'none';
+  unitTestRunner?: 'jest' | 'vitest' | 'none';
+  bundler?: Bundler;
+  preset?: 'none' | 'react';
+}

package/generators/init/schema.json

@@ -0,0 +1,55 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "InitGenerator",
+  "title": "Tactical DDD: Init Generator",
+  "type": "object",
+  "properties": {
+    "sharedDirectory": {
+      "type": "string",
+      "description": "Root folder for the shared kernel (it is recommended to keep libs/shared)",
+      "default": "libs/shared",
+      "x-prompt": "Which directory should the Shared Kernel 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)?"
+    },
+    "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": "none",
+      "description": "Which bundler to use?"
+    },
+    "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)"
+          }
+        ]
+      }
+    }
+  },
+  "required": ["prefix", "linter", "unitTestRunner"]
+}

package/generators/shared-kernel/schema.json

@@ -34,5 +34,5 @@
       "description": "Which bundler to use?"
     }
   },
-  "required": ["directory", "linter", "unitTestRunner"]
+  "required": ["directory", "linter", "unitTestRunner", "prefix"]
 }

package/generators/shared-kernel/shared-kernel.d.ts

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

package/generators/shared-kernel/shared-kernel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shared-kernel.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/generators/shared-kernel/shared-kernel.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,IAAI,EACV,MAAM,YAAY,CAAC;AAIpB,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,UAAU,CAAC;AAI5D,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,2BAA2B,iBAoFrC;AAED,eAAe,qBAAqB,CAAC"}
+{"version":3,"file":"shared-kernel.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/generators/shared-kernel/shared-kernel.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,iBAAiB,EACtB,KAAK,IAAI,EACV,MAAM,YAAY,CAAC;AAIpB,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,UAAU,CAAC;AAM5D,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,2BAA2B,GACnC,OAAO,CAAC,iBAAiB,CAAC,CAuG5B;AAED,eAAe,qBAAqB,CAAC"}

package/generators/shared-kernel/shared-kernel.js

@@ -21,23 +21,34 @@ const _js = require("@nx/js");
 const _path = require("path");
 const _types = require("../../types");
 const _resolvemoduleformat = require("../../utils/resolve-module-format");
+const _libraryexist = require("../../utils/library-exist");
+const _logger = require("../../utils/logger");
 async function sharedKernelGenerator(tree, options) {
     const sharedDirectory = options.directory;
     const contractsRoot = `${sharedDirectory}/contracts`;
     const utilsRoot = `${sharedDirectory}/utils`;
     const infrastructureRoot = `${sharedDirectory}/infrastructure`;
-    if (!tree.exists(contractsRoot)) {
-        console.log(`Creating contracts library at ${contractsRoot}...`);
-        await (0, _js.libraryGenerator)(tree, {
+    // Install callbacks returned by the delegated `@nx/js:library` generator.
+    // They must be returned to Nx so the packages backing the inferred plugins
+    // registered via `addPlugin` — `@nx/eslint`, `@nx/jest` — actually get
+    // installed; otherwise nx.json references plugins Nx cannot load on the next
+    // command. Every library also passes `addPlugin: true`: the `@nx/js` public
+    // wrapper defaults it to `false`, which makes the delegated generators emit
+    // deprecated executor targets instead of inferred tasks (Project Crystal).
+    const tasks = [];
+    if (!(0, _libraryexist.libraryExists)(tree, contractsRoot)) {
+        (0, _logger.info)(`Creating contracts library at ${contractsRoot}...`);
+        tasks.push(await (0, _js.libraryGenerator)(tree, {
             name: options.prefix ? `${options.prefix}/shared-contracts` : 'shared-contracts',
             directory: contractsRoot,
             useProjectJson: false,
+            addPlugin: true,
             unitTestRunner: 'none',
             bundler: options.bundler,
             linter: options.linter,
             tags: `${_types.LibraryScope.Shared},${_types.LibraryType.Contracts}`,
             minimal: true
-        });
+        }));
         const type = (0, _resolvemoduleformat.resolveLibraryModuleFormat)(tree, contractsRoot);
         tree.delete(`${contractsRoot}/src/lib/shared-contracts.ts`);
         (0, _devkit.generateFiles)(tree, (0, _path.resolve)(__dirname, 'files/contracts'), contractsRoot, {
@@ -46,45 +57,48 @@ async function sharedKernelGenerator(tree, options) {
             overwriteStrategy: _devkit.OverwriteStrategy.Overwrite
         });
     } else {
-        console.log(`Contracts library already exists at ${contractsRoot}`);
+        (0, _logger.info)(`Contracts library already exists at ${contractsRoot}`);
     }
-    if (!tree.exists(utilsRoot)) {
-        console.log(`Creating utils library at ${utilsRoot}...`);
-        await (0, _js.libraryGenerator)(tree, {
+    if (!(0, _libraryexist.libraryExists)(tree, utilsRoot)) {
+        (0, _logger.info)(`Creating utils library at ${utilsRoot}...`);
+        tasks.push(await (0, _js.libraryGenerator)(tree, {
             name: options.prefix ? `${options.prefix}/shared-utils` : 'shared-utils',
             directory: utilsRoot,
             useProjectJson: false,
+            addPlugin: true,
             unitTestRunner: options.unitTestRunner,
             bundler: options.bundler,
             linter: options.linter,
             tags: `${_types.LibraryScope.Shared},${_types.LibraryType.Utils}`,
             minimal: true
-        });
+        }));
         tree.delete(`${utilsRoot}/src/lib/shared-utils.ts`);
         tree.delete(`${utilsRoot}/src/lib/shared-utils.spec.ts`);
         tree.write(`${utilsRoot}/src/index.ts`, '');
     } else {
-        console.log(`Utils library already exists at ${utilsRoot}`);
+        (0, _logger.info)(`Utils library already exists at ${utilsRoot}`);
     }
-    if (!tree.exists(infrastructureRoot)) {
-        console.log(`Creating infrastructure library at ${infrastructureRoot}...`);
-        await (0, _js.libraryGenerator)(tree, {
+    if (!(0, _libraryexist.libraryExists)(tree, infrastructureRoot)) {
+        (0, _logger.info)(`Creating infrastructure library at ${infrastructureRoot}...`);
+        tasks.push(await (0, _js.libraryGenerator)(tree, {
             name: options.prefix ? `${options.prefix}/shared-infrastructure` : 'shared-infrastructure',
             directory: infrastructureRoot,
             useProjectJson: false,
+            addPlugin: true,
             unitTestRunner: options.unitTestRunner,
             bundler: options.bundler,
             linter: options.linter,
             tags: `${_types.LibraryScope.Shared},${_types.LibraryType.Infrastructure}`,
             minimal: true
-        });
+        }));
         tree.delete(`${infrastructureRoot}/src/lib/shared-infrastructure.ts`);
         tree.delete(`${infrastructureRoot}/src/lib/shared-infrastructure.spec.ts`);
         tree.write(`${infrastructureRoot}/src/index.ts`, '');
     } else {
-        console.log(`Infrastructure library already exists at ${infrastructureRoot}`);
+        (0, _logger.info)(`Infrastructure library already exists at ${infrastructureRoot}`);
     }
     await (0, _devkit.formatFiles)(tree);
+    return (0, _devkit.runTasksInSerial)(...tasks);
 }
 const _default = sharedKernelGenerator;