spec-gen-cli 1.2.6 → 1.2.8

package/examples/drift-demo/src/auth/auth-service.ts

@@ -0,0 +1,45 @@
+import bcrypt from 'bcrypt';
+import jwt from 'jsonwebtoken';
+
+const JWT_SECRET = process.env.JWT_SECRET || 'dev-secret';
+
+export interface AuthResult {
+  token: string;
+  expiresIn: number;
+  userId: string;
+}
+
+export class AuthService {
+  async login(email: string, password: string): Promise<AuthResult> {
+    const user = await this.findUserByEmail(email);
+    if (!user) throw new Error('User not found');
+
+    const valid = await bcrypt.compare(password, user.passwordHash);
+    if (!valid) throw new Error('Invalid credentials');
+
+    const token = jwt.sign({ userId: user.id, role: user.role }, JWT_SECRET, { expiresIn: '24h' });
+    return { token, expiresIn: 86400, userId: user.id };
+  }
+
+  async register(email: string, password: string, name: string): Promise<AuthResult> {
+    const existing = await this.findUserByEmail(email);
+    if (existing) throw new Error('Email already registered');
+
+    const passwordHash = await bcrypt.hash(password, 12);
+    const user = await this.createUser({ email, passwordHash, name, role: 'user' });
+
+    const token = jwt.sign({ userId: user.id, role: user.role }, JWT_SECRET, { expiresIn: '24h' });
+    return { token, expiresIn: 86400, userId: user.id };
+  }
+
+  verifyToken(token: string): { userId: string; role: string } | null {
+    try {
+      return jwt.verify(token, JWT_SECRET) as { userId: string; role: string };
+    } catch {
+      return null;
+    }
+  }
+
+  private async findUserByEmail(email: string) { return null as any; }
+  private async createUser(data: any) { return { id: 'new-id', ...data }; }
+}

package/examples/drift-demo/src/database/connection.ts

@@ -0,0 +1,27 @@
+import { Pool } from 'pg';
+
+const pool = new Pool({
+  connectionString: process.env.DATABASE_URL || 'postgresql://localhost:5432/taskflow',
+  max: 20,
+  idleTimeoutMillis: 30000,
+});
+
+export async function query(sql: string, params?: any[]) {
+  const client = await pool.connect();
+  try {
+    return await client.query(sql, params);
+  } finally {
+    client.release();
+  }
+}
+
+export async function healthCheck(): Promise<boolean> {
+  try {
+    await query('SELECT 1');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export { pool };

package/examples/drift-demo/src/index.ts

@@ -0,0 +1,16 @@
+import express from 'express';
+import { authRouter } from './auth/auth-routes.js';
+import { taskRouter } from './tasks/task-routes.js';
+
+const app = express();
+app.use(express.json());
+
+app.use('/api/auth', authRouter);
+app.use('/api/tasks', taskRouter);
+
+app.get('/health', (_, res) => res.json({ status: 'ok' }));
+
+const PORT = process.env.PORT || 3000;
+app.listen(PORT, () => console.log(`TaskFlow API listening on port ${PORT}`));
+
+export { app };

package/examples/drift-demo/src/projects/project-model.ts

@@ -0,0 +1,15 @@
+export interface Project {
+  id: string;
+  name: string;
+  description: string;
+  ownerId: string;
+  members: string[];
+  createdAt: Date;
+  updatedAt: Date;
+  isArchived: boolean;
+}
+
+export interface CreateProjectInput {
+  name: string;
+  description?: string;
+}

package/examples/drift-demo/src/projects/project-service.ts

@@ -0,0 +1,34 @@
+import type { Project, CreateProjectInput } from './project-model.js';
+
+export class ProjectService {
+  async createProject(input: CreateProjectInput, userId: string): Promise<Project> {
+    if (!input.name?.trim()) throw new Error('Project name is required');
+
+    return {
+      id: `proj_${Date.now()}`,
+      name: input.name.trim(),
+      description: input.description || '',
+      ownerId: userId,
+      members: [userId],
+      createdAt: new Date(),
+      updatedAt: new Date(),
+      isArchived: false,
+    };
+  }
+
+  async getProject(projectId: string): Promise<Project | null> {
+    return null;
+  }
+
+  async addMember(projectId: string, userId: string): Promise<void> {
+    const project = await this.getProject(projectId);
+    if (!project) throw new Error('Project not found');
+    if (project.members.includes(userId)) throw new Error('User is already a member');
+  }
+
+  async archiveProject(projectId: string, userId: string): Promise<void> {
+    const project = await this.getProject(projectId);
+    if (!project) throw new Error('Project not found');
+    if (project.ownerId !== userId) throw new Error('Only the owner can archive a project');
+  }
+}

package/examples/drift-demo/src/tasks/task-model.ts

@@ -0,0 +1,37 @@
+export type TaskStatus = 'todo' | 'in_progress' | 'done' | 'cancelled';
+export type TaskPriority = 'low' | 'medium' | 'high' | 'urgent';
+
+export interface Task {
+  id: string;
+  title: string;
+  description: string;
+  status: TaskStatus;
+  priority: TaskPriority;
+  assigneeId: string | null;
+  projectId: string;
+  createdBy: string;
+  createdAt: Date;
+  updatedAt: Date;
+  dueDate: Date | null;
+  tags: string[];
+}
+
+export interface CreateTaskInput {
+  title: string;
+  description?: string;
+  priority?: TaskPriority;
+  assigneeId?: string;
+  projectId: string;
+  dueDate?: string;
+  tags?: string[];
+}
+
+export interface UpdateTaskInput {
+  title?: string;
+  description?: string;
+  status?: TaskStatus;
+  priority?: TaskPriority;
+  assigneeId?: string | null;
+  dueDate?: string | null;
+  tags?: string[];
+}

package/examples/drift-demo/src/tasks/task-routes.ts

@@ -0,0 +1,53 @@
+import { Router } from 'express';
+import { TaskService } from './task-service.js';
+import { requireAuth } from '../auth/auth-middleware.js';
+
+const router = Router();
+const taskService = new TaskService();
+
+router.use(requireAuth);
+
+router.post('/', async (req, res) => {
+  try {
+    const task = await taskService.createTask(req.body, (req as any).userId);
+    res.status(201).json(task);
+  } catch (err: any) {
+    res.status(400).json({ error: err.message });
+  }
+});
+
+router.get('/:id', async (req, res) => {
+  const task = await taskService.getTask(req.params.id);
+  if (!task) return res.status(404).json({ error: 'Task not found' });
+  res.json(task);
+});
+
+router.patch('/:id', async (req, res) => {
+  try {
+    const task = await taskService.updateTask(req.params.id, req.body);
+    res.json(task);
+  } catch (err: any) {
+    res.status(400).json({ error: err.message });
+  }
+});
+
+router.delete('/:id', async (req, res) => {
+  try {
+    await taskService.deleteTask(req.params.id);
+    res.status(204).send();
+  } catch (err: any) {
+    res.status(404).json({ error: err.message });
+  }
+});
+
+router.get('/', async (req, res) => {
+  const { projectId, status, assigneeId } = req.query;
+  if (!projectId) return res.status(400).json({ error: 'projectId is required' });
+  const tasks = await taskService.listTasks(projectId as string, {
+    status: status as any,
+    assigneeId: assigneeId as string,
+  });
+  res.json(tasks);
+});
+
+export { router as taskRouter };

package/examples/drift-demo/src/tasks/task-service.ts

@@ -0,0 +1,60 @@
+import type { Task, CreateTaskInput, UpdateTaskInput, TaskStatus } from './task-model.js';
+
+export class TaskService {
+  async createTask(input: CreateTaskInput, userId: string): Promise<Task> {
+    if (!input.title?.trim()) throw new Error('Task title is required');
+    if (!input.projectId) throw new Error('Project ID is required');
+
+    return {
+      id: `task_${Date.now()}`,
+      title: input.title.trim(),
+      description: input.description || '',
+      status: 'todo',
+      priority: input.priority || 'medium',
+      assigneeId: input.assigneeId || null,
+      projectId: input.projectId,
+      createdBy: userId,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+      dueDate: input.dueDate ? new Date(input.dueDate) : null,
+      tags: input.tags || [],
+    };
+  }
+
+  async getTask(taskId: string): Promise<Task | null> {
+    return null; // DB lookup
+  }
+
+  async updateTask(taskId: string, input: UpdateTaskInput): Promise<Task> {
+    const task = await this.getTask(taskId);
+    if (!task) throw new Error('Task not found');
+
+    // Validate status transitions
+    if (input.status) {
+      this.validateStatusTransition(task.status, input.status);
+    }
+
+    return { ...task, ...input, updatedAt: new Date() } as Task;
+  }
+
+  async deleteTask(taskId: string): Promise<void> {
+    const task = await this.getTask(taskId);
+    if (!task) throw new Error('Task not found');
+  }
+
+  async listTasks(projectId: string, filters?: { status?: TaskStatus; assigneeId?: string }): Promise<Task[]> {
+    return []; // DB query with filters
+  }
+
+  private validateStatusTransition(current: TaskStatus, next: TaskStatus): void {
+    const allowed: Record<TaskStatus, TaskStatus[]> = {
+      'todo': ['in_progress', 'cancelled'],
+      'in_progress': ['done', 'todo', 'cancelled'],
+      'done': ['todo'],
+      'cancelled': ['todo'],
+    };
+    if (!allowed[current]?.includes(next)) {
+      throw new Error(`Cannot transition from ${current} to ${next}`);
+    }
+  }
+}

package/examples/drift-demo/src/utils/validation.ts

@@ -0,0 +1,11 @@
+export function isValidEmail(email: string): boolean {
+  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
+}
+
+export function isValidUUID(id: string): boolean {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(id);
+}
+
+export function sanitizeString(input: string): string {
+  return input.trim().replace(/[<>&'"]/g, '');
+}

package/examples/drift-demo/tests/auth.test.ts

@@ -0,0 +1,4 @@
+import { describe, it, expect } from 'vitest';
+describe('auth', () => {
+  it('should exist', () => { expect(true).toBe(true); });
+});

package/examples/drift-demo/tests/tasks.test.ts

@@ -0,0 +1,4 @@
+import { describe, it, expect } from 'vitest';
+describe('tasks', () => {
+  it('should exist', () => { expect(true).toBe(true); });
+});

package/examples/drift-demo/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "nodenext",
+    "outDir": "./dist",
+    "strict": true
+  },
+  "include": ["src/**/*"]
+}