@qianxude/tem 0.2.0

package/src/mock-server/server.ts

@@ -0,0 +1,148 @@
+import type * as i from './types';
+import { MockService } from './service';
+import { createRouter } from './router';
+
+const DEFAULT_MOCK_URL = 'http://localhost:19999';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type BunServer = any;
+
+interface ServerState {
+  services: Map<string, MockService>;
+  mode: i.ServerMode;
+  defaultService: MockService | null;
+  server: BunServer | null;
+}
+
+const globalState: ServerState = {
+  services: new Map(),
+  mode: 'multi',
+  defaultService: null,
+  server: null,
+};
+
+/**
+ * Start the mock server with the given configuration.
+ */
+export function startMockServer(config: i.ServerConfig): void {
+  // Reset state for fresh start
+  globalState.services.clear();
+  globalState.mode = config.mode ?? 'multi';
+  globalState.defaultService = null;
+
+  // Setup default service for single mode
+  if (globalState.mode === 'single') {
+    if (!config.defaultService) {
+      throw new Error('defaultService is required in single mode');
+    }
+    globalState.defaultService = new MockService('default', config.defaultService);
+  }
+
+  // Create router with state
+  const router = createRouter({
+    services: globalState.services,
+    getMode: () => globalState.mode,
+    getDefaultService: () => globalState.defaultService,
+    shutdownFn: () => shutdown(),
+  });
+
+  // Start server
+  globalState.server = Bun.serve({
+    port: config.port,
+    fetch: router,
+  });
+
+  console.log(`[INFO] Mock server started on port ${config.port} (${globalState.mode} mode)`);
+
+  if (globalState.mode === 'single') {
+    console.log(`[INFO] Default service configured with maxConcurrency=${config.defaultService!.maxConcurrency}`);
+  }
+}
+
+/**
+ * Shutdown the server gracefully.
+ */
+function shutdown(): void {
+  console.log('[INFO] Shutting down mock server...');
+
+  if (globalState.server) {
+    globalState.server.stop();
+    globalState.server = null;
+  }
+
+  globalState.services.clear();
+  globalState.defaultService = null;
+
+  console.log('[INFO] Mock server stopped');
+
+  // Exit process
+  process.exit(0);
+}
+
+/**
+ * Get the current server state (for testing).
+ */
+export function getServerState(): {
+  services: Map<string, MockService>;
+  mode: i.ServerMode;
+  hasDefaultService: boolean;
+} {
+  return {
+    services: globalState.services,
+    mode: globalState.mode,
+    hasDefaultService: globalState.defaultService !== null,
+  };
+}
+
+/**
+ * Stop the server programmatically (for testing).
+ */
+export function stopMockServer(): void {
+  if (globalState.server) {
+    globalState.server.stop();
+    globalState.server = null;
+  }
+  globalState.services.clear();
+  globalState.defaultService = null;
+}
+
+/**
+ * Client helper to create a configured mock service on the mock server.
+ * @param name - Unique service name/identifier
+ * @param config - Service configuration (concurrency, rate limit, delay)
+ * @param mockUrl - Base URL of the mock server (defaults to localhost:19999)
+ * @returns The Response object from the fetch call
+ */
+export async function createMockService(
+  name: string,
+  config: i.CreateServiceRequest,
+  mockUrl: string = DEFAULT_MOCK_URL
+): Promise<Response> {
+  const res = await fetch(`${mockUrl}/service/${name}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(config),
+  });
+  return res;
+}
+
+/**
+ * Helper to create error simulation config with validation.
+ * @param rate - Error rate 0-1
+ * @param statusCode - HTTP status code (default: 500)
+ * @param errorMessage - Error message
+ */
+export function createErrorSimulation(
+  rate: number,
+  statusCode?: number,
+  errorMessage?: string
+): i.ErrorSimulationConfig {
+  if (rate < 0 || rate > 1) {
+    throw new Error('Error rate must be between 0 and 1');
+  }
+  return {
+    rate,
+    statusCode,
+    errorMessage,
+  };
+}

package/src/mock-server/service.ts

@@ -0,0 +1,122 @@
+import type * as i from './types';
+
+/**
+ * Rate limiter with tryAcquire pattern for immediate reject/allow decision.
+ * Uses token bucket algorithm.
+ */
+class RejectingRateLimiter {
+  private tokens: number;
+  private lastRefill: number;
+
+  constructor(private limit: number, private windowMs: number) {
+    this.tokens = limit;
+    this.lastRefill = Date.now();
+  }
+
+  /**
+   * Try to acquire a token. Returns immediately with success/failure.
+   */
+  tryAcquire(): boolean {
+    const now = Date.now();
+    this.refill(now);
+
+    if (this.tokens >= 1) {
+      this.tokens--;
+      return true;
+    }
+
+    return false;
+  }
+
+  private refill(now: number): void {
+    const elapsedMs = now - this.lastRefill;
+    const tokensToAdd = (elapsedMs / this.windowMs) * this.limit;
+
+    if (tokensToAdd > 0) {
+      this.tokens = Math.min(this.limit, this.tokens + tokensToAdd);
+      this.lastRefill = now;
+    }
+  }
+}
+
+/**
+ * Mock service with concurrency and rate limiting.
+ */
+export class MockService {
+  private currentConcurrency = 0;
+  private rateLimiter: RejectingRateLimiter;
+
+  constructor(
+    public name: string,
+    private config: i.ServiceConfig
+  ) {
+    this.rateLimiter = new RejectingRateLimiter(
+      config.rateLimit.limit,
+      config.rateLimit.windowMs
+    );
+  }
+
+  /**
+   * Try to acquire both concurrency slot and rate limit token.
+   * Returns immediately with result - no waiting.
+   */
+  tryAcquire(): i.TryAcquireResult {
+    // Check concurrency first
+    if (this.currentConcurrency >= this.config.maxConcurrency) {
+      return { allowed: false, error: 'concurrency' };
+    }
+
+    // Then check rate limit
+    if (!this.rateLimiter.tryAcquire()) {
+      return { allowed: false, error: 'rateLimit' };
+    }
+
+    // Both passed - acquire concurrency
+    this.currentConcurrency++;
+    return { allowed: true };
+  }
+
+  /**
+   * Release a concurrency slot.
+   */
+  release(): void {
+    if (this.currentConcurrency > 0) {
+      this.currentConcurrency--;
+    }
+  }
+
+  /**
+   * Get random delay within configured range.
+   */
+  getDelay(): number {
+    const [min, max] = this.config.delayMs;
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+  }
+
+  /**
+   * Get current concurrency count.
+   */
+  getCurrentConcurrency(): number {
+    return this.currentConcurrency;
+  }
+
+  /**
+   * Check if a random service error should be simulated.
+   * Returns the error config if error should occur, null otherwise.
+   */
+  checkRandomError(): { statusCode: number; errorMessage: string } | null {
+    const errorConfig = this.config.errorSimulation;
+    if (!errorConfig || errorConfig.rate <= 0) {
+      return null;
+    }
+
+    if (Math.random() < errorConfig.rate) {
+      return {
+        statusCode: errorConfig.statusCode ?? 500,
+        errorMessage: errorConfig.errorMessage ?? 'internal_server_error',
+      };
+    }
+
+    return null;
+  }
+}

package/src/mock-server/types.ts

@@ -0,0 +1,62 @@
+// Mock Server Types
+// Import as: import * as i from './types'
+
+export type ServerMode = 'single' | 'multi';
+
+export interface RateLimitConfig {
+  limit: number;
+  windowMs: number;
+}
+
+export interface ErrorSimulationConfig {
+  rate: number;        // Error rate 0-1 (e.g., 0.1 = 10% error rate)
+  statusCode?: number; // HTTP status code to return (default: 500)
+  errorMessage?: string; // Error message (default: "internal_server_error")
+}
+
+export interface ServiceConfig {
+  maxConcurrency: number;
+  rateLimit: RateLimitConfig;
+  delayMs: [number, number];  // [min, max]
+  errorSimulation?: ErrorSimulationConfig;  // Optional error simulation
+}
+
+export interface ServerConfig {
+  port: number;
+  mode?: ServerMode;
+  defaultService?: ServiceConfig;
+}
+
+export interface CreateServiceRequest {
+  maxConcurrency: number;
+  rateLimit: RateLimitConfig;
+  delayMs?: [number, number];  // [min, max], defaults to [10, 200]
+  errorSimulation?: ErrorSimulationConfig;  // Optional error simulation
+}
+
+export interface ServiceResponse {
+  service: string;
+  status: string;
+}
+
+export interface MockResponse {
+  requestId: string;
+  meta: {
+    ts: number;
+    rt: number;
+  };
+  data: string;
+}
+
+export interface ErrorResponse {
+  error: string;
+}
+
+export interface ShutdownResponse {
+  status: string;
+}
+
+export interface TryAcquireResult {
+  allowed: boolean;
+  error?: 'concurrency' | 'rateLimit';
+}

package/src/services/batch.ts

@@ -0,0 +1,121 @@
+import * as i from '../interfaces/index.js';
+import type { Database } from '../database/index.js';
+
+export interface BatchRow {
+  id: string;
+  code: string;
+  type: string;
+  created_at: string;
+  completed_at: string | null;
+  metadata: string | null;
+}
+
+function rowToBatch(row: BatchRow): i.Batch {
+  return {
+    id: row.id,
+    code: row.code,
+    type: row.type,
+    createdAt: new Date(row.created_at),
+    completedAt: row.completed_at ? new Date(row.completed_at) : null,
+    metadata: row.metadata ? (JSON.parse(row.metadata) as Record<string, unknown>) : null,
+  };
+}
+
+export class BatchService implements i.BatchService {
+  constructor(private db: Database) {}
+
+  async create(input: i.CreateBatchInput): Promise<i.Batch> {
+    const id = crypto.randomUUID();
+    const now = new Date().toISOString();
+
+    this.db.run(
+      `INSERT INTO batch (id, code, type, created_at, metadata)
+       VALUES (?, ?, ?, ?, ?)`,
+      [id, input.code, input.type, now, input.metadata ? JSON.stringify(input.metadata) : null]
+    );
+
+    const rows = this.db.query<BatchRow>('SELECT * FROM batch WHERE id = ?', [id]);
+    const row = rows[0];
+    if (row === undefined) {
+      throw new Error('Failed to create batch');
+    }
+
+    return rowToBatch(row);
+  }
+
+  async getById(id: string): Promise<i.Batch | null> {
+    const rows = this.db.query<BatchRow>('SELECT * FROM batch WHERE id = ?', [id]);
+    const row = rows[0];
+    if (row === undefined) return null;
+    return rowToBatch(row);
+  }
+
+  async getByCode(code: string): Promise<i.Batch | null> {
+    const rows = this.db.query<BatchRow>('SELECT * FROM batch WHERE code = ?', [code]);
+    const row = rows[0];
+    if (row === undefined) return null;
+    return rowToBatch(row);
+  }
+
+  async complete(id: string): Promise<void> {
+    const now = new Date().toISOString();
+    this.db.run(
+      `UPDATE batch SET completed_at = ? WHERE id = ?`,
+      [now, id]
+    );
+  }
+
+  async list(filter?: { type?: string }): Promise<i.Batch[]> {
+    let sql = 'SELECT * FROM batch';
+    const params: string[] = [];
+
+    if (filter?.type) {
+      sql += ' WHERE type = ?';
+      params.push(filter.type);
+    }
+
+    sql += ' ORDER BY created_at DESC';
+
+    const rows = this.db.query<BatchRow>(sql, params);
+    return rows.map(rowToBatch);
+  }
+
+  async getStats(id: string): Promise<i.BatchStats> {
+    const result = this.db.query<{ status: i.TaskStatus; count: number }>(
+      `SELECT status, COUNT(*) as count FROM task WHERE batch_id = ? GROUP BY status`,
+      [id]
+    );
+
+    const stats: i.BatchStats = {
+      batchId: id,
+      total: 0,
+      pending: 0,
+      running: 0,
+      completed: 0,
+      failed: 0,
+    };
+
+    for (const row of result) {
+      stats[row.status] = row.count;
+      stats.total += row.count;
+    }
+
+    return stats;
+  }
+
+  async resume(id: string): Promise<number> {
+    const result = this.db.run(
+      `UPDATE task SET status = 'pending' WHERE batch_id = ? AND status = 'running'`,
+      [id]
+    );
+    return result.changes ?? 0;
+  }
+
+  async retryFailed(id: string): Promise<number> {
+    const result = this.db.run(
+      `UPDATE task SET status = 'pending', attempt = 0 WHERE batch_id = ? AND status = 'failed'`,
+      [id]
+    );
+    return result.changes ?? 0;
+  }
+}

package/src/services/index.ts

@@ -0,0 +1,2 @@
+export { BatchService } from './batch.js';
+export { TaskService } from './task.js';

package/src/services/task.ts

@@ -0,0 +1,176 @@
+import * as i from '../interfaces/index.js';
+import type { Database } from '../database/index.js';
+
+export interface TaskRow {
+  id: string;
+  batch_id: string | null;
+  type: string;
+  status: i.TaskStatus;
+  payload: string;
+  result: string | null;
+  error: string | null;
+  attempt: number;
+  max_attempt: number;
+  claimed_at: string | null;
+  completed_at: string | null;
+  version: number;
+  created_at: string;
+}
+
+function rowToTask(row: TaskRow): i.Task {
+  return {
+    id: row.id,
+    batchId: row.batch_id,
+    type: row.type,
+    status: row.status,
+    payload: row.payload,
+    result: row.result,
+    error: row.error,
+    attempt: row.attempt,
+    maxAttempt: row.max_attempt,
+    claimedAt: row.claimed_at ? new Date(row.claimed_at) : null,
+    completedAt: row.completed_at ? new Date(row.completed_at) : null,
+    version: row.version,
+    createdAt: new Date(row.created_at),
+  };
+}
+
+export class TaskService implements i.TaskService {
+  constructor(private db: Database) {}
+
+  async create(input: i.CreateTaskInput): Promise<i.Task> {
+    const id = crypto.randomUUID();
+    const now = new Date().toISOString();
+    const maxAttempt = input.maxAttempt ?? 3;
+
+    this.db.run(
+      `INSERT INTO task (id, batch_id, type, status, payload, max_attempt, created_at)
+       VALUES (?, ?, ?, 'pending', ?, ?, ?)`,
+      [
+        id,
+        input.batchId ?? null,
+        input.type,
+        JSON.stringify(input.payload),
+        maxAttempt,
+        now,
+      ]
+    );
+
+    const rows = this.db.query<TaskRow>('SELECT * FROM task WHERE id = ?', [id]);
+    const row = rows[0];
+    if (row === undefined) {
+      throw new Error('Failed to create task');
+    }
+
+    return rowToTask(row);
+  }
+
+  async createMany(inputs: i.CreateTaskInput[]): Promise<i.Task[]> {
+    const tasks: i.Task[] = [];
+
+    this.db.transaction(() => {
+      for (const input of inputs) {
+        const id = crypto.randomUUID();
+        const now = new Date().toISOString();
+        const maxAttempt = input.maxAttempt ?? 3;
+
+        this.db.run(
+          `INSERT INTO task (id, batch_id, type, status, payload, max_attempt, created_at)
+           VALUES (?, ?, ?, 'pending', ?, ?, ?)`,
+          [
+            id,
+            input.batchId ?? null,
+            input.type,
+            JSON.stringify(input.payload),
+            maxAttempt,
+            now,
+          ]
+        );
+
+        const rows = this.db.query<TaskRow>('SELECT * FROM task WHERE id = ?', [id]);
+        const row = rows[0];
+        if (row === undefined) {
+          throw new Error('Failed to create task');
+        }
+
+        tasks.push(rowToTask(row));
+      }
+    });
+
+    return tasks;
+  }
+
+  async getById(id: string): Promise<i.Task | null> {
+    const rows = this.db.query<TaskRow>('SELECT * FROM task WHERE id = ?', [id]);
+    const row = rows[0];
+    if (row === undefined) return null;
+    return rowToTask(row);
+  }
+
+  async claim(batchId?: string): Promise<i.Task | null> {
+    const now = new Date().toISOString();
+
+    // Atomic claim using UPDATE ... WHERE status='pending'
+    // This ensures no duplicate execution even with concurrent async operations
+    const claimed = this.db.query<TaskRow>(
+      `UPDATE task
+       SET status = 'running',
+           claimed_at = ?,
+           version = version + 1,
+           attempt = attempt + 1
+       WHERE id = (
+         SELECT id FROM task
+         WHERE status = 'pending'
+           AND (batch_id = ? OR ? IS NULL)
+         ORDER BY created_at
+         LIMIT 1
+       )
+       AND status = 'pending'
+       RETURNING *`,
+      [now, batchId ?? null, batchId ?? null]
+    );
+
+    const row = claimed[0];
+    if (row === undefined) return null;
+    return rowToTask(row);
+  }
+
+  async complete(id: string, result: unknown): Promise<void> {
+    const now = new Date().toISOString();
+
+    this.db.run(
+      `UPDATE task
+       SET status = 'completed',
+           result = ?,
+           completed_at = ?,
+           version = version + 1
+       WHERE id = ?`,
+      [JSON.stringify(result), now, id]
+    );
+  }
+
+  async fail(id: string, error: string): Promise<void> {
+    const now = new Date().toISOString();
+
+    this.db.run(
+      `UPDATE task
+       SET status = 'failed',
+           error = ?,
+           completed_at = ?,
+           version = version + 1
+       WHERE id = ?`,
+      [error, now, id]
+    );
+  }
+
+  async retry(id: string): Promise<void> {
+    this.db.run(
+      `UPDATE task
+       SET status = 'pending',
+           claimed_at = NULL,
+           version = version + 1
+       WHERE id = ?`,
+      [id]
+    );
+  }
+}