@podosoft/podokit 0.1.0 → 0.2.0

package/dist/templates/modules/auth-jwt/files/apps/api/src/auth/dto/login.dto.ts

@@ -0,0 +1,12 @@
+import { ApiProperty } from "@nestjs/swagger";
+import { IsEmail, IsString } from "class-validator";
+
+export class LoginDto {
+  @ApiProperty({ example: "user@example.com" })
+  @IsEmail()
+  email!: string;
+
+  @ApiProperty({ example: "password123" })
+  @IsString()
+  password!: string;
+}

package/dist/templates/modules/auth-jwt/files/apps/api/src/auth/dto/register.dto.ts

@@ -0,0 +1,13 @@
+import { ApiProperty } from "@nestjs/swagger";
+import { IsEmail, IsString, MinLength } from "class-validator";
+
+export class RegisterDto {
+  @ApiProperty({ example: "user@example.com" })
+  @IsEmail()
+  email!: string;
+
+  @ApiProperty({ example: "password123", minLength: 8 })
+  @IsString()
+  @MinLength(8)
+  password!: string;
+}

package/dist/templates/modules/auth-jwt/files/apps/api/src/auth/jwt-auth.guard.ts

@@ -0,0 +1,5 @@
+import { Injectable } from "@nestjs/common";
+import { AuthGuard } from "@nestjs/passport";
+
+@Injectable()
+export class JwtAuthGuard extends AuthGuard("jwt") {}

package/dist/templates/modules/auth-jwt/files/apps/api/src/auth/jwt.strategy.ts

@@ -0,0 +1,23 @@
+import { Injectable } from "@nestjs/common";
+import { PassportStrategy } from "@nestjs/passport";
+import { ExtractJwt, Strategy } from "passport-jwt";
+
+export interface JwtPayload {
+  sub: string;
+  email: string;
+}
+
+@Injectable()
+export class JwtStrategy extends PassportStrategy(Strategy) {
+  constructor() {
+    super({
+      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
+      ignoreExpiration: false,
+      secretOrKey: process.env.JWT_SECRET ?? "change-me-in-production",
+    });
+  }
+
+  validate(payload: JwtPayload): { userId: string; email: string } {
+    return { userId: payload.sub, email: payload.email };
+  }
+}

package/dist/templates/modules/auth-jwt/files/apps/api/src/auth/user.entity.ts

@@ -0,0 +1,16 @@
+import { Column, CreateDateColumn, Entity, PrimaryGeneratedColumn } from "typeorm";
+
+@Entity("users")
+export class User {
+  @PrimaryGeneratedColumn("uuid")
+  id!: string;
+
+  @Column({ type: "varchar", length: 320, unique: true })
+  email!: string;
+
+  @Column({ type: "varchar" })
+  passwordHash!: string;
+
+  @CreateDateColumn({ type: "timestamptz" })
+  createdAt!: Date;
+}

package/dist/templates/modules/auth-jwt/files/apps/api/src/migrations/1720200000000-InitUsers.ts

@@ -0,0 +1,23 @@
+import type { MigrationInterface, QueryRunner } from "typeorm";
+
+export class InitUsers1720200000000 implements MigrationInterface {
+  name = "InitUsers1720200000000";
+
+  async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`CREATE EXTENSION IF NOT EXISTS "pgcrypto"`);
+    await queryRunner.query(`
+      CREATE TABLE "users" (
+        "id" uuid NOT NULL DEFAULT gen_random_uuid(),
+        "email" character varying(320) NOT NULL,
+        "passwordHash" character varying NOT NULL,
+        "createdAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(),
+        CONSTRAINT "PK_users_id" PRIMARY KEY ("id"),
+        CONSTRAINT "UQ_users_email" UNIQUE ("email")
+      )
+    `);
+  }
+
+  async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE "users"`);
+  }
+}

package/dist/templates/modules/auth-jwt/module.manifest.json

@@ -0,0 +1,31 @@
+{
+  "name": "auth-jwt",
+  "description": "JWT auth: register, login, a JWT guard, and a protected /auth/me route (TypeORM users).",
+  "requires": [],
+  "targetApp": "api",
+  "dependencies": {
+    "@nestjs/jwt": "^10.2.0",
+    "@nestjs/passport": "^10.0.3",
+    "bcryptjs": "^2.4.3",
+    "passport": "^0.7.0",
+    "passport-jwt": "^4.0.1"
+  },
+  "devDependencies": {
+    "@types/bcryptjs": "^2.4.6",
+    "@types/passport-jwt": "^4.0.1"
+  },
+  "env": [
+    "# auth-jwt",
+    "JWT_SECRET=change-me-in-production",
+    "JWT_EXPIRES_IN=3600s"
+  ],
+  "inject": [
+    { "file": "apps/api/src/app.module.ts", "marker": "// podokit:imports", "text": "import { AuthModule } from \"./auth/auth.module\";" },
+    { "file": "apps/api/src/app.module.ts", "marker": "// podokit:module-imports", "text": "AuthModule," }
+  ],
+  "instructions": [
+    "Run the users migration:  npm run migration:run -w <app>-api",
+    "Register:  curl -XPOST localhost:3000/auth/register -H 'content-type: application/json' -d '{\"email\":\"a@example.com\",\"password\":\"password123\"}'",
+    "Call the protected route with the returned token:  curl localhost:3000/auth/me -H 'authorization: Bearer <token>'"
+  ]
+}

package/dist/templates/modules/bullmq/files/apps/api/src/jobs/demo.processor.ts

@@ -0,0 +1,12 @@
+import { Processor, WorkerHost } from "@nestjs/bullmq";
+import type { Job } from "bullmq";
+import { DEMO_QUEUE } from "./queue";
+
+@Processor(DEMO_QUEUE)
+export class DemoProcessor extends WorkerHost {
+  async process(job: Job<{ text: string }>): Promise<{ upper: string }> {
+    // Simulate work.
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    return { upper: String(job.data.text ?? "").toUpperCase() };
+  }
+}

package/dist/templates/modules/bullmq/files/apps/api/src/jobs/dto/create-job.dto.ts

@@ -0,0 +1,9 @@
+import { ApiProperty } from "@nestjs/swagger";
+import { IsNotEmpty, IsString } from "class-validator";
+
+export class CreateJobDto {
+  @ApiProperty({ example: "hello" })
+  @IsString()
+  @IsNotEmpty()
+  text!: string;
+}

package/dist/templates/modules/bullmq/files/apps/api/src/jobs/jobs.controller.ts

@@ -0,0 +1,29 @@
+import { Body, Controller, Get, NotFoundException, Param, Post } from "@nestjs/common";
+import { InjectQueue } from "@nestjs/bullmq";
+import { ApiTags } from "@nestjs/swagger";
+import { Queue } from "bullmq";
+import { CreateJobDto } from "./dto/create-job.dto";
+import { DEMO_QUEUE } from "./queue";
+
+@ApiTags("jobs")
+@Controller("jobs")
+export class JobsController {
+  constructor(@InjectQueue(DEMO_QUEUE) private readonly queue: Queue) {}
+
+  @Post()
+  async enqueue(@Body() dto: CreateJobDto): Promise<{ id: string | undefined }> {
+    const job = await this.queue.add("demo", { text: dto.text });
+    return { id: job.id };
+  }
+
+  @Get(":id")
+  async status(
+    @Param("id") id: string,
+  ): Promise<{ id: string | undefined; state: string; result: unknown }> {
+    const job = await this.queue.getJob(id);
+    if (!job) {
+      throw new NotFoundException(`Job ${id} not found`);
+    }
+    return { id: job.id, state: await job.getState(), result: job.returnvalue ?? null };
+  }
+}

package/dist/templates/modules/bullmq/files/apps/api/src/jobs/jobs.module.ts

@@ -0,0 +1,15 @@
+import { Module } from "@nestjs/common";
+import { BullModule } from "@nestjs/bullmq";
+import { JobsController } from "./jobs.controller";
+import { DEMO_QUEUE, redisConnection } from "./queue";
+
+// Producer side: registers the queue and exposes enqueue/status endpoints.
+// The processor runs in a separate worker process (see main-worker.ts).
+@Module({
+  imports: [
+    BullModule.forRoot({ connection: redisConnection() }),
+    BullModule.registerQueue({ name: DEMO_QUEUE }),
+  ],
+  controllers: [JobsController],
+})
+export class JobsModule {}

package/dist/templates/modules/bullmq/files/apps/api/src/jobs/queue.ts

@@ -0,0 +1,8 @@
+export const DEMO_QUEUE = "demo";
+
+export function redisConnection(): { host: string; port: number } {
+  return {
+    host: process.env.REDIS_HOST ?? "localhost",
+    port: Number(process.env.REDIS_PORT ?? 6379),
+  };
+}

package/dist/templates/modules/bullmq/files/apps/api/src/jobs/worker.module.ts

@@ -0,0 +1,20 @@
+import { Module } from "@nestjs/common";
+import { BullModule } from "@nestjs/bullmq";
+import { DemoProcessor } from "./demo.processor";
+import { DEMO_QUEUE, redisConnection } from "./queue";
+// podokit:worker-imports
+
+// Consumer side: runs BullMQ processors. Bootstrapped by main-worker.ts as a
+// separate process so workers scale independently of the API.
+@Module({
+  imports: [
+    BullModule.forRoot({ connection: redisConnection() }),
+    BullModule.registerQueue({ name: DEMO_QUEUE }),
+    // podokit:worker-queues
+  ],
+  providers: [
+    DemoProcessor,
+    // podokit:worker-providers
+  ],
+})
+export class WorkerModule {}

package/dist/templates/modules/bullmq/files/apps/api/src/main-worker.ts

@@ -0,0 +1,14 @@
+import "dotenv/config";
+import { NestFactory } from "@nestjs/core";
+import { WorkerModule } from "./jobs/worker.module";
+
+// Runs BullMQ processors in their own process (no HTTP server).
+async function bootstrap(): Promise<void> {
+  const app = await NestFactory.createApplicationContext(WorkerModule);
+  await app.init();
+  // Keep the process alive to consume jobs.
+  process.on("SIGINT", () => void app.close().then(() => process.exit(0)));
+  process.on("SIGTERM", () => void app.close().then(() => process.exit(0)));
+}
+
+void bootstrap();

package/dist/templates/modules/bullmq/files/infra/docker/worker.compose.example.yml

@@ -0,0 +1,18 @@
+# Example: run the BullMQ worker as its own service.
+#
+# The default infra/docker/docker-compose.yml is dev infra (PostgreSQL + Redis)
+# only, with the app running on the host. For a fully containerized deployment,
+# build the API image and run the worker entrypoint against it — for example:
+#
+#   docker compose -f infra/docker/docker-compose.yml -f infra/docker/worker.compose.example.yml up -d
+services:
+  worker:
+    build:
+      context: ../../apps/api
+    command: ["node", "dist/main-worker"]
+    environment:
+      REDIS_HOST: redis
+      REDIS_PORT: "6379"
+    depends_on:
+      redis:
+        condition: service_healthy

package/dist/templates/modules/bullmq/files/infra/k3s/worker-deployment.yaml

@@ -0,0 +1,22 @@
+# BullMQ worker — runs the same API image with the worker entrypoint.
+# It has no HTTP server, so there is no Service or Ingress.
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: worker
+  namespace: podokit
+spec:
+  replicas: 1
+  selector:
+    matchLabels: { app: worker }
+  template:
+    metadata:
+      labels: { app: worker }
+    spec:
+      containers:
+        - name: worker
+          image: ghcr.io/example/podokit-api:latest
+          command: ["node", "dist/main-worker"]
+          envFrom:
+            - configMapRef: { name: app-config }
+            - secretRef: { name: app-secrets }

package/dist/templates/modules/bullmq/module.manifest.json

@@ -0,0 +1,28 @@
+{
+  "name": "bullmq",
+  "description": "Background jobs with BullMQ: a demo queue, a separate worker process, and enqueue/status endpoints (needs Redis).",
+  "requires": [],
+  "targetApp": "api",
+  "dependencies": {
+    "@nestjs/bullmq": "^10.2.0",
+    "bullmq": "^5.34.0"
+  },
+  "scripts": {
+    "start:worker": "node dist/main-worker",
+    "dev:worker": "nest start --watch --entryFile main-worker"
+  },
+  "env": [
+    "# bullmq uses REDIS_HOST / REDIS_PORT (already defined above)"
+  ],
+  "inject": [
+    { "file": "apps/api/src/app.module.ts", "marker": "// podokit:imports", "text": "import { JobsModule } from \"./jobs/jobs.module\";" },
+    { "file": "apps/api/src/app.module.ts", "marker": "// podokit:module-imports", "text": "JobsModule," }
+  ],
+  "instructions": [
+    "Ensure Redis is running:  docker compose -f infra/docker/docker-compose.yml up -d",
+    "Run the worker in a separate terminal:  npm run dev:worker -w <app>-api",
+    "Enqueue a job:  curl -XPOST localhost:3000/jobs -H 'content-type: application/json' -d '{\"text\":\"hello\"}'",
+    "Check status:   curl localhost:3000/jobs/<id>  (state goes waiting -> active -> completed)",
+    "Deploy the worker as its own process: k3s manifest added at infra/k3s/worker-deployment.yaml; Docker Compose example at infra/docker/worker.compose.example.yml"
+  ]
+}

package/dist/templates/modules/file-upload/files/apps/api/src/files/files.controller.ts

@@ -0,0 +1,29 @@
+import { BadRequestException, Controller, Get, Param, Post, UploadedFile, UseInterceptors } from "@nestjs/common";
+import { FileInterceptor } from "@nestjs/platform-express";
+import { ApiConsumes, ApiTags } from "@nestjs/swagger";
+import { randomUUID } from "node:crypto";
+import { StorageService } from "../storage/storage.service";
+
+@ApiTags("files")
+@Controller("files")
+export class FilesController {
+  constructor(private readonly storage: StorageService) {}
+
+  @Post()
+  @ApiConsumes("multipart/form-data")
+  @UseInterceptors(FileInterceptor("file"))
+  async upload(@UploadedFile() file?: Express.Multer.File): Promise<{ key: string; url: string }> {
+    if (!file) {
+      throw new BadRequestException("A file field is required (multipart/form-data)");
+    }
+    const safeName = file.originalname.replace(/[^\w.-]+/g, "_");
+    const key = `uploads/${randomUUID()}-${safeName}`;
+    await this.storage.put(key, file.buffer, file.mimetype);
+    return { key, url: await this.storage.presignedGetUrl(key) };
+  }
+
+  @Get(":key/url")
+  async url(@Param("key") key: string): Promise<{ url: string }> {
+    return { url: await this.storage.presignedGetUrl(key) };
+  }
+}

package/dist/templates/modules/file-upload/files/apps/api/src/files/files.module.ts

@@ -0,0 +1,9 @@
+import { Module } from "@nestjs/common";
+import { FilesController } from "./files.controller";
+
+// Uploads are stored through StorageService, provided globally by the
+// object-storage-s3 module.
+@Module({
+  controllers: [FilesController],
+})
+export class FilesModule {}

package/dist/templates/modules/file-upload/module.manifest.json

@@ -0,0 +1,19 @@
+{
+  "name": "file-upload",
+  "description": "Multipart file upload endpoint that stores files via object storage and returns a presigned URL.",
+  "requires": ["object-storage-s3"],
+  "targetApp": "api",
+  "devDependencies": {
+    "@types/multer": "^1.4.12"
+  },
+  "env": [],
+  "inject": [
+    { "file": "apps/api/src/app.module.ts", "marker": "// podokit:imports", "text": "import { FilesModule } from \"./files/files.module\";" },
+    { "file": "apps/api/src/app.module.ts", "marker": "// podokit:module-imports", "text": "FilesModule," }
+  ],
+  "instructions": [
+    "Start MinIO (or configure AWS S3):  docker compose -f infra/docker/docker-compose.yml -f infra/docker/minio.compose.yml up -d",
+    "Upload a file:  curl -F 'file=@./some.png' localhost:3000/files",
+    "The response includes { key, url } — a presigned download URL."
+  ]
+}

package/dist/templates/modules/job-progress/files/apps/api/src/progress/dto/start-job.dto.ts

@@ -0,0 +1,11 @@
+import { ApiPropertyOptional } from "@nestjs/swagger";
+import { IsInt, IsOptional, Max, Min } from "class-validator";
+
+export class StartJobDto {
+  @ApiPropertyOptional({ example: 5, description: "Number of progress steps" })
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  @Max(100)
+  steps?: number;
+}

package/dist/templates/modules/job-progress/files/apps/api/src/progress/job-progress.module.ts

@@ -0,0 +1,13 @@
+import { Module } from "@nestjs/common";
+import { BullModule } from "@nestjs/bullmq";
+import { ProgressController } from "./progress.controller";
+import { ProgressBridge } from "./progress.bridge";
+
+// API side: enqueue progress jobs and relay their progress to SSE.
+// RedisService and EventsService are provided globally by their modules.
+@Module({
+  imports: [BullModule.registerQueue({ name: "progress" })],
+  controllers: [ProgressController],
+  providers: [ProgressBridge],
+})
+export class JobProgressModule {}

package/dist/templates/modules/job-progress/files/apps/api/src/progress/progress.bridge.ts

@@ -0,0 +1,19 @@
+import { Injectable, type OnModuleInit } from "@nestjs/common";
+import { RedisService } from "../redis/redis.service";
+import { EventsService } from "../events/events.service";
+import { PROGRESS_CHANNEL } from "./progress.processor";
+
+// Runs in the API process: relays worker progress (Redis pub/sub) to SSE.
+@Injectable()
+export class ProgressBridge implements OnModuleInit {
+  constructor(
+    private readonly redis: RedisService,
+    private readonly events: EventsService,
+  ) {}
+
+  onModuleInit(): void {
+    this.redis.subscribe(PROGRESS_CHANNEL, (message) => {
+      this.events.publish({ type: "job-progress", ...JSON.parse(message) });
+    });
+  }
+}

package/dist/templates/modules/job-progress/files/apps/api/src/progress/progress.controller.ts

@@ -0,0 +1,17 @@
+import { Body, Controller, Post } from "@nestjs/common";
+import { InjectQueue } from "@nestjs/bullmq";
+import { ApiTags } from "@nestjs/swagger";
+import { Queue } from "bullmq";
+import { StartJobDto } from "./dto/start-job.dto";
+
+@ApiTags("progress")
+@Controller("progress")
+export class ProgressController {
+  constructor(@InjectQueue("progress") private readonly queue: Queue) {}
+
+  @Post()
+  async start(@Body() dto: StartJobDto): Promise<{ jobId: string | undefined }> {
+    const job = await this.queue.add("progress", { steps: dto.steps ?? 5 });
+    return { jobId: job.id };
+  }
+}

package/dist/templates/modules/job-progress/files/apps/api/src/progress/progress.processor.ts

@@ -0,0 +1,25 @@
+import { Processor, WorkerHost } from "@nestjs/bullmq";
+import type { Job } from "bullmq";
+import { RedisService } from "../redis/redis.service";
+
+export const PROGRESS_CHANNEL = "job:progress";
+
+// Runs in the worker process. Reports progress both to BullMQ and, via Redis
+// pub/sub, to the API process (which relays it to SSE clients).
+@Processor("progress")
+export class ProgressProcessor extends WorkerHost {
+  constructor(private readonly redis: RedisService) {
+    super();
+  }
+
+  async process(job: Job<{ steps?: number }>): Promise<{ done: true }> {
+    const steps = job.data.steps ?? 5;
+    for (let i = 1; i <= steps; i += 1) {
+      await new Promise((resolve) => setTimeout(resolve, 400));
+      const progress = Math.round((i / steps) * 100);
+      await job.updateProgress(progress);
+      await this.redis.publish(PROGRESS_CHANNEL, JSON.stringify({ jobId: job.id, progress }));
+    }
+    return { done: true };
+  }
+}

package/dist/templates/modules/job-progress/module.manifest.json

@@ -0,0 +1,23 @@
+{
+  "name": "job-progress",
+  "description": "Live job progress: a worker reports progress over Redis pub/sub and the API relays it to SSE clients (combines bullmq + redis + sse).",
+  "requires": ["bullmq", "sse", "redis"],
+  "targetApp": "api",
+  "env": [],
+  "inject": [
+    { "file": "apps/api/src/app.module.ts", "marker": "// podokit:imports", "text": "import { JobProgressModule } from \"./progress/job-progress.module\";" },
+    { "file": "apps/api/src/app.module.ts", "marker": "// podokit:module-imports", "text": "JobProgressModule," },
+    { "file": "apps/api/src/jobs/worker.module.ts", "marker": "// podokit:worker-imports", "text": "import { ProgressProcessor } from \"../progress/progress.processor\";" },
+    { "file": "apps/api/src/jobs/worker.module.ts", "marker": "// podokit:worker-imports", "text": "import { RedisModule } from \"../redis/redis.module\";" },
+    { "file": "apps/api/src/jobs/worker.module.ts", "marker": "// podokit:worker-queues", "text": "RedisModule," },
+    { "file": "apps/api/src/jobs/worker.module.ts", "marker": "// podokit:worker-queues", "text": "BullModule.registerQueue({ name: \"progress\" })," },
+    { "file": "apps/api/src/jobs/worker.module.ts", "marker": "// podokit:worker-providers", "text": "ProgressProcessor," }
+  ],
+  "instructions": [
+    "Start Redis + Postgres:  docker compose -f infra/docker/docker-compose.yml up -d",
+    "Run API and worker in separate terminals:  npm run dev   /   npm run dev:worker -w <app>-api",
+    "Watch progress:  curl -N localhost:3000/events/stream",
+    "Start a job:     curl -XPOST localhost:3000/progress -H 'content-type: application/json' -d '{\"steps\":5}'",
+    "The stream shows job-progress events 20 -> 40 -> ... -> 100 pushed from the worker via Redis."
+  ]
+}

package/dist/templates/modules/object-storage-s3/files/apps/api/src/storage/dto/put-object.dto.ts

@@ -0,0 +1,8 @@
+import { ApiProperty } from "@nestjs/swagger";
+import { IsString } from "class-validator";
+
+export class PutObjectDto {
+  @ApiProperty({ example: "hello world" })
+  @IsString()
+  content!: string;
+}

package/dist/templates/modules/object-storage-s3/files/apps/api/src/storage/storage.config.ts

@@ -0,0 +1,31 @@
+import type { S3ClientConfig } from "@aws-sdk/client-s3";
+
+export interface StorageSettings {
+  provider: "minio" | "aws";
+  bucket: string;
+}
+
+export function storageSettings(): StorageSettings {
+  const provider = process.env.STORAGE_PROVIDER === "aws" ? "aws" : "minio";
+  return { provider, bucket: process.env.S3_BUCKET ?? "podokit" };
+}
+
+// Build an S3 client config that works for both AWS S3 and MinIO.
+// MinIO needs a custom endpoint and path-style addressing; AWS does not.
+export function storageClientConfig(): S3ClientConfig {
+  const { provider } = storageSettings();
+  const region = process.env.S3_REGION ?? "us-east-1";
+
+  const accessKeyId = process.env.S3_ACCESS_KEY_ID;
+  const secretAccessKey = process.env.S3_SECRET_ACCESS_KEY;
+  const credentials = accessKeyId && secretAccessKey ? { accessKeyId, secretAccessKey } : undefined;
+
+  const forcePathStyle = process.env.S3_FORCE_PATH_STYLE
+    ? process.env.S3_FORCE_PATH_STYLE === "true"
+    : provider === "minio";
+
+  const config: S3ClientConfig = { region, forcePathStyle };
+  if (credentials) config.credentials = credentials;
+  if (process.env.S3_ENDPOINT) config.endpoint = process.env.S3_ENDPOINT;
+  return config;
+}

package/dist/templates/modules/object-storage-s3/files/apps/api/src/storage/storage.controller.ts

@@ -0,0 +1,29 @@
+import { Body, Controller, Get, Param, Put } from "@nestjs/common";
+import { ApiTags } from "@nestjs/swagger";
+import { StorageService } from "./storage.service";
+import { PutObjectDto } from "./dto/put-object.dto";
+
+// Demo endpoints — replace with your own. See the file-upload module for
+// multipart uploads built on this service.
+@ApiTags("storage")
+@Controller("storage")
+export class StorageController {
+  constructor(private readonly storage: StorageService) {}
+
+  @Put(":key")
+  async put(@Param("key") key: string, @Body() dto: PutObjectDto): Promise<{ key: string }> {
+    await this.storage.put(key, dto.content, "text/plain");
+    return { key };
+  }
+
+  @Get(":key")
+  async get(@Param("key") key: string): Promise<{ key: string; content: string }> {
+    const buffer = await this.storage.get(key);
+    return { key, content: buffer.toString("utf8") };
+  }
+
+  @Get(":key/presigned")
+  async presigned(@Param("key") key: string): Promise<{ url: string }> {
+    return { url: await this.storage.presignedGetUrl(key) };
+  }
+}

package/dist/templates/modules/object-storage-s3/files/apps/api/src/storage/storage.module.ts

@@ -0,0 +1,11 @@
+import { Global, Module } from "@nestjs/common";
+import { StorageController } from "./storage.controller";
+import { StorageService } from "./storage.service";
+
+@Global()
+@Module({
+  controllers: [StorageController],
+  providers: [StorageService],
+  exports: [StorageService],
+})
+export class StorageModule {}

package/dist/templates/modules/object-storage-s3/files/apps/api/src/storage/storage.service.ts

@@ -0,0 +1,37 @@
+import { Injectable } from "@nestjs/common";
+import {
+  DeleteObjectCommand,
+  GetObjectCommand,
+  PutObjectCommand,
+  S3Client,
+} from "@aws-sdk/client-s3";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+import { storageClientConfig, storageSettings } from "./storage.config";
+
+@Injectable()
+export class StorageService {
+  private readonly client = new S3Client(storageClientConfig());
+  private readonly bucket = storageSettings().bucket;
+
+  async put(key: string, body: Buffer | string, contentType?: string): Promise<void> {
+    await this.client.send(
+      new PutObjectCommand({ Bucket: this.bucket, Key: key, Body: body, ContentType: contentType }),
+    );
+  }
+
+  async get(key: string): Promise<Buffer> {
+    const res = await this.client.send(new GetObjectCommand({ Bucket: this.bucket, Key: key }));
+    const bytes = await res.Body?.transformToByteArray();
+    return Buffer.from(bytes ?? new Uint8Array());
+  }
+
+  presignedGetUrl(key: string, expiresIn = 3600): Promise<string> {
+    return getSignedUrl(this.client, new GetObjectCommand({ Bucket: this.bucket, Key: key }), {
+      expiresIn,
+    });
+  }
+
+  async delete(key: string): Promise<void> {
+    await this.client.send(new DeleteObjectCommand({ Bucket: this.bucket, Key: key }));
+  }
+}