@stackguide/mcp-server 1.0.0

package/data/knowledge/python-django/common-issues/common-issues.md

@@ -0,0 +1,181 @@
+# Django Common Issues and Solutions
+
+Solutions to frequently encountered problems in Django development.
+
+## Database Issues
+
+### Migration Conflicts
+
+**Problem**: Multiple developers create migrations that conflict.
+
+**Solution**:
+```bash
+# Merge migrations
+python manage.py makemigrations --merge
+
+# Or squash old migrations
+python manage.py squashmigrations app_name 0001 0010
+```
+
+### Circular Import in Models
+
+**Problem**: Two models reference each other causing import errors.
+
+**Solution**:
+```python
+# Use string reference for ForeignKey
+class Article(models.Model):
+    author = models.ForeignKey(
+        "users.User",  # String reference
+        on_delete=models.CASCADE
+    )
+
+# Or use lazy import in methods
+def get_related_articles(self):
+    from articles.models import Article
+    return Article.objects.filter(author=self.author)
+```
+
+## Performance Issues
+
+### N+1 Query Problem
+
+**Problem**: Loop causes multiple database queries.
+
+**Solution**:
+```python
+# Before: N+1 queries
+for article in Article.objects.all():
+    print(article.author.name)
+
+# After: 1 query with join
+for article in Article.objects.select_related("author"):
+    print(article.author.name)
+
+# For reverse relations or M2M
+Article.objects.prefetch_related("comments", "tags")
+```
+
+### Slow QuerySet Evaluation
+
+**Problem**: Large querysets evaluated multiple times.
+
+**Solution**:
+```python
+# Cache the queryset result
+articles = list(Article.objects.all())  # Evaluate once
+
+# Or use iterator for large datasets
+for article in Article.objects.iterator(chunk_size=1000):
+    process(article)
+```
+
+## Authentication Issues
+
+### Custom User Model Not Working
+
+**Problem**: Migrated before creating custom user model.
+
+**Solution**:
+```python
+# settings.py - Set this BEFORE first migration
+AUTH_USER_MODEL = "users.User"
+
+# users/models.py
+from django.contrib.auth.models import AbstractUser
+
+class User(AbstractUser):
+    # Custom fields
+    phone = models.CharField(max_length=20, blank=True)
+```
+
+### Session Not Persisting
+
+**Problem**: User logged out unexpectedly.
+
+**Solution**:
+```python
+# Check session settings
+SESSION_COOKIE_AGE = 1209600  # 2 weeks
+SESSION_SAVE_EVERY_REQUEST = True
+SESSION_EXPIRE_AT_BROWSER_CLOSE = False
+```
+
+## Static Files Issues
+
+### Static Files Not Loading in Production
+
+**Problem**: Static files 404 in production.
+
+**Solution**:
+```python
+# settings.py
+STATIC_URL = "/static/"
+STATIC_ROOT = BASE_DIR / "staticfiles"
+
+# Run collectstatic
+# python manage.py collectstatic
+
+# Use whitenoise for serving
+MIDDLEWARE = [
+    "django.middleware.security.SecurityMiddleware",
+    "whitenoise.middleware.WhiteNoiseMiddleware",
+    # ...
+]
+STATICFILES_STORAGE = "whitenoise.storage.CompressedManifestStaticFilesStorage"
+```
+
+## Form Issues
+
+### Form Not Saving Data
+
+**Problem**: ModelForm save() not persisting to database.
+
+**Solution**:
+```python
+# Ensure commit=True or call save() on instance
+if form.is_valid():
+    instance = form.save(commit=False)
+    instance.user = request.user  # Add extra data
+    instance.save()
+    form.save_m2m()  # Save many-to-many relationships
+```
+
+### File Upload Not Working
+
+**Problem**: request.FILES is empty.
+
+**Solution**:
+```html
+<!-- Form must have enctype -->
+<form method="post" enctype="multipart/form-data">
+    {% csrf_token %}
+    {{ form }}
+    <button type="submit">Upload</button>
+</form>
+```
+
+## Celery Issues
+
+### Task Not Executing
+
+**Problem**: Celery task defined but not running.
+
+**Solution**:
+```python
+# Ensure app is loaded
+# config/__init__.py
+from .celery import app as celery_app
+__all__ = ("celery_app",)
+
+# Register task correctly
+from celery import shared_task
+
+@shared_task
+def send_email_task(email_id):
+    # Task logic
+    pass
+
+# Call with .delay() or .apply_async()
+send_email_task.delay(email.id)
+```

package/data/knowledge/python-django/patterns/drf-patterns.md

@@ -0,0 +1,133 @@
+# Django REST Framework Patterns
+
+Common patterns for building APIs with Django REST Framework.
+
+## Serializer Patterns
+
+### Nested Serializers
+
+```python
+from rest_framework import serializers
+
+class AuthorSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Author
+        fields = ["id", "name", "email"]
+
+class ArticleSerializer(serializers.ModelSerializer):
+    author = AuthorSerializer(read_only=True)
+    author_id = serializers.PrimaryKeyRelatedField(
+        queryset=Author.objects.all(),
+        write_only=True,
+        source="author"
+    )
+    
+    class Meta:
+        model = Article
+        fields = ["id", "title", "content", "author", "author_id"]
+```
+
+### Dynamic Serializers
+
+```python
+class DynamicFieldsSerializer(serializers.ModelSerializer):
+    def __init__(self, *args, **kwargs):
+        fields = kwargs.pop("fields", None)
+        super().__init__(*args, **kwargs)
+        
+        if fields is not None:
+            allowed = set(fields)
+            existing = set(self.fields)
+            for field_name in existing - allowed:
+                self.fields.pop(field_name)
+```
+
+## ViewSet Patterns
+
+### Custom Actions
+
+```python
+from rest_framework import viewsets, status
+from rest_framework.decorators import action
+from rest_framework.response import Response
+
+class ArticleViewSet(viewsets.ModelViewSet):
+    queryset = Article.objects.all()
+    serializer_class = ArticleSerializer
+    
+    @action(detail=True, methods=["post"])
+    def publish(self, request, pk=None):
+        article = self.get_object()
+        article.status = "published"
+        article.published_at = timezone.now()
+        article.save()
+        return Response({"status": "published"})
+    
+    @action(detail=False, methods=["get"])
+    def recent(self, request):
+        recent = self.queryset.order_by("-created_at")[:5]
+        serializer = self.get_serializer(recent, many=True)
+        return Response(serializer.data)
+```
+
+## Filtering and Pagination
+
+```python
+from rest_framework import filters
+from django_filters.rest_framework import DjangoFilterBackend
+
+class ArticleViewSet(viewsets.ModelViewSet):
+    queryset = Article.objects.all()
+    serializer_class = ArticleSerializer
+    filter_backends = [DjangoFilterBackend, filters.SearchFilter, filters.OrderingFilter]
+    filterset_fields = ["status", "author", "category"]
+    search_fields = ["title", "content"]
+    ordering_fields = ["created_at", "title"]
+    ordering = ["-created_at"]
+```
+
+## Authentication and Permissions
+
+```python
+from rest_framework.permissions import IsAuthenticated, IsAdminUser
+
+class ArticleViewSet(viewsets.ModelViewSet):
+    permission_classes = [IsAuthenticated]
+    
+    def get_permissions(self):
+        if self.action in ["create", "update", "destroy"]:
+            return [IsAdminUser()]
+        return super().get_permissions()
+```
+
+## Error Handling
+
+```python
+from rest_framework.views import exception_handler
+from rest_framework.response import Response
+
+def custom_exception_handler(exc, context):
+    response = exception_handler(exc, context)
+    
+    if response is not None:
+        response.data["status_code"] = response.status_code
+        response.data["error_type"] = exc.__class__.__name__
+    
+    return response
+```
+
+## API Versioning
+
+```python
+# settings.py
+REST_FRAMEWORK = {
+    "DEFAULT_VERSIONING_CLASS": "rest_framework.versioning.URLPathVersioning",
+    "DEFAULT_VERSION": "v1",
+    "ALLOWED_VERSIONS": ["v1", "v2"],
+}
+
+# urls.py
+urlpatterns = [
+    path("api/<version>/", include("api.urls")),
+]
+```

package/data/knowledge/react-node/architecture/node-architecture.md

@@ -0,0 +1,257 @@
+# Node.js Architecture Patterns
+
+Recommended architecture patterns for scalable Node.js applications.
+
+## Clean Architecture
+
+```
+┌─────────────────────────────────────┐
+│           Presentation              │
+│    (Controllers, Routes, DTOs)      │
+├─────────────────────────────────────┤
+│            Application              │
+│      (Use Cases, Services)          │
+├─────────────────────────────────────┤
+│             Domain                  │
+│   (Entities, Business Rules)        │
+├─────────────────────────────────────┤
+│          Infrastructure             │
+│  (Database, External APIs, etc.)    │
+└─────────────────────────────────────┘
+```
+
+## Service Layer Pattern
+
+```typescript
+// services/UserService.ts
+import { User } from '../entities/User';
+import { IUserRepository } from '../repositories/IUserRepository';
+import { CreateUserDTO, UpdateUserDTO } from '../dtos/UserDTO';
+import { NotFoundError, ValidationError } from '../errors';
+
+export class UserService {
+  constructor(
+    private userRepository: IUserRepository,
+    private emailService: EmailService
+  ) {}
+
+  async createUser(dto: CreateUserDTO): Promise<User> {
+    // Business validation
+    const existing = await this.userRepository.findByEmail(dto.email);
+    if (existing) {
+      throw new ValidationError('Email already registered');
+    }
+
+    // Create entity
+    const user = User.create({
+      email: dto.email,
+      password: await this.hashPassword(dto.password),
+      name: dto.name
+    });
+
+    // Persist
+    const saved = await this.userRepository.save(user);
+
+    // Side effects
+    await this.emailService.sendWelcome(saved.email);
+
+    return saved;
+  }
+
+  async getById(id: string): Promise<User> {
+    const user = await this.userRepository.findById(id);
+    if (!user) {
+      throw new NotFoundError('User');
+    }
+    return user;
+  }
+}
+```
+
+## Repository Pattern
+
+```typescript
+// repositories/IUserRepository.ts
+export interface IUserRepository {
+  findById(id: string): Promise<User | null>;
+  findByEmail(email: string): Promise<User | null>;
+  findAll(options?: FindOptions): Promise<User[]>;
+  save(user: User): Promise<User>;
+  update(id: string, data: Partial<User>): Promise<User>;
+  delete(id: string): Promise<void>;
+}
+
+// repositories/PrismaUserRepository.ts
+import { PrismaClient } from '@prisma/client';
+
+export class PrismaUserRepository implements IUserRepository {
+  constructor(private prisma: PrismaClient) {}
+
+  async findById(id: string): Promise<User | null> {
+    const data = await this.prisma.user.findUnique({ where: { id } });
+    return data ? User.fromPersistence(data) : null;
+  }
+
+  async save(user: User): Promise<User> {
+    const data = await this.prisma.user.create({
+      data: user.toPersistence()
+    });
+    return User.fromPersistence(data);
+  }
+}
+```
+
+## Dependency Injection
+
+```typescript
+// container.ts
+import { Container } from 'inversify';
+
+const container = new Container();
+
+// Repositories
+container.bind<IUserRepository>('UserRepository')
+  .to(PrismaUserRepository)
+  .inSingletonScope();
+
+// Services
+container.bind<UserService>('UserService')
+  .toDynamicValue((context) => {
+    const repo = context.container.get<IUserRepository>('UserRepository');
+    const email = context.container.get<EmailService>('EmailService');
+    return new UserService(repo, email);
+  });
+
+export { container };
+
+// Usage in controller
+@injectable()
+export class UserController {
+  constructor(
+    @inject('UserService') private userService: UserService
+  ) {}
+}
+```
+
+## CQRS (Command Query Responsibility Segregation)
+
+```typescript
+// commands/CreateUserCommand.ts
+export class CreateUserCommand {
+  constructor(
+    public readonly email: string,
+    public readonly password: string,
+    public readonly name: string
+  ) {}
+}
+
+// handlers/CreateUserHandler.ts
+export class CreateUserHandler {
+  constructor(private userRepo: IUserRepository) {}
+
+  async execute(command: CreateUserCommand): Promise<string> {
+    const user = User.create(command);
+    await this.userRepo.save(user);
+    return user.id;
+  }
+}
+
+// queries/GetUserQuery.ts
+export class GetUserQuery {
+  constructor(public readonly userId: string) {}
+}
+
+// handlers/GetUserHandler.ts
+export class GetUserHandler {
+  constructor(private readRepo: IUserReadRepository) {}
+
+  async execute(query: GetUserQuery): Promise<UserDTO> {
+    return this.readRepo.getUserView(query.userId);
+  }
+}
+
+// CommandBus
+export class CommandBus {
+  private handlers = new Map<string, any>();
+
+  register(commandName: string, handler: any) {
+    this.handlers.set(commandName, handler);
+  }
+
+  async execute<T>(command: any): Promise<T> {
+    const handler = this.handlers.get(command.constructor.name);
+    return handler.execute(command);
+  }
+}
+```
+
+## Event-Driven Architecture
+
+```typescript
+// events/UserCreatedEvent.ts
+export class UserCreatedEvent {
+  constructor(
+    public readonly userId: string,
+    public readonly email: string,
+    public readonly createdAt: Date
+  ) {}
+}
+
+// EventBus
+export class EventBus {
+  private handlers = new Map<string, Function[]>();
+
+  subscribe(eventName: string, handler: Function) {
+    const existing = this.handlers.get(eventName) || [];
+    this.handlers.set(eventName, [...existing, handler]);
+  }
+
+  publish(event: any) {
+    const handlers = this.handlers.get(event.constructor.name) || [];
+    handlers.forEach(handler => handler(event));
+  }
+}
+
+// Usage
+eventBus.subscribe('UserCreatedEvent', async (event: UserCreatedEvent) => {
+  await emailService.sendWelcome(event.email);
+});
+
+eventBus.subscribe('UserCreatedEvent', async (event: UserCreatedEvent) => {
+  await analyticsService.trackSignup(event.userId);
+});
+```
+
+## Middleware Pipeline
+
+```typescript
+// middleware/Pipeline.ts
+type Middleware<T> = (context: T, next: () => Promise<void>) => Promise<void>;
+
+export class Pipeline<T> {
+  private middlewares: Middleware<T>[] = [];
+
+  use(middleware: Middleware<T>): this {
+    this.middlewares.push(middleware);
+    return this;
+  }
+
+  async execute(context: T): Promise<void> {
+    const dispatch = async (index: number): Promise<void> => {
+      if (index >= this.middlewares.length) return;
+      
+      const middleware = this.middlewares[index];
+      await middleware(context, () => dispatch(index + 1));
+    };
+
+    await dispatch(0);
+  }
+}
+
+// Usage
+const pipeline = new Pipeline<RequestContext>()
+  .use(loggingMiddleware)
+  .use(authenticationMiddleware)
+  .use(validationMiddleware)
+  .use(handlerMiddleware);
+```