llm-content-creator 0.1.0

package/src/infrastructure/database/BaseRepository.ts

@@ -0,0 +1,214 @@
+/**
+ * BaseRepository - Repository 基类
+ *
+ * 提供通用的数据库操作和事务管理
+ * 所有具体 Repository 应该继承此类
+ */
+
+import type { Pool, PoolClient, QueryResult, QueryResultRow } from 'pg';
+import { Pool as PoolClass } from 'pg';
+import { config } from '../../config/index.js';
+
+/**
+ * 查询统计信息
+ */
+export interface QueryStats {
+  text: string;
+  duration: number;
+  rows: number;
+}
+
+/**
+ * Repository 基类
+ */
+export abstract class BaseRepository {
+  protected pool: Pool;
+
+  constructor(pool?: Pool) {
+    this.pool = pool || new PoolClass({
+      host: config.database.host,
+      port: config.database.port,
+      database: config.database.database,
+      user: config.database.user,
+      password: config.database.password,
+      max: 20, // 连接池大小
+      idleTimeoutMillis: 30000,
+      connectionTimeoutMillis: 2000,
+    });
+
+    // 监听连接池错误
+    this.pool.on('error', (err: Error) => {
+      console.error('Unexpected error on idle client', err);
+      process.exit(-1);
+    });
+  }
+
+  /**
+   * 执行查询
+   *
+   * @param text - SQL 查询语句
+   * @param params - 查询参数
+   * @returns 查询结果
+   */
+  protected async query<T extends QueryResultRow>(text: string, params?: any[]): Promise<QueryResult<T>> {
+    const start = Date.now();
+
+    try {
+      const res = await this.pool.query<T>(text, params);
+      const duration = Date.now() - start;
+
+      // 记录查询统计（开发环境）
+      if (process.env.NODE_ENV !== 'production') {
+        this.logQuery({ text, duration, rows: res.rowCount || 0 });
+      }
+
+      return res;
+    } catch (error) {
+      console.error('Query error', { text, error });
+      throw error;
+    }
+  }
+
+  /**
+   * 获取数据库连接（用于事务）
+   *
+   * @returns 数据库连接
+   */
+  protected async getConnection(): Promise<PoolClient> {
+    return await this.pool.connect();
+  }
+
+  /**
+   * 执行事务
+   *
+   * @param callback - 事务回调函数
+   * @returns 回调函数的返回值
+   */
+  protected async transaction<T>(
+    callback: (client: PoolClient) => Promise<T>
+  ): Promise<T> {
+    const client = await this.getConnection();
+
+    try {
+      await client.query('BEGIN');
+      const result = await callback(client);
+      await client.query('COMMIT');
+      return result;
+    } catch (error) {
+      await client.query('ROLLBACK');
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+
+  /**
+   * 批量执行查询（在单个事务中）
+   *
+   * @param queries - 查询数组
+   * @returns 所有查询的结果数组
+   */
+  protected async batchQuery<T extends QueryResultRow>(queries: Array<{
+    text: string;
+    params?: any[];
+  }>): Promise<QueryResult<T>[]> {
+    return this.transaction(async (client) => {
+      const results: QueryResult<T>[] = [];
+
+      for (const query of queries) {
+        const result = await client.query<T>(query.text, query.params);
+        results.push(result);
+      }
+
+      return results;
+    });
+  }
+
+  /**
+   * 检查记录是否存在
+   *
+   * @param table - 表名
+   * @param field - 字段名
+   * @param value - 字段值
+   * @returns 是否存在
+   */
+  protected async exists(
+    table: string,
+    field: string,
+    value: any
+  ): Promise<boolean> {
+    const text = `SELECT EXISTS(SELECT 1 FROM ${table} WHERE ${field} = $1)`;
+    const result = await this.query<{ exists: boolean }>(text, [value]);
+    return result.rows[0]?.exists ?? false;
+  }
+
+  /**
+   * 计数查询
+   *
+   * @param table - 表名
+   * @param where - WHERE 条件（可选）
+   * @returns 记录数
+   */
+  protected async count(table: string, where: string = 'TRUE'): Promise<number> {
+    const text = `SELECT COUNT(*) as count FROM ${table} WHERE ${where}`;
+    const result = await this.query<{ count: string }>(text);
+    return parseInt(result.rows[0]?.count ?? '0', 10);
+  }
+
+  /**
+   * 记录查询日志
+   *
+   * @param stats - 查询统计信息
+   */
+  private logQuery(stats: QueryStats): void {
+    const { text, duration, rows } = stats;
+
+    // 截断过长的查询语句
+    const truncatedText =
+      text.length > 100 ? text.substring(0, 100) + '...' : text;
+
+    console.log(`[Query] ${truncatedText} - ${duration}ms - ${rows} rows`);
+  }
+
+  /**
+   * 获取连接池统计信息
+   *
+   * @returns 连接池统计信息
+   */
+  getPoolStats(): { totalCount: number; idleCount: number; waitingCount: number } {
+    return {
+      totalCount: this.pool.totalCount,
+      idleCount: this.pool.idleCount,
+      waitingCount: this.pool.waitingCount,
+    };
+  }
+
+  /**
+   * 关闭连接池
+   * 应该在应用关闭时调用
+   */
+  async close(): Promise<void> {
+    try {
+      await this.pool.end();
+      console.log('Database connection pool closed');
+    } catch (error) {
+      console.error('Error closing database connection pool:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * 健康检查
+   *
+   * @returns 数据库是否健康
+   */
+  async healthCheck(): Promise<boolean> {
+    try {
+      await this.query('SELECT 1');
+      return true;
+    } catch (error) {
+      console.error('Database health check failed:', error);
+      return false;
+    }
+  }
+}

package/src/infrastructure/database/MemoryTaskRepository.ts

@@ -0,0 +1,377 @@
+/**
+ * Memory Task Repository
+ *
+ * 内存版本的 Task Repository，用于测试和开发
+ * 数据不持久化，适合快速测试工作流
+ */
+
+import { createLogger } from '../../infrastructure/logging/logger.js';
+import type {
+  Task,
+  TaskCreateParams,
+  TaskUpdateParams,
+  TaskListFilters,
+  PaginatedResult,
+} from '../../domain/repositories/TaskRepository.js';
+import { TaskStatus } from '../../domain/entities/Task.js';
+
+const logger = createLogger('Memory:TaskRepository');
+
+/**
+ * 内存 Task Repository 实现
+ */
+export class MemoryTaskRepository {
+  private tasks: Map<string, Task> = new Map();
+  private snapshots: Map<string, any> = new Map();
+
+  constructor() {
+    logger.info('Memory repository initialized (no persistence)');
+  }
+
+  /**
+   * 创建任务
+   */
+  async create(params: TaskCreateParams): Promise<Task> {
+    const now = new Date();
+
+    const task: Task = {
+      id: params.id,
+      taskId: params.id,
+      mode: params.mode as any,
+      type: params.type as any,
+      topic: params.topic,
+      requirements: params.requirements,
+      hardConstraints: params.hardConstraints,
+      status: TaskStatus.PENDING,
+      priority: 2, // NORMAL
+      version: 1,
+      textRetryCount: 0,
+      imageRetryCount: 0,
+      targetAudience: 'general',
+      createdAt: now,
+      updatedAt: now,
+    };
+
+    this.tasks.set(task.id, task);
+
+    logger.info('Task created (memory)', { taskId: task.id, topic: task.topic });
+    return task;
+  }
+
+  /**
+   * 根据 ID 查找任务
+   */
+  async findById(id: string): Promise<Task | null> {
+    const task = this.tasks.get(id);
+    return task || null;
+  }
+
+  /**
+   * 更新任务
+   */
+  async update(id: string, params: TaskUpdateParams): Promise<Task> {
+    const task = this.tasks.get(id);
+    if (!task) {
+      throw new Error(`Task not found: ${id}`);
+    }
+
+    const now = new Date();
+    const updatedTask: Task = {
+      ...task,
+      ...(params.status !== undefined && { status: params.status as any }),
+      ...(params.currentStep !== undefined && { currentStep: params.currentStep }),
+      ...(params.errorMessage !== undefined && { errorMessage: params.errorMessage }),
+      ...(params.workerId !== undefined && { workerId: params.workerId }),
+      ...(params.startedAt !== undefined && { startedAt: params.startedAt ? new Date(params.startedAt) : undefined }),
+      ...(params.completedAt !== undefined && { completedAt: params.completedAt ? new Date(params.completedAt) : undefined }),
+      ...(params.version !== undefined && { version: params.version }),
+      updatedAt: now,
+    };
+
+    this.tasks.set(id, updatedTask);
+
+    logger.debug('Task updated (memory)', { taskId: id, updates: Object.keys(params) });
+    return updatedTask;
+  }
+
+  /**
+   * 更新任务状态（带乐观锁）
+   */
+  async updateStatus(taskId: string, status: TaskStatus, version: number): Promise<boolean> {
+    const task = this.tasks.get(taskId);
+    if (!task) {
+      return false;
+    }
+
+    // 检查版本号（乐观锁）
+    if (task.version !== version) {
+      logger.warn('Task version mismatch for updateStatus', { taskId, expectedVersion: version, actualVersion: task.version });
+      return false;
+    }
+
+    const now = new Date();
+    const updatedTask: Task = {
+      ...task,
+      status,
+      version: version + 1,
+      updatedAt: now,
+      ...(status === TaskStatus.RUNNING && { startedAt: now }),
+      ...(status === TaskStatus.COMPLETED && { completedAt: now }),
+      ...(status === TaskStatus.FAILED && { completedAt: now }),
+      ...(status === TaskStatus.CANCELLED && { completedAt: now }),
+    };
+
+    this.tasks.set(taskId, updatedTask);
+    logger.debug('Task status updated (memory)', { taskId, status, newVersion: updatedTask.version });
+    return true;
+  }
+
+  /**
+   * 抢占任务（Worker 抢占机制）
+   */
+  async claimForProcessing(workerId: string, limit: number = 1): Promise<Task[]> {
+    const now = new Date();
+    const claimedTasks: Task[] = [];
+
+    // 找出待处理任务
+    const pendingTasks = Array.from(this.tasks.values())
+      .filter(
+        (task) =>
+          task.status === TaskStatus.PENDING ||
+          (task.status === TaskStatus.WAITING &&
+            new Date(task.updatedAt).getTime() < Date.now() - 5 * 60 * 1000)
+      )
+      .sort((a, b) => {
+        // 按优先级降序，然后按创建时间升序
+        if (a.priority !== b.priority) {
+          return b.priority - a.priority;
+        }
+        return new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime();
+      })
+      .slice(0, limit);
+
+    // 更新任务状态
+    for (const task of pendingTasks) {
+      const updatedTask = await this.update(task.id, {
+        status: TaskStatus.RUNNING,
+        workerId,
+        startedAt: now.toISOString(),
+      });
+      claimedTasks.push(updatedTask);
+    }
+
+    if (claimedTasks.length > 0) {
+      logger.info('Tasks claimed for processing (memory)', {
+        workerId,
+        count: claimedTasks.length,
+        taskIds: claimedTasks.map((t) => t.id),
+      });
+    }
+
+    return claimedTasks;
+  }
+
+  /**
+   * 保存状态快照（用于崩溃恢复）
+   */
+  async saveStateSnapshot(taskId: string, step: string, state: any): Promise<void> {
+    const key = `${taskId}_${step}`;
+    this.snapshots.set(key, {
+      taskId,
+      step,
+      state,
+      savedAt: new Date(),
+    });
+
+    logger.debug('State snapshot saved (memory)', { taskId, step });
+  }
+
+  /**
+   * 恢复状态快照
+   */
+  async loadStateSnapshot(taskId: string): Promise<any | null> {
+    // 找到最新的快照
+    const snapshots = Array.from(this.snapshots.values())
+      .filter((s) => s.taskId === taskId)
+      .sort((a, b) => new Date(b.savedAt).getTime() - new Date(a.savedAt).getTime());
+
+    if (snapshots.length === 0) {
+      return null;
+    }
+
+    return snapshots[0].state;
+  }
+
+  /**
+   * 列出任务（带过滤和分页）
+   */
+  async list(filters: TaskListFilters = {}): Promise<PaginatedResult<Task>> {
+    const {
+      status,
+      workerId,
+      type,
+      limit = 50,
+      offset = 0,
+      sortBy = 'createdAt',
+      sortOrder = 'DESC',
+    } = filters;
+
+    let tasks = Array.from(this.tasks.values());
+
+    // 应用过滤
+    if (status) {
+      tasks = tasks.filter((t) => t.status === status);
+    }
+    if (workerId) {
+      tasks = tasks.filter((t) => t.workerId === workerId);
+    }
+    if (type) {
+      tasks = tasks.filter((t) => t.type === type);
+    }
+
+    const total = tasks.length;
+
+    // 排序
+    tasks.sort((a, b) => {
+      const aVal = (a as any)[sortBy];
+      const bVal = (b as any)[sortBy];
+      const comparison = aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
+      return sortOrder === 'DESC' ? -comparison : comparison;
+    });
+
+    // 分页
+    const data = tasks.slice(offset, offset + limit);
+
+    return {
+      data,
+      total,
+      limit,
+      offset,
+    };
+  }
+
+  /**
+   * 删除任务
+   */
+  async delete(id: string): Promise<boolean> {
+    const existed = this.tasks.has(id);
+    this.tasks.delete(id);
+
+    // 清理相关快照
+    for (const [key, snapshot] of this.snapshots.entries()) {
+      if (snapshot.taskId === id) {
+        this.snapshots.delete(key);
+      }
+    }
+
+    return existed;
+  }
+
+  /**
+   * 健康检查
+   */
+  async healthCheck(): Promise<boolean> {
+    return true; // 内存版本永远健康
+  }
+
+  /**
+   * 更新当前步骤（带乐观锁）
+   */
+  async updateCurrentStep(taskId: string, step: string, version: number): Promise<boolean> {
+    const task = this.tasks.get(taskId);
+    if (!task) {
+      return false;
+    }
+
+    // 检查版本号（乐观锁）
+    if (task.version !== version) {
+      logger.warn('Task version mismatch for updateCurrentStep', { taskId, expectedVersion: version, actualVersion: task.version });
+      return false;
+    }
+
+    const now = new Date();
+    const updatedTask: Task = {
+      ...task,
+      currentStep: step,
+      version: version + 1,
+      updatedAt: now,
+    };
+
+    this.tasks.set(taskId, updatedTask);
+    logger.debug('Task currentStep updated (memory)', { taskId, step });
+    return true;
+  }
+
+  /**
+   * 标记任务完成（带乐观锁）
+   */
+  async markAsCompleted(taskId: string, version: number): Promise<boolean> {
+    const task = this.tasks.get(taskId);
+    if (!task) {
+      return false;
+    }
+
+    // 检查版本号（乐观锁）
+    if (task.version !== version) {
+      logger.warn('Task version mismatch for markAsCompleted', { taskId, expectedVersion: version, actualVersion: task.version });
+      return false;
+    }
+
+    const now = new Date();
+    const updatedTask: Task = {
+      ...task,
+      status: TaskStatus.COMPLETED,
+      completedAt: now,
+      version: version + 1,
+      updatedAt: now,
+    };
+
+    this.tasks.set(taskId, updatedTask);
+    logger.info('Task marked as completed (memory)', { taskId });
+    return true;
+  }
+
+  /**
+   * 标记任务失败（带乐观锁）
+   */
+  async markAsFailed(taskId: string, errorMessage: string, version: number): Promise<boolean> {
+    const task = this.tasks.get(taskId);
+    if (!task) {
+      return false;
+    }
+
+    // 检查版本号（乐观锁）
+    if (task.version !== version) {
+      logger.warn('Task version mismatch for markAsFailed', { taskId, expectedVersion: version, actualVersion: task.version });
+      return false;
+    }
+
+    const now = new Date();
+    const updatedTask: Task = {
+      ...task,
+      status: TaskStatus.FAILED,
+      errorMessage,
+      completedAt: now,
+      version: version + 1,
+      updatedAt: now,
+    };
+
+    this.tasks.set(taskId, updatedTask);
+    logger.info('Task marked as failed (memory)', { taskId, errorMessage });
+    return true;
+  }
+
+  /**
+   * 获取统计信息
+   */
+  getStats() {
+    return {
+      totalTasks: this.tasks.size,
+      snapshots: this.snapshots.size,
+      byStatus: Array.from(this.tasks.values()).reduce((acc, task) => {
+        acc[task.status] = (acc[task.status] || 0) + 1;
+        return acc;
+      }, {} as Record<string, number>),
+    };
+  }
+}

package/src/infrastructure/database/PostgresQualityCheckRepository.ts

@@ -0,0 +1,115 @@
+/**
+ * Quality Check Repository
+ *
+ * 负责质量检查结果的数据库操作
+ */
+
+import { Pool } from 'pg';
+import { createLogger } from '../logging/logger.js';
+import type {
+  IQualityCheckRepository,
+  CreateQualityCheckParams,
+} from '../../domain/repositories/QualityCheckRepository.js';
+
+const logger = createLogger('QualityCheckRepository');
+
+/**
+ * PostgreSQL Quality Check Repository 实现
+ */
+export class PostgresQualityCheckRepository implements IQualityCheckRepository {
+  private pool: Pool;
+
+  constructor(pool: Pool) {
+    this.pool = pool;
+  }
+
+  /**
+   * 创建质量检查记录
+   */
+  async create(params: CreateQualityCheckParams): Promise<void> {
+    const client = await this.pool.connect();
+    try {
+      await client.query(
+        `INSERT INTO quality_checks
+           (task_id, check_type, score, passed, hard_constraints_passed,
+            details, fix_suggestions, rubric_version, model_name, prompt_hash)
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)`,
+        [
+          params.taskId,
+          params.checkType,
+          params.score,
+          params.passed,
+          params.hardConstraintsPassed,
+          JSON.stringify(params.details || {}),
+          params.fixSuggestions || null,
+          params.rubricVersion || null,
+          params.modelName || null,
+          params.promptHash || null,
+        ]
+      );
+
+      logger.info('Quality check created', {
+        taskId: params.taskId,
+        checkType: params.checkType,
+        score: params.score,
+        passed: params.passed,
+      });
+    } catch (error) {
+      logger.error('Failed to create quality check', error as Error);
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+
+  /**
+   * 根据任务 ID 查询质量检查
+   */
+  // @ts-ignore - Database returns string for checkType, interface expects union type
+  async findByTaskId(taskId: string): Promise<Array<{
+    id: number;
+    taskId: string;
+    checkType: string;
+    score: number;
+    passed: boolean;
+    hardConstraintsPassed: boolean;
+    details: any;
+    fixSuggestions: string[] | null;
+    rubricVersion: string | null;
+    modelName: string | null;
+    promptHash: string | null;
+    createdAt: Date;
+  }>> {
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(
+        `SELECT id, task_id, check_type, score, passed, hard_constraints_passed,
+                details, fix_suggestions, rubric_version, model_name, prompt_hash, created_at
+         FROM quality_checks
+         WHERE task_id = $1
+         ORDER BY created_at DESC`,
+        [taskId]
+      );
+
+      return result.rows.map((row: any) => ({
+        id: row.id,
+        taskId: row.task_id,
+        checkType: row.check_type,
+        score: row.score,
+        passed: row.passed,
+        hardConstraintsPassed: row.hard_constraints_passed,
+        details: row.details ? JSON.parse(row.details) : null,
+        fixSuggestions: row.fix_suggestions,
+        rubricVersion: row.rubric_version,
+        modelName: row.model_name,
+        promptHash: row.prompt_hash,
+        createdAt: row.created_at,
+      })) as any;
+    } catch (error) {
+      logger.error('Failed to query quality checks', error as Error);
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+}