@trinacria/cli 0.1.1-alpha.1

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

@@ -0,0 +1,36 @@
+import mongoose, { type Connection } from "mongoose";
+import { createToken } from "@trinacria/core";
+import type { ConfigService } from "./config.service";
+
+export const MONGOOSE_SERVICE =
+  createToken<MongooseService>("MONGOOSE_SERVICE");
+
+export class MongooseService {
+  private connection?: Connection;
+
+  constructor(private readonly config: ConfigService) {}
+
+  async onInit(): Promise<void> {
+    if (this.connection?.readyState === 1) {
+      return;
+    }
+
+    await mongoose.connect(this.config.get("DATABASE_URL"));
+    this.connection = mongoose.connection;
+  }
+
+  getConnection(): Connection {
+    if (!this.connection || this.connection.readyState !== 1) {
+      throw new Error("Mongoose connection is not ready");
+    }
+
+    return this.connection;
+  }
+
+  async onDestroy(): Promise<void> {
+    if (this.connection) {
+      await mongoose.disconnect();
+      this.connection = undefined;
+    }
+  }
+}

package/dist/templates/api-mongoose-mongodb/src/global/register-global-controllers.ts

@@ -0,0 +1,20 @@
+import { TrinacriaApp } from "@trinacria/core";
+import { httpProvider } from "@trinacria/http";
+import { ConfigService, CONFIG_SERVICE } from "./config.service";
+import {
+  SWAGGER_DOCS_CONTROLLER,
+  SwaggerDocsController,
+} from "./controllers/swagger/swagger-docs.controller";
+
+export function registerGlobalControllers(
+  app: TrinacriaApp,
+  config: ConfigService,
+): void {
+  if (config.get("OPENAPI_ENABLED")) {
+    app.registerGlobalProvider(
+      httpProvider(SWAGGER_DOCS_CONTROLLER, SwaggerDocsController, [
+        CONFIG_SERVICE,
+      ]),
+    );
+  }
+}

package/dist/templates/api-mongoose-mongodb/src/main.ts

@@ -0,0 +1,70 @@
+import { TrinacriaApp, classProvider, valueProvider } from "@trinacria/core";
+import {
+  cors,
+  createHttpPlugin,
+  createSecurityHeadersBuilder,
+  rateLimit,
+  requestId,
+  requestLogger,
+  requestTimeout,
+} from "@trinacria/http";
+import { CONFIG_SERVICE, ConfigService } from "./global/config.service";
+import { MONGOOSE_SERVICE, MongooseService } from "./global/mongoose.service";
+import { registerGlobalControllers } from "./global/register-global-controllers";
+import { UsersModule } from "./modules/users/users.module";
+
+async function bootstrap() {
+  const app = new TrinacriaApp();
+  const configService = new ConfigService();
+  const config = configService.getAll();
+  const isProduction = config.ENV === "production";
+  const corsOrigins = config.CORS_ALLOWED_ORIGINS;
+  const securityHeadersMiddleware = createSecurityHeadersBuilder()
+    .preset(config.ENV)
+    .trustProxy(false)
+    .build();
+
+  app.registerGlobalProvider(valueProvider(CONFIG_SERVICE, configService));
+  app.registerGlobalProvider(
+    classProvider(MONGOOSE_SERVICE, MongooseService, [CONFIG_SERVICE]),
+  );
+  registerGlobalControllers(app, configService);
+
+  app.use(
+    createHttpPlugin({
+      host: config.HOST,
+      port: config.PORT,
+      middlewares: [
+        requestId(),
+        requestLogger({ includeUserAgent: !isProduction }),
+        cors({
+          origin: corsOrigins.length > 0 ? corsOrigins : "*",
+          credentials: true,
+          methods: ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"],
+        }),
+        rateLimit({
+          windowMs: 60_000,
+          max: isProduction ? 240 : 2_000,
+          trustProxy: false,
+        }),
+        requestTimeout({ timeoutMs: 15_000 }),
+        securityHeadersMiddleware,
+      ],
+      openApi: config.OPENAPI_ENABLED
+        ? {
+            enabled: true,
+            title: "API Mongoose MongoDB Example",
+            version: "1.0.0",
+          }
+        : undefined,
+    }),
+  );
+
+  await app.registerModule(UsersModule);
+  await app.start();
+}
+
+bootstrap().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/dist/templates/api-mongoose-mongodb/src/modules/users/dto/create-user.dto.ts

@@ -0,0 +1,14 @@
+import { s } from "@trinacria/schema";
+
+export interface CreateUserDto {
+  name: string;
+  email: string;
+}
+
+export const CreateUserDtoSchema = s.objectOf<CreateUserDto>()(
+  {
+    name: s.string({ trim: true, minLength: 1 }),
+    email: s.string({ trim: true, toLowerCase: true, email: true }),
+  },
+  { strict: true },
+);

package/dist/templates/api-mongoose-mongodb/src/modules/users/dto/index.ts

@@ -0,0 +1,2 @@
+export * from "./create-user.dto";
+export * from "./public-user.dto";

package/dist/templates/api-mongoose-mongodb/src/modules/users/dto/public-user.dto.ts

@@ -0,0 +1,22 @@
+import { s } from "@trinacria/schema";
+
+export interface PublicUserDto {
+  id: string;
+  name: string;
+  email: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export const PublicUserDtoSchema = s.objectOf<PublicUserDto>()(
+  {
+    id: s.string({ trim: true, minLength: 1 }),
+    name: s.string({ trim: true, minLength: 1 }),
+    email: s.string({ trim: true, toLowerCase: true, email: true }),
+    createdAt: s.date(),
+    updatedAt: s.date(),
+  },
+  { strict: true },
+);
+
+export const PublicUserListDtoSchema = s.array(PublicUserDtoSchema);

package/dist/templates/api-mongoose-mongodb/src/modules/users/users.controller.ts

@@ -0,0 +1,89 @@
+import {
+  ConflictException,
+  HttpController,
+  HttpContext,
+  response,
+} from "@trinacria/http";
+import { UsersService } from "./users.service";
+import {
+  CreateUserDtoSchema,
+  PublicUserDtoSchema,
+  PublicUserListDtoSchema,
+} from "./dto";
+
+export class UsersController extends HttpController {
+  constructor(private readonly users: UsersService) {
+    super();
+  }
+
+  routes() {
+    return this.router()
+      .get("/health", () => ({ status: "ok" }), {
+        docs: {
+          tags: ["Health"],
+          summary: "Health check",
+        },
+      })
+      .get("/users", this.listUsers, {
+        docs: {
+          tags: ["Users"],
+          summary: "List users",
+          responses: {
+            200: {
+              description: "Users list",
+              schema: PublicUserListDtoSchema.toOpenApi(),
+            },
+          },
+        },
+      })
+      .post("/users", this.createUser, {
+        docs: {
+          tags: ["Users"],
+          summary: "Create user",
+          requestBody: {
+            required: true,
+            schema: CreateUserDtoSchema.toOpenApi(),
+          },
+          responses: {
+            201: {
+              description: "Created user",
+              schema: PublicUserDtoSchema.toOpenApi(),
+            },
+            409: {
+              description: "Email already exists",
+            },
+          },
+        },
+      })
+      .build();
+  }
+
+  async listUsers() {
+    return this.users.list();
+  }
+
+  async createUser(ctx: HttpContext) {
+    const payload = CreateUserDtoSchema.parse(ctx.body);
+
+    try {
+      const created = await this.users.create(payload);
+      return response(created, {
+        status: 201,
+        headers: {
+          location: `/users/${created.id}`,
+        },
+      });
+    } catch (error) {
+      if (
+        error &&
+        typeof error === "object" &&
+        "code" in error &&
+        error.code === 11000
+      ) {
+        throw new ConflictException("Email already exists");
+      }
+
+      throw error;
+    }
+  }
+}

package/dist/templates/api-mongoose-mongodb/src/modules/users/users.module.ts

@@ -0,0 +1,17 @@
+import { classProvider, defineModule } from "@trinacria/core";
+import { httpProvider } from "@trinacria/http";
+import { createMongooseSchemaProvider } from "../../global/mongoose-schema.provider";
+import { USERS_CONTROLLER, USERS_SERVICE, USER_SCHEMA } from "./users.tokens";
+import { UsersController } from "./users.controller";
+import { userSchema } from "./users.schema";
+import { UsersService } from "./users.service";
+
+export const UsersModule = defineModule({
+  name: "UsersModule",
+  providers: [
+    createMongooseSchemaProvider(USER_SCHEMA, "User", userSchema),
+    classProvider(USERS_SERVICE, UsersService, [USER_SCHEMA]),
+    httpProvider(USERS_CONTROLLER, UsersController, [USERS_SERVICE]),
+  ],
+  exports: [USERS_SERVICE, USERS_CONTROLLER],
+});

package/dist/templates/api-mongoose-mongodb/src/modules/users/users.schema.ts

@@ -0,0 +1,35 @@
+import { type HydratedDocument, type Model, Schema } from "mongoose";
+
+export interface UserEntity {
+  name: string;
+  email: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export type UserDocument = HydratedDocument<UserEntity>;
+export type UserSchemaModel = Model<UserEntity>;
+
+const userSchema = new Schema<UserEntity>(
+  {
+    name: {
+      type: String,
+      required: true,
+      trim: true,
+    },
+    email: {
+      type: String,
+      required: true,
+      unique: true,
+      lowercase: true,
+      trim: true,
+    },
+  },
+  {
+    timestamps: true,
+    versionKey: false,
+  },
+);
+
+userSchema.index({ email: 1 }, { unique: true });
+export { userSchema };

package/dist/templates/api-mongoose-mongodb/src/modules/users/users.service.ts

@@ -0,0 +1,35 @@
+import type { CreateUserDto, PublicUserDto } from "./dto";
+import type { UserDocument, UserSchemaModel } from "./users.schema";
+
+export class UsersService {
+  constructor(private readonly userSchema: UserSchemaModel) {}
+
+  async list(): Promise<PublicUserDto[]> {
+    const users: UserDocument[] = await this.userSchema
+      .find({}, undefined, { sort: { createdAt: -1 } })
+      .exec();
+
+    return users.map((user: UserDocument) => ({
+      id: String(user._id),
+      name: user.name,
+      email: user.email,
+      createdAt: user.createdAt,
+      updatedAt: user.updatedAt,
+    }));
+  }
+
+  async create(input: CreateUserDto): Promise<PublicUserDto> {
+    const created = await this.userSchema.create({
+      name: input.name,
+      email: input.email.toLowerCase(),
+    });
+
+    return {
+      id: String(created._id),
+      name: created.name,
+      email: created.email,
+      createdAt: created.createdAt,
+      updatedAt: created.updatedAt,
+    };
+  }
+}

package/dist/templates/api-mongoose-mongodb/src/modules/users/users.tokens.ts

@@ -0,0 +1,9 @@
+import { createToken } from "@trinacria/core";
+import type { UserSchemaModel } from "./users.schema";
+import { UsersController } from "./users.controller";
+import { UsersService } from "./users.service";
+
+export const USER_SCHEMA = createToken<UserSchemaModel>("USER_SCHEMA");
+export const USERS_SERVICE = createToken<UsersService>("USERS_SERVICE");
+export const USERS_CONTROLLER =
+  createToken<UsersController>("USERS_CONTROLLER");

package/dist/templates/api-mongoose-mongodb/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-mongoose-mongodb/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-prisma-postgresql/.env.example

@@ -0,0 +1,19 @@
+# ------------------------------------------------------------
+# Local app runtime (used by `npm run dev -w api-prisma-postgresql`)
+# ------------------------------------------------------------
+ENV=development
+HOST=127.0.0.1
+PORT=4001
+OPENAPI_ENABLED=true
+CORS_ALLOWED_ORIGINS=
+DATABASE_URL="postgresql://postgres:postgres@localhost:5432/trinacria_example?schema=public"
+
+# ------------------------------------------------------------
+# Docker runtime (used by `docker compose ... --env-file .../.env`)
+# ------------------------------------------------------------
+DOCKER_POSTGRES_DB=trinacria_example
+DOCKER_POSTGRES_USER=postgres
+DOCKER_POSTGRES_PASSWORD=postgres
+DOCKER_POSTGRES_PORT=5432
+DOCKER_API_PORT=4001
+DOCKER_DATABASE_URL="postgresql://postgres:postgres@postgres:5432/trinacria_example?schema=public"

package/dist/templates/api-prisma-postgresql/Dockerfile

@@ -0,0 +1,24 @@
+FROM node:24-bookworm-slim
+
+WORKDIR /app
+
+RUN apt-get update -y && apt-get install -y --no-install-recommends openssl \
+  && rm -rf /var/lib/apt/lists/*
+
+ENV DATABASE_URL=postgresql://postgres:postgres@localhost:5432/trinacria_example?schema=public
+
+COPY package.json package-lock.json tsconfig.base.json ./
+COPY packages ./packages
+COPY apps/api-prisma-postgresql ./apps/api-prisma-postgresql
+
+RUN npm ci
+RUN npm run build:packages
+RUN npm run prisma:generate -w api-prisma-postgresql
+RUN npm run build -w api-prisma-postgresql
+
+ENV HOST=0.0.0.0
+ENV PORT=4001
+
+EXPOSE 4001
+
+CMD ["sh", "-c", "npm run prisma:push -w api-prisma-postgresql && npm run start -w api-prisma-postgresql"]

package/dist/templates/api-prisma-postgresql/README.md

@@ -0,0 +1,107 @@
+# API Example: Prisma + PostgreSQL
+
+A minimal API-only example using Trinacria, Prisma, and PostgreSQL.
+
+## 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-prisma-postgresql/.env.example apps/api-prisma-postgresql/.env.development
+```
+
+3. Make sure PostgreSQL is running locally and matches `DATABASE_URL`.
+
+4. Push schema and generate Prisma client:
+
+```bash
+npm run prisma:push -w api-prisma-postgresql
+npm run prisma:generate -w api-prisma-postgresql
+```
+
+5. Start the API:
+
+```bash
+npm run dev -w api-prisma-postgresql
+```
+
+6. Verify the app is running:
+
+```bash
+curl http://127.0.0.1:4001/health
+```
+
+## Create your first user
+
+```bash
+curl -X POST http://127.0.0.1:4001/users \
+  -H 'content-type: application/json' \
+  -d '{"name":"Mario Rossi","email":"mario@example.com"}'
+```
+
+Then list users:
+
+```bash
+curl http://127.0.0.1:4001/users
+```
+
+## Docker quick start
+
+1. Create the Docker env file from the same template:
+
+```bash
+cp apps/api-prisma-postgresql/.env.example apps/api-prisma-postgresql/.env
+```
+
+2. Edit the Docker section in `apps/api-prisma-postgresql/.env` if you want custom credentials/ports.
+
+3. Start PostgreSQL + API using that `.env` file:
+
+```bash
+docker compose \
+  --env-file apps/api-prisma-postgresql/.env \
+  -f apps/api-prisma-postgresql/docker-compose.yml \
+  up --build
+```
+
+The API will be available at `http://127.0.0.1:${DOCKER_API_PORT}` (default `4001`).
+
+Compose services:
+
+- `postgres`: PostgreSQL 16
+- `api`: this Trinacria API (built from this monorepo)
+
+The container startup command automatically runs `prisma db push` before starting the API.

package/dist/templates/api-prisma-postgresql/docker-compose.yml

@@ -0,0 +1,38 @@
+services:
+  postgres:
+    image: postgres:16-alpine
+    environment:
+      POSTGRES_DB: ${DOCKER_POSTGRES_DB}
+      POSTGRES_USER: ${DOCKER_POSTGRES_USER}
+      POSTGRES_PASSWORD: ${DOCKER_POSTGRES_PASSWORD}
+    ports:
+      - "${DOCKER_POSTGRES_PORT}:5432"
+    volumes:
+      - trinacria_api_pg_data:/var/lib/postgresql/data
+    healthcheck:
+      test:
+        [
+          "CMD-SHELL",
+          "pg_isready -U ${DOCKER_POSTGRES_USER} -d ${DOCKER_POSTGRES_DB}",
+        ]
+      interval: 5s
+      timeout: 5s
+      retries: 20
+
+  api:
+    build:
+      context: ../..
+      dockerfile: apps/api-prisma-postgresql/Dockerfile
+    environment:
+      ENV: development
+      HOST: 0.0.0.0
+      PORT: 4001
+      DATABASE_URL: ${DOCKER_DATABASE_URL}
+    ports:
+      - "${DOCKER_API_PORT}:4001"
+    depends_on:
+      postgres:
+        condition: service_healthy
+
+volumes:
+  trinacria_api_pg_data:

package/dist/templates/api-prisma-postgresql/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "api-prisma-postgresql",
+  "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",
+    "prisma:generate": "prisma generate --schema prisma/schema.prisma",
+    "prisma:migrate:dev": "prisma migrate dev --schema prisma/schema.prisma",
+    "prisma:push": "prisma db push --schema prisma/schema.prisma",
+    "prisma:studio": "prisma studio --schema prisma/schema.prisma"
+  },
+  "dependencies": {
+    "@prisma/adapter-pg": "^7.4.1",
+    "@prisma/client": "^7.4.1",
+    "@trinacria/cli": "*",
+    "@trinacria/core": "*",
+    "@trinacria/http": "*",
+    "@trinacria/schema": "*",
+    "pg": "^8.16.3"
+  },
+  "devDependencies": {
+    "prisma": "^7.4.1"
+  }
+}

package/dist/templates/api-prisma-postgresql/prisma/schema.prisma

@@ -0,0 +1,15 @@
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "postgresql"
+}
+
+model User {
+  id        String   @id @default(cuid())
+  name      String
+  email     String   @unique
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}

package/dist/templates/api-prisma-postgresql/prisma.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from "prisma/config";
+import "dotenv/config";
+
+export default defineConfig({
+  schema: "prisma/schema.prisma",
+  datasource: {
+    url: process.env.DATABASE_URL,
+  },
+});