@open-rlb/nestjs-amqp 2.0.4 → 2.0.6

package/schematics/nest-add/index.js

@@ -7,38 +7,185 @@ const path_1 = require("path");
 const formatting_1 = require("../utils/formatting");
 const name_parser_1 = require("../utils/name.parser");
 const source_root_helpers_1 = require("../utils/source-root.helpers");
-function brokerImportLine(gateway) {
-    const broker = gateway
-        ? "import { AppConfig, BrokerModule, BrokerTopic, GatewayConfig, HandlerAuthConfig, ProxyModule, RabbitMQConfig } from '@open-rlb/nestjs-amqp';"
-        : "import { AppConfig, BrokerModule, BrokerTopic, RabbitMQConfig } from '@open-rlb/nestjs-amqp';";
-    const config = "\nimport { ConfigModule, ConfigService } from '@nestjs/config';";
-    const http = gateway ? "\nimport { HttpModule } from '@nestjs/axios';" : '';
-    return broker + config + http;
-}
-function brokerForRootAsync() {
-    return `BrokerModule.forRootAsync({
-      imports: [ConfigModule],
-      inject: [ConfigService],
-      useFactory: async (configService: ConfigService) => ({
-        options: configService.get<RabbitMQConfig>('broker')!,
-        topics: configService.get<BrokerTopic[]>('topics')!,
-        appOptions: configService.get<AppConfig>('app'),
-      })
-    })`;
+function defaultNames(project) {
+    return {
+        exchange: 'rlb',
+        aclQueue: 'rlb-acl',
+        adminQueue: 'rlb-gateway-admin',
+        controlTopic: 'rlb-gateway-control',
+        routeExchange: 'rlb-route-discovery',
+        routeQueue: 'rlb-route-sync',
+        serviceName: project || 'my-service',
+    };
 }
-function proxyForRootAsync() {
-    return `ProxyModule.forRootAsync({
-      imports: [ConfigModule],
-      inject: [ConfigService],
-      useFactory: (configService: ConfigService) => ({
-        authOptions: configService.get<HandlerAuthConfig[]>('auth-providers'),
-        gatewayOptions: configService.get<GatewayConfig>('gateway'),
-      }),
-      providers: [],
-    })`;
+async function resolveSelections(o, context) {
+    const project = (o.project || 'my-service').toString();
+    const d = defaultNames(project);
+    const flagsProvided = o.gatewayConfig !== undefined || (Array.isArray(o.features) && o.features.length > 0);
+    const canPrompt = !!process.stdout && !!process.stdout.isTTY && !process.env.CI && !flagsProvided;
+    let prompts;
+    if (canPrompt) {
+        try {
+            prompts = require('@inquirer/prompts');
+        }
+        catch {
+            context.logger.warn('[nest-add] @inquirer/prompts not found; falling back to flags/defaults (non-interactive).');
+            prompts = undefined;
+        }
+    }
+    if (!prompts) {
+        const features = new Set((o.features || []).map((f) => String(f).trim()));
+        const gatewayConfig = o.gatewayConfig === true;
+        return {
+            gatewayConfig,
+            acl: gatewayConfig && features.has('acl'),
+            admin: gatewayConfig && features.has('gateway-admin'),
+            routeReception: gatewayConfig && features.has('route-reception'),
+            autoPublish: !gatewayConfig && features.has('auto-config-publish'),
+            skills: o.skills !== false,
+            names: {
+                exchange: o.exchange || d.exchange,
+                aclQueue: o.aclQueue || d.aclQueue,
+                adminQueue: o.adminQueue || d.adminQueue,
+                controlTopic: o.controlTopic || d.controlTopic,
+                routeExchange: o.routeExchange || d.routeExchange,
+                routeQueue: o.routeQueue || d.routeQueue,
+                serviceName: o.serviceName || d.serviceName,
+            },
+        };
+    }
+    const { confirm, checkbox, input } = prompts;
+    const names = { ...d };
+    let acl = false, admin = false, routeReception = false, autoPublish = false;
+    const gatewayConfig = await confirm({
+        message: 'Create a gateway (HTTP/WebSocket) configuration?',
+        default: false,
+    });
+    if (gatewayConfig) {
+        const picked = await checkbox({
+            message: 'Select gateway features to include',
+            choices: [
+                { name: 'ACL — role-based authorization + management', value: 'acl' },
+                { name: 'Gateway admin + auth — DB-managed routes, auth-providers, metrics', value: 'gateway-admin' },
+                { name: 'Route reception — apply routes auto-published by microservices', value: 'route-reception' },
+            ],
+        });
+        acl = picked.includes('acl');
+        admin = picked.includes('gateway-admin');
+        routeReception = picked.includes('route-reception');
+        if (acl || admin || routeReception) {
+            names.exchange = await input({ message: 'Main AMQP exchange name', default: d.exchange });
+        }
+        if (acl) {
+            names.aclQueue = await input({ message: 'Queue backing the rlb-acl topic', default: d.aclQueue });
+        }
+        if (admin || routeReception) {
+            names.adminQueue = await input({ message: 'Queue backing the rlb-gateway-admin topic', default: d.adminQueue });
+            names.controlTopic = await input({ message: 'Broadcast control/reload topic name', default: d.controlTopic });
+        }
+        if (routeReception) {
+            names.routeExchange = await input({ message: 'Route-discovery exchange (must match the publishers)', default: d.routeExchange });
+            names.routeQueue = await input({ message: 'Route-sync queue', default: d.routeQueue });
+        }
+    }
+    else {
+        const picked = await checkbox({
+            message: 'Select microservice features to include',
+            choices: [
+                { name: 'Auto-send config at startup — publish this service’s @BrokerHTTP routes to the gateway on boot', value: 'auto-config-publish' },
+            ],
+        });
+        autoPublish = picked.includes('auto-config-publish');
+        if (autoPublish) {
+            names.serviceName = await input({ message: 'Service name (route ownership + AMQP connection_name)', default: d.serviceName });
+            names.routeExchange = await input({ message: 'Route-discovery exchange', default: d.routeExchange });
+            names.routeQueue = await input({ message: 'Route-sync queue', default: d.routeQueue });
+        }
+    }
+    const skills = await confirm({ message: 'Copy the Claude skills into .claude/skills?', default: true });
+    return { gatewayConfig, acl, admin, routeReception, autoPublish, skills, names };
 }
-const CONFIG_YAML_BASE = `
-app:
+function buildConfigYaml(sel) {
+    const n = sel.names;
+    const anyAdmin = sel.admin || sel.routeReception;
+    const routeDiscoveryPub = sel.autoPublish ? `
+  # Route auto-discovery (publisher side): announce this service's @BrokerHTTP routes on boot.
+  # serviceName also fills the AMQP connection_name (none is set explicitly below).
+  routeDiscovery:
+    serviceName: "${n.serviceName}"
+    publishOnBoot: true
+    exchange: ${n.routeExchange}
+    queue: ${n.routeQueue}` : '';
+    const clientProps = sel.autoPublish ? '' : `
+      clientProperties:
+        connection_name: "<APP_NAME>"`;
+    const exchanges = [];
+    if (sel.acl || anyAdmin) {
+        exchanges.push(`    - name: ${n.exchange}
+      type: "direct"
+      createExchangeIfNotExists: true
+      options:
+        durable: true`);
+    }
+    exchanges.push(`    - name: example.fanout
+      type: "fanout"
+      createExchangeIfNotExists: true
+      options:
+        durable: true
+        autoDelete: false
+        internal: false`);
+    const queues = [];
+    if (sel.acl) {
+        queues.push(`    - name: ${n.aclQueue}
+      exchange: ${n.exchange}
+      routingKey: ${n.aclQueue}
+      createQueueIfNotExists: true
+      options:
+        durable: true`);
+    }
+    if (anyAdmin) {
+        queues.push(`    - name: ${n.adminQueue}
+      exchange: ${n.exchange}
+      routingKey: ${n.adminQueue}
+      createQueueIfNotExists: true
+      options:
+        durable: true`);
+    }
+    queues.push(`    - name: example.queue
+      exchange: example.fanout
+      routingKey: example.queue
+      createQueueIfNotExists: true
+      options:
+        durable: true
+        autoDelete: false
+        exclusive: false`);
+    const topics = [];
+    if (sel.acl) {
+        topics.push(`  # Fixed topic name (decorator-bound in the lib): the ACL handlers bind to 'rlb-acl'.
+  - name: rlb-acl
+    mode: rpc
+    queue: ${n.aclQueue}
+    exchange: ${n.exchange}
+    routingKey: ${n.aclQueue}`);
+    }
+    if (anyAdmin) {
+        topics.push(`  # Fixed topic name (decorator-bound): the gateway-admin handlers bind to 'rlb-gateway-admin'.
+  - name: rlb-gateway-admin
+    mode: rpc
+    queue: ${n.adminQueue}
+    exchange: ${n.exchange}
+    routingKey: ${n.adminQueue}
+  # Broadcast control topic: the gateway rebuilds its routes at runtime on a 'gw-reload'.
+  - name: ${n.controlTopic}
+    mode: broadcast
+    exchange: ${n.exchange}
+    routingKey: ${n.controlTopic}`);
+    }
+    topics.push(`  - name: example.topic
+    exchange: example.fanout
+    routingKey: "example.topic"
+    mode: event`);
+    let yaml = `app:
   port: 80
   host: 0.0.0.0
   environment: "development"
@@ -49,72 +196,395 @@ broker:
   name: "rabbitmq"
   uri: "<AMQP_URI>"
   defaultSubscribeErrorBehavior: "ack"
-  defaultPublishErrorBehavior: "reject"
+  defaultPublishErrorBehavior: "reject"${routeDiscoveryPub}
   connectionManagerOptions:
     heartbeatIntervalInSeconds: 60
     reconnectTimeInSeconds: 60
-    connectionOptions:
-      clientProperties:
-        connection_name: "<APP_NAME>"
+    connectionOptions:${clientProps}
       credentials:
         mechanism: PLAIN
         username: "<AMQP_USERNAME>"
         password: "<AMQP_PASSWORD>"
   exchanges:
-    - name: example.fanout
-      type: "fanout"
-      createExchangeIfNotExists: true
-      options:
-        durable: true
-        autoDelete: false
-        internal: false
+${exchanges.join('\n')}
   queues:
-    - name: example.queue
-      createQueueIfNotExists: true
-      exchange: example.fanout
-      routingKey: example.queue
-      options:
-        durable: true
-        autoDelete: false
-        exclusive: false
+${queues.join('\n')}
 
 topics:
-  - name: example.topic
-    exchange: example.fanout
-    routingKey: "example.topic"
-    mode: event
+${topics.join('\n')}
 `;
-const CONFIG_YAML_GATEWAY = `
-gateway:
+    if (sel.gatewayConfig) {
+        yaml += '\n' + buildGatewayBlock(sel);
+    }
+    return yaml;
+}
+function buildGatewayBlock(sel) {
+    const n = sel.names;
+    const anyAdmin = sel.admin || sel.routeReception;
+    const paths = [];
+    if (sel.acl)
+        paths.push(ACL_PATHS);
+    if (sel.admin)
+        paths.push(adminPaths(n.controlTopic));
+    paths.push(`    - name: example-path
+      method: POST
+      dataSource: body
+      path: /example
+      topic: example.topic
+      action: example-action
+      mode: event`);
+    let block = `gateway:
   events: []
   ws:
     heartbeatIntervalMs: 30000
     # Auth is declared per-event (events[].auth / requireAuth / roles / scopeClaim).
   paths:
-    - name: example-path
+${paths.join('\n')}`;
+    if (anyAdmin) {
+        block += `
+  # Load DB-managed routes at boot AND on every runtime reload (ordered static-before-param).
+  loadConfig:
+    paths:
+      topic: rlb-gateway-admin
+      action: gw-path-export
+  # Broadcast topic that triggers a runtime route rebuild (see topics: ${n.controlTopic}).
+  reloadTopic: ${n.controlTopic}
+  # Per-request metrics auto-emitted to the gateway-admin metrics handler.
+  metrics:
+    topic: rlb-gateway-admin
+    action: gw-metrics-track`;
+    }
+    return block + '\n';
+}
+const ACL_PATHS = `    # --- ACL management: actions (name is the key — PUT upserts, GET lists, DELETE by name) ---
+    - name: acl-action-list
+      method: GET
+      path: /acl/actions
+      dataSource: query
+      topic: rlb-acl
+      action: acl-action-list
+      mode: rpc
+    - name: acl-action-get
+      method: GET
+      path: /acl/actions/get
+      dataSource: query
+      topic: rlb-acl
+      action: acl-action-get
+      mode: rpc
+    - name: acl-action-upsert
+      method: PUT
+      path: /acl/actions
+      dataSource: body
+      topic: rlb-acl
+      action: acl-action-update
+      mode: rpc
+    - name: acl-action-delete
+      method: DELETE
+      path: /acl/actions
+      dataSource: body
+      topic: rlb-acl
+      action: acl-action-delete
+      mode: rpc
+    # --- ACL management: roles ---
+    - name: acl-role-list
+      method: GET
+      path: /acl/roles
+      dataSource: query
+      topic: rlb-acl
+      action: acl-role-list
+      mode: rpc
+    - name: acl-role-get
+      method: GET
+      path: /acl/roles/get
+      dataSource: query
+      topic: rlb-acl
+      action: acl-role-get
+      mode: rpc
+    - name: acl-role-upsert
+      method: PUT
+      path: /acl/roles
+      dataSource: body
+      topic: rlb-acl
+      action: acl-role-update
+      mode: rpc
+    - name: acl-role-delete
+      method: DELETE
+      path: /acl/roles
+      dataSource: body
+      topic: rlb-acl
+      action: acl-role-delete
+      mode: rpc
+    # --- ACL grants (per-user; resourceId/companyId optional) ---
+    - name: acl-grant
       method: POST
+      path: /acl/grants
       dataSource: body
-      path: /example
-      topic: example.topic
-      action: example-action
+      topic: rlb-acl
+      action: acl-grant
+      mode: rpc
+    - name: acl-revoke
+      method: DELETE
+      path: /acl/grants
+      dataSource: body
+      topic: rlb-acl
+      action: acl-revoke
+      mode: rpc
+    # --- ACL checks (GET → 200 with true/false) ---
+    - name: acl-check-gtw
+      method: GET
+      path: /acl/check
+      dataSource: query
+      topic: rlb-acl
+      action: acl-can-user-do-gtw
+      mode: rpc
+    - name: acl-check-resource
+      method: GET
+      path: /acl/check-resource
+      dataSource: query
+      topic: rlb-acl
+      action: acl-can-user-do
+      mode: rpc
+    # Lists the caller's accessible resources. Add an 'auth: <provider>' line once you declare an auth-provider.
+    - name: acl-list-resources-by-user
+      method: GET
+      path: /acl/resources
+      dataSource: query
+      topic: rlb-acl
+      action: acl-list-resources-by-user
+      mode: rpc`;
+function adminPaths(controlTopic) {
+    return `    # --- gateway-admin: health + DB routes + auth-providers + metrics ---
+    - name: health
+      method: GET
+      path: /health
+      dataSource: query
+      topic: rlb-gateway-admin
+      action: gw-health
+      mode: rpc
+    - name: gw-path-create
+      method: POST
+      path: /admin/paths
+      dataSource: body
+      topic: rlb-gateway-admin
+      action: gw-path-create
+      mode: rpc
+    - name: gw-path-list
+      method: GET
+      path: /admin/paths
+      dataSource: query
+      topic: rlb-gateway-admin
+      action: gw-path-list
+      mode: rpc
+    - name: gw-path-export
+      method: GET
+      path: /admin/paths/export
+      dataSource: query
+      topic: rlb-gateway-admin
+      action: gw-path-export
+      mode: rpc
+    - name: gw-path-update
+      method: PUT
+      path: /admin/paths
+      dataSource: body
+      topic: rlb-gateway-admin
+      action: gw-path-update
+      mode: rpc
+    - name: gw-path-get
+      method: GET
+      path: /admin/paths/get
+      dataSource: query
+      topic: rlb-gateway-admin
+      action: gw-path-get
+      mode: rpc
+    - name: gw-path-delete
+      method: DELETE
+      path: /admin/paths
+      dataSource: body
+      topic: rlb-gateway-admin
+      action: gw-path-delete
+      mode: rpc
+    - name: gw-auth-list
+      method: GET
+      path: /admin/auth
+      dataSource: query
+      topic: rlb-gateway-admin
+      action: gw-auth-list
+      mode: rpc
+    - name: gw-auth-upsert
+      method: PUT
+      path: /admin/auth
+      dataSource: body
+      topic: rlb-gateway-admin
+      action: gw-auth-update
+      mode: rpc
+    - name: gw-auth-get
+      method: GET
+      path: /admin/auth/get
+      dataSource: query
+      topic: rlb-gateway-admin
+      action: gw-auth-get
+      mode: rpc
+    - name: gw-auth-delete
+      method: DELETE
+      path: /admin/auth
+      dataSource: body
+      topic: rlb-gateway-admin
+      action: gw-auth-delete
+      mode: rpc
+    - name: gw-metrics-get
+      method: GET
+      path: /admin/metrics
+      dataSource: query
+      topic: rlb-gateway-admin
+      action: gw-metrics-get
+      mode: rpc
+    - name: gw-metrics-series
+      method: GET
+      path: /admin/metrics/series
+      dataSource: query
+      topic: rlb-gateway-admin
+      action: gw-metrics-series
+      mode: rpc
+    - name: gw-metrics-points
+      method: GET
+      path: /admin/metrics/points
+      dataSource: query
+      topic: rlb-gateway-admin
+      action: gw-metrics-points
+      mode: rpc
+    - name: gw-metrics-track
+      method: POST
+      path: /admin/metrics/track
+      dataSource: body
+      topic: rlb-gateway-admin
+      action: gw-metrics-track
       mode: event
-`;
-function configYaml(gateway) {
-    return gateway ? CONFIG_YAML_BASE.trimEnd() + '\n' + CONFIG_YAML_GATEWAY : CONFIG_YAML_BASE;
+    - name: gw-reload
+      method: POST
+      path: /admin/reload
+      dataSource: body
+      topic: ${controlTopic}
+      action: gw-reload
+      mode: event`;
+}
+function buildImportStatements(sel) {
+    const libSymbols = ['AppConfig', 'BrokerModule', 'BrokerTopic', 'RabbitMQConfig'];
+    if (sel.gatewayConfig)
+        libSymbols.push('GatewayConfig', 'HandlerAuthConfig', 'ProxyModule');
+    if (sel.acl)
+        libSymbols.push('AclActionRepository', 'AclGrantRepository', 'AclModule', 'AclRoleRepository', 'AclService', 'RLB_ACL_CACHE_STORE', 'RLB_GTW_ACL_ROLE_SERVICE');
+    if (sel.admin || sel.routeReception)
+        libSymbols.push('AuthProviderRepository', 'GatewayAdminModule', 'HttpMetricRepository', 'HttpPathRepository', 'RouteSyncLogRepository');
+    const lib = `import { ${[...new Set(libSymbols)].sort().join(', ')} } from '@open-rlb/nestjs-amqp';`;
+    const lines = [lib, `import { ConfigModule, ConfigService } from '@nestjs/config';`, `import yamlConfig from './config/config.loader';`];
+    if (sel.gatewayConfig)
+        lines.push(`import { HttpModule } from '@nestjs/axios';`);
+    if (sel.acl) {
+        lines.push(`import { InMemoryAclActionRepository, InMemoryAclGrantRepository, InMemoryAclRoleRepository } from './modules/database/repository/acl.repository';`);
+        lines.push(`import { InMemoryAclStore } from './cache/in-memory-acl-store';`);
+    }
+    if (sel.admin || sel.routeReception) {
+        lines.push(`import { InMemoryAuthProviderRepository, InMemoryHttpMetricRepository, InMemoryHttpPathRepository } from './modules/database/repository/gateway.repository';`);
+        lines.push(`import { InMemoryRouteSyncLogRepository } from './modules/database/repository/route-sync.repository';`);
+    }
+    return lines.join('\n');
+}
+function brokerForRootAsync() {
+    return `BrokerModule.forRootAsync({
+      imports: [ConfigModule],
+      inject: [ConfigService],
+      useFactory: async (configService: ConfigService) => ({
+        options: configService.get<RabbitMQConfig>('broker')!,
+        topics: configService.get<BrokerTopic[]>('topics')!,
+        appOptions: configService.get<AppConfig>('app'),
+      })
+    })`;
+}
+function proxyForRootAsync(sel) {
+    const providers = sel.acl
+        ? `[
+        // Role-gated paths resolve the caller's roles via AclService (in-process, no broker hop).
+        { provide: RLB_GTW_ACL_ROLE_SERVICE, useExisting: AclService },
+      ]`
+        : `[]`;
+    return `ProxyModule.forRootAsync({
+      imports: [ConfigModule],
+      inject: [ConfigService],
+      useFactory: (configService: ConfigService) => ({
+        authOptions: configService.get<HandlerAuthConfig[]>('auth-providers'),
+        gatewayOptions: configService.get<GatewayConfig>('gateway'),
+      }),
+      providers: ${providers},
+    })`;
+}
+function aclForRoot() {
+    return `AclModule.forRoot(
+      [
+        InMemoryAclActionRepository,
+        { provide: AclActionRepository, useExisting: InMemoryAclActionRepository },
+        InMemoryAclRoleRepository,
+        { provide: AclRoleRepository, useExisting: InMemoryAclRoleRepository },
+        InMemoryAclGrantRepository,
+        { provide: AclGrantRepository, useExisting: InMemoryAclGrantRepository },
+        InMemoryAclStore,
+        { provide: RLB_ACL_CACHE_STORE, useExisting: InMemoryAclStore },
+      ],
+      { cache: { ramTtlMs: 30000, l2TtlSec: 600 } },
+    )`;
+}
+function gatewayAdminForRoot(sel) {
+    const options = sel.routeReception
+        ? `,
+      {
+        // Consumer-side route-discovery — names MUST match the publishers' broker.routeDiscovery.
+        routeDiscovery: { exchange: '${sel.names.routeExchange}', queue: '${sel.names.routeQueue}' },
+      }`
+        : '';
+    return `GatewayAdminModule.forRoot(
+      [
+        InMemoryHttpPathRepository,
+        { provide: HttpPathRepository, useExisting: InMemoryHttpPathRepository },
+        InMemoryAuthProviderRepository,
+        { provide: AuthProviderRepository, useExisting: InMemoryAuthProviderRepository },
+        InMemoryHttpMetricRepository,
+        { provide: HttpMetricRepository, useExisting: InMemoryHttpMetricRepository },
+        InMemoryRouteSyncLogRepository,
+        { provide: RouteSyncLogRepository, useExisting: InMemoryRouteSyncLogRepository },
+      ]${options},
+    )`;
+}
+function buildModuleEntries(sel) {
+    const entries = [];
+    entries.push(`ConfigModule.forRoot({ isGlobal: true, load: [yamlConfig] })`);
+    entries.push(brokerForRootAsync());
+    if (sel.gatewayConfig) {
+        entries.push('HttpModule');
+        entries.push(proxyForRootAsync(sel));
+    }
+    if (sel.acl)
+        entries.push(aclForRoot());
+    if (sel.admin || sel.routeReception)
+        entries.push(gatewayAdminForRoot(sel));
+    return entries;
 }
 function main(options) {
+    const project = (options.project || 'my-service').toString();
     options = transform(options);
-    const gateway = options.gateway !== false;
-    const skills = options.skills !== false;
-    return (tree, context) => {
+    return async (tree, context) => {
+        const sel = await resolveSelections({ ...options, project }, context);
+        const anyRepo = sel.acl || sel.admin || sel.routeReception;
         return (0, schematics_1.branchAndMerge)((0, schematics_1.chain)([
             (0, source_root_helpers_1.mergeSourceRoot)(options),
-            addBrokerModuleToAppModule(gateway),
-            updateConfigYaml(gateway),
-            gateway ? configureMainForGateway() : (0, schematics_1.noop)(),
-            updatePackageJson(options),
-            skills ? copySkills() : (0, schematics_1.noop)(),
-        ]))(tree, context);
+            addModulesToAppModule(sel),
+            createConfigLoader(),
+            updateConfigYaml(sel),
+            sel.gatewayConfig ? configureMainForGateway() : (0, schematics_1.noop)(),
+            anyRepo ? copyAsset('db-core') : (0, schematics_1.noop)(),
+            sel.acl ? copyAsset('acl') : (0, schematics_1.noop)(),
+            (sel.admin || sel.routeReception) ? copyAsset('gateway-admin') : (0, schematics_1.noop)(),
+            sel.skills ? copySkills() : (0, schematics_1.noop)(),
+            updatePackageJson(sel),
+        ]));
     };
 }
 function transform(source) {
@@ -128,26 +598,45 @@ function transform(source) {
     target.specFileSuffix = (0, formatting_1.normalizeToKebabOrSnakeCase)(source.specFileSuffix || 'spec');
     return target;
 }
+function copyAsset(name) {
+    return (0, schematics_1.mergeWith)((0, schematics_1.apply)((0, schematics_1.url)(`./files/${name}`), [(0, schematics_1.move)((0, path_1.normalize)('.'))]), schematics_1.MergeStrategy.Overwrite);
+}
 function copySkills() {
     return (0, schematics_1.mergeWith)((0, schematics_1.apply)((0, schematics_1.url)('./files/skills'), [(0, schematics_1.move)((0, path_1.normalize)('.claude/skills'))]), schematics_1.MergeStrategy.Overwrite);
 }
-function updateConfigYaml(gateway) {
+function createConfigLoader() {
+    return (tree) => {
+        const path = 'src/config/config.loader.ts';
+        if (tree.exists(path))
+            return tree;
+        tree.create(path, `import { readFileSync } from 'fs';
+import * as yaml from 'js-yaml';
+import { join } from 'path';
+
+const YAML_CONFIG_FILENAME = 'config/config.yaml';
+
+export default () =>
+  yaml.load(readFileSync(join(process.cwd(), YAML_CONFIG_FILENAME), 'utf8')) as Record<string, any>;
+`);
+        return tree;
+    };
+}
+function updateConfigYaml(sel) {
     return (tree) => {
         const CONFIG_PATH = 'config/config.yaml';
-        const block = configYaml(gateway);
+        const block = buildConfigYaml(sel);
         if (!tree.exists(CONFIG_PATH)) {
-            tree.create(CONFIG_PATH, block.trimStart());
+            tree.create(CONFIG_PATH, block);
             return tree;
         }
         const existing = tree.read(CONFIG_PATH).toString('utf-8');
-        const SECTION_KEYS = ['app:', 'auth-providers:', 'broker:', 'topics:', ...(gateway ? ['gateway:'] : [])];
+        const SECTION_KEYS = ['app:', 'auth-providers:', 'broker:', 'topics:', ...(sel.gatewayConfig ? ['gateway:'] : [])];
         let toAppend = '';
         for (const key of SECTION_KEYS) {
             if (!existing.includes(key)) {
                 const section = extractYamlSection(block, key);
-                if (section) {
-                    toAppend += '\n' + section;
-                }
+                if (section)
+                    toAppend += '\n' + section + '\n';
             }
         }
         if (toAppend.length > 0) {
@@ -158,47 +647,34 @@ function updateConfigYaml(gateway) {
 }
 function extractYamlSection(yaml, sectionKey) {
     const lines = yaml.split('\n');
-    const startIdx = lines.findIndex(l => l.startsWith(sectionKey));
+    const startIdx = lines.findIndex((l) => l.startsWith(sectionKey));
     if (startIdx === -1)
         return '';
     const endIdx = lines.findIndex((l, i) => i > startIdx && l.length > 0 && !l.startsWith(' ') && !l.startsWith('#'));
     const sectionLines = endIdx === -1 ? lines.slice(startIdx) : lines.slice(startIdx, endIdx);
     return sectionLines.join('\n').trimEnd();
 }
-function addBrokerModuleToAppModule(gateway) {
+function addModulesToAppModule(sel) {
     return (tree) => {
-        const candidatePaths = [
-            '/src/app.module.ts',
-            '/app/app.module.ts',
-            'src/app.module.ts',
-            'app/app.module.ts',
-        ];
-        let modulePath = candidatePaths.find(p => tree.exists(p));
-        if (!modulePath) {
-            modulePath = findFileInTree(tree, 'app.module.ts');
-        }
+        const candidatePaths = ['/src/app.module.ts', '/app/app.module.ts', 'src/app.module.ts', 'app/app.module.ts'];
+        let modulePath = candidatePaths.find((p) => tree.exists(p)) || findFileInTree(tree, 'app.module.ts');
         if (!modulePath) {
-            console.warn('[nest-add] app.module.ts non trovato: BrokerModule non aggiunto.');
+            console.warn('[nest-add] app.module.ts not found: AppModule wiring skipped.');
             return tree;
         }
-        const rawContent = tree.read(modulePath);
-        if (!rawContent) {
+        const raw = tree.read(modulePath);
+        if (!raw)
+            return tree;
+        let content = raw.toString('utf-8');
+        if (content.includes('BrokerModule.forRootAsync'))
             return tree;
-        }
-        let content = rawContent.toString('utf-8');
         if (!content.includes('@open-rlb/nestjs-amqp')) {
-            const importInsertPos = findLastImportEndIndex(content);
-            content =
-                content.slice(0, importInsertPos) +
-                    '\n' + brokerImportLine(gateway) +
-                    content.slice(importInsertPos);
+            const pos = findLastImportEndIndex(content);
+            content = content.slice(0, pos) + '\n' + buildImportStatements(sel) + content.slice(pos);
         }
-        if (!content.includes('BrokerModule.forRootAsync')) {
-            if (gateway) {
-                content = insertIntoImportsArray(content, proxyForRootAsync());
-                content = insertIntoImportsArray(content, 'HttpModule');
-            }
-            content = insertIntoImportsArray(content, brokerForRootAsync());
+        const entries = buildModuleEntries(sel);
+        for (let i = entries.length - 1; i >= 0; i--) {
+            content = insertIntoImportsArray(content, entries[i]);
         }
         tree.overwrite(modulePath, content);
         return tree;
@@ -207,37 +683,34 @@ function addBrokerModuleToAppModule(gateway) {
 function configureMainForGateway() {
     return (tree) => {
         const candidatePaths = ['/src/main.ts', '/app/main.ts', 'src/main.ts', 'app/main.ts'];
-        const mainPath = candidatePaths.find(p => tree.exists(p)) || findFileInTree(tree, 'main.ts');
+        const mainPath = candidatePaths.find((p) => tree.exists(p)) || findFileInTree(tree, 'main.ts');
         if (!mainPath) {
-            console.warn('[nest-add] main.ts non trovato: abilita manualmente rawBody e WsAdapter.');
+            console.warn('[nest-add] main.ts not found: enable rawBody + WsAdapter manually.');
             return tree;
         }
         let content = tree.read(mainPath).toString('utf-8');
-        if (content.includes('WsAdapter')) {
+        if (content.includes('WsAdapter'))
             return tree;
-        }
         const pos = findLastImportEndIndex(content);
         content = content.slice(0, pos) + "\nimport { WsAdapter } from '@nestjs/platform-ws';" + content.slice(pos);
         const m = content.match(/const\s+(\w+)\s*=\s*await\s+NestFactory\.create\(\s*([A-Za-z0-9_]+)\s*(,\s*\{[^}]*\})?\s*\)\s*;?/);
         if (m) {
             const appVar = m[1];
             const moduleArg = m[2];
-            const replacement = `const ${appVar} = await NestFactory.create(${moduleArg}, { rawBody: true });\n  ${appVar}.useWebSocketAdapter(new WsAdapter(${appVar}));`;
+            const replacement = `const ${appVar} = await NestFactory.create(${moduleArg}, { rawBody: true });\n  ${appVar}.useWebSocketAdapter(new WsAdapter(${appVar}));\n  ${appVar}.enableShutdownHooks();`;
             content = content.replace(m[0], replacement);
         }
         else {
-            console.warn('[nest-add] NestFactory.create() non trovato in main.ts: aggiungi { rawBody: true } e useWebSocketAdapter manualmente.');
+            console.warn('[nest-add] NestFactory.create() not found in main.ts: add { rawBody: true } + useWebSocketAdapter manually.');
         }
         tree.overwrite(mainPath, content);
         return tree;
     };
 }
 function insertIntoImportsArray(source, moduleEntry) {
-    const importsArrayRegex = /imports\s*:\s*\[/;
-    const match = importsArrayRegex.exec(source);
-    if (!match) {
+    const match = /imports\s*:\s*\[/.exec(source);
+    if (!match)
         return source;
-    }
     const openBracketPos = source.indexOf('[', match.index);
     let depth = 0;
     let closeBracketPos = -1;
@@ -252,20 +725,13 @@ function insertIntoImportsArray(source, moduleEntry) {
             }
         }
     }
-    if (closeBracketPos === -1) {
+    if (closeBracketPos === -1)
         return source;
-    }
     const arrayContent = source.slice(openBracketPos + 1, closeBracketPos).trim();
-    let newArrayContent;
-    if (arrayContent.length === 0) {
-        newArrayContent = `\n    ${moduleEntry},\n  `;
-    }
-    else {
-        newArrayContent = `\n    ${moduleEntry},\n    ${arrayContent}\n  `;
-    }
-    return (source.slice(0, openBracketPos + 1) +
-        newArrayContent +
-        source.slice(closeBracketPos));
+    const newArrayContent = arrayContent.length === 0
+        ? `\n    ${moduleEntry},\n  `
+        : `\n    ${moduleEntry},\n    ${arrayContent}\n  `;
+    return source.slice(0, openBracketPos + 1) + newArrayContent + source.slice(closeBracketPos);
 }
 function findLastImportEndIndex(source) {
     const importRegex = /^import\s+.+from\s+['"][^'"]+['"];?\s*$/gm;
@@ -278,36 +744,40 @@ function findLastImportEndIndex(source) {
 }
 function findFileInTree(tree, fileName) {
     let found;
-    tree.visit(path => {
-        if (!found && path.endsWith(`/${fileName}`)) {
+    tree.visit((path) => {
+        if (!found && path.endsWith(`/${fileName}`))
             found = path;
-        }
     });
     return found;
 }
-function updatePackageJson(options) {
+function updatePackageJson(sel) {
     return (host) => {
-        if (!host.exists('package.json')) {
+        if (!host.exists('package.json'))
             return host;
-        }
         return updateJsonFile(host, 'package.json', (packageJson) => {
-            updateNpmScripts(packageJson.scripts, options);
+            packageJson.dependencies = packageJson.dependencies || {};
+            const add = (name, version) => {
+                if (!packageJson.dependencies[name])
+                    packageJson.dependencies[name] = version;
+            };
+            add('@nestjs/config', '^4.0.4');
+            add('js-yaml', '^4.1.0');
+            if (sel.gatewayConfig) {
+                add('@nestjs/axios', '^4.0.1');
+                add('@nestjs/platform-ws', '^11.0.1');
+                add('@nestjs/websockets', '^11.0.1');
+                add('ws', '^8.21.0');
+            }
         });
     };
 }
 function updateJsonFile(host, path, callback) {
     const source = host.read(path);
     if (source) {
-        const sourceText = source.toString('utf-8');
-        const json = (0, jsonc_parser_1.parse)(sourceText);
+        const json = (0, jsonc_parser_1.parse)(source.toString('utf-8'));
         callback(json);
         host.overwrite(path, JSON.stringify(json, null, 2));
     }
     return host;
 }
-function updateNpmScripts(scripts, _options) {
-    if (!scripts) {
-        return;
-    }
-}
 //# sourceMappingURL=index.js.map