@trinacria/cli 0.1.1-alpha.1

package/dist/templates/api-events-redis/src/modules/events/dto/event.dto.ts

@@ -0,0 +1,24 @@
+import { s } from "@trinacria/schema";
+
+export interface EventDto {
+  id: string;
+  name: string;
+  payload: {
+    message: string;
+  };
+  receivedAt: Date;
+}
+
+export const EventDtoSchema = s.objectOf<EventDto>()(
+  {
+    id: s.string({ trim: true, minLength: 1 }),
+    name: s.string({ trim: true, minLength: 1 }),
+    payload: s.object({
+      message: s.string({ trim: true, minLength: 1 }),
+    }),
+    receivedAt: s.date(),
+  },
+  { strict: true },
+);
+
+export const EventListDtoSchema = s.array(EventDtoSchema);

package/dist/templates/api-events-redis/src/modules/events/dto/index.ts

@@ -0,0 +1,2 @@
+export * from "./event.dto";
+export * from "./publish-event.dto";

package/dist/templates/api-events-redis/src/modules/events/dto/publish-event.dto.ts

@@ -0,0 +1,12 @@
+import { s } from "@trinacria/schema";
+
+export interface PublishEventDto {
+  message: string;
+}
+
+export const PublishEventDtoSchema = s.objectOf<PublishEventDto>()(
+  {
+    message: s.string({ trim: true, minLength: 1 }),
+  },
+  { strict: true },
+);

package/dist/templates/api-events-redis/src/modules/events/events.controller.ts

@@ -0,0 +1,76 @@
+import { HttpController, HttpContext, response } from "@trinacria/http";
+import type { EventBus } from "@trinacria/events";
+import { EventListDtoSchema, PublishEventDtoSchema } from "./dto";
+import { DEMO_EVENT_NAME } from "./events.provider";
+import { EventsService } from "./events.service";
+
+export class EventsController extends HttpController {
+  constructor(
+    private readonly eventsService: EventsService,
+    private readonly eventBus: EventBus,
+  ) {
+    super();
+  }
+
+  routes() {
+    return this.router()
+      .get("/health", this.healthCheck, {
+        docs: {
+          tags: ["Health"],
+          summary: "Health check",
+        },
+      })
+      .get("/events", this.listEvents, {
+        docs: {
+          tags: ["Events"],
+          summary: "List consumed events",
+          responses: {
+            200: {
+              description: "Consumed events",
+              schema: EventListDtoSchema.toOpenApi(),
+            },
+          },
+        },
+      })
+      .post("/events/publish", this.publishEvent, {
+        docs: {
+          tags: ["Events"],
+          summary: "Publish demo event to Redis transport",
+          requestBody: {
+            required: true,
+            schema: PublishEventDtoSchema.toOpenApi(),
+          },
+          responses: {
+            202: {
+              description: "Event accepted",
+            },
+          },
+        },
+      })
+      .build();
+  }
+
+  healthCheck() {
+    return { status: "ok" };
+  }
+
+  listEvents() {
+    return this.eventsService.list();
+  }
+
+  async publishEvent(ctx: HttpContext) {
+    const payload = PublishEventDtoSchema.parse(ctx.body);
+
+    await this.eventBus.emit(DEMO_EVENT_NAME, {
+      message: payload.message,
+    });
+
+    return response(
+      {
+        status: "accepted",
+        event: DEMO_EVENT_NAME,
+      },
+      { status: 202 },
+    );
+  }
+}

package/dist/templates/api-events-redis/src/modules/events/events.module.ts

@@ -0,0 +1,27 @@
+import { classProvider, defineModule } from "@trinacria/core";
+import { EVENT_BUS_TOKEN, eventProvider } from "@trinacria/events";
+import { httpProvider } from "@trinacria/http";
+import {
+  EVENTS_CONTROLLER,
+  EVENTS_PROVIDER,
+  EVENTS_SERVICE,
+  EVENTS_STORE,
+} from "./events.tokens";
+import { EventsController } from "./events.controller";
+import { EventsProvider } from "./events.provider";
+import { EventsService } from "./events.service";
+import { EventsStore } from "./events.store";
+
+export const EventsModule = defineModule({
+  name: "EventsModule",
+  providers: [
+    classProvider(EVENTS_STORE, EventsStore),
+    classProvider(EVENTS_SERVICE, EventsService, [EVENTS_STORE]),
+    httpProvider(EVENTS_CONTROLLER, EventsController, [
+      EVENTS_SERVICE,
+      EVENT_BUS_TOKEN,
+    ]),
+    eventProvider(EVENTS_PROVIDER, EventsProvider, [EVENTS_SERVICE]),
+  ],
+  exports: [EVENTS_SERVICE, EVENTS_CONTROLLER, EVENTS_PROVIDER],
+});

package/dist/templates/api-events-redis/src/modules/events/events.provider.ts

@@ -0,0 +1,28 @@
+import type { EventProvider } from "@trinacria/events";
+import { EventsService } from "./events.service";
+
+export const DEMO_EVENT_NAME = "events.demo";
+
+export class EventsProvider implements EventProvider {
+  constructor(private readonly eventsService: EventsService) {}
+
+  subscriptions() {
+    return [
+      {
+        event: DEMO_EVENT_NAME,
+        handler: async (payload: unknown) => {
+          if (
+            payload &&
+            typeof payload === "object" &&
+            "message" in payload &&
+            typeof payload.message === "string"
+          ) {
+            this.eventsService.add(DEMO_EVENT_NAME, {
+              message: payload.message,
+            });
+          }
+        },
+      },
+    ];
+  }
+}

package/dist/templates/api-events-redis/src/modules/events/events.service.ts

@@ -0,0 +1,19 @@
+import type { EventRecord } from "./events.store";
+import { EventsStore } from "./events.store";
+
+export class EventsService {
+  constructor(private readonly store: EventsStore) {}
+
+  list(): EventRecord[] {
+    return this.store.list();
+  }
+
+  add(
+    name: string,
+    payload: {
+      message: string;
+    },
+  ): EventRecord {
+    return this.store.add(name, payload);
+  }
+}

package/dist/templates/api-events-redis/src/modules/events/events.store.ts

@@ -0,0 +1,42 @@
+import { randomUUID } from "node:crypto";
+
+export interface EventRecord {
+  id: string;
+  name: string;
+  payload: {
+    message: string;
+  };
+  receivedAt: Date;
+}
+
+const MAX_EVENTS = 100;
+
+export class EventsStore {
+  private readonly events: EventRecord[] = [];
+
+  add(
+    name: string,
+    payload: {
+      message: string;
+    },
+  ): EventRecord {
+    const entry: EventRecord = {
+      id: randomUUID(),
+      name,
+      payload,
+      receivedAt: new Date(),
+    };
+
+    this.events.unshift(entry);
+
+    if (this.events.length > MAX_EVENTS) {
+      this.events.length = MAX_EVENTS;
+    }
+
+    return entry;
+  }
+
+  list(): EventRecord[] {
+    return [...this.events];
+  }
+}

package/dist/templates/api-events-redis/src/modules/events/events.tokens.ts

@@ -0,0 +1,11 @@
+import { createToken } from "@trinacria/core";
+import type { EventProvider } from "@trinacria/events";
+import { EventsController } from "./events.controller";
+import { EventsService } from "./events.service";
+import { EventsStore } from "./events.store";
+
+export const EVENTS_STORE = createToken<EventsStore>("EVENTS_STORE");
+export const EVENTS_SERVICE = createToken<EventsService>("EVENTS_SERVICE");
+export const EVENTS_CONTROLLER =
+  createToken<EventsController>("EVENTS_CONTROLLER");
+export const EVENTS_PROVIDER = createToken<EventProvider>("EVENTS_PROVIDER");

package/dist/templates/api-events-redis/trinacria.config.mjs

@@ -0,0 +1,12 @@
+/** @type {import('@trinacria/cli').TrinacriaConfig} */
+
+const config = {
+  entry: "src/main.ts",
+  outDir: "dist",
+  watchDir: "src",
+  env: "development",
+  crashLoopWindowMs: 15_000,
+  maxConsecutiveCrashRestarts: 3,
+};
+
+export default config;

package/dist/templates/api-events-redis/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "types": ["node"],
+    "target": "ES2022",
+    "module": "CommonJS",
+    "strict": true,
+    "declaration": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src"]
+}

package/dist/templates/api-mongoose-mongodb/.env.example

@@ -0,0 +1,17 @@
+# ------------------------------------------------------------
+# Local app runtime (used by `npm run dev -w api-mongoose-mongodb`)
+# ------------------------------------------------------------
+ENV=development
+HOST=127.0.0.1
+PORT=4002
+OPENAPI_ENABLED=true
+CORS_ALLOWED_ORIGINS=
+DATABASE_URL="mongodb://127.0.0.1:27017/trinacria_example"
+
+# ------------------------------------------------------------
+# Docker runtime (used by `docker compose ... --env-file .../.env`)
+# ------------------------------------------------------------
+DOCKER_MONGO_INITDB_DATABASE=trinacria_example
+DOCKER_MONGO_PORT=27017
+DOCKER_API_PORT=4002
+DOCKER_DATABASE_URL="mongodb://mongo:27017/trinacria_example"

package/dist/templates/api-mongoose-mongodb/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-mongoose-mongodb ./apps/api-mongoose-mongodb
+
+RUN npm ci
+RUN npm run build:packages
+RUN npm run build -w api-mongoose-mongodb
+
+ENV HOST=0.0.0.0
+ENV PORT=4002
+
+EXPOSE 4002
+
+CMD ["npm", "run", "start", "-w", "api-mongoose-mongodb"]

package/dist/templates/api-mongoose-mongodb/README.md

@@ -0,0 +1,98 @@
+# API Example: Mongoose + MongoDB
+
+A minimal API-only example using Trinacria, Mongoose, and MongoDB.
+
+## Scope
+
+This app is intentionally a base template:
+
+- no authentication (no JWT/session/password flow)
+- no authorization roles/policies
+- no background jobs
+
+Use this as a starting point for integration examples.
+
+## Endpoints
+
+- `GET /health`
+- `GET /users`
+- `POST /users`
+- `GET /openapi.json`
+- `GET /docs` (Swagger UI)
+
+## Built-in middleware enabled
+
+- `requestId`
+- `requestLogger`
+- `cors`
+- `rateLimit`
+- `requestTimeout`
+- `securityHeaders`
+
+## First steps (local)
+
+1. Install dependencies from the monorepo root:
+
+```bash
+npm install
+```
+
+2. Copy the environment file:
+
+```bash
+cp apps/api-mongoose-mongodb/.env.example apps/api-mongoose-mongodb/.env.development
+```
+
+3. Make sure MongoDB is running locally and matches `DATABASE_URL`.
+
+4. Start the API:
+
+```bash
+npm run dev -w api-mongoose-mongodb
+```
+
+5. Verify the app is running:
+
+```bash
+curl http://127.0.0.1:4002/health
+```
+
+## Create your first user
+
+```bash
+curl -X POST http://127.0.0.1:4002/users \
+  -H 'content-type: application/json' \
+  -d '{"name":"Mario Rossi","email":"mario@example.com"}'
+```
+
+Then list users:
+
+```bash
+curl http://127.0.0.1:4002/users
+```
+
+## Docker quick start
+
+1. Create the Docker env file from the same template:
+
+```bash
+cp apps/api-mongoose-mongodb/.env.example apps/api-mongoose-mongodb/.env
+```
+
+2. Edit the Docker section in `apps/api-mongoose-mongodb/.env` if you want custom DB name/ports.
+
+3. Start MongoDB + API using that `.env` file:
+
+```bash
+docker compose \
+  --env-file apps/api-mongoose-mongodb/.env \
+  -f apps/api-mongoose-mongodb/docker-compose.yml \
+  up --build
+```
+
+The API will be available at `http://127.0.0.1:${DOCKER_API_PORT}` (default `4002`).
+
+Compose services:
+
+- `mongo`: MongoDB 7
+- `api`: this Trinacria API (built from this monorepo)

package/dist/templates/api-mongoose-mongodb/docker-compose.yml

@@ -0,0 +1,34 @@
+services:
+  mongo:
+    image: mongo:7
+    environment:
+      MONGO_INITDB_DATABASE: ${DOCKER_MONGO_INITDB_DATABASE}
+    ports:
+      - "${DOCKER_MONGO_PORT}:27017"
+    volumes:
+      - trinacria_api_mongo_data:/data/db
+    healthcheck:
+      test:
+        ["CMD", "mongosh", "--quiet", "--eval", "db.runCommand({ ping: 1 }).ok"]
+      interval: 5s
+      timeout: 5s
+      retries: 20
+
+  api:
+    build:
+      context: ../..
+      dockerfile: apps/api-mongoose-mongodb/Dockerfile
+    environment:
+      ENV: development
+      HOST: 0.0.0.0
+      PORT: 4002
+      OPENAPI_ENABLED: true
+      DATABASE_URL: ${DOCKER_DATABASE_URL}
+    ports:
+      - "${DOCKER_API_PORT}:4002"
+    depends_on:
+      mongo:
+        condition: service_healthy
+
+volumes:
+  trinacria_api_mongo_data:

package/dist/templates/api-mongoose-mongodb/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "api-mongoose-mongodb",
+  "private": true,
+  "type": "commonjs",
+  "scripts": {
+    "start": "node ../../packages/cli/dist/index.js start",
+    "build": "node ../../packages/cli/dist/index.js build",
+    "dev": "node ../../packages/cli/dist/index.js dev"
+  },
+  "dependencies": {
+    "@trinacria/cli": "*",
+    "@trinacria/core": "*",
+    "@trinacria/http": "*",
+    "@trinacria/schema": "*",
+    "mongoose": "^9.2.2"
+  }
+}

package/dist/templates/api-mongoose-mongodb/src/global/config.service.ts

@@ -0,0 +1,92 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createToken } from "@trinacria/core";
+import {
+  formatValidationError,
+  Infer,
+  s,
+  ValidationError,
+} from "@trinacria/schema";
+
+export const configSchema = s.object({
+  ENV: s.enum(["development", "staging", "production"]).default("development"),
+  PORT: s.number({ coerce: true, int: true, min: 1, max: 65535 }).default(4002),
+  HOST: s.string().default("127.0.0.1"),
+  DATABASE_URL: s.string(),
+  OPENAPI_ENABLED: s.boolean({ coerce: true }).default(true),
+  CORS_ALLOWED_ORIGINS: s.array(s.string(), { coerce: true }).default([]),
+});
+
+export type ConfigModel = Infer<typeof configSchema>;
+export const CONFIG_SERVICE = createToken<ConfigService>("CONFIG_SERVICE");
+
+export class ConfigService {
+  private readonly config: ConfigModel;
+
+  constructor() {
+    this.loadEnvFile();
+
+    try {
+      this.config = configSchema.parse(process.env);
+    } catch (error) {
+      if (error instanceof ValidationError) {
+        throw new Error(
+          formatValidationError(error, {
+            prefix: "Invalid environment configuration:",
+          }),
+        );
+      }
+
+      throw error;
+    }
+  }
+
+  private loadEnvFile() {
+    const currentEnv = process.env.ENV || "development";
+    const fileNames = [".env", `.env.${currentEnv}`];
+    const roots = [
+      process.cwd(),
+      path.join(process.cwd(), "apps/api-mongoose-mongodb"),
+    ];
+
+    fileNames.forEach((fileName) => {
+      roots.forEach((root) => {
+        const filePath = path.join(root, fileName);
+        if (!fs.existsSync(filePath)) {
+          return;
+        }
+
+        const data = fs.readFileSync(filePath, "utf8");
+        data.split("\n").forEach((line) => {
+          const trimmed = line.trim();
+          if (!trimmed || trimmed.startsWith("#")) {
+            return;
+          }
+
+          const separatorIndex = trimmed.indexOf("=");
+          if (separatorIndex === -1) {
+            return;
+          }
+
+          const key = trimmed.slice(0, separatorIndex).trim();
+          const rawValue = trimmed.slice(separatorIndex + 1).trim();
+          const value =
+            (rawValue.startsWith('"') && rawValue.endsWith('"')) ||
+            (rawValue.startsWith("'") && rawValue.endsWith("'"))
+              ? rawValue.slice(1, -1)
+              : rawValue;
+
+          process.env[key] = value;
+        });
+      });
+    });
+  }
+
+  get<K extends keyof ConfigModel>(key: K): ConfigModel[K] {
+    return this.config[key];
+  }
+
+  getAll(): ConfigModel {
+    return this.config;
+  }
+}

package/dist/templates/api-mongoose-mongodb/src/global/controllers/swagger/docs.html

@@ -0,0 +1,28 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>API Mongoose MongoDB Docs</title>
+    <link
+      rel="stylesheet"
+      href="https://unpkg.com/swagger-ui-dist@5/swagger-ui.css"
+    />
+  </head>
+  <body>
+    <div id="swagger-ui"></div>
+    <script src="https://unpkg.com/swagger-ui-dist@5/swagger-ui-bundle.js"></script>
+    <script src="https://unpkg.com/swagger-ui-dist@5/swagger-ui-standalone-preset.js"></script>
+    <script>
+      window.ui = SwaggerUIBundle({
+        url: "/openapi.json",
+        dom_id: "#swagger-ui",
+        deepLinking: true,
+        tryItOutEnabled: true,
+        persistAuthorization: true,
+        presets: [SwaggerUIBundle.presets.apis, SwaggerUIStandalonePreset],
+        layout: "StandaloneLayout",
+      });
+    </script>
+  </body>
+</html>

package/dist/templates/api-mongoose-mongodb/src/global/controllers/swagger/swagger-docs.controller.ts

@@ -0,0 +1,79 @@
+import { createToken } from "@trinacria/core";
+import { HttpController, response } from "@trinacria/http";
+import fs from "node:fs/promises";
+import path from "node:path";
+import type { ConfigService } from "../../config.service";
+
+export const SWAGGER_DOCS_CONTROLLER = createToken<SwaggerDocsController>(
+  "SWAGGER_DOCS_CONTROLLER",
+);
+
+export class SwaggerDocsController extends HttpController {
+  constructor(private readonly config: ConfigService) {
+    super();
+  }
+
+  routes() {
+    return this.router()
+      .get("/docs", this.renderDocs, {
+        docs: {
+          excludeFromOpenApi: true,
+        },
+      })
+      .build();
+  }
+
+  async renderDocs() {
+    if (!this.config.get("OPENAPI_ENABLED")) {
+      return response({ message: "OpenAPI is disabled" }, { status: 404 });
+    }
+
+    return response(await readSwaggerHtml(), {
+      headers: {
+        "content-type": "text/html; charset=utf-8",
+        "content-security-policy": docsContentSecurityPolicy(),
+      },
+    });
+  }
+}
+
+let cachedSwaggerHtml: string | undefined;
+
+async function readSwaggerHtml(): Promise<string> {
+  if (cachedSwaggerHtml) {
+    return cachedSwaggerHtml;
+  }
+
+  const candidates = [
+    path.resolve(process.cwd(), "src/global/controllers/swagger/docs.html"),
+    path.resolve(
+      process.cwd(),
+      "apps/api-mongoose-mongodb/src/global/controllers/swagger/docs.html",
+    ),
+  ];
+
+  for (const filePath of candidates) {
+    try {
+      cachedSwaggerHtml = await fs.readFile(filePath, "utf8");
+      return cachedSwaggerHtml;
+    } catch {
+      // keep trying next candidate
+    }
+  }
+
+  throw new Error("Swagger docs HTML template not found.");
+}
+
+function docsContentSecurityPolicy(): string {
+  return [
+    "default-src 'self'",
+    "base-uri 'self'",
+    "object-src 'none'",
+    "frame-ancestors 'none'",
+    "script-src 'self' 'unsafe-inline' https://unpkg.com",
+    "style-src 'self' 'unsafe-inline' https://unpkg.com",
+    "img-src 'self' data: blob:",
+    "font-src 'self' data: https://unpkg.com",
+    "connect-src 'self'",
+  ].join("; ");
+}

package/dist/templates/api-mongoose-mongodb/src/global/mongoose-schema.provider.ts

@@ -0,0 +1,18 @@
+import { factoryProvider, type Token } from "@trinacria/core";
+import { type Model, type Schema } from "mongoose";
+import { MONGOOSE_SERVICE, type MongooseService } from "./mongoose.service";
+
+export function createMongooseSchemaProvider<
+  TEntity,
+  TModel extends Model<TEntity>,
+>(token: Token<TModel>, schemaName: string, schema: Schema<TEntity>) {
+  return factoryProvider(
+    token,
+    (mongooseService: MongooseService) => {
+      const connection = mongooseService.getConnection();
+      return ((connection.models[schemaName] as TModel | undefined) ??
+        connection.model<TEntity>(schemaName, schema)) as TModel;
+    },
+    [MONGOOSE_SERVICE],
+  );
+}