openlore 2.0.0

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/**/*"]
+}