@lenne.tech/cli 1.0.0 → 1.0.1

package/build/templates/claude-skills/story-tdd/code-quality.md

@@ -0,0 +1,266 @@
+---
+name: story-tdd-code-quality
+version: 1.0.0
+description: Code quality and refactoring guidelines for Test-Driven Development
+---
+
+# Code Quality & Refactoring Check
+
+**BEFORE marking the task as complete, perform a code quality review!**
+
+Once all tests are passing, analyze your implementation for code quality issues.
+
+---
+
+## 1. Check for Code Duplication
+
+**Identify redundant code patterns:**
+- Repeated logic in multiple methods
+- Similar code blocks with minor variations
+- Duplicated validation logic
+- Repeated data transformations
+- Multiple similar helper functions
+
+**Example of code duplication:**
+
+```typescript
+// ❌ BAD: Duplicated validation logic
+async createProduct(input: ProductInput) {
+  if (!input.name || input.name.trim().length === 0) {
+    throw new BadRequestException('Name is required');
+  }
+  if (!input.price || input.price <= 0) {
+    throw new BadRequestException('Price must be positive');
+  }
+  // ... create product
+}
+
+async updateProduct(id: string, input: ProductInput) {
+  if (!input.name || input.name.trim().length === 0) {
+    throw new BadRequestException('Name is required');
+  }
+  if (!input.price || input.price <= 0) {
+    throw new BadRequestException('Price must be positive');
+  }
+  // ... update product
+}
+
+// ✅ GOOD: Extracted to reusable function
+private validateProductInput(input: ProductInput) {
+  if (!input.name || input.name.trim().length === 0) {
+    throw new BadRequestException('Name is required');
+  }
+  if (!input.price || input.price <= 0) {
+    throw new BadRequestException('Price must be positive');
+  }
+}
+
+async createProduct(input: ProductInput) {
+  this.validateProductInput(input);
+  // ... create product
+}
+
+async updateProduct(id: string, input: ProductInput) {
+  this.validateProductInput(input);
+  // ... update product
+}
+```
+
+---
+
+## 2. Extract Common Functionality
+
+**Look for opportunities to create helper functions:**
+- Data transformation logic
+- Validation logic
+- Query building
+- Response formatting
+- Common calculations
+
+**Example of extracting common functionality:**
+
+```typescript
+// ❌ BAD: Repeated price calculation logic
+async createOrder(input: OrderInput) {
+  let totalPrice = 0;
+  for (const item of input.items) {
+    const product = await this.productService.findById(item.productId);
+    totalPrice += product.price * item.quantity;
+  }
+  // ... create order
+}
+
+async estimateOrderPrice(items: OrderItem[]) {
+  let totalPrice = 0;
+  for (const item of items) {
+    const product = await this.productService.findById(item.productId);
+    totalPrice += product.price * item.quantity;
+  }
+  return totalPrice;
+}
+
+// ✅ GOOD: Extracted to reusable helper
+private async calculateOrderTotal(items: OrderItem[]): Promise<number> {
+  let totalPrice = 0;
+  for (const item of items) {
+    const product = await this.productService.findById(item.productId);
+    totalPrice += product.price * item.quantity;
+  }
+  return totalPrice;
+}
+
+async createOrder(input: OrderInput) {
+  const totalPrice = await this.calculateOrderTotal(input.items);
+  // ... create order
+}
+
+async estimateOrderPrice(items: OrderItem[]) {
+  return this.calculateOrderTotal(items);
+}
+```
+
+---
+
+## 3. Consolidate Similar Code Paths
+
+**Identify code paths that can be unified:**
+- Methods with similar logic but different parameters
+- Conditional branches that can be combined
+- Similar error handling patterns
+
+**Example of consolidating code paths:**
+
+```typescript
+// ❌ BAD: Similar methods with duplicated logic
+async findProductsByCategory(category: string) {
+  return this.find({
+    where: { category },
+    relations: ['reviews', 'supplier'],
+    order: { createdAt: 'DESC' },
+  });
+}
+
+async findProductsBySupplier(supplierId: string) {
+  return this.find({
+    where: { supplierId },
+    relations: ['reviews', 'supplier'],
+    order: { createdAt: 'DESC' },
+  });
+}
+
+async findProductsByPriceRange(minPrice: number, maxPrice: number) {
+  return this.find({
+    where: { price: Between(minPrice, maxPrice) },
+    relations: ['reviews', 'supplier'],
+    order: { createdAt: 'DESC' },
+  });
+}
+
+// ✅ GOOD: Unified method with flexible filtering
+async findProducts(filters: {
+  category?: string;
+  supplierId?: string;
+  priceRange?: { min: number; max: number };
+}) {
+  const where: any = {};
+
+  if (filters.category) {
+    where.category = filters.category;
+  }
+
+  if (filters.supplierId) {
+    where.supplierId = filters.supplierId;
+  }
+
+  if (filters.priceRange) {
+    where.price = Between(filters.priceRange.min, filters.priceRange.max);
+  }
+
+  return this.find({
+    where,
+    relations: ['reviews', 'supplier'],
+    order: { createdAt: 'DESC' },
+  });
+}
+```
+
+---
+
+## 4. Review for Consistency
+
+**Ensure consistent patterns throughout your implementation:**
+- Naming conventions match existing codebase
+- Error handling follows project patterns
+- Return types are consistent
+- Similar operations use similar approaches
+
+---
+
+## 5. Refactoring Decision Tree
+
+```
+Code duplication detected?
+    │
+    ├─► Used in 2+ places?
+    │   │
+    │   ├─► YES: Extract to private method
+    │   │   │
+    │   │   └─► Used across multiple services?
+    │   │       │
+    │   │       ├─► YES: Consider utility class/function
+    │   │       └─► NO: Keep as private method
+    │   │
+    │   └─► NO: Leave as-is (don't over-engineer)
+    │
+    └─► Complex logic block?
+        │
+        ├─► Hard to understand?
+        │   └─► Extract to well-named method
+        │
+        └─► Simple and clear?
+            └─► Leave as-is
+```
+
+---
+
+## 6. Run Tests After Refactoring
+
+**CRITICAL: After any refactoring:**
+
+```bash
+npm test
+```
+
+**Ensure:**
+- ✅ All tests still pass
+- ✅ No new failures introduced
+- ✅ Code is more maintainable
+- ✅ No functionality changed
+
+---
+
+## 7. When to Skip Refactoring
+
+**Don't refactor if:**
+- Code is used in only ONE place
+- Extraction would make code harder to understand
+- The duplication is coincidental, not conceptual
+- Time constraints don't allow for safe refactoring
+
+**Remember:**
+- **Working code > Perfect code**
+- **Refactor only if it improves maintainability**
+- **Always run tests after refactoring**
+
+---
+
+## Quick Code Quality Checklist
+
+Before marking complete:
+
+- [ ] **No obvious code duplication**
+- [ ] **Common functionality extracted to helpers**
+- [ ] **Consistent patterns throughout**
+- [ ] **Code follows existing patterns**
+- [ ] **Proper error handling**
+- [ ] **Tests still pass after refactoring**

package/build/templates/claude-skills/story-tdd/database-indexes.md

@@ -0,0 +1,173 @@
+---
+name: story-tdd-database-indexes
+version: 1.0.0
+description: Database index guidelines for @UnifiedField decorator - keep indexes visible with properties
+---
+
+# 🔍 Database Indexes with @UnifiedField
+
+**IMPORTANT: Always define indexes directly in the @UnifiedField decorator!**
+
+This keeps indexes visible right where properties are defined, making them easy to spot during code reviews.
+
+---
+
+## When to Add Indexes
+
+- ✅ Fields used in queries (find, filter, search)
+- ✅ Foreign keys (references to other collections)
+- ✅ Fields used in sorting operations
+- ✅ Unique constraints (email, username, etc.)
+- ✅ Fields frequently accessed together (compound indexes)
+
+---
+
+## Example Patterns
+
+### Single Field Index
+
+```typescript
+@UnifiedField({
+  description: 'User email address',
+  mongoose: { index: true, unique: true, type: String }  // ✅ Simple index + unique constraint
+})
+email: string;
+```
+
+### Compound Index
+
+```typescript
+@UnifiedField({
+  description: 'Product category',
+  mongoose: { index: true, type: String }  // ✅ Part of compound index
+})
+category: string;
+
+@UnifiedField({
+  description: 'Product status',
+  mongoose: { index: true, type: String }  // ✅ Part of compound index
+})
+status: string;
+
+// Both fields indexed individually for flexible querying
+```
+
+### Text Index for Search
+
+```typescript
+@UnifiedField({
+  description: 'Product name',
+  mongoose: { type: String, text: true }  // ✅ Full-text search index
+})
+name: string;
+```
+
+### Foreign Key Index
+
+```typescript
+@UnifiedField({
+  description: 'Reference to user who created this',
+  mongoose: { index: true, type: String }  // ✅ Index for JOIN operations
+})
+createdBy: string;
+```
+
+---
+
+## ⚠️ DON'T Create Indexes Separately!
+
+```typescript
+// ❌ WRONG: Separate schema index definition
+@Schema()
+export class Product {
+  @UnifiedField({
+    description: 'Category',
+    mongoose: { type: String }
+  })
+  category: string;
+}
+
+ProductSchema.index({ category: 1 }); // ❌ Index hidden away from property
+
+// ✅ CORRECT: Index in decorator mongoose option
+@Schema()
+export class Product {
+  @UnifiedField({
+    description: 'Category',
+    mongoose: { index: true, type: String }  // ✅ Immediately visible
+  })
+  category: string;
+}
+```
+
+---
+
+## Benefits of Decorator-Based Indexes
+
+- ✅ Indexes visible when reviewing properties
+- ✅ No need to search schema files
+- ✅ Clear documentation of query patterns
+- ✅ Easier to maintain and update
+- ✅ Self-documenting code
+
+---
+
+## Index Verification Checklist
+
+**Look for fields that should have indexes:**
+- Fields used in find/filter operations
+- Foreign keys (userId, productId, etc.)
+- Fields used in sorting (createdAt, updatedAt, name)
+- Unique fields (email, username, slug)
+
+**Example check:**
+
+```typescript
+// Service has this query:
+const orders = await this.orderService.find({
+  where: { customerId: userId, status: 'pending' }
+});
+
+// ✅ Model should have indexes:
+export class Order {
+  @UnifiedField({
+    description: 'Customer reference',
+    mongoose: { index: true, type: String }  // ✅ Used in queries
+  })
+  customerId: string;
+
+  @UnifiedField({
+    description: 'Order status',
+    mongoose: { index: true, type: String }  // ✅ Used in filtering
+  })
+  status: string;
+}
+```
+
+---
+
+## Red Flags - Missing Indexes
+
+🚩 **Check for these issues:**
+- Service queries a field but model has no index
+- Foreign key fields without index
+- Unique constraints not marked in decorator
+- Fields used in sorting without index
+
+**If indexes are missing:**
+1. Add them to the @UnifiedField decorator immediately
+2. Re-run tests to ensure everything still works
+3. Document why the index is needed (query pattern)
+
+---
+
+## Quick Index Checklist
+
+Before marking complete:
+
+- [ ] **Fields used in find() queries have indexes**
+- [ ] **Foreign keys (userId, productId, etc.) have indexes**
+- [ ] **Unique fields (email, username) marked with unique: true**
+- [ ] **Fields used in sorting have indexes**
+- [ ] **All indexes in @UnifiedField decorator (NOT separate schema)**
+- [ ] **Indexes match query patterns in services**