kybernus 3.0.1 → 3.2.0

package/templates/ecommerce/apps/api/src/domain/cart/coupon.repository.ts

@@ -0,0 +1,10 @@
+import { CouponEntity } from './coupon.entity';
+
+export interface ICouponRepository {
+  findByCode(code: string): Promise<CouponEntity | null>;
+  findById(id: string): Promise<CouponEntity | null>;
+  findAll(): Promise<CouponEntity[]>;
+  save(coupon: CouponEntity): Promise<CouponEntity>;
+  deleteById(id: string): Promise<void>;
+  incrementUsage(code: string): Promise<void>;
+}

package/templates/ecommerce/apps/api/src/domain/catalog/category.entity.ts

@@ -0,0 +1,51 @@
+import { randomUUID } from 'crypto';
+
+export interface CategoryProps {
+  id: string;
+  name: string;
+  slug: string;
+  description: string | null;
+  parentId: string | null;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export interface CreateCategoryInput {
+  name: string;
+  slug: string;
+  description?: string | null;
+  parentId?: string | null;
+}
+
+export class CategoryEntity {
+  private constructor(private readonly props: CategoryProps) {}
+
+  static create(input: CreateCategoryInput): CategoryEntity {
+    if (!input.name.trim()) throw new Error('Category name is required');
+    return new CategoryEntity({
+      id: randomUUID(),
+      name: input.name.trim(),
+      slug: input.slug.toLowerCase(),
+      description: input.description ?? null,
+      parentId: input.parentId ?? null,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    });
+  }
+
+  static reconstitute(props: CategoryProps): CategoryEntity {
+    return new CategoryEntity(props);
+  }
+
+  get id(): string { return this.props.id; }
+  get name(): string { return this.props.name; }
+  get slug(): string { return this.props.slug; }
+  get description(): string | null { return this.props.description; }
+  get parentId(): string | null { return this.props.parentId; }
+  get createdAt(): Date { return this.props.createdAt; }
+  get updatedAt(): Date { return this.props.updatedAt; }
+
+  toRecord(): CategoryProps {
+    return { ...this.props };
+  }
+}

package/templates/ecommerce/apps/api/src/domain/catalog/category.repository.ts

@@ -0,0 +1,10 @@
+import { CategoryEntity } from './category.entity';
+
+export interface ICategoryRepository {
+  findById(id: string): Promise<CategoryEntity | null>;
+  findBySlug(slug: string): Promise<CategoryEntity | null>;
+  findAll(): Promise<CategoryEntity[]>;
+  create(category: CategoryEntity): Promise<CategoryEntity>;
+  update(category: CategoryEntity): Promise<CategoryEntity>;
+  delete(id: string): Promise<void>;
+}

package/templates/ecommerce/apps/api/src/domain/catalog/product.entity.ts

@@ -0,0 +1,130 @@
+import { randomUUID } from 'crypto';
+import { AppError } from '../shared/AppError';
+
+export enum ProductStatus {
+  ACTIVE = 'ACTIVE',
+  INACTIVE = 'INACTIVE',
+  DELETED = 'DELETED',
+}
+
+export interface ProductVariantProps {
+  id: string;
+  sku: string;
+  size: string | null;
+  color: string | null;
+  stock: number;
+  price: number | null;
+  productId: string;
+}
+
+export interface ProductProps {
+  id: string;
+  name: string;
+  slug: string;
+  description: string | null;
+  price: number;
+  categoryId: string;
+  status: ProductStatus;
+  images: string[];
+  createdAt: Date;
+  updatedAt: Date;
+  variants: ProductVariantProps[];
+}
+
+export interface CreateProductInput {
+  name: string;
+  slug: string;
+  description?: string | null;
+  price: number;
+  categoryId: string;
+  images?: string[];
+  variants: Array<{
+    sku: string;
+    size?: string | null;
+    color?: string | null;
+    stock: number;
+    price?: number | null;
+  }>;
+}
+
+export class ProductEntity {
+  private constructor(private readonly props: ProductProps) {}
+
+  static create(input: CreateProductInput): ProductEntity {
+    if (!input.name.trim()) {
+      throw new AppError('Nome do produto é obrigatório', 422);
+    }
+    if (input.price < 0) {
+      throw new AppError('Preço não pode ser negativo', 422);
+    }
+
+    const id = randomUUID();
+    return new ProductEntity({
+      id,
+      name: input.name.trim(),
+      slug: input.slug,
+      description: input.description ?? null,
+      price: input.price,
+      categoryId: input.categoryId,
+      status: ProductStatus.ACTIVE,
+      images: input.images ?? [],
+      createdAt: new Date(),
+      updatedAt: new Date(),
+      variants: input.variants.map((v) => ({
+        id: randomUUID(),
+        sku: v.sku,
+        size: v.size ?? null,
+        color: v.color ?? null,
+        stock: v.stock,
+        price: v.price ?? null,
+        productId: id,
+      })),
+    });
+  }
+
+  static reconstitute(props: ProductProps): ProductEntity {
+    return new ProductEntity(props);
+  }
+
+  get id(): string { return this.props.id; }
+  get name(): string { return this.props.name; }
+  get slug(): string { return this.props.slug; }
+  get description(): string | null { return this.props.description; }
+  get price(): number { return this.props.price; }
+  get categoryId(): string { return this.props.categoryId; }
+  get status(): ProductStatus { return this.props.status; }
+  get images(): string[] { return this.props.images; }
+  get createdAt(): Date { return this.props.createdAt; }
+  get updatedAt(): Date { return this.props.updatedAt; }
+  get variants(): ProductVariantProps[] { return this.props.variants; }
+
+  isDeleted(): boolean {
+    return this.props.status === ProductStatus.DELETED;
+  }
+
+  withUpdates(updates: Partial<Pick<ProductProps, 'name' | 'description' | 'price' | 'images' | 'status'>>): ProductEntity {
+    return new ProductEntity({
+      ...this.props,
+      ...updates,
+      updatedAt: new Date(),
+    });
+  }
+
+  withDeletedStatus(): ProductEntity {
+    return this.withUpdates({ status: ProductStatus.DELETED });
+  }
+
+  withVariantStockUpdate(variantId: string, newStock: number): ProductEntity {
+    return new ProductEntity({
+      ...this.props,
+      updatedAt: new Date(),
+      variants: this.props.variants.map((v) =>
+        v.id === variantId ? { ...v, stock: newStock } : v,
+      ),
+    });
+  }
+
+  toRecord(): ProductProps {
+    return { ...this.props, variants: this.props.variants.map((v) => ({ ...v })) };
+  }
+}

package/templates/ecommerce/apps/api/src/domain/catalog/product.repository.ts

@@ -0,0 +1,28 @@
+import { ProductEntity } from './product.entity';
+
+export interface SearchParams {
+  q?: string;
+  categoryId?: string;
+  minPrice?: number;
+  maxPrice?: number;
+  sortBy?: 'price_asc' | 'price_desc' | 'newest';
+  cursor?: string;
+  limit?: number;
+}
+
+export interface SearchResult {
+  items: ProductEntity[];
+  nextCursor: string | null;
+}
+
+export interface IProductRepository {
+  findById(id: string): Promise<ProductEntity | null>;
+  findBySlug(slug: string): Promise<ProductEntity | null>;
+  findAll(): Promise<ProductEntity[]>;
+  search(params: SearchParams): Promise<SearchResult>;
+  create(product: ProductEntity): Promise<ProductEntity>;
+  update(product: ProductEntity): Promise<ProductEntity>;
+  softDelete(id: string): Promise<undefined>;
+  updateVariantStock(productId: string, variantId: string, newStock: number): Promise<undefined>;
+  slugExists(slug: string): Promise<boolean>;
+}

package/templates/ecommerce/apps/api/src/domain/checkout/order.entity.ts

@@ -0,0 +1,121 @@
+import { AppError } from '../shared/AppError';
+
+// ── Types ─────────────────────────────────────────────────────────────────────
+export type OrderStatus = 'PENDING' | 'PAID' | 'FAILED' | 'SHIPPED' | 'DELIVERED' | 'CANCELLED';
+
+export interface OrderItemProps {
+  id: string;
+  variantId: string;
+  productId: string;
+  name: string;
+  sku: string;
+  price: number;
+  qty: number;
+  image: string | null;
+}
+
+export interface OrderProps {
+  id: string;
+  userId: string;
+  status: OrderStatus;
+  items: OrderItemProps[];
+  subtotal: number;
+  discount: number;
+  shippingCost: number;
+  tax: number;
+  total: number;
+  couponCode: string | null;
+  paymentIntentId: string | null;
+  trackingCode: string | null;
+  shippingAddress: Record<string, string> | null;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export type CreateOrderInput = Pick<
+  OrderProps,
+  'userId' | 'items' | 'subtotal' | 'discount' | 'shippingCost' | 'tax' | 'total' | 'couponCode' | 'paymentIntentId' | 'shippingAddress'
+>;
+
+// ── Valid status transitions ───────────────────────────────────────────────────
+const ALLOWED_TRANSITIONS: Partial<Record<OrderStatus, OrderStatus[]>> = {
+  PENDING:   ['PAID', 'FAILED', 'CANCELLED'],
+  PAID:      ['SHIPPED', 'CANCELLED'],
+  SHIPPED:   ['DELIVERED'],
+  FAILED:    [],
+  DELIVERED: [],
+  CANCELLED: [],
+};
+
+// ── OrderEntity ───────────────────────────────────────────────────────────────
+export class OrderEntity {
+  private constructor(private readonly props: OrderProps) {}
+
+  // ── Factory ───────────────────────────────────────────────────────────────
+  static create(input: CreateOrderInput): OrderEntity {
+    return new OrderEntity({
+      id: crypto.randomUUID(),
+      status: 'PENDING',
+      trackingCode: null,
+      ...input,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    });
+  }
+
+  static reconstitute(props: OrderProps): OrderEntity {
+    return new OrderEntity({ ...props });
+  }
+
+  // ── Getters ───────────────────────────────────────────────────────────────
+  get id(): string { return this.props.id; }
+  get userId(): string { return this.props.userId; }
+  get status(): OrderStatus { return this.props.status; }
+  get items(): ReadonlyArray<OrderItemProps> { return this.props.items; }
+  get subtotal(): number { return this.props.subtotal; }
+  get discount(): number { return this.props.discount; }
+  get shippingCost(): number { return this.props.shippingCost; }
+  get tax(): number { return this.props.tax; }
+  get total(): number { return this.props.total; }
+  get couponCode(): string | null { return this.props.couponCode; }
+  get paymentIntentId(): string | null { return this.props.paymentIntentId; }
+  get trackingCode(): string | null { return this.props.trackingCode; }
+  get shippingAddress(): Record<string, string> | null { return this.props.shippingAddress; }
+  get createdAt(): Date { return this.props.createdAt; }
+  get updatedAt(): Date { return this.props.updatedAt; }
+
+  // ── State transitions (immutable) ─────────────────────────────────────────
+  private transition(to: OrderStatus): OrderEntity {
+    const allowed = ALLOWED_TRANSITIONS[this.props.status] ?? [];
+    if (!allowed.includes(to)) {
+      throw new AppError(
+        `Transição inválida: ${this.props.status} → ${to}`,
+        400,
+      );
+    }
+    return new OrderEntity({ ...this.props, status: to, updatedAt: new Date() });
+  }
+
+  pay(): OrderEntity { return this.transition('PAID'); }
+  fail(): OrderEntity { return this.transition('FAILED'); }
+  ship(trackingCode?: string): OrderEntity {
+    const next = this.transition('SHIPPED');
+    if (trackingCode) return new OrderEntity({ ...next.props, trackingCode, updatedAt: new Date() });
+    return next;
+  }
+  deliver(): OrderEntity { return this.transition('DELIVERED'); }
+  cancel(): OrderEntity { return this.transition('CANCELLED'); }
+
+  withPaymentIntentId(id: string): OrderEntity {
+    return new OrderEntity({ ...this.props, paymentIntentId: id, updatedAt: new Date() });
+  }
+
+  withTrackingCode(code: string): OrderEntity {
+    return new OrderEntity({ ...this.props, trackingCode: code, updatedAt: new Date() });
+  }
+
+  // ── Serialization ─────────────────────────────────────────────────────────
+  toRecord(): OrderProps {
+    return { ...this.props, items: [...this.props.items] };
+  }
+}

package/templates/ecommerce/apps/api/src/domain/checkout/order.repository.ts

@@ -0,0 +1,11 @@
+import { OrderEntity } from './order.entity';
+import type { OrderStatus } from './order.entity';
+
+export interface IOrderRepository {
+  findById(id: string): Promise<OrderEntity | null>;
+  findByPaymentIntentId(paymentIntentId: string): Promise<OrderEntity | null>;
+  findByUserId(userId: string, opts?: { cursor?: string; limit?: number }): Promise<{ items: OrderEntity[]; nextCursor: string | null }>;
+  findAll(opts?: { status?: OrderStatus; cursor?: string; limit?: number }): Promise<{ items: OrderEntity[]; nextCursor: string | null }>;
+  create(order: OrderEntity): Promise<OrderEntity>;
+  update(order: OrderEntity): Promise<OrderEntity>;
+}

package/templates/ecommerce/apps/api/src/domain/shared/AppError.ts

@@ -0,0 +1,12 @@
+export class AppError extends Error {
+  public readonly statusCode: number;
+  public readonly isOperational: boolean;
+
+  constructor(message: string, statusCode: number = 500, isOperational: boolean = true) {
+    super(message);
+    this.statusCode = statusCode;
+    this.isOperational = isOperational;
+    Object.setPrototypeOf(this, new.target.prototype);
+    Error.captureStackTrace(this, this.constructor);
+  }
+}

package/templates/ecommerce/apps/api/src/infrastructure/cache/redis.ts

@@ -0,0 +1,16 @@
+import Redis from 'ioredis';
+
+// Prevent multiple Redis clients in development hot-reload
+const globalForRedis = globalThis as unknown as { redis?: Redis };
+
+export const redis =
+  globalForRedis.redis ??
+  new Redis(process.env['REDIS_URL'] ?? 'redis://localhost:6379', {
+    lazyConnect: true,
+    maxRetriesPerRequest: 3,
+    enableReadyCheck: false,
+  });
+
+if (process.env['NODE_ENV'] !== 'production') {
+  globalForRedis.redis = redis;
+}

package/templates/ecommerce/apps/api/src/infrastructure/config/registry/admin.registry.ts

@@ -0,0 +1,13 @@
+import { DashboardService } from '../../../application/admin/dashboard.service';
+import { AdminUserService } from '../../../application/admin/admin-user.service';
+import { AdminController } from '../../../presentation/modules/admin/admin.controller';
+import { orderRepository } from './checkout.registry';
+import { userRepository } from './auth.registry';
+import { couponRepository } from './cart.registry';
+import { CouponAdminService } from '../../../application/cart/coupon.service';
+
+const dashboardService = new DashboardService(orderRepository);
+const adminUserService = new AdminUserService(userRepository);
+const couponAdminService = new CouponAdminService(couponRepository);
+
+export const adminController = new AdminController(dashboardService, adminUserService, couponAdminService);

package/templates/ecommerce/apps/api/src/infrastructure/config/registry/auth.registry.ts

@@ -0,0 +1,34 @@
+import { InMemoryUserRepository } from '../../persistence/in-memory/user.memory.repository';
+import { PrismaUserRepository } from '../../persistence/prisma/auth/user.prisma.repository';
+import { TokenService } from '../../services/token/token.service';
+import { AuthService } from '../../../application/auth/auth.service';
+import { prisma } from '../../persistence/prisma-client';
+import { InMemoryTokenBlacklist } from '../../services/token/token.blacklist';
+import { RedisTokenBlacklist } from '../../services/token/redis.token.blacklist';
+import { redis } from '../../cache/redis';
+import { emailService } from '../../services/email/email.registry';
+
+/**
+ * Module-level singletons.
+ * Uses PrismaUserRepository when DATABASE_URL is set (production / integration
+ * tests). Falls back to InMemoryUserRepository when NODE_ENV is 'test' without
+ * a DATABASE_URL, or when NODE_ENV is 'test-inmemory'.
+ */
+const useDb =
+  Boolean(process.env['DATABASE_URL']) &&
+  process.env['NODE_ENV'] !== 'test-inmemory';
+
+export const userRepository = useDb
+  ? new PrismaUserRepository(prisma)
+  : new InMemoryUserRepository();
+
+const useRedis =
+  Boolean(process.env['REDIS_URL']) &&
+  process.env['NODE_ENV'] !== 'test-inmemory';
+
+const blacklist = useRedis
+  ? new RedisTokenBlacklist(redis)
+  : new InMemoryTokenBlacklist();
+
+export const tokenService = new TokenService(blacklist, useDb ? prisma : undefined);
+export const authService = new AuthService(userRepository, tokenService, emailService);

package/templates/ecommerce/apps/api/src/infrastructure/config/registry/cart.registry.ts

@@ -0,0 +1,49 @@
+import { InMemoryCartRepository } from '../../persistence/in-memory/cart.memory.repository';
+import { InMemoryCouponRepository } from '../../persistence/in-memory/coupon.memory.repository';
+import { MockShippingService } from '../../services/shipping/mock.shipping.service';
+import { CouponEntity } from '../../../domain/cart/coupon.entity';
+import { CartService } from '../../../application/cart/cart.service';
+import { productRepository } from './catalog.registry';
+
+// ── Singletons ────────────────────────────────────────────────────────────────
+export const cartRepository = new InMemoryCartRepository();
+export const couponRepository = new InMemoryCouponRepository();
+export const shippingService = new MockShippingService();
+export const cartService = new CartService(
+  cartRepository,
+  couponRepository,
+  shippingService,
+  productRepository,
+);
+
+// ── Seed test coupons ─────────────────────────────────────────────────────────
+couponRepository.seed(
+  CouponEntity.reconstitute({
+    id: 'seed-coup-1',
+    code: 'PROMO10',
+    discountType: 'percent',
+    discountValue: 10,
+    minOrderValue: 0,
+    usageLimit: null,
+    usageCount: 0,
+    expiresAt: null,
+    createdAt: new Date(),
+  }),
+);
+
+couponRepository.seed(
+  CouponEntity.reconstitute({
+    id: 'seed-coup-2',
+    code: 'EXPIRED',
+    discountType: 'percent',
+    discountValue: 5,
+    minOrderValue: 0,
+    usageLimit: null,
+    usageCount: 0,
+    expiresAt: new Date('2020-01-01'),
+    createdAt: new Date(),
+  }),
+);
+
+// ── Named export for test setup ───────────────────────────────────────────────
+export const cartRegistry = { cartRepository, couponRepository, shippingService, cartService };

package/templates/ecommerce/apps/api/src/infrastructure/config/registry/catalog.registry.ts

@@ -0,0 +1,24 @@
+import { InMemoryCategoryRepository } from '../../persistence/in-memory/category.memory.repository';
+import { InMemoryProductRepository } from '../../persistence/in-memory/product.memory.repository';
+import { PrismaCategoryRepository } from '../../persistence/prisma/catalog/category.prisma.repository';
+import { PrismaProductRepository } from '../../persistence/prisma/catalog/product.prisma.repository';
+import { CatalogService } from '../../../application/catalog/catalog.service';
+import { prisma } from '../../persistence/prisma-client';
+import { storageService } from '../../services/storage/storage.registry';
+
+const useDb =
+  Boolean(process.env['DATABASE_URL']) &&
+  process.env['NODE_ENV'] !== 'test-inmemory';
+
+export const categoryRepository = useDb
+  ? new PrismaCategoryRepository(prisma)
+  : new InMemoryCategoryRepository();
+
+export const productRepository = useDb
+  ? new PrismaProductRepository(prisma)
+  : new InMemoryProductRepository();
+
+export const catalogService = new CatalogService(categoryRepository, productRepository, storageService);
+
+// Named export for test setup access
+export const catalogRegistry = { categoryRepository, productRepository, catalogService };

package/templates/ecommerce/apps/api/src/infrastructure/config/registry/checkout.registry.ts

@@ -0,0 +1,47 @@
+import { InMemoryOrderRepository } from '../../persistence/in-memory/order.memory.repository';
+import { PrismaOrderRepository } from '../../persistence/prisma/checkout/order.prisma.repository';
+import { StripeAdapter } from '../../services/payment/stripe.adapter';
+import { StripeWebhookHandler } from '../../services/payment/stripe-webhook.handler';
+import { CheckoutService } from '../../../application/checkout/checkout.service';
+import { cartRepository, couponRepository } from './cart.registry';
+import { productRepository } from './catalog.registry';
+import { prisma } from '../../persistence/prisma-client';
+import { emailService } from '../../services/email/email.registry';
+import { userRepository } from './auth.registry';
+
+const useDb =
+  Boolean(process.env['DATABASE_URL']) &&
+  process.env['NODE_ENV'] !== 'test-inmemory';
+
+// ── Singletons ────────────────────────────────────────────────────────────────
+export const orderRepository = useDb
+  ? new PrismaOrderRepository(prisma)
+  : new InMemoryOrderRepository();
+
+export const paymentAdapter = new StripeAdapter(
+  process.env['STRIPE_SECRET_KEY'] ?? 'sk_test_dummy',
+);
+
+export const webhookHandler = new StripeWebhookHandler(
+  process.env['STRIPE_SECRET_KEY'] ?? 'sk_test_dummy',
+  process.env['STRIPE_WEBHOOK_SECRET'] ?? 'whsec_dummy',
+  orderRepository,
+  couponRepository,
+  emailService,
+  userRepository,
+);
+
+export const checkoutService = new CheckoutService(
+  orderRepository,
+  paymentAdapter,
+  cartRepository,
+  productRepository,
+);
+
+// ── Named export for test overrides ──────────────────────────────────────────
+export const checkoutRegistry = {
+  orderRepository,
+  paymentAdapter,
+  webhookHandler,
+  checkoutService,
+};

package/templates/ecommerce/apps/api/src/infrastructure/config/registry/orders.registry.ts

@@ -0,0 +1,6 @@
+import { OrderService } from '../../../application/orders/order.service';
+import { orderRepository } from './checkout.registry';
+import { emailService } from '../../services/email/email.registry';
+import { userRepository } from './auth.registry';
+
+export const orderService = new OrderService(orderRepository, emailService, userRepository);

package/templates/ecommerce/apps/api/src/infrastructure/config/registry/profile.registry.ts

@@ -0,0 +1,4 @@
+import { ProfileService } from '../../../application/profile/profile.service';
+import { userRepository } from './auth.registry';
+
+export const profileService = new ProfileService(userRepository);

package/templates/ecommerce/apps/api/src/infrastructure/persistence/in-memory/cart.memory.repository.ts

@@ -0,0 +1,33 @@
+import { CartEntity } from '../../../domain/cart/cart.entity';
+import type { ICartRepository } from '../../../domain/cart/cart.repository';
+
+// Simulates Redis TTL-based storage using two Maps (by userId and by sessionId).
+export class InMemoryCartRepository implements ICartRepository {
+  private byUser = new Map<string, CartEntity>();
+  private bySession = new Map<string, CartEntity>();
+
+  async findByUserId(userId: string): Promise<CartEntity | null> {
+    return this.byUser.get(userId) ?? null;
+  }
+
+  async findBySessionId(sessionId: string): Promise<CartEntity | null> {
+    return this.bySession.get(sessionId) ?? null;
+  }
+
+  async save(cart: CartEntity): Promise<CartEntity> {
+    if (cart.userId) this.byUser.set(cart.userId, cart);
+    if (cart.sessionId) this.bySession.set(cart.sessionId, cart);
+    return cart;
+  }
+
+  async delete(key: { userId?: string; sessionId?: string }): Promise<void> {
+    if (key.userId) this.byUser.delete(key.userId);
+    if (key.sessionId) this.bySession.delete(key.sessionId);
+  }
+
+  /** Test helper — wipe all entries */
+  clear(): void {
+    this.byUser.clear();
+    this.bySession.clear();
+  }
+}

package/templates/ecommerce/apps/api/src/infrastructure/persistence/in-memory/category.memory.repository.ts

@@ -0,0 +1,41 @@
+import { CategoryEntity, CategoryProps } from '../../../domain/catalog/category.entity';
+import type { ICategoryRepository } from '../../../domain/catalog/category.repository';
+
+export class InMemoryCategoryRepository implements ICategoryRepository {
+  private store = new Map<string, CategoryProps>();
+
+  async findById(id: string): Promise<CategoryEntity | null> {
+    const props = this.store.get(id);
+    return props ? CategoryEntity.reconstitute(props) : null;
+  }
+
+  async findBySlug(slug: string): Promise<CategoryEntity | null> {
+    for (const props of this.store.values()) {
+      if (props.slug === slug) return CategoryEntity.reconstitute(props);
+    }
+    return null;
+  }
+
+  async findAll(): Promise<CategoryEntity[]> {
+    return Array.from(this.store.values()).map(CategoryEntity.reconstitute);
+  }
+
+  async create(category: CategoryEntity): Promise<CategoryEntity> {
+    this.store.set(category.id, category.toRecord());
+    return category;
+  }
+
+  async update(category: CategoryEntity): Promise<CategoryEntity> {
+    this.store.set(category.id, category.toRecord());
+    return category;
+  }
+
+  async delete(id: string): Promise<undefined> {
+    this.store.delete(id);
+    return undefined;
+  }
+
+  clear(): void {
+    this.store.clear();
+  }
+}