kybernus 3.1.0 → 3.2.0

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

@@ -0,0 +1,55 @@
+import { CouponEntity } from '../../../domain/cart/coupon.entity';
+import type { ICouponRepository } from '../../../domain/cart/coupon.repository';
+
+export class InMemoryCouponRepository implements ICouponRepository {
+  private store = new Map<string, CouponEntity>();
+
+  async findByCode(code: string): Promise<CouponEntity | null> {
+    return this.store.get(code.toUpperCase()) ?? null;
+  }
+
+  async findById(id: string): Promise<CouponEntity | null> {
+    for (const coupon of this.store.values()) {
+      if (coupon.id === id) return coupon;
+    }
+    return null;
+  }
+
+  async findAll(): Promise<CouponEntity[]> {
+    return [...this.store.values()];
+  }
+
+  async save(coupon: CouponEntity): Promise<CouponEntity> {
+    this.store.set(coupon.code.toUpperCase(), coupon);
+    return coupon;
+  }
+
+  async deleteById(id: string): Promise<void> {
+    for (const [key, coupon] of this.store.entries()) {
+      if (coupon.id === id) {
+        this.store.delete(key);
+        return;
+      }
+    }
+  }
+
+  async incrementUsage(code: string): Promise<void> {
+    const coupon = this.store.get(code.toUpperCase());
+    if (!coupon) return;
+    const props = coupon.toRecord();
+    const updated = CouponEntity.reconstitute({
+      ...props,
+      usageCount: props.usageCount + 1,
+    });
+    this.store.set(code.toUpperCase(), updated);
+  }
+
+  // ── Test / seeding helpers ────────────────────────────────────────────────
+  seed(coupon: CouponEntity): void {
+    this.store.set(coupon.code.toUpperCase(), coupon);
+  }
+
+  clear(): void {
+    this.store.clear();
+  }
+}

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

@@ -0,0 +1,75 @@
+import { OrderEntity } from '../../../domain/checkout/order.entity';
+import type { OrderStatus } from '../../../domain/checkout/order.entity';
+import type { IOrderRepository } from '../../../domain/checkout/order.repository';
+
+export class InMemoryOrderRepository implements IOrderRepository {
+  private store = new Map<string, OrderEntity>();
+
+  async findById(id: string): Promise<OrderEntity | null> {
+    return this.store.get(id) ?? null;
+  }
+
+  async findByPaymentIntentId(paymentIntentId: string): Promise<OrderEntity | null> {
+    for (const order of this.store.values()) {
+      if (order.paymentIntentId === paymentIntentId) return order;
+    }
+    return null;
+  }
+
+  async findByUserId(
+    userId: string,
+    opts: { cursor?: string; limit?: number } = {},
+  ): Promise<{ items: OrderEntity[]; nextCursor: string | null }> {
+    const limit = opts.limit ?? 20;
+    const all = [...this.store.values()]
+      .filter((o) => o.userId === userId)
+      .sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+
+    let startIdx = 0;
+    if (opts.cursor) {
+      const idx = all.findIndex((o) => o.id === opts.cursor);
+      if (idx !== -1) startIdx = idx + 1;
+    }
+
+    const page = all.slice(startIdx, startIdx + limit);
+    const nextCursor = all.length > startIdx + limit ? page[page.length - 1]!.id : null;
+    return { items: page, nextCursor };
+  }
+
+  async create(order: OrderEntity): Promise<OrderEntity> {
+    this.store.set(order.id, order);
+    return order;
+  }
+
+  async update(order: OrderEntity): Promise<OrderEntity> {
+    this.store.set(order.id, order);
+    return order;
+  }
+
+  async findAll(
+    opts: { status?: OrderStatus; cursor?: string; limit?: number } = {},
+  ): Promise<{ items: OrderEntity[]; nextCursor: string | null }> {
+    const limit = opts.limit ?? 20;
+    let all = [...this.store.values()]
+      .sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+
+    if (opts.status) {
+      all = all.filter((o) => o.status === opts.status);
+    }
+
+    let startIdx = 0;
+    if (opts.cursor) {
+      const idx = all.findIndex((o) => o.id === opts.cursor);
+      if (idx !== -1) startIdx = idx + 1;
+    }
+
+    const page = all.slice(startIdx, startIdx + limit);
+    const nextCursor = all.length > startIdx + limit ? page[page.length - 1]!.id : null;
+    return { items: page, nextCursor };
+  }
+
+  /** Test helper */
+  clear(): void {
+    this.store.clear();
+  }
+}

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

@@ -0,0 +1,100 @@
+import { ProductEntity, ProductProps, ProductStatus } from '../../../domain/catalog/product.entity';
+import type { IProductRepository, SearchParams, SearchResult } from '../../../domain/catalog/product.repository';
+
+export class InMemoryProductRepository implements IProductRepository {
+  private store = new Map<string, ProductProps>();
+
+  async findById(id: string): Promise<ProductEntity | null> {
+    const props = this.store.get(id);
+    if (!props || props.status === ProductStatus.DELETED) return null;
+    return ProductEntity.reconstitute(props);
+  }
+
+  async findBySlug(slug: string): Promise<ProductEntity | null> {
+    for (const props of this.store.values()) {
+      if (props.slug === slug && props.status !== ProductStatus.DELETED) {
+        return ProductEntity.reconstitute(props);
+      }
+    }
+    return null;
+  }
+
+  async findAll(): Promise<ProductEntity[]> {
+    return Array.from(this.store.values())
+      .filter((p) => p.status === ProductStatus.ACTIVE)
+      .map(ProductEntity.reconstitute);
+  }
+
+  async search(params: SearchParams): Promise<SearchResult> {
+    const { q, categoryId, minPrice, maxPrice, sortBy, cursor, limit = 20 } = params;
+    let items = Array.from(this.store.values()).filter(
+      (p) => p.status === ProductStatus.ACTIVE,
+    );
+
+    if (categoryId) items = items.filter((p) => p.categoryId === categoryId);
+    if (minPrice !== undefined) items = items.filter((p) => p.price >= minPrice);
+    if (maxPrice !== undefined) items = items.filter((p) => p.price <= maxPrice);
+    if (q) {
+      const lower = q.toLowerCase();
+      items = items.filter((p) => p.name.toLowerCase().includes(lower));
+    }
+
+    // Sorting
+    if (sortBy === 'price_asc') items.sort((a, b) => a.price - b.price);
+    else if (sortBy === 'price_desc') items.sort((a, b) => b.price - a.price);
+    else items.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+
+    // Cursor-based pagination
+    let start = 0;
+    if (cursor) {
+      const idx = items.findIndex((p) => p.id === cursor);
+      if (idx !== -1) start = idx + 1;
+    }
+
+    const page = items.slice(start, start + limit);
+    const nextItem = items[start + limit];
+    const nextCursor = nextItem ? nextItem.id : null;
+
+    return { items: page.map(ProductEntity.reconstitute), nextCursor };
+  }
+
+  async create(product: ProductEntity): Promise<ProductEntity> {
+    this.store.set(product.id, product.toRecord());
+    return product;
+  }
+
+  async update(product: ProductEntity): Promise<ProductEntity> {
+    this.store.set(product.id, product.toRecord());
+    return product;
+  }
+
+  async softDelete(id: string): Promise<undefined> {
+    const props = this.store.get(id);
+    if (props) {
+      this.store.set(id, { ...props, status: ProductStatus.DELETED, updatedAt: new Date() });
+    }
+    return undefined;
+  }
+
+  async updateVariantStock(productId: string, variantId: string, newStock: number): Promise<undefined> {
+    const props = this.store.get(productId);
+    if (props) {
+      const updatedVariants = props.variants.map((v) =>
+        v.id === variantId ? { ...v, stock: newStock } : v,
+      );
+      this.store.set(productId, { ...props, variants: updatedVariants });
+    }
+    return undefined;
+  }
+
+  async slugExists(slug: string): Promise<boolean> {
+    for (const props of this.store.values()) {
+      if (props.slug === slug) return true;
+    }
+    return false;
+  }
+
+  clear(): void {
+    this.store.clear();
+  }
+}

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

@@ -0,0 +1,54 @@
+import { UserEntity } from '../../../domain/auth/user.entity';
+import type { UserRole } from '../../../domain/auth/user.entity';
+import type { IUserRepository } from '../../../domain/auth/user.repository';
+
+export class InMemoryUserRepository implements IUserRepository {
+  private readonly store = new Map<string, ReturnType<UserEntity['toRecord']>>();
+
+  async findByEmail(email: string): Promise<UserEntity | null> {
+    const record = [...this.store.values()].find(
+      (u) => u.email === email.toLowerCase(),
+    );
+    return record ? UserEntity.reconstitute(record) : null;
+  }
+
+  async findById(id: string): Promise<UserEntity | null> {
+    const record = this.store.get(id);
+    return record ? UserEntity.reconstitute(record) : null;
+  }
+
+  async create(user: UserEntity): Promise<UserEntity> {
+    this.store.set(user.id, user.toRecord());
+    return user;
+  }
+
+  async update(user: UserEntity): Promise<UserEntity> {
+    this.store.set(user.id, user.toRecord());
+    return user;
+  }
+
+  async delete(id: string): Promise<void> {
+    this.store.delete(id);
+  }
+
+  async findAll(
+    opts: { role?: UserRole; cursor?: string; limit?: number } = {},
+  ): Promise<{ items: UserEntity[]; nextCursor: string | null }> {
+    const { role, cursor, limit = 20 } = opts;
+    let all = [...this.store.values()].map((u) => UserEntity.reconstitute(u));
+    if (role) all = all.filter((u) => u.role === role);
+    all.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+    const startIdx = cursor ? all.findIndex((u) => u.id === cursor) + 1 : 0;
+    const page = all.slice(startIdx, startIdx + limit);
+    const nextCursor =
+      page.length === limit && startIdx + limit < all.length
+        ? (page[page.length - 1]!.id)
+        : null;
+    return { items: page, nextCursor };
+  }
+
+  /** Test helper — reset state between test suites */
+  clear(): void {
+    this.store.clear();
+  }
+}

package/templates/ecommerce/apps/api/src/infrastructure/persistence/prisma/auth/user.prisma.repository.ts

@@ -0,0 +1,83 @@
+import type { PrismaClient, User } from '@prisma/client';
+import { UserEntity } from '../../../../domain/auth/user.entity';
+import type { IUserRepository } from '../../../../domain/auth/user.repository';
+import type { UserRole } from '../../../../domain/auth/user.entity';
+
+function toEntity(row: User): UserEntity {
+  return UserEntity.reconstitute({
+    id: row.id,
+    name: row.name,
+    email: row.email,
+    passwordHash: row.passwordHash,
+    role: row.role as UserRole,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+  });
+}
+
+export class PrismaUserRepository implements IUserRepository {
+  constructor(private readonly db: PrismaClient) {}
+
+  async findByEmail(email: string): Promise<UserEntity | null> {
+    const row = await this.db.user.findUnique({ where: { email } });
+    return row ? toEntity(row) : null;
+  }
+
+  async findById(id: string): Promise<UserEntity | null> {
+    const row = await this.db.user.findUnique({ where: { id } });
+    return row ? toEntity(row) : null;
+  }
+
+  async create(user: UserEntity): Promise<UserEntity> {
+    const row = await this.db.user.create({
+      data: {
+        id: user.id,
+        name: user.name,
+        email: user.email,
+        passwordHash: user.passwordHash,
+        role: user.role,
+        createdAt: user.createdAt,
+        updatedAt: user.updatedAt,
+      },
+    });
+    return toEntity(row);
+  }
+
+  async update(user: UserEntity): Promise<UserEntity> {
+    const row = await this.db.user.update({
+      where: { id: user.id },
+      data: {
+        name: user.name,
+        email: user.email,
+        passwordHash: user.passwordHash,
+        role: user.role,
+      },
+    });
+    return toEntity(row);
+  }
+
+  async delete(id: string): Promise<void> {
+    await this.db.user.delete({ where: { id } });
+  }
+
+  async findAll(
+    opts: { role?: UserRole; cursor?: string; limit?: number } = {},
+  ): Promise<{ items: UserEntity[]; nextCursor: string | null }> {
+    const limit = opts.limit ?? 20;
+
+    const rows = await this.db.user.findMany({
+      where: opts.role ? { role: opts.role } : undefined,
+      orderBy: { createdAt: 'desc' },
+      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 };
+  }
+}

package/templates/ecommerce/apps/api/src/infrastructure/persistence/prisma/catalog/category.prisma.repository.ts

@@ -0,0 +1,69 @@
+import type { PrismaClient, Category } from '@prisma/client';
+import { CategoryEntity } from '../../../../domain/catalog/category.entity';
+import type { ICategoryRepository } from '../../../../domain/catalog/category.repository';
+
+function toEntity(row: Category): CategoryEntity {
+  return CategoryEntity.reconstitute({
+    id: row.id,
+    name: row.name,
+    slug: row.slug,
+    description: row.description,
+    parentId: row.parentId,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+  });
+}
+
+export class PrismaCategoryRepository implements ICategoryRepository {
+  constructor(private readonly db: PrismaClient) {}
+
+  async findById(id: string): Promise<CategoryEntity | null> {
+    const row = await this.db.category.findUnique({ where: { id } });
+    return row ? toEntity(row) : null;
+  }
+
+  async findBySlug(slug: string): Promise<CategoryEntity | null> {
+    const row = await this.db.category.findUnique({ where: { slug } });
+    return row ? toEntity(row) : null;
+  }
+
+  async findAll(): Promise<CategoryEntity[]> {
+    const rows = await this.db.category.findMany({
+      orderBy: { name: 'asc' },
+    });
+    return rows.map(toEntity);
+  }
+
+  async create(category: CategoryEntity): Promise<CategoryEntity> {
+    const row = await this.db.category.create({
+      data: {
+        id: category.id,
+        name: category.name,
+        slug: category.slug,
+        description: category.description,
+        parentId: category.parentId,
+        createdAt: category.createdAt,
+        updatedAt: category.updatedAt,
+      },
+    });
+    return toEntity(row);
+  }
+
+  async update(category: CategoryEntity): Promise<CategoryEntity> {
+    const row = await this.db.category.update({
+      where: { id: category.id },
+      data: {
+        name: category.name,
+        slug: category.slug,
+        description: category.description,
+        parentId: category.parentId,
+      },
+    });
+    return toEntity(row);
+  }
+
+  async delete(id: string): Promise<undefined> {
+    await this.db.category.delete({ where: { id } });
+    return undefined;
+  }
+}

package/templates/ecommerce/apps/api/src/infrastructure/persistence/prisma/catalog/product.prisma.repository.ts

@@ -0,0 +1,185 @@
+import type { PrismaClient, Product, ProductVariant } from '@prisma/client';
+import { ProductEntity, ProductStatus } from '../../../../domain/catalog/product.entity';
+import type { IProductRepository, SearchParams, SearchResult } from '../../../../domain/catalog/product.repository';
+
+type ProductWithVariants = Product & { variants: ProductVariant[] };
+
+function toEntity(row: ProductWithVariants): ProductEntity {
+  return ProductEntity.reconstitute({
+    id: row.id,
+    name: row.name,
+    slug: row.slug,
+    description: row.description,
+    price: Number(row.price),
+    categoryId: row.categoryId,
+    status: row.status as ProductStatus,
+    images: row.images,
+    variants: row.variants.map((v) => ({
+      id: v.id,
+      productId: v.productId,
+      sku: v.sku,
+      size: v.size,
+      color: v.color,
+      stock: v.stock,
+      price: v.price !== null ? Number(v.price) : null,
+    })),
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+  });
+}
+
+const INCLUDE_VARIANTS = { variants: true } as const;
+
+export class PrismaProductRepository implements IProductRepository {
+  constructor(private readonly db: PrismaClient) {}
+
+  async findById(id: string): Promise<ProductEntity | null> {
+    const row = await this.db.product.findFirst({
+      where: { id, status: { not: 'DELETED' } },
+      include: INCLUDE_VARIANTS,
+    });
+    return row ? toEntity(row) : null;
+  }
+
+  async findBySlug(slug: string): Promise<ProductEntity | null> {
+    const row = await this.db.product.findFirst({
+      where: { slug, status: { not: 'DELETED' } },
+      include: INCLUDE_VARIANTS,
+    });
+    return row ? toEntity(row) : null;
+  }
+
+  async findAll(): Promise<ProductEntity[]> {
+    const rows = await this.db.product.findMany({
+      where: { status: 'ACTIVE' },
+      include: INCLUDE_VARIANTS,
+      orderBy: { createdAt: 'desc' },
+    });
+    return rows.map(toEntity);
+  }
+
+  async search(params: SearchParams): Promise<SearchResult> {
+    const { q, categoryId, minPrice, maxPrice, sortBy, cursor, limit = 20 } = params;
+
+    const rows = await this.db.product.findMany({
+      where: {
+        status: 'ACTIVE',
+        ...(categoryId ? { categoryId } : {}),
+        ...(q ? { name: { contains: q, mode: 'insensitive' } } : {}),
+        ...(minPrice !== undefined || maxPrice !== undefined
+          ? {
+              price: {
+                ...(minPrice !== undefined ? { gte: minPrice } : {}),
+                ...(maxPrice !== undefined ? { lte: maxPrice } : {}),
+              },
+            }
+          : {}),
+      },
+      orderBy:
+        sortBy === 'price_asc'
+          ? { price: 'asc' }
+          : sortBy === 'price_desc'
+            ? { price: 'desc' }
+            : { createdAt: 'desc' },
+      include: INCLUDE_VARIANTS,
+      take: limit + 1,
+      ...(cursor ? { cursor: { id: 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(product: ProductEntity): Promise<ProductEntity> {
+    const row = await this.db.product.create({
+      data: {
+        id: product.id,
+        name: product.name,
+        slug: product.slug,
+        description: product.description,
+        price: product.price,
+        categoryId: product.categoryId,
+        status: product.status,
+        images: product.images,
+        createdAt: product.createdAt,
+        updatedAt: product.updatedAt,
+        variants: {
+          createMany: {
+            data: product.variants.map((v) => ({
+              id: v.id,
+              sku: v.sku,
+              size: v.size,
+              color: v.color,
+              stock: v.stock,
+              price: v.price ?? null,
+            })),
+          },
+        },
+      },
+      include: INCLUDE_VARIANTS,
+    });
+    return toEntity(row);
+  }
+
+  async update(product: ProductEntity): Promise<ProductEntity> {
+    const row = await this.db.$transaction(async (tx) => {
+      // Replace all variants atomically
+      await tx.productVariant.deleteMany({ where: { productId: product.id } });
+
+      return tx.product.update({
+        where: { id: product.id },
+        data: {
+          name: product.name,
+          slug: product.slug,
+          description: product.description,
+          price: product.price,
+          categoryId: product.categoryId,
+          status: product.status,
+          images: product.images,
+          variants: {
+            createMany: {
+              data: product.variants.map((v) => ({
+                id: v.id,
+                sku: v.sku,
+                size: v.size,
+                color: v.color,
+                stock: v.stock,
+                price: v.price ?? null,
+              })),
+            },
+          },
+        },
+        include: INCLUDE_VARIANTS,
+      });
+    });
+    return toEntity(row);
+  }
+
+  async softDelete(id: string): Promise<undefined> {
+    await this.db.product.update({
+      where: { id },
+      data: { status: 'DELETED' },
+    });
+    return undefined;
+  }
+
+  async updateVariantStock(
+    productId: string,
+    variantId: string,
+    newStock: number,
+  ): Promise<undefined> {
+    await this.db.productVariant.updateMany({
+      where: { id: variantId, productId },
+      data: { stock: newStock },
+    });
+    return undefined;
+  }
+
+  async slugExists(slug: string): Promise<boolean> {
+    const count = await this.db.product.count({ where: { slug } });
+    return count > 0;
+  }
+}