@trinacria/cli 0.1.1-alpha.1

package/dist/commands/new.js

@@ -0,0 +1,280 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__newTestUtils = void 0;
+exports.createNewApp = createNewApp;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const core_1 = require("@trinacria/core");
+const context = "TrinacriaCLI";
+const log = new core_1.ConsoleLogger(context);
+const DEFAULT_GITIGNORE = "node_modules\ndist\n.env\n";
+const TEMPLATE_APP_NAMES = [
+    "app-starter",
+    "cron-example",
+    "api-prisma-postgresql",
+    "api-mongoose-mongodb",
+    "api-events-redis",
+    "api-events-rabbitmq",
+];
+const defaultDeps = {
+    cwd: () => process.cwd(),
+    templatesRoot: () => resolveTemplatesRoot(),
+    pathExists: (target) => node_fs_1.default.existsSync(target),
+    mkdir: (target) => node_fs_1.default.mkdirSync(target, { recursive: true }),
+    readdir: (target) => node_fs_1.default.readdirSync(target, { withFileTypes: true }),
+    stat: (target) => node_fs_1.default.statSync(target),
+    readFile: (target) => node_fs_1.default.readFileSync(target, "utf8"),
+    writeFile: (target, content) => node_fs_1.default.writeFileSync(target, content, "utf8"),
+    copyFile: (from, to) => node_fs_1.default.copyFileSync(from, to),
+    runCommand: (command, args, cwd) => new Promise((resolve, reject) => {
+        const child = (0, node_child_process_1.spawn)(command, args, {
+            cwd,
+            stdio: "inherit",
+        });
+        child.on("error", reject);
+        child.on("exit", (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(`Command failed: ${command} ${args.join(" ")}`));
+        });
+    }),
+    info: (message) => log.info(message, context),
+};
+function resolveTemplatesRoot() {
+    const distributedTemplatesRoot = node_path_1.default.resolve(__dirname, "../templates");
+    if (node_fs_1.default.existsSync(distributedTemplatesRoot)) {
+        return distributedTemplatesRoot;
+    }
+    return node_path_1.default.resolve(__dirname, "../../../../apps");
+}
+async function createNewApp(args, deps = defaultDeps) {
+    const options = parseNewArgs(args);
+    const sourceDir = resolveTemplatePath(options.template, deps.templatesRoot());
+    const targetDir = node_path_1.default.resolve(deps.cwd(), options.projectName);
+    const publishedTrinacriaVersion = resolvePublishedTrinacriaVersion();
+    ensureTargetDirectory(targetDir, options.force, deps);
+    copyDirectory(sourceDir, targetDir, deps);
+    ensureGeneratedProjectFiles(targetDir, deps);
+    adaptGeneratedPackageJson(targetDir, options.projectName, publishedTrinacriaVersion, deps);
+    deps.info(`Project "${options.projectName}" generated from template "${options.template}".`);
+    if (options.git) {
+        deps.info("Initializing git repository...");
+        await deps.runCommand("git", ["init"], targetDir);
+    }
+    if (options.install) {
+        const packageManager = detectPackageManager();
+        const command = packageManager === "npm" ? "npm" : packageManager;
+        const commandArgs = packageManager === "npm" ? ["install"] : ["install"];
+        deps.info(`Installing dependencies with ${packageManager}...`);
+        await deps.runCommand(command, commandArgs, targetDir);
+    }
+}
+function parseNewArgs(args) {
+    const positionals = [];
+    let templateInput = "app-starter";
+    let install = true;
+    let git = true;
+    let force = false;
+    for (let index = 0; index < args.length; index++) {
+        const arg = args[index];
+        if (!arg.startsWith("-")) {
+            positionals.push(arg);
+            continue;
+        }
+        if (arg === "--template" || arg === "-t") {
+            const next = args[index + 1];
+            if (!next || next.startsWith("-")) {
+                throw new Error("Missing value for --template <name>.");
+            }
+            templateInput = next;
+            index += 1;
+            continue;
+        }
+        if (arg === "--install") {
+            install = true;
+            continue;
+        }
+        if (arg === "--no-install") {
+            install = false;
+            continue;
+        }
+        if (arg === "--git") {
+            git = true;
+            continue;
+        }
+        if (arg === "--no-git") {
+            git = false;
+            continue;
+        }
+        if (arg === "--force" || arg === "-f") {
+            force = true;
+            continue;
+        }
+        throw new Error(`Unknown option for "new": ${arg}`);
+    }
+    const projectName = positionals[0];
+    if (!projectName) {
+        throw new Error(`Missing project name. Usage: trinacria new <project-name> [--template <name>] [--no-install] [--no-git] [--force]. Available templates: ${TEMPLATE_APP_NAMES.join(", ")}.`);
+    }
+    const template = normalizeTemplateName(templateInput);
+    return {
+        projectName,
+        template,
+        install,
+        git,
+        force,
+    };
+}
+function normalizeTemplateName(templateInput) {
+    const normalized = templateInput.trim().toLowerCase();
+    if (normalized === "minimal" ||
+        normalized === "starter" ||
+        normalized === "base" ||
+        normalized === "default") {
+        return "app-starter";
+    }
+    if (isTemplateAppName(normalized)) {
+        return normalized;
+    }
+    throw new Error(`Unknown template "${templateInput}". Available templates: ${TEMPLATE_APP_NAMES.join(", ")}, minimal.`);
+}
+function isTemplateAppName(value) {
+    return TEMPLATE_APP_NAMES.includes(value);
+}
+function resolveTemplatePath(template, templatesRoot) {
+    const templatePath = node_path_1.default.resolve(templatesRoot, template);
+    if (!node_fs_1.default.existsSync(templatePath)) {
+        throw new Error(`Template source not found: ${templatePath}`);
+    }
+    return templatePath;
+}
+function ensureTargetDirectory(targetDir, force, deps) {
+    if (!deps.pathExists(targetDir)) {
+        deps.mkdir(targetDir);
+        return;
+    }
+    const stat = deps.stat(targetDir);
+    if (!stat.isDirectory()) {
+        throw new Error(`Target path exists and is not a directory: ${targetDir}`);
+    }
+    const entries = deps.readdir(targetDir);
+    if (entries.length > 0 && !force) {
+        throw new Error(`Target directory is not empty: ${targetDir}. Use --force to continue.`);
+    }
+}
+function copyDirectory(fromDir, toDir, deps) {
+    for (const entry of deps.readdir(fromDir)) {
+        if (shouldSkipEntry(entry.name)) {
+            continue;
+        }
+        const sourcePath = node_path_1.default.resolve(fromDir, entry.name);
+        const targetPath = node_path_1.default.resolve(toDir, entry.name);
+        if (entry.isDirectory()) {
+            deps.mkdir(targetPath);
+            copyDirectory(sourcePath, targetPath, deps);
+            continue;
+        }
+        deps.copyFile(sourcePath, targetPath);
+    }
+}
+function shouldSkipEntry(entryName) {
+    return (entryName === "dist" || entryName === "node_modules" || entryName === ".git");
+}
+function resolvePublishedTrinacriaVersion() {
+    const packageJsonPath = node_path_1.default.resolve(__dirname, "../../package.json");
+    const packageJson = JSON.parse(node_fs_1.default.readFileSync(packageJsonPath, "utf8"));
+    if (typeof packageJson.version === "string" && packageJson.version.length > 0) {
+        return packageJson.version;
+    }
+    return "latest";
+}
+function ensureGeneratedProjectFiles(targetDir, deps) {
+    const envExamplePath = node_path_1.default.resolve(targetDir, ".env.example");
+    const envPath = node_path_1.default.resolve(targetDir, ".env");
+    if (deps.pathExists(envExamplePath) && !deps.pathExists(envPath)) {
+        deps.writeFile(envPath, deps.readFile(envExamplePath));
+    }
+    const gitignorePath = node_path_1.default.resolve(targetDir, ".gitignore");
+    if (!deps.pathExists(gitignorePath)) {
+        deps.writeFile(gitignorePath, DEFAULT_GITIGNORE);
+    }
+}
+function adaptGeneratedPackageJson(targetDir, projectName, trinacriaVersion, deps) {
+    const packageJsonPath = node_path_1.default.resolve(targetDir, "package.json");
+    if (!deps.pathExists(packageJsonPath)) {
+        return;
+    }
+    const packageJson = JSON.parse(deps.readFile(packageJsonPath));
+    const projectBaseName = node_path_1.default.basename(targetDir);
+    packageJson.name = projectBaseName || projectName;
+    const scripts = normalizeScripts(packageJson.scripts);
+    packageJson.scripts = scripts;
+    const dependencies = normalizeDependencyMap(packageJson.dependencies, trinacriaVersion);
+    const devDependencies = normalizeDependencyMap(packageJson.devDependencies, trinacriaVersion);
+    const cliVersion = dependencies["@trinacria/cli"] ?? devDependencies["@trinacria/cli"];
+    if (cliVersion) {
+        delete dependencies["@trinacria/cli"];
+        devDependencies["@trinacria/cli"] = cliVersion;
+    }
+    else {
+        devDependencies["@trinacria/cli"] = trinacriaVersion;
+    }
+    if (!devDependencies.typescript) {
+        devDependencies.typescript = "latest";
+    }
+    if (!devDependencies["@types/node"]) {
+        devDependencies["@types/node"] = "latest";
+    }
+    packageJson.dependencies = dependencies;
+    packageJson.devDependencies = devDependencies;
+    deps.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`);
+}
+function normalizeScripts(scriptsInput) {
+    const scripts = {};
+    for (const [key, value] of Object.entries(scriptsInput ?? {})) {
+        if (typeof value === "string") {
+            scripts[key] = value;
+        }
+    }
+    scripts.dev = "trinacria dev";
+    scripts.build = "trinacria build";
+    scripts.start = "trinacria start";
+    return scripts;
+}
+function normalizeDependencyMap(input, trinacriaVersion) {
+    const output = {};
+    for (const [pkgName, version] of Object.entries(input ?? {})) {
+        if (typeof version !== "string") {
+            continue;
+        }
+        output[pkgName] = pkgName.startsWith("@trinacria/")
+            ? trinacriaVersion
+            : version;
+    }
+    return output;
+}
+function detectPackageManager() {
+    const userAgent = process.env.npm_config_user_agent ?? "";
+    if (userAgent.startsWith("pnpm/"))
+        return "pnpm";
+    if (userAgent.startsWith("yarn/"))
+        return "yarn";
+    if (userAgent.startsWith("bun/"))
+        return "bun";
+    return "npm";
+}
+exports.__newTestUtils = {
+    parseNewArgs,
+    normalizeTemplateName,
+    normalizeDependencyMap,
+    normalizeScripts,
+    adaptGeneratedPackageJson,
+    ensureGeneratedProjectFiles,
+    ensureTargetDirectory,
+};

package/dist/commands/start.d.ts

@@ -0,0 +1,13 @@
+import { ResolvedConfig } from "../config/config.contract";
+export declare function start(config: ResolvedConfig): Promise<void>;
+declare function resolveBuiltEntryPath(entry: string, outDir: string): string;
+declare function resolveCommonRootDir(fileNames: readonly string[]): string;
+declare function commonDirectory(a: string, b: string): string;
+declare function replaceSourceExtension(filePath: string): string;
+export declare const __startTestUtils: {
+    resolveBuiltEntryPath: typeof resolveBuiltEntryPath;
+    resolveCommonRootDir: typeof resolveCommonRootDir;
+    commonDirectory: typeof commonDirectory;
+    replaceSourceExtension: typeof replaceSourceExtension;
+};
+export {};

package/dist/commands/start.js

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__startTestUtils = void 0;
+exports.start = start;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+const core_1 = require("@trinacria/core");
+const context = "TrinacriaCLI";
+const log = new core_1.ConsoleLogger(context);
+async function start(config) {
+    const entry = resolveBuiltEntryPath(config.entry, config.outDir);
+    log.info(`Starting application in production mode (${entry})`, context);
+    if (!node_fs_1.default.existsSync(entry)) {
+        throw new Error(`Built entry file not found: ${entry}. Run "trinacria build" first or verify tsconfig rootDir/outDir.`);
+    }
+    await new Promise((resolve, reject) => {
+        const child = (0, node_child_process_1.spawn)(process.execPath, [entry], {
+            stdio: "inherit",
+        });
+        child.on("exit", (code) => {
+            if (code !== 0) {
+                reject(new Error(`Exited with code ${code}`));
+            }
+            else {
+                resolve();
+            }
+        });
+        child.on("error", reject);
+    });
+}
+function resolveBuiltEntryPath(entry, outDir) {
+    const entryAbs = node_path_1.default.resolve(entry);
+    const outDirAbs = node_path_1.default.resolve(outDir);
+    const configPath = typescript_1.default.findConfigFile(process.cwd(), typescript_1.default.sys.fileExists, "tsconfig.json");
+    let rootDirAbs = process.cwd();
+    if (configPath) {
+        const configFile = typescript_1.default.readConfigFile(configPath, typescript_1.default.sys.readFile);
+        if (configFile.error) {
+            throw new Error(`Failed to read tsconfig.json: ${typescript_1.default.flattenDiagnosticMessageText(configFile.error.messageText, "\n")}`);
+        }
+        const parsed = typescript_1.default.parseJsonConfigFileContent(configFile.config, typescript_1.default.sys, node_path_1.default.dirname(configPath), { outDir: outDirAbs });
+        if (parsed.errors.length > 0) {
+            const message = parsed.errors
+                .map((diagnostic) => typescript_1.default.flattenDiagnosticMessageText(diagnostic.messageText, "\n"))
+                .join("; ");
+            throw new Error(`Failed to parse tsconfig.json: ${message}`);
+        }
+        if (parsed.options.rootDir) {
+            rootDirAbs = node_path_1.default.resolve(parsed.options.rootDir);
+        }
+        else {
+            rootDirAbs = resolveCommonRootDir(parsed.fileNames);
+        }
+    }
+    const relativeFromRoot = node_path_1.default.relative(rootDirAbs, entryAbs);
+    if (relativeFromRoot.startsWith("..") ||
+        node_path_1.default.isAbsolute(relativeFromRoot) ||
+        relativeFromRoot === "") {
+        throw new Error(`Entry "${entryAbs}" is outside resolved TypeScript rootDir "${rootDirAbs}".`);
+    }
+    return node_path_1.default.resolve(outDirAbs, replaceSourceExtension(relativeFromRoot));
+}
+function resolveCommonRootDir(fileNames) {
+    if (fileNames.length === 0) {
+        return process.cwd();
+    }
+    const directories = fileNames.map((file) => node_path_1.default.dirname(node_path_1.default.resolve(file)));
+    let common = directories[0];
+    for (let i = 1; i < directories.length; i++) {
+        common = commonDirectory(common, directories[i]);
+    }
+    return common;
+}
+function commonDirectory(a, b) {
+    const aParts = node_path_1.default.resolve(a).split(node_path_1.default.sep);
+    const bParts = node_path_1.default.resolve(b).split(node_path_1.default.sep);
+    const length = Math.min(aParts.length, bParts.length);
+    const shared = [];
+    for (let i = 0; i < length; i++) {
+        if (aParts[i] !== bParts[i])
+            break;
+        shared.push(aParts[i]);
+    }
+    if (shared.length === 0) {
+        return process.cwd();
+    }
+    return shared.join(node_path_1.default.sep) || node_path_1.default.sep;
+}
+function replaceSourceExtension(filePath) {
+    if (filePath.endsWith(".mts"))
+        return filePath.slice(0, -4) + ".mjs";
+    if (filePath.endsWith(".cts"))
+        return filePath.slice(0, -4) + ".cjs";
+    if (filePath.endsWith(".tsx"))
+        return filePath.slice(0, -4) + ".js";
+    if (filePath.endsWith(".ts"))
+        return filePath.slice(0, -3) + ".js";
+    return filePath;
+}
+exports.__startTestUtils = {
+    resolveBuiltEntryPath,
+    resolveCommonRootDir,
+    commonDirectory,
+    replaceSourceExtension,
+};

package/dist/config/config.contract.d.ts

@@ -0,0 +1,9 @@
+export interface ResolvedConfig {
+    entry: string;
+    outDir: string;
+    watchDir: string;
+    env: "development" | "production" | string;
+    crashLoopWindowMs: number;
+    maxConsecutiveCrashRestarts: number;
+}
+export type TrinacriaConfig = Partial<ResolvedConfig>;

package/dist/config/config.contract.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/config/default-config.d.ts

@@ -0,0 +1,2 @@
+import { ResolvedConfig } from "./config.contract.js";
+export declare const defaultConfig: ResolvedConfig;

package/dist/config/default-config.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultConfig = void 0;
+exports.defaultConfig = {
+    entry: "src/main.ts",
+    outDir: "dist",
+    watchDir: "src",
+    env: "development",
+    crashLoopWindowMs: 15_000,
+    maxConsecutiveCrashRestarts: 3,
+};

package/dist/config/load-config.d.ts

@@ -0,0 +1,2 @@
+import type { ResolvedConfig } from "./config.contract";
+export declare function loadConfig(args: string[]): Promise<ResolvedConfig>;

package/dist/config/load-config.js

@@ -0,0 +1,113 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_url_1 = require("node:url");
+const default_config_1 = require("./default-config");
+async function loadConfig(args) {
+    const configFlagIndex = args.indexOf("--config");
+    const hasExplicitConfig = configFlagIndex !== -1;
+    let configPath;
+    if (hasExplicitConfig && args[configFlagIndex + 1]) {
+        configPath = node_path_1.default.resolve(args[configFlagIndex + 1]);
+    }
+    else if (hasExplicitConfig) {
+        throw new Error("Missing value for --config <path>.");
+    }
+    else {
+        configPath = resolveDefaultConfigPath();
+    }
+    if (hasExplicitConfig && configPath && !node_fs_1.default.existsSync(configPath)) {
+        throw new Error(`Config file not found: ${configPath}`);
+    }
+    if (!configPath || !node_fs_1.default.existsSync(configPath)) {
+        return normalizeConfig(default_config_1.defaultConfig);
+    }
+    try {
+        // 🟢 Prima prova CommonJS
+        const required = require(configPath);
+        const userConfig = required.default ?? required;
+        return normalizeConfig({
+            ...default_config_1.defaultConfig,
+            ...userConfig,
+        });
+    }
+    catch (err) {
+        // 🔵 Se è errore ESM → fallback a dynamic import
+        if (err.code === "ERR_REQUIRE_ESM") {
+            const module = await Promise.resolve(`${(0, node_url_1.pathToFileURL)(configPath).href}`).then(s => __importStar(require(s)));
+            const userConfig = module.default ?? module;
+            return normalizeConfig({
+                ...default_config_1.defaultConfig,
+                ...userConfig,
+            });
+        }
+        throw new Error(`Failed to load config file "${configPath}": ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+function normalizeConfig(config) {
+    const crashLoopWindowMs = Number(config.crashLoopWindowMs);
+    const maxConsecutiveCrashRestarts = Number(config.maxConsecutiveCrashRestarts);
+    return {
+        ...config,
+        crashLoopWindowMs: Number.isFinite(crashLoopWindowMs) && crashLoopWindowMs > 0
+            ? Math.floor(crashLoopWindowMs)
+            : default_config_1.defaultConfig.crashLoopWindowMs,
+        maxConsecutiveCrashRestarts: Number.isFinite(maxConsecutiveCrashRestarts) &&
+            maxConsecutiveCrashRestarts >= 1
+            ? Math.floor(maxConsecutiveCrashRestarts)
+            : default_config_1.defaultConfig.maxConsecutiveCrashRestarts,
+    };
+}
+function resolveDefaultConfigPath() {
+    const cwd = process.cwd();
+    const possibleFiles = [
+        "trinacria.config.js",
+        "trinacria.config.cjs",
+        "trinacria.config.mjs",
+    ];
+    for (const file of possibleFiles) {
+        const fullPath = node_path_1.default.resolve(cwd, file);
+        if (node_fs_1.default.existsSync(fullPath)) {
+            return fullPath;
+        }
+    }
+    return null;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export type { TrinacriaConfig } from "./config/config.contract";

package/dist/index.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cli_1 = require("./cli");
+(0, cli_1.main)();

package/dist/templates/api-events-rabbitmq/.env.example

@@ -0,0 +1,23 @@
+# ------------------------------------------------------------
+# Local app runtime (used by `npm run dev -w api-events-rabbitmq`)
+# ------------------------------------------------------------
+ENV=development
+HOST=127.0.0.1
+PORT=4004
+OPENAPI_ENABLED=true
+CORS_ALLOWED_ORIGINS=
+RABBITMQ_URL=amqp://127.0.0.1:5672
+RABBITMQ_EXCHANGE=trinacria.events
+RABBITMQ_QUEUE_NAME=api-events-rabbitmq.events
+RABBITMQ_ROUTING_PATTERN=#
+
+# ------------------------------------------------------------
+# Docker runtime (used by `docker compose ... --env-file .../.env`)
+# ------------------------------------------------------------
+DOCKER_RABBITMQ_PORT=5672
+DOCKER_RABBITMQ_MANAGEMENT_PORT=15672
+DOCKER_API_PORT=4004
+DOCKER_RABBITMQ_URL=amqp://rabbitmq:5672
+DOCKER_RABBITMQ_EXCHANGE=trinacria.events
+DOCKER_RABBITMQ_QUEUE_NAME=api-events-rabbitmq.events
+DOCKER_RABBITMQ_ROUTING_PATTERN=#

package/dist/templates/api-events-rabbitmq/Dockerfile

@@ -0,0 +1,18 @@
+FROM node:24-bookworm-slim
+
+WORKDIR /app
+
+COPY package.json package-lock.json tsconfig.base.json ./
+COPY packages ./packages
+COPY apps/api-events-rabbitmq ./apps/api-events-rabbitmq
+
+RUN npm ci
+RUN npm run build:packages
+RUN npm run build -w api-events-rabbitmq
+
+ENV HOST=0.0.0.0
+ENV PORT=4004
+
+EXPOSE 4004
+
+CMD ["npm", "run", "start", "-w", "api-events-rabbitmq"]