speedrun-cli 2.6.1

package/templates/base-crud-drizzle/src/modules/products/products.module.ts

@@ -0,0 +1,24 @@
+import { Module } from '@nestjs/common';
+import { ProductsController } from './products.controller';
+import { ProductsService } from './products.service';
+import { DatabaseModule } from '../../database/database.module';
+
+/**
+ * Products Module (Drizzle)
+ *
+ * DatabaseModule is @Global() so DRIZZLE token is available app-wide,
+ * but we import it here explicitly for documentation clarity.
+ *
+ * @example
+ * // In app.module.ts:
+ * import { ProductsModule } from './modules/products/products.module';
+ * @Module({ imports: [ProductsModule] })
+ * export class AppModule {}
+ */
+@Module({
+  imports: [DatabaseModule],
+  controllers: [ProductsController],
+  providers: [ProductsService],
+  exports: [ProductsService],
+})
+export class ProductsModule {}

package/templates/base-crud-drizzle/src/modules/products/products.service.ts

@@ -0,0 +1,140 @@
+import { Injectable, Inject, NotFoundException } from '@nestjs/common';
+import { eq, isNull, and, sql } from 'drizzle-orm';
+import { NodePgDatabase } from 'drizzle-orm/node-postgres';
+import { DRIZZLE } from '../../database/database.module';
+import { BaseService, IBaseRepository, PaginationQueryDto } from '../../common/base';
+import { CreateProductDto } from './dto/create-product.dto';
+import { UpdateProductDto } from './dto/update-product.dto';
+import { products, Product } from './schema/products.schema';
+
+/** Uniform entity alias used by the shared ProductsController */
+export type ProductEntity = Product;
+
+// ─────────────────────────────────────────────────────────────
+// Drizzle Product Repository
+// ─────────────────────────────────────────────────────────────
+class DrizzleProductRepository
+  implements IBaseRepository<Product, CreateProductDto, UpdateProductDto>
+{
+  constructor(private readonly db: NodePgDatabase) {}
+
+  async create(dto: CreateProductDto): Promise<Product> {
+    const [product] = await this.db
+      .insert(products)
+      .values({
+        name: dto.name,
+        description: dto.description,
+        sku: dto.sku,
+        price: String(dto.price),  // Drizzle numeric → string
+        stock: dto.stock,
+        category: dto.category,
+        status: dto.status as Product['status'],
+      })
+      .returning();
+    return product;
+  }
+
+  async findAll(
+    pagination: PaginationQueryDto,
+  ): Promise<{ data: Product[]; total: number }> {
+    const { page = 1, limit = 10 } = pagination;
+    const offset = (page - 1) * limit;
+
+    const [data, [{ count }]] = await Promise.all([
+      this.db
+        .select()
+        .from(products)
+        .where(isNull(products.deletedAt))
+        .orderBy(sql`${products.createdAt} DESC`)
+        .limit(limit)
+        .offset(offset),
+      this.db
+        .select({ count: sql<number>`count(*)::int` })
+        .from(products)
+        .where(isNull(products.deletedAt)),
+    ]);
+
+    return { data, total: count };
+  }
+
+  async findOne(id: string): Promise<Product | null> {
+    const [product] = await this.db
+      .select()
+      .from(products)
+      .where(and(eq(products.id, id), isNull(products.deletedAt)));
+    return product ?? null;
+  }
+
+  async update(id: string, dto: UpdateProductDto): Promise<Product> {
+    const updateData: Partial<typeof products.$inferInsert> = {};
+    if (dto.name !== undefined) updateData.name = dto.name;
+    if (dto.description !== undefined) updateData.description = dto.description;
+    if (dto.sku !== undefined) updateData.sku = dto.sku;
+    if (dto.price !== undefined) updateData.price = String(dto.price);
+    if (dto.stock !== undefined) updateData.stock = dto.stock;
+    if (dto.category !== undefined) updateData.category = dto.category;
+    if (dto.status !== undefined) updateData.status = dto.status as Product['status'];
+    updateData.updatedAt = new Date();
+
+    const [updated] = await this.db
+      .update(products)
+      .set(updateData)
+      .where(eq(products.id, id))
+      .returning();
+    return updated;
+  }
+
+  async remove(id: string): Promise<Product> {
+    const [deleted] = await this.db
+      .update(products)
+      .set({ deletedAt: new Date() })
+      .where(eq(products.id, id))
+      .returning();
+    return deleted;
+  }
+}
+
+// ─────────────────────────────────────────────────────────────
+// Products Service (Drizzle)
+// ─────────────────────────────────────────────────────────────
+@Injectable()
+export class ProductsService extends BaseService<
+  Product,
+  CreateProductDto,
+  UpdateProductDto
+> {
+  private readonly repository: DrizzleProductRepository;
+
+  constructor(@Inject(DRIZZLE) private readonly db: NodePgDatabase) {
+    super();
+    this.repository = new DrizzleProductRepository(this.db);
+  }
+
+  protected getRepository(): IBaseRepository<Product, CreateProductDto, UpdateProductDto> {
+    return this.repository;
+  }
+
+  /** Find by SKU */
+  async findBySku(sku: string): Promise<Product> {
+    const [product] = await this.db
+      .select()
+      .from(products)
+      .where(and(eq(products.sku, sku), isNull(products.deletedAt)));
+
+    if (!product) {
+      throw new NotFoundException(`Product with SKU "${sku}" was not found`);
+    }
+    return product;
+  }
+
+  /** Adjust stock */
+  async adjustStock(id: string, delta: number): Promise<Product> {
+    await this.findOne(id);
+    const [updated] = await this.db
+      .update(products)
+      .set({ stock: sql`${products.stock} + ${delta}` })
+      .where(eq(products.id, id))
+      .returning();
+    return updated;
+  }
+}

package/templates/base-crud-drizzle/src/modules/products/schema/products.schema.ts

@@ -0,0 +1,39 @@
+import {
+  pgTable,
+  varchar,
+  text,
+  timestamp,
+  integer,
+  numeric,
+  pgEnum,
+  uuid,
+} from 'drizzle-orm/pg-core';
+
+// ProductStatus enum
+export const productStatusEnum = pgEnum('product_status', [
+  'ACTIVE',
+  'INACTIVE',
+  'OUT_OF_STOCK',
+  'DISCONTINUED',
+]);
+
+// Products table
+export const products = pgTable('products', {
+  id: uuid('id').defaultRandom().primaryKey(),
+  name: varchar('name', { length: 150 }).notNull(),
+  description: text('description'),
+  sku: varchar('sku', { length: 50 }).notNull().unique(),
+  price: numeric('price', { precision: 10, scale: 2 }).notNull(),
+  stock: integer('stock').default(0).notNull(),
+  category: varchar('category', { length: 100 }),
+  status: productStatusEnum('status').default('ACTIVE').notNull(),
+  createdAt: timestamp('created_at').defaultNow().notNull(),
+  updatedAt: timestamp('updated_at').defaultNow().notNull(),
+  deletedAt: timestamp('deleted_at'),
+});
+
+// Inferred types
+export type Product = typeof products.$inferSelect;
+export type NewProduct = typeof products.$inferInsert;
+
+export type ProductStatus = 'ACTIVE' | 'INACTIVE' | 'OUT_OF_STOCK' | 'DISCONTINUED';

package/templates/base-crud-mongoose/src/modules/products/products.controller.ts

@@ -0,0 +1,79 @@
+import {
+  Controller,
+  Get,
+  Param,
+  Query,
+  ParseUUIDPipe,
+  HttpStatus,
+  Type,
+} from '@nestjs/common';
+import {
+  ApiTags,
+  ApiOperation,
+  ApiResponse,
+  ApiBearerAuth,
+  ApiExtraModels,
+  ApiParam,
+} from '@nestjs/swagger';
+import { BaseController } from '../../common/base/base.controller';
+import {
+  ApiResponseDto,
+  ApiResponseSchema,
+  PaginatedResponseDto,
+  PaginatedResponseSchema,
+  PaginationQueryDto,
+} from '../../common/base';
+import { ProductsService, ProductEntity } from './products.service';
+import { CreateProductDto } from './dto/create-product.dto';
+import { UpdateProductDto } from './dto/update-product.dto';
+import { ProductDto } from './dto/product.dto';
+
+@ApiTags('Products')
+@ApiBearerAuth('bearer')
+@ApiExtraModels(ApiResponseDto, PaginatedResponseDto, ProductDto)
+@Controller('products')
+export class ProductsController extends BaseController<
+  ProductEntity,
+  CreateProductDto,
+  UpdateProductDto
+> {
+  constructor(private readonly productsService: ProductsService) {
+    super(productsService);
+  }
+
+  protected getDtoClass(): Type<ProductEntity> {
+    return ProductDto as unknown as Type<ProductEntity>;
+  }
+
+  @Get()
+  @ApiOperation({ summary: 'Get all products (paginated)' })
+  @ApiResponse({ status: HttpStatus.OK, schema: PaginatedResponseSchema(ProductDto) })
+  @ApiResponse({ status: HttpStatus.UNAUTHORIZED, description: 'Unauthorized' })
+  override async findAll(@Query() pagination: PaginationQueryDto): Promise<PaginatedResponseDto<ProductEntity>> {
+    return super.findAll(pagination);
+  }
+
+  @Get('by-sku/:sku')
+  @ApiOperation({ summary: 'Get a product by SKU' })
+  @ApiParam({ name: 'sku', example: 'KB-WL-MEC-001' })
+  @ApiResponse({ status: HttpStatus.OK, schema: ApiResponseSchema(ProductDto) })
+  @ApiResponse({ status: HttpStatus.NOT_FOUND, description: 'Product not found' })
+  async findBySku(@Param('sku') sku: string): Promise<ApiResponseDto<ProductEntity>> {
+    const data = await this.productsService.findBySku(sku);
+    return { success: true, data, meta: { correlationId: '', timestamp: new Date().toISOString() } };
+  }
+
+  @Get(':id')
+  @ApiOperation({ summary: 'Get a product by ID' })
+  @ApiParam({ name: 'id', format: 'uuid', example: '123e4567-e89b-12d3-a456-426614174000' })
+  @ApiResponse({ status: HttpStatus.OK, schema: ApiResponseSchema(ProductDto) })
+  @ApiResponse({ status: HttpStatus.NOT_FOUND, description: 'Product not found' })
+  @ApiResponse({ status: HttpStatus.BAD_REQUEST, description: 'Invalid UUID' })
+  override async findOne(
+    @Param('id', new ParseUUIDPipe({ version: '4', errorHttpStatusCode: HttpStatus.BAD_REQUEST }))
+    id: string,
+  ): Promise<ApiResponseDto<ProductEntity>> {
+    return super.findOne(id);
+  }
+}
+

package/templates/base-crud-mongoose/src/modules/products/products.module.ts

@@ -0,0 +1,26 @@
+import { Module } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { ProductsController } from './products.controller';
+import { ProductsService } from './products.service';
+import { Product, ProductSchema } from './schemas/product.schema';
+
+/**
+ * Products Module (Mongoose)
+ *
+ * Registers Product schema with MongooseModule.forFeature.
+ *
+ * @example
+ * // In app.module.ts:
+ * import { ProductsModule } from './modules/products/products.module';
+ * @Module({ imports: [ProductsModule] })
+ * export class AppModule {}
+ */
+@Module({
+  imports: [
+    MongooseModule.forFeature([{ name: Product.name, schema: ProductSchema }]),
+  ],
+  controllers: [ProductsController],
+  providers: [ProductsService],
+  exports: [ProductsService],
+})
+export class ProductsModule {}

package/templates/base-crud-mongoose/src/modules/products/products.service.ts

@@ -0,0 +1,133 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import { BaseService, IBaseRepository, PaginationQueryDto } from '../../common/base';
+import { CreateProductDto } from './dto/create-product.dto';
+import { UpdateProductDto } from './dto/update-product.dto';
+import { Product, ProductDocument, ProductStatus } from './schemas/product.schema';
+
+/** Lean plain-object type returned from Mongoose .lean() queries */
+export type LeanProduct = {
+  id: string;
+  name: string;
+  description?: string;
+  sku: string;
+  price: number;
+  stock: number;
+  category?: string;
+  status: ProductStatus;
+  createdAt: Date;
+  updatedAt: Date;
+  deletedAt?: Date | null;
+};
+
+/** Uniform entity alias used by the shared ProductsController */
+export type ProductEntity = LeanProduct;
+
+// ─────────────────────────────────────────────────────────────
+// Mongoose Product Repository
+// ─────────────────────────────────────────────────────────────
+class MongooseProductRepository
+  implements IBaseRepository<LeanProduct, CreateProductDto, UpdateProductDto>
+{
+  constructor(private readonly model: Model<ProductDocument>) {}
+
+  async create(dto: CreateProductDto): Promise<LeanProduct> {
+    const created = await this.model.create(dto);
+    return created.toJSON() as LeanProduct;
+  }
+
+  async findAll(
+    pagination: PaginationQueryDto,
+  ): Promise<{ data: LeanProduct[]; total: number }> {
+    const { page = 1, limit = 10 } = pagination;
+    const skip = (page - 1) * limit;
+    const filter = { deletedAt: null };
+
+    const [data, total] = await Promise.all([
+      this.model
+        .find(filter)
+        .sort({ createdAt: -1 })
+        .skip(skip)
+        .limit(limit)
+        .lean<LeanProduct[]>({ virtuals: true }),
+      this.model.countDocuments(filter),
+    ]);
+
+    return { data, total };
+  }
+
+  async findOne(id: string): Promise<LeanProduct | null> {
+    return this.model
+      .findOne({ _id: id, deletedAt: null })
+      .lean<LeanProduct>({ virtuals: true });
+  }
+
+  async update(id: string, dto: UpdateProductDto): Promise<LeanProduct> {
+    return this.model
+      .findByIdAndUpdate(
+        id,
+        { $set: dto },
+        { new: true, runValidators: true },
+      )
+      .lean<LeanProduct>({ virtuals: true }) as Promise<LeanProduct>;
+  }
+
+  async remove(id: string): Promise<LeanProduct> {
+    return this.model
+      .findByIdAndUpdate(
+        id,
+        { $set: { deletedAt: new Date() } },
+        { new: true },
+      )
+      .lean<LeanProduct>({ virtuals: true }) as Promise<LeanProduct>;
+  }
+}
+
+// ─────────────────────────────────────────────────────────────
+// Products Service (Mongoose)
+// ─────────────────────────────────────────────────────────────
+@Injectable()
+export class ProductsService extends BaseService<
+  LeanProduct,
+  CreateProductDto,
+  UpdateProductDto
+> {
+  private readonly repository: MongooseProductRepository;
+
+  constructor(
+    @InjectModel(Product.name)
+    private readonly productModel: Model<ProductDocument>,
+  ) {
+    super();
+    this.repository = new MongooseProductRepository(this.productModel);
+  }
+
+  protected getRepository(): IBaseRepository<LeanProduct, CreateProductDto, UpdateProductDto> {
+    return this.repository;
+  }
+
+  /** Find by SKU */
+  async findBySku(sku: string): Promise<LeanProduct> {
+    const product = await this.productModel
+      .findOne({ sku, deletedAt: null })
+      .lean<LeanProduct>({ virtuals: true });
+
+    if (!product) {
+      throw new NotFoundException(`Product with SKU "${sku}" was not found`);
+    }
+    return product;
+  }
+
+  /** Adjust stock */
+  async adjustStock(id: string, delta: number): Promise<LeanProduct> {
+    await this.findOne(id);
+    return this.productModel
+      .findByIdAndUpdate(
+        id,
+        { $inc: { stock: delta } },
+        { new: true },
+      )
+      .lean<LeanProduct>({ virtuals: true }) as Promise<LeanProduct>;
+  }
+}

package/templates/base-crud-mongoose/src/modules/products/schemas/product.schema.ts

@@ -0,0 +1,67 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { Document, HydratedDocument } from 'mongoose';
+
+export type ProductDocument = HydratedDocument<Product>;
+
+export enum ProductStatus {
+  ACTIVE = 'ACTIVE',
+  INACTIVE = 'INACTIVE',
+  OUT_OF_STOCK = 'OUT_OF_STOCK',
+  DISCONTINUED = 'DISCONTINUED',
+}
+
+@Schema({
+  timestamps: true,
+  collection: 'products',
+  toJSON: {
+    virtuals: true,
+    transform: (_, ret: Record<string, unknown>) => {
+      ret['id'] = ret['_id'];
+      delete ret['_id'];
+      delete ret['__v'];
+      return ret;
+    },
+  },
+})
+export class Product {
+  // Virtual id field (mapped from _id)
+  id: string;
+
+  @Prop({ required: true, maxlength: 150, trim: true })
+  name: string;
+
+  @Prop({ maxlength: 1000 })
+  description?: string;
+
+  @Prop({ required: true, unique: true, uppercase: true, trim: true })
+  sku: string;
+
+  @Prop({ required: true, min: 0 })
+  price: number;
+
+  @Prop({ required: true, min: 0, default: 0 })
+  stock: number;
+
+  @Prop({ maxlength: 100 })
+  category?: string;
+
+  @Prop({
+    type: String,
+    enum: Object.values(ProductStatus),
+    default: ProductStatus.ACTIVE,
+  })
+  status: ProductStatus;
+
+  /** Soft-delete timestamp — null/undefined means record is active */
+  @Prop({ type: Date, default: null, index: true })
+  deletedAt?: Date | null;
+
+  // Timestamps added automatically by { timestamps: true }
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export const ProductSchema = SchemaFactory.createForClass(Product);
+
+// Partial index: only index active documents
+ProductSchema.index({ sku: 1 }, { unique: true, partialFilterExpression: { deletedAt: null } });

package/templates/base-crud-prisma/src/modules/products/products.module.ts

@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common';
+import { ProductsController } from './products.controller';
+import { ProductsService } from './products.service';
+import { PrismaModule } from '../../prisma/prisma.module';
+
+@Module({
+  imports: [PrismaModule],
+  controllers: [ProductsController],
+  providers: [ProductsService],
+  exports: [ProductsService],
+})
+export class ProductsModule {}

package/templates/base-crud-prisma/src/modules/products/products.service.ts

@@ -0,0 +1,100 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { PrismaService } from '../../prisma/prisma.service';
+import { BaseService, IBaseRepository, PaginationQueryDto } from '../../common/base';
+import { CreateProductDto } from './dto/create-product.dto';
+import { UpdateProductDto } from './dto/update-product.dto';
+
+// ─────────────────────────────────────────────────────────────
+// Product Entity Interface
+//
+// TODO: Once you add the Product model to prisma/schema.prisma
+//       and run `npx prisma migrate dev`, replace this interface
+//       with the generated Prisma type:
+//         import { Product } from '@prisma/client';
+//         export type ProductEntity = Product;
+//
+// Prisma schema to add:
+//   model Product {
+//     id          String    @id @default(uuid())
+//     name        String
+//     description String?
+//     sku         String    @unique
+//     price       Float
+//     stock       Int       @default(0)
+//     category    String?
+//     status      String    @default("ACTIVE")
+//     createdAt   DateTime  @default(now())
+//     updatedAt   DateTime  @updatedAt
+//     deletedAt   DateTime?
+//   }
+// ─────────────────────────────────────────────────────────────
+export interface ProductEntity {
+  id: string;
+  name: string;
+  description?: string | null;
+  sku: string;
+  price: number;
+  stock: number;
+  category?: string | null;
+  status: string;
+  createdAt: Date;
+  updatedAt: Date;
+  deletedAt?: Date | null;
+}
+
+class PrismaProductRepository
+  implements IBaseRepository<ProductEntity, CreateProductDto, UpdateProductDto>
+{
+  constructor(private readonly prisma: PrismaService) {}
+
+  async create(dto: CreateProductDto): Promise<ProductEntity> {
+    return (this.prisma as any).product.create({ data: dto }) as Promise<ProductEntity>;
+  }
+
+  async findAll(p: PaginationQueryDto): Promise<{ data: ProductEntity[]; total: number }> {
+    const { page = 1, limit = 10 } = p;
+    const skip = (page - 1) * limit;
+    const [data, total] = await this.prisma.$transaction([
+      (this.prisma as any).product.findMany({ where: { deletedAt: null }, skip, take: limit, orderBy: { createdAt: 'desc' } }),
+      (this.prisma as any).product.count({ where: { deletedAt: null } }),
+    ]);
+    return { data: data as ProductEntity[], total };
+  }
+
+  async findOne(id: string): Promise<ProductEntity | null> {
+    return (this.prisma as any).product.findFirst({ where: { id, deletedAt: null } }) as Promise<ProductEntity | null>;
+  }
+
+  async update(id: string, dto: UpdateProductDto): Promise<ProductEntity> {
+    return (this.prisma as any).product.update({ where: { id }, data: dto }) as Promise<ProductEntity>;
+  }
+
+  async remove(id: string): Promise<ProductEntity> {
+    return (this.prisma as any).product.update({ where: { id }, data: { deletedAt: new Date() } }) as Promise<ProductEntity>;
+  }
+}
+
+@Injectable()
+export class ProductsService extends BaseService<ProductEntity, CreateProductDto, UpdateProductDto> {
+  private readonly repository: PrismaProductRepository;
+
+  constructor(private readonly prisma: PrismaService) {
+    super();
+    this.repository = new PrismaProductRepository(this.prisma);
+  }
+
+  protected getRepository(): IBaseRepository<ProductEntity, CreateProductDto, UpdateProductDto> {
+    return this.repository;
+  }
+
+  async findBySku(sku: string): Promise<ProductEntity> {
+    const p = await (this.prisma as any).product.findFirst({ where: { sku, deletedAt: null } });
+    if (!p) throw new NotFoundException(`Product with SKU "${sku}" was not found`);
+    return p as ProductEntity;
+  }
+
+  async adjustStock(id: string, delta: number): Promise<ProductEntity> {
+    await this.findOne(id);
+    return (this.prisma as any).product.update({ where: { id }, data: { stock: { increment: delta } } }) as Promise<ProductEntity>;
+  }
+}

package/templates/base-crud-typeorm/src/modules/products/entities/product.entity.ts

@@ -0,0 +1,58 @@
+import {
+  Entity,
+  PrimaryGeneratedColumn,
+  Column,
+  CreateDateColumn,
+  UpdateDateColumn,
+  DeleteDateColumn,
+  Index,
+} from 'typeorm';
+
+export enum ProductStatus {
+  ACTIVE = 'ACTIVE',
+  INACTIVE = 'INACTIVE',
+  OUT_OF_STOCK = 'OUT_OF_STOCK',
+  DISCONTINUED = 'DISCONTINUED',
+}
+
+@Entity('products')
+export class Product {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column({ length: 150 })
+  name: string;
+
+  @Column({ type: 'text', nullable: true })
+  description: string | null;
+
+  @Column({ length: 50, unique: true })
+  @Index()
+  sku: string;
+
+  @Column({ type: 'decimal', precision: 10, scale: 2 })
+  price: number;
+
+  @Column({ default: 0 })
+  stock: number;
+
+  @Column({ length: 100, nullable: true })
+  category: string | null;
+
+  @Column({
+    type: 'enum',
+    enum: ProductStatus,
+    default: ProductStatus.ACTIVE,
+  })
+  status: ProductStatus;
+
+  @CreateDateColumn({ name: 'created_at' })
+  createdAt: Date;
+
+  @UpdateDateColumn({ name: 'updated_at' })
+  updatedAt: Date;
+
+  /** Soft-delete column — null means the record is active */
+  @DeleteDateColumn({ name: 'deleted_at', nullable: true })
+  deletedAt: Date | null;
+}