kybernus 3.0.1 → 3.2.0

package/templates/ecommerce/apps/api/src/infrastructure/persistence/prisma/checkout/order.prisma.repository.ts

@@ -0,0 +1,149 @@
+import type { PrismaClient, Order, OrderItem } from '@prisma/client';
+import { OrderEntity } from '../../../../domain/checkout/order.entity';
+import type { IOrderRepository } from '../../../../domain/checkout/order.repository';
+import type { OrderStatus } from '../../../../domain/checkout/order.entity';
+
+type OrderWithItems = Order & { items: OrderItem[] };
+
+function toEntity(row: OrderWithItems): OrderEntity {
+  return OrderEntity.reconstitute({
+    id: row.id,
+    userId: row.userId,
+    status: row.status as OrderStatus,
+    items: row.items.map((i) => ({
+      id: i.id,
+      variantId: i.variantId,
+      productId: i.productId,
+      name: i.name,
+      sku: i.sku,
+      price: Number(i.price),
+      qty: i.qty,
+      image: i.image,
+    })),
+    subtotal: Number(row.subtotal),
+    discount: Number(row.discount),
+    shippingCost: Number(row.shippingCost),
+    tax: Number(row.tax),
+    total: Number(row.total),
+    couponCode: row.couponCode,
+    paymentIntentId: row.paymentIntentId,
+    trackingCode: row.trackingCode,
+    shippingAddress: row.shippingAddress as Record<string, string> | null,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+  });
+}
+
+const INCLUDE_ITEMS = { items: true } as const;
+
+export class PrismaOrderRepository implements IOrderRepository {
+  constructor(private readonly db: PrismaClient) {}
+
+  async findById(id: string): Promise<OrderEntity | null> {
+    const row = await this.db.order.findUnique({
+      where: { id },
+      include: INCLUDE_ITEMS,
+    });
+    return row ? toEntity(row) : null;
+  }
+
+  async findByPaymentIntentId(paymentIntentId: string): Promise<OrderEntity | null> {
+    const row = await this.db.order.findUnique({
+      where: { paymentIntentId },
+      include: INCLUDE_ITEMS,
+    });
+    return row ? toEntity(row) : null;
+  }
+
+  async findByUserId(
+    userId: string,
+    opts: { cursor?: string; limit?: number } = {},
+  ): Promise<{ items: OrderEntity[]; nextCursor: string | null }> {
+    const limit = opts.limit ?? 20;
+
+    const rows = await this.db.order.findMany({
+      where: { userId },
+      orderBy: { createdAt: 'desc' },
+      include: INCLUDE_ITEMS,
+      take: limit + 1,
+      ...(opts.cursor ? { cursor: { id: opts.cursor }, skip: 1 } : {}),
+    });
+
+    const hasMore = rows.length > limit;
+    const items = hasMore ? rows.slice(0, limit) : rows;
+    const nextCursor = hasMore ? items[items.length - 1]!.id : null;
+
+    return { items: items.map(toEntity), nextCursor };
+  }
+
+  async findAll(
+    opts: { status?: OrderStatus; cursor?: string; limit?: number } = {},
+  ): Promise<{ items: OrderEntity[]; nextCursor: string | null }> {
+    const limit = opts.limit ?? 20;
+
+    const rows = await this.db.order.findMany({
+      where: opts.status ? { status: opts.status } : undefined,
+      orderBy: { createdAt: 'desc' },
+      include: INCLUDE_ITEMS,
+      take: limit + 1,
+      ...(opts.cursor ? { cursor: { id: opts.cursor }, skip: 1 } : {}),
+    });
+
+    const hasMore = rows.length > limit;
+    const items = hasMore ? rows.slice(0, limit) : rows;
+    const nextCursor = hasMore ? items[items.length - 1]!.id : null;
+
+    return { items: items.map(toEntity), nextCursor };
+  }
+
+  async create(order: OrderEntity): Promise<OrderEntity> {
+    const row = await this.db.order.create({
+      data: {
+        id: order.id,
+        userId: order.userId,
+        status: order.status,
+        subtotal: order.subtotal,
+        discount: order.discount,
+        shippingCost: order.shippingCost,
+        tax: order.tax,
+        total: order.total,
+        couponCode: order.couponCode,
+        paymentIntentId: order.paymentIntentId,
+        trackingCode: order.trackingCode,
+        shippingAddress: order.shippingAddress ?? undefined,
+        createdAt: order.createdAt,
+        updatedAt: order.updatedAt,
+        items: {
+          createMany: {
+            data: order.items.map((i) => ({
+              id: i.id,
+              variantId: i.variantId,
+              productId: i.productId,
+              name: i.name,
+              sku: i.sku,
+              price: i.price,
+              qty: i.qty,
+              image: i.image,
+            })),
+          },
+        },
+      },
+      include: INCLUDE_ITEMS,
+    });
+    return toEntity(row);
+  }
+
+  async update(order: OrderEntity): Promise<OrderEntity> {
+    const row = await this.db.order.update({
+      where: { id: order.id },
+      data: {
+        status: order.status,
+        paymentIntentId: order.paymentIntentId,
+        trackingCode: order.trackingCode,
+        shippingAddress: order.shippingAddress ?? undefined,
+      },
+      include: INCLUDE_ITEMS,
+    });
+    return toEntity(row);
+  }
+}

package/templates/ecommerce/apps/api/src/infrastructure/persistence/prisma-client.ts

@@ -0,0 +1,17 @@
+import { PrismaClient } from '@prisma/client';
+
+// Prevent multiple PrismaClient instances in development / hot-reload
+const globalForPrisma = globalThis as unknown as { prisma?: PrismaClient };
+
+export const prisma =
+  globalForPrisma.prisma ??
+  new PrismaClient({
+    log:
+      process.env['NODE_ENV'] === 'development'
+        ? ['query', 'error', 'warn']
+        : ['error'],
+  });
+
+if (process.env['NODE_ENV'] !== 'production') {
+  globalForPrisma.prisma = prisma;
+}

package/templates/ecommerce/apps/api/src/infrastructure/services/email/email.registry.ts

@@ -0,0 +1,18 @@
+import type { IEmailService } from '../../../application/ports/email.port';
+import { EtherealEmailService } from './ethereal.email.service';
+import { SmtpEmailService } from './smtp.email.service';
+import { NoopEmailService } from './noop.email.service';
+
+/**
+ * Picks the email service implementation based on NODE_ENV.
+ *   production → SmtpEmailService  (real SMTP via env vars)
+ *   test / test-inmemory → NoopEmailService  (silent, no network calls)
+ *   everything else → EtherealEmailService  (fake SMTP, no real delivery)
+ */
+const env = process.env['NODE_ENV'];
+export const emailService: IEmailService =
+  env === 'production'
+    ? new SmtpEmailService()
+    : env === 'test' || env === 'test-inmemory'
+      ? new NoopEmailService()
+      : new EtherealEmailService();

package/templates/ecommerce/apps/api/src/infrastructure/services/email/ethereal.email.service.ts

@@ -0,0 +1,38 @@
+import nodemailer from 'nodemailer';
+import type { IEmailService } from '../../../application/ports/email.port';
+
+/**
+ * Email service that uses Ethereal (https://ethereal.email) — a fake SMTP
+ * server that captures messages without delivering them. Perfect for
+ * development and testing. Logs a preview URL to the console after each send.
+ */
+export class EtherealEmailService implements IEmailService {
+  private transporter: nodemailer.Transporter | null = null;
+
+  private async getTransporter(): Promise<nodemailer.Transporter> {
+    if (this.transporter) return this.transporter;
+
+    const testAccount = await nodemailer.createTestAccount();
+    this.transporter = nodemailer.createTransport({
+      host: 'smtp.ethereal.email',
+      port: 587,
+      auth: {
+        user: testAccount.user,
+        pass: testAccount.pass,
+      },
+    });
+
+    return this.transporter;
+  }
+
+  async send(to: string, subject: string, html: string): Promise<void> {
+    const transporter = await this.getTransporter();
+    const info = await transporter.sendMail({
+      from: process.env['EMAIL_FROM'] ?? 'noreply@example.com',
+      to,
+      subject,
+      html,
+    });
+    console.log(`[Ethereal Email] Preview URL: ${nodemailer.getTestMessageUrl(info)}`);
+  }
+}

package/templates/ecommerce/apps/api/src/infrastructure/services/email/noop.email.service.ts

@@ -0,0 +1,12 @@
+import type { IEmailService } from '../../../application/ports/email.port';
+
+/**
+ * No-op email service used during tests.
+ * Silently discards all messages — no network calls, no side effects.
+ */
+export class NoopEmailService implements IEmailService {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async send(_to: string, _subject: string, _html: string): Promise<void> {
+    // intentionally empty
+  }
+}

package/templates/ecommerce/apps/api/src/infrastructure/services/email/smtp.email.service.ts

@@ -0,0 +1,36 @@
+import nodemailer from 'nodemailer';
+import type { IEmailService } from '../../../application/ports/email.port';
+import { AppError } from '../../../domain/shared/AppError';
+
+/**
+ * Production email service that uses a real SMTP server configured via
+ * environment variables: SMTP_HOST, SMTP_PORT, SMTP_USER, SMTP_PASS, EMAIL_FROM.
+ */
+export class SmtpEmailService implements IEmailService {
+  private readonly transporter: nodemailer.Transporter;
+
+  constructor() {
+    this.transporter = nodemailer.createTransport({
+      host: process.env['SMTP_HOST'],
+      port: parseInt(process.env['SMTP_PORT'] ?? '587', 10),
+      secure: process.env['SMTP_PORT'] === '465',
+      auth: {
+        user: process.env['SMTP_USER'],
+        pass: process.env['SMTP_PASS'],
+      },
+    });
+  }
+
+  async send(to: string, subject: string, html: string): Promise<void> {
+    try {
+      await this.transporter.sendMail({
+        from: process.env['EMAIL_FROM'] ?? 'noreply@example.com',
+        to,
+        subject,
+        html,
+      });
+    } catch {
+      throw new AppError('Falha ao enviar email', 500);
+    }
+  }
+}

package/templates/ecommerce/apps/api/src/infrastructure/services/payment/stripe-webhook.handler.ts

@@ -0,0 +1,83 @@
+import Stripe from 'stripe';
+import { AppError } from '../../../domain/shared/AppError';
+import type { IOrderRepository } from '../../../domain/checkout/order.repository';
+import type { ICouponRepository } from '../../../domain/cart/coupon.repository';
+import type { IEmailService } from '../../../application/ports/email.port';
+import type { IUserRepository } from '../../../domain/auth/user.repository';
+import { OrderEntity } from '../../../domain/checkout/order.entity';
+
+export class StripeWebhookHandler {
+  private readonly stripe: Stripe;
+
+  constructor(
+    secretKey: string,
+    private readonly webhookSecret: string,
+    private readonly orderRepo: IOrderRepository,
+    private readonly couponRepo?: ICouponRepository,
+    private readonly emailService?: IEmailService,
+    private readonly userRepo?: IUserRepository,
+  ) {
+    this.stripe = new Stripe(secretKey);
+  }
+
+  async handleEvent(payload: string, signature: string): Promise<void> {
+    let event: Stripe.Event;
+    try {
+      event = this.stripe.webhooks.constructEvent(payload, signature, this.webhookSecret);
+    } catch {
+      throw new AppError('Webhook Stripe: assinatura inválida', 400);
+    }
+
+    switch (event.type) {
+      case 'payment_intent.succeeded':
+        await this._handleSucceeded(event.data.object as Stripe.PaymentIntent);
+        break;
+      case 'payment_intent.payment_failed':
+        await this._handleFailed(event.data.object as Stripe.PaymentIntent);
+        break;
+      default:
+        // Unknown events are silently ignored
+        break;
+    }
+  }
+
+  private async _handleSucceeded(pi: Stripe.PaymentIntent): Promise<void> {
+    const order = await this.orderRepo.findByPaymentIntentId(pi.id);
+    if (!order) return; // Order not found — ignore
+    if (order.status === 'PAID') return; // Idempotent: already processed
+    const updated = order.pay();
+    await this.orderRepo.update(updated);
+    if (order.couponCode && this.couponRepo) {
+      await this.couponRepo.incrementUsage(order.couponCode);
+    }
+    await this._sendOrderConfirmedEmail(updated);
+  }
+
+  private async _sendOrderConfirmedEmail(order: OrderEntity): Promise<void> {
+    if (!this.emailService || !this.userRepo) return;
+    try {
+      const user = await this.userRepo.findById(order.userId);
+      if (!user) return;
+      const itemsHtml = order.items
+        .map((i) => `<li>${i.name} x${i.qty} — R$ ${(i.price * i.qty).toFixed(2)}</li>`)
+        .join('');
+      const html = `
+        <h2>Pedido confirmado!</h2>
+        <p>Olá ${user.name}, seu pedido <strong>#${order.id.slice(0, 8)}</strong> foi confirmado.</p>
+        <ul>${itemsHtml}</ul>
+        <p><strong>Total: R$ ${order.total.toFixed(2)}</strong></p>
+        <p>Prazo estimado de entrega: 5–10 dias úteis.</p>
+      `;
+      await this.emailService.send(user.email, 'Pedido confirmado 🎉', html);
+    } catch {
+      // Email failure must never break the webhook flow
+    }
+  }
+
+  private async _handleFailed(pi: Stripe.PaymentIntent): Promise<void> {
+    const order = await this.orderRepo.findByPaymentIntentId(pi.id);
+    if (!order) return;
+    if (order.status === 'FAILED') return; // Idempotent
+    await this.orderRepo.update(order.fail());
+  }
+}

package/templates/ecommerce/apps/api/src/infrastructure/services/payment/stripe.adapter.ts

@@ -0,0 +1,39 @@
+import Stripe from 'stripe';
+import { IPaymentAdapter, PaymentError, PaymentIntentResult } from '../../../application/ports/payment.port';
+
+export class StripeAdapter implements IPaymentAdapter {
+  private readonly stripe: Stripe;
+
+  constructor(secretKey: string) {
+    this.stripe = new Stripe(secretKey);
+  }
+
+  async createPaymentIntent(
+    amount: number,
+    currency: string,
+    metadata: Record<string, string>,
+  ): Promise<PaymentIntentResult> {
+    try {
+      const intent = await this.stripe.paymentIntents.create({
+        amount: Math.round(amount * 100), // BRL → centavos
+        currency,
+        metadata,
+        automatic_payment_methods: { enabled: true },
+      });
+
+      if (!intent.client_secret) {
+        throw new PaymentError('missing_client_secret', 'Stripe não retornou client_secret');
+      }
+
+      return { id: intent.id, clientSecret: intent.client_secret };
+    } catch (err) {
+      if (err instanceof PaymentError) throw err;
+      // Wrap Stripe errors in a PaymentError so callers don't depend on Stripe types
+      const stripeErr = err as { type?: string; code?: string; message?: string };
+      throw new PaymentError(
+        stripeErr.code ?? stripeErr.type ?? 'stripe_error',
+        stripeErr.message ?? 'Erro no processamento do pagamento',
+      );
+    }
+  }
+}

package/templates/ecommerce/apps/api/src/infrastructure/services/shipping/mock.shipping.service.ts

@@ -0,0 +1,17 @@
+import type { IShippingService, ShippingOption } from '../../../application/ports/shipping.port';
+
+/**
+ * Returns deterministic mock options — pluggable with Correios / Melhor Envio
+ * in a real deployment by swapping the implementation.
+ */
+export class MockShippingService implements IShippingService {
+  async calculate(
+    _cep: string,
+    _items: Array<{ qty: number; weight?: number }>,
+  ): Promise<ShippingOption[]> {
+    return [
+      { name: 'PAC', price: 18.5, estimatedDays: 7 },
+      { name: 'SEDEX', price: 32.0, estimatedDays: 2 },
+    ];
+  }
+}

package/templates/ecommerce/apps/api/src/infrastructure/services/storage/in-memory.storage.service.ts

@@ -0,0 +1,11 @@
+import type { IStorageService } from '../../../application/ports/storage.port';
+
+/**
+ * In-memory storage — used in tests and when S3_BUCKET is not configured.
+ * Files are never persisted; returns a deterministic fake URL.
+ */
+export class InMemoryStorageService implements IStorageService {
+  async upload(key: string, _buffer: Buffer, _mimetype: string): Promise<string> {
+    return `http://storage.local/${key}`;
+  }
+}

package/templates/ecommerce/apps/api/src/infrastructure/services/storage/local-disk.storage.service.ts

@@ -0,0 +1,27 @@
+import fs from 'fs';
+import path from 'path';
+import type { IStorageService } from '../../../application/ports/storage.port';
+
+/**
+ * LocalDiskStorageService — persists uploaded files to the local filesystem
+ * under `apps/api/public/uploads/`. Used for local development when neither
+ * S3 nor MinIO is configured.
+ *
+ * Files are served by the Express static middleware at /public/uploads/<key>.
+ */
+export class LocalDiskStorageService implements IStorageService {
+  private readonly uploadDir: string;
+
+  constructor(uploadDir?: string) {
+    this.uploadDir =
+      uploadDir ?? path.join(__dirname, '../../../../../public/uploads');
+  }
+
+  async upload(key: string, buffer: Buffer, _mimetype: string): Promise<string> {
+    fs.mkdirSync(this.uploadDir, { recursive: true });
+    const filePath = path.join(this.uploadDir, key);
+    fs.writeFileSync(filePath, buffer);
+    const baseUrl = process.env['BASE_URL'] ?? 'http://localhost:3000';
+    return `${baseUrl}/public/uploads/${key}`;
+  }
+}

package/templates/ecommerce/apps/api/src/infrastructure/services/storage/s3.storage.service.ts

@@ -0,0 +1,52 @@
+import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';
+import type { IStorageService } from '../../../application/ports/storage.port';
+import { AppError } from '../../../domain/shared/AppError';
+
+/**
+ * S3-compatible storage service.
+ * Points to AWS S3 in production.
+ * In dev/CI, override S3_ENDPOINT to use MinIO (http://localhost:9000).
+ */
+export class S3StorageService implements IStorageService {
+  private readonly client: S3Client;
+  private readonly bucket: string;
+  private readonly publicBase: string;
+
+  constructor() {
+    this.bucket = process.env['S3_BUCKET'] ?? 'products';
+    const region = process.env['S3_REGION'] ?? 'us-east-1';
+    const endpoint = process.env['S3_ENDPOINT'];
+
+    this.client = new S3Client({
+      region,
+      ...(endpoint
+        ? { endpoint, forcePathStyle: true }
+        : {}),
+      credentials: {
+        accessKeyId: process.env['AWS_ACCESS_KEY_ID'] ?? '',
+        secretAccessKey: process.env['AWS_SECRET_ACCESS_KEY'] ?? '',
+      },
+    });
+
+    // Public URL base: MinIO-style (endpoint/bucket) or S3 virtual-hosted
+    this.publicBase = endpoint
+      ? `${endpoint}/${this.bucket}`
+      : `https://${this.bucket}.s3.${region}.amazonaws.com`;
+  }
+
+  async upload(key: string, buffer: Buffer, mimetype: string): Promise<string> {
+    try {
+      await this.client.send(
+        new PutObjectCommand({
+          Bucket: this.bucket,
+          Key: key,
+          Body: buffer,
+          ContentType: mimetype,
+        }),
+      );
+      return `${this.publicBase}/${key}`;
+    } catch {
+      throw new AppError('Falha ao fazer upload da imagem', 500);
+    }
+  }
+}

package/templates/ecommerce/apps/api/src/infrastructure/services/storage/storage.registry.ts

@@ -0,0 +1,19 @@
+import type { IStorageService } from '../../../application/ports/storage.port';
+import { S3StorageService } from './s3.storage.service';
+import { InMemoryStorageService } from './in-memory.storage.service';
+import { LocalDiskStorageService } from './local-disk.storage.service';
+
+const env = process.env['NODE_ENV'];
+
+/**
+ * Picks the storage implementation:
+ *   test / test-inmemory → InMemoryStorageService (no disk I/O in tests)
+ *   S3_BUCKET set        → S3StorageService (real S3 or MinIO)
+ *   Otherwise            → LocalDiskStorageService (dev without MinIO)
+ */
+export const storageService: IStorageService =
+  env === 'test' || env === 'test-inmemory'
+    ? new InMemoryStorageService()
+    : process.env['S3_BUCKET']
+      ? new S3StorageService()
+      : new LocalDiskStorageService();

package/templates/ecommerce/apps/api/src/infrastructure/services/token/redis.token.blacklist.ts

@@ -0,0 +1,23 @@
+import type { Redis } from 'ioredis';
+import type { ITokenBlacklist } from '../../../application/ports/token-blacklist.port';
+
+const KEY_PREFIX = 'blacklist:';
+
+/**
+ * Redis-backed token blacklist.
+ * Uses a simple SET with EX (TTL) — the key expires automatically, so no
+ * manual cleanup is needed.
+ */
+export class RedisTokenBlacklist implements ITokenBlacklist {
+  constructor(private readonly redis: Redis) {}
+
+  async add(jti: string, ttlSeconds: number): Promise<void> {
+    if (ttlSeconds <= 0) return; // token already expired — nothing to store
+    await this.redis.set(`${KEY_PREFIX}${jti}`, '1', 'EX', ttlSeconds);
+  }
+
+  async has(jti: string): Promise<boolean> {
+    const val = await this.redis.get(`${KEY_PREFIX}${jti}`);
+    return val !== null;
+  }
+}

package/templates/ecommerce/apps/api/src/infrastructure/services/token/token.blacklist.ts

@@ -0,0 +1,30 @@
+import type { ITokenBlacklist } from '../../../application/ports/token-blacklist.port';
+
+/**
+ * In-process implementation used for unit tests and dev when Redis is not
+ * available. Honors TTL via timestamp comparison.
+ */
+export class InMemoryTokenBlacklist implements ITokenBlacklist {
+  /** jti → expiry epoch-ms (0 = never expires) */
+  private readonly store = new Map<string, number>();
+
+  async add(jti: string, ttlSeconds: number): Promise<void> {
+    const expiry = ttlSeconds > 0 ? Date.now() + ttlSeconds * 1000 : 0;
+    this.store.set(jti, expiry);
+  }
+
+  async has(jti: string): Promise<boolean> {
+    const expiry = this.store.get(jti);
+    if (expiry === undefined) return false;
+    if (expiry !== 0 && Date.now() > expiry) {
+      this.store.delete(jti);
+      return false;
+    }
+    return true;
+  }
+
+  /** Used in tests to reset state between cases. */
+  clear(): void {
+    this.store.clear();
+  }
+}