speedrun-cli 2.6.1

package/templates/base-crud-typeorm/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-typeorm/src/modules/products/products.module.ts

@@ -0,0 +1,25 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { ProductsController } from './products.controller';
+import { ProductsService } from './products.service';
+import { Product } from './entities/product.entity';
+
+/**
+ * Products Module (TypeORM)
+ *
+ * Registers Product entity with TypeORM and wires the controller & service.
+ * The Product entity must also be added to the DatabaseModule's entities array.
+ *
+ * @example
+ * // In app.module.ts:
+ * import { ProductsModule } from './modules/products/products.module';
+ * @Module({ imports: [ProductsModule] })
+ * export class AppModule {}
+ */
+@Module({
+  imports: [TypeOrmModule.forFeature([Product])],
+  controllers: [ProductsController],
+  providers: [ProductsService],
+  exports: [ProductsService],
+})
+export class ProductsModule {}

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

@@ -0,0 +1,102 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository, IsNull } from 'typeorm';
+import { BaseService, IBaseRepository, PaginationQueryDto } from '../../common/base';
+import { CreateProductDto } from './dto/create-product.dto';
+import { UpdateProductDto } from './dto/update-product.dto';
+import { Product } from './entities/product.entity';
+
+/** Uniform entity alias used by the shared ProductsController */
+export type ProductEntity = Product;
+
+// ─────────────────────────────────────────────────────────────
+// TypeORM Product Repository
+//
+// Implements IBaseRepository using TypeORM's Repository<Product>.
+// Soft-delete via deletedAt column (TypeORM also supports @DeleteDateColumn).
+// ─────────────────────────────────────────────────────────────
+class TypeOrmProductRepository
+  implements IBaseRepository<Product, CreateProductDto, UpdateProductDto>
+{
+  constructor(private readonly repo: Repository<Product>) {}
+
+  async create(dto: CreateProductDto): Promise<Product> {
+    const product = this.repo.create(dto);
+    return this.repo.save(product);
+  }
+
+  async findAll(
+    pagination: PaginationQueryDto,
+  ): Promise<{ data: Product[]; total: number }> {
+    const { page = 1, limit = 10 } = pagination;
+    const skip = (page - 1) * limit;
+
+    const [data, total] = await this.repo.findAndCount({
+      where: { deletedAt: IsNull() },
+      skip,
+      take: limit,
+      order: { createdAt: 'DESC' },
+    });
+
+    return { data, total };
+  }
+
+  async findOne(id: string): Promise<Product | null> {
+    return this.repo.findOne({
+      where: { id, deletedAt: IsNull() },
+    });
+  }
+
+  async update(id: string, dto: UpdateProductDto): Promise<Product> {
+    await this.repo.update(id, dto as Partial<Product>);
+    return this.repo.findOneOrFail({ where: { id } });
+  }
+
+  async remove(id: string): Promise<Product> {
+    const product = await this.repo.findOneOrFail({ where: { id } });
+    product.deletedAt = new Date();
+    return this.repo.save(product);
+  }
+}
+
+// ─────────────────────────────────────────────────────────────
+// Products Service (TypeORM)
+// ─────────────────────────────────────────────────────────────
+@Injectable()
+export class ProductsService extends BaseService<
+  Product,
+  CreateProductDto,
+  UpdateProductDto
+> {
+  private readonly repository: TypeOrmProductRepository;
+
+  constructor(
+    @InjectRepository(Product)
+    private readonly productRepo: Repository<Product>,
+  ) {
+    super();
+    this.repository = new TypeOrmProductRepository(this.productRepo);
+  }
+
+  protected getRepository(): IBaseRepository<Product, CreateProductDto, UpdateProductDto> {
+    return this.repository;
+  }
+
+  /** Find by SKU — domain-specific method */
+  async findBySku(sku: string): Promise<Product> {
+    const product = await this.productRepo.findOne({
+      where: { sku, deletedAt: IsNull() },
+    });
+    if (!product) {
+      throw new NotFoundException(`Product with SKU "${sku}" was not found`);
+    }
+    return product;
+  }
+
+  /** Adjust stock delta */
+  async adjustStock(id: string, delta: number): Promise<Product> {
+    await this.findOne(id);
+    await this.productRepo.increment({ id }, 'stock', delta);
+    return this.productRepo.findOneOrFail({ where: { id } });
+  }
+}

package/templates/database/mongodb/.env.example

@@ -0,0 +1,22 @@
+# Database Configuration
+DATABASE_URL=mongodb://user:password@localhost:27017/database_name
+
+# JWT Configuration
+JWT_ACCESS_SECRET=your_jwt_access_secret_key_here_minimum_32_characters
+JWT_REFRESH_SECRET=your_jwt_refresh_secret_key_here_minimum_32_characters
+# Token expiration (format: {number}{unit} where unit = s|m|h|d)
+JWT_ACCESS_EXPIRY=60m
+JWT_REFRESH_EXPIRY=30d
+
+# Server Configuration
+PORT=8080
+NODE_ENV=development
+
+# CORS Configuration
+# Single origin: http://localhost:3000
+# Multiple origins: http://localhost:3000,https://app.example.com
+# Wildcard (use with caution): *
+CORS_ORIGIN=http://localhost:3000
+
+# Logging
+LOG_LEVEL=info

package/templates/database/mysql/.env.example

@@ -0,0 +1,24 @@
+# Database Configuration
+DATABASE_URL=mysql://user:password@localhost:3306/database_name
+# DB_TYPE is used by TypeORM (postgres, mysql, sqlite)
+DB_TYPE=mysql
+
+# JWT Configuration
+JWT_ACCESS_SECRET=your_jwt_access_secret_key_here_minimum_32_characters
+JWT_REFRESH_SECRET=your_jwt_refresh_secret_key_here_minimum_32_characters
+# Token expiration (format: {number}{unit} where unit = s|m|h|d)
+JWT_ACCESS_EXPIRY=60m
+JWT_REFRESH_EXPIRY=30d
+
+# Server Configuration
+PORT=8080
+NODE_ENV=development
+
+# CORS Configuration
+# Single origin: http://localhost:3000
+# Multiple origins: http://localhost:3000,https://app.example.com
+# Wildcard (use with caution): *
+CORS_ORIGIN=http://localhost:3000
+
+# Logging
+LOG_LEVEL=info

package/templates/database/mysql/drizzle.config.ts

@@ -0,0 +1,13 @@
+import type { Config } from 'drizzle-kit';
+import * as dotenv from 'dotenv';
+
+dotenv.config();
+
+export default {
+  schema: './src/database/schema.ts',
+  out: './drizzle',
+  dialect: 'mysql',
+  dbCredentials: {
+    url: process.env.DATABASE_URL!,
+  },
+} satisfies Config;

package/templates/database/mysql/package.json

@@ -0,0 +1,5 @@
+{
+  "dependencies": {
+    "mysql2": "^3.9.1"
+  }
+}

package/templates/database/mysql/prisma/schema.prisma

@@ -0,0 +1,55 @@
+// This is your Prisma schema file for MySQL
+// learn more about it in the docs: https://pris.ly/d/prisma-schema
+
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "mysql"
+  url      = env("DATABASE_URL")
+}
+
+// Enums
+enum UserRole {
+  USER
+  ADMIN
+}
+
+// Tables
+model User {
+  id        String   @id @default(uuid())
+  fullName  String   @db.VarChar(100)
+  email     String   @unique @db.VarChar(100)
+  passwordHash String @db.Text
+  role      UserRole @default(USER)
+
+  refreshToken String? @db.Text  // Legacy field - kept for backward compatibility
+  isActive  Boolean  @default(true) // for soft delete
+
+  // Relations
+  refreshTokens RefreshToken[]
+
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  @@map("users")
+}
+
+model RefreshToken {
+  id        String   @id @default(uuid())
+  token     String   @db.Text
+  userId    String
+  user      User     @relation(fields: [userId], references: [id], onDelete: Cascade)
+  
+  deviceInfo String? @db.VarChar(255)
+  ipAddress  String? @db.VarChar(45)
+  
+  expiresAt DateTime
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  @@index([userId])
+  @@index([token(length: 255)])
+  @@map("refresh_tokens")
+}

package/templates/database/mysql/src/database/drizzle.ts

@@ -0,0 +1,13 @@
+import { drizzle } from 'drizzle-orm/mysql2';
+import mysql from 'mysql2/promise';
+import * as schema from './schema';
+
+// Create MySQL connection pool
+const pool = mysql.createPool({
+  uri: process.env.DATABASE_URL,
+});
+
+// Create drizzle instance with schema
+export const db = drizzle(pool, { schema, mode: 'default' });
+
+export type DrizzleDB = typeof db;

package/templates/database/mysql/src/database/schema.ts

@@ -0,0 +1,58 @@
+import {
+  mysqlTable,
+  varchar,
+  text,
+  timestamp,
+  boolean,
+  mysqlEnum,
+} from 'drizzle-orm/mysql-core';
+import { relations } from 'drizzle-orm';
+
+// Role enum
+export const roleEnum = mysqlEnum('role', ['USER', 'ADMIN']);
+
+// Users table
+export const users = mysqlTable('users', {
+  id: varchar('id', { length: 36 }).primaryKey().$defaultFn(() => crypto.randomUUID()),
+  name: varchar('name', { length: 255 }).notNull(),
+  email: varchar('email', { length: 255 }).notNull().unique(),
+  password: text('password').notNull(),
+  role: roleEnum.default('USER').notNull(),
+  createdAt: timestamp('created_at').defaultNow().notNull(),
+  updatedAt: timestamp('updated_at').defaultNow().notNull().$onUpdate(() => new Date()),
+});
+
+// Refresh tokens table
+export const refreshTokens = mysqlTable('refresh_tokens', {
+  id: varchar('id', { length: 36 }).primaryKey().$defaultFn(() => crypto.randomUUID()),
+  token: text('token').notNull(),
+  userId: varchar('user_id', { length: 36 })
+    .notNull()
+    .references(() => users.id, { onDelete: 'cascade' }),
+  userAgent: varchar('user_agent', { length: 500 }).notNull(),
+  ipAddress: varchar('ip_address', { length: 45 }).notNull(),
+  expiresAt: timestamp('expires_at').notNull(),
+  isRevoked: boolean('is_revoked').default(false).notNull(),
+  createdAt: timestamp('created_at').defaultNow().notNull(),
+  updatedAt: timestamp('updated_at').defaultNow().notNull().$onUpdate(() => new Date()),
+});
+
+// Relations
+export const usersRelations = relations(users, ({ many }) => ({
+  refreshTokens: many(refreshTokens),
+}));
+
+export const refreshTokensRelations = relations(refreshTokens, ({ one }) => ({
+  user: one(users, {
+    fields: [refreshTokens.userId],
+    references: [users.id],
+  }),
+}));
+
+// Types
+export type User = typeof users.$inferSelect;
+export type NewUser = typeof users.$inferInsert;
+export type RefreshToken = typeof refreshTokens.$inferSelect;
+export type NewRefreshToken = typeof refreshTokens.$inferInsert;
+
+export type Role = 'USER' | 'ADMIN';

package/templates/database/postgres/.env.example

@@ -0,0 +1,24 @@
+# Database Configuration
+DATABASE_URL=postgresql://user:password@localhost:5432/database_name
+# DB_TYPE is used by TypeORM (postgres, mysql, sqlite)
+DB_TYPE=postgres
+
+# JWT Configuration
+JWT_ACCESS_SECRET=your_jwt_access_secret_key_here_minimum_32_characters
+JWT_REFRESH_SECRET=your_jwt_refresh_secret_key_here_minimum_32_characters
+# Token expiration (format: {number}{unit} where unit = s|m|h|d)
+JWT_ACCESS_EXPIRY=60m
+JWT_REFRESH_EXPIRY=30d
+
+# Server Configuration
+PORT=8080
+NODE_ENV=development
+
+# CORS Configuration
+# Single origin: http://localhost:3000
+# Multiple origins: http://localhost:3000,https://app.example.com
+# Wildcard (use with caution): *
+CORS_ORIGIN=http://localhost:3000
+
+# Logging
+LOG_LEVEL=info

package/templates/database/postgres/drizzle.config.ts

@@ -0,0 +1,13 @@
+import type { Config } from 'drizzle-kit';
+import * as dotenv from 'dotenv';
+
+dotenv.config();
+
+export default {
+  schema: './src/database/schema.ts',
+  out: './drizzle',
+  dialect: 'postgresql',
+  dbCredentials: {
+    url: process.env.DATABASE_URL!,
+  },
+} satisfies Config;

package/templates/database/postgres/package.json

@@ -0,0 +1,8 @@
+{
+  "dependencies": {
+    "pg": "^8.13.0"
+  },
+  "devDependencies": {
+    "@types/pg": "^8.11.10"
+  }
+}

package/templates/database/postgres/prisma/schema.prisma

@@ -0,0 +1,55 @@
+// This is your Prisma schema file for PostgreSQL
+// learn more about it in the docs: https://pris.ly/d/prisma-schema
+
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "postgresql"
+  url      = env("DATABASE_URL")
+}
+
+// Enums
+enum UserRole {
+  USER
+  ADMIN
+}
+
+// Tables
+model User {
+  id        String   @id @default(uuid())
+  fullName  String   @db.VarChar(100)
+  email     String   @unique @db.VarChar(100)
+  passwordHash String @db.Text
+  role      UserRole @default(USER)
+
+  refreshToken String? @db.Text  // Legacy field - kept for backward compatibility
+  isActive  Boolean  @default(true) // for soft delete
+
+  // Relations
+  refreshTokens RefreshToken[]
+
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  @@map("users")
+}
+
+model RefreshToken {
+  id        String   @id @default(uuid())
+  token     String   @db.Text
+  userId    String
+  user      User     @relation(fields: [userId], references: [id], onDelete: Cascade)
+  
+  deviceInfo String? @db.VarChar(255)
+  ipAddress  String? @db.VarChar(45)
+  
+  expiresAt DateTime
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  @@index([userId])
+  @@index([token])
+  @@map("refresh_tokens")
+}

package/templates/database/sqlite/.env.example

@@ -0,0 +1,24 @@
+# Database Configuration
+DATABASE_URL=file:./dev.db
+# DB_TYPE is used by TypeORM (postgres, mysql, sqlite)
+DB_TYPE=sqlite
+
+# JWT Configuration
+JWT_ACCESS_SECRET=your_jwt_access_secret_key_here_minimum_32_characters
+JWT_REFRESH_SECRET=your_jwt_refresh_secret_key_here_minimum_32_characters
+# Token expiration (format: {number}{unit} where unit = s|m|h|d)
+JWT_ACCESS_EXPIRY=60m
+JWT_REFRESH_EXPIRY=30d
+
+# Server Configuration
+PORT=8080
+NODE_ENV=development
+
+# CORS Configuration
+# Single origin: http://localhost:3000
+# Multiple origins: http://localhost:3000,https://app.example.com
+# Wildcard (use with caution): *
+CORS_ORIGIN=http://localhost:3000
+
+# Logging
+LOG_LEVEL=info

package/templates/database/sqlite/drizzle.config.ts

@@ -0,0 +1,13 @@
+import type { Config } from 'drizzle-kit';
+import * as dotenv from 'dotenv';
+
+dotenv.config();
+
+export default {
+  schema: './src/database/schema.ts',
+  out: './drizzle',
+  dialect: 'sqlite',
+  dbCredentials: {
+    url: process.env.DATABASE_URL!,
+  },
+} satisfies Config;

package/templates/database/sqlite/package.json

@@ -0,0 +1,8 @@
+{
+  "dependencies": {
+    "better-sqlite3": "^9.4.3"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.8"
+  }
+}

package/templates/database/sqlite/prisma/schema.prisma

@@ -0,0 +1,48 @@
+// This is your Prisma schema file for SQLite
+// learn more about it in the docs: https://pris.ly/d/prisma-schema
+
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "sqlite"
+  url      = env("DATABASE_URL")
+}
+
+// Tables (SQLite doesn't support enums, using String instead)
+model User {
+  id        String   @id @default(uuid())
+  fullName  String
+  email     String   @unique
+  passwordHash String
+  role      String   @default("USER") // USER or ADMIN
+
+  refreshToken String?
+  isActive  Boolean  @default(true)
+
+  // Relations
+  refreshTokens RefreshToken[]
+
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  @@map("users")
+}
+
+model RefreshToken {
+  id        String   @id @default(uuid())
+  token     String
+  userId    String
+  user      User     @relation(fields: [userId], references: [id], onDelete: Cascade)
+  
+  deviceInfo String?
+  ipAddress  String?
+  
+  expiresAt DateTime
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  @@index([userId])
+  @@map("refresh_tokens")
+}

package/templates/database/sqlite/src/database/drizzle.ts

@@ -0,0 +1,11 @@
+import { drizzle } from 'drizzle-orm/better-sqlite3';
+import Database from 'better-sqlite3';
+import * as schema from './schema';
+
+// Create SQLite database connection
+const sqlite = new Database(process.env.DATABASE_URL?.replace('file:', '') || './dev.db');
+
+// Create drizzle instance with schema
+export const db = drizzle(sqlite, { schema });
+
+export type DrizzleDB = typeof db;

package/templates/database/sqlite/src/database/schema.ts

@@ -0,0 +1,52 @@
+import {
+  sqliteTable,
+  text,
+  integer,
+} from 'drizzle-orm/sqlite-core';
+import { relations, sql } from 'drizzle-orm';
+
+// Users table (SQLite doesn't support enums, using text)
+export const users = sqliteTable('users', {
+  id: text('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
+  name: text('name').notNull(),
+  email: text('email').notNull().unique(),
+  password: text('password').notNull(),
+  role: text('role', { enum: ['USER', 'ADMIN'] }).default('USER').notNull(),
+  createdAt: integer('created_at', { mode: 'timestamp' }).default(sql`(unixepoch())`).notNull(),
+  updatedAt: integer('updated_at', { mode: 'timestamp' }).default(sql`(unixepoch())`).notNull(),
+});
+
+// Refresh tokens table
+export const refreshTokens = sqliteTable('refresh_tokens', {
+  id: text('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
+  token: text('token').notNull(),
+  userId: text('user_id')
+    .notNull()
+    .references(() => users.id, { onDelete: 'cascade' }),
+  userAgent: text('user_agent').notNull(),
+  ipAddress: text('ip_address').notNull(),
+  expiresAt: integer('expires_at', { mode: 'timestamp' }).notNull(),
+  isRevoked: integer('is_revoked', { mode: 'boolean' }).default(false).notNull(),
+  createdAt: integer('created_at', { mode: 'timestamp' }).default(sql`(unixepoch())`).notNull(),
+  updatedAt: integer('updated_at', { mode: 'timestamp' }).default(sql`(unixepoch())`).notNull(),
+});
+
+// Relations
+export const usersRelations = relations(users, ({ many }) => ({
+  refreshTokens: many(refreshTokens),
+}));
+
+export const refreshTokensRelations = relations(refreshTokens, ({ one }) => ({
+  user: one(users, {
+    fields: [refreshTokens.userId],
+    references: [users.id],
+  }),
+}));
+
+// Types
+export type User = typeof users.$inferSelect;
+export type NewUser = typeof users.$inferInsert;
+export type RefreshToken = typeof refreshTokens.$inferSelect;
+export type NewRefreshToken = typeof refreshTokens.$inferInsert;
+
+export type Role = 'USER' | 'ADMIN';