@qianxude/tem 0.4.2 → 0.4.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qianxude/tem",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "A lightweight task execution engine for IO-bound workloads with SQLite persistence, retry, and rate limiting",
   "module": "src/index.ts",
   "type": "module",

package/src/core/tem.ts

@@ -6,6 +6,7 @@ import {
   type DetectOptions,
   type DetectedConfig,
 } from '../utils/auto-detect.js';
+import type { BatchInterruptionReason, BatchInterruptionCriteria } from '../interfaces/index.js';
 
 export type { DetectOptions, DetectedConfig };
 
@@ -30,6 +31,9 @@ export interface TEMConfig {
 
   // Optional: Specific batch ID to process (if set, only processes this batch)
   batchId?: string;
+
+  // Default interruption criteria for all batches (batch-level overrides these)
+  defaultInterruptionCriteria?: BatchInterruptionCriteria;
 }
 
 export class TEM {
@@ -84,7 +88,7 @@ export class TEM {
     // Initialize services
     this.batch = new BatchService(this.database);
     this.task = new TaskService(this.database);
-    this.interruption = new BatchInterruptionService(this.database, this.batch);
+    this.interruption = new BatchInterruptionService(this.database, this.batch, config.defaultInterruptionCriteria);
 
     // Initialize worker with config
     const workerConfig: WorkerConfig = {
@@ -116,7 +120,7 @@ export class TEM {
    */
   async interruptBatch(
     batchId: string,
-    reason?: import('../interfaces/index.js').BatchInterruptionReason,
+    reason?: BatchInterruptionReason,
     message?: string
   ): Promise<void> {
     await this.interruption.interrupt(

package/src/database/index.ts

@@ -1,4 +1,6 @@
 import { Database as SQLiteDatabase, type SQLQueryBindings } from 'bun:sqlite';
+import { readFileSync } from 'fs';
+import { join } from 'path';
 import * as i from '../interfaces/index.js';
 
 export interface DatabaseOptions {
@@ -13,121 +15,22 @@ export class Database implements i.DatabaseConnection {
     this.db = new SQLiteDatabase(options.path);
 
     // Enable WAL mode for better concurrency
-    this.db.exec('PRAGMA journal_mode = WAL;');
+    this.db.run('PRAGMA journal_mode = WAL;');
 
     // Set busy timeout for concurrent access safety (default 5 seconds)
     const timeout = options.busyTimeout ?? 5000;
-    this.db.exec(`PRAGMA busy_timeout = ${timeout};`);
+    this.db.run(`PRAGMA busy_timeout = ${timeout};`);
 
-    // Run migrations
-    this.migrate();
+    // Initialize schema
+    this.initSchema();
   }
 
-  private migrate(): void {
-    // Create migration tracking table first
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS _migration (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        name TEXT NOT NULL UNIQUE,
-        applied_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
-      )
-    `);
+  private initSchema(): void {
+    // Read schema from file
+    const schemaPath = join(import.meta.dirname, 'schema.sql');
+    const schema = readFileSync(schemaPath, 'utf-8');
 
-    // Check and apply migrations in order
-    const migrations = [
-      { name: '001_initial_schema', apply: () => this.applyInitialSchema() },
-      { name: '002_batch_interruption', apply: () => this.applyBatchInterruptionMigration() },
-    ];
-
-    for (const migration of migrations) {
-      const migrationCount = this.db
-        .query('SELECT COUNT(*) as count FROM _migration WHERE name = $name')
-        .get({ $name: migration.name }) as { count: number };
-
-      if (migrationCount.count === 0) {
-        migration.apply();
-      }
-    }
-  }
-
-  private applyInitialSchema(): void {
-    const schema = `
-      -- Batch: Groups of related tasks
-      CREATE TABLE IF NOT EXISTS batch (
-        id TEXT PRIMARY KEY,
-        code TEXT NOT NULL UNIQUE,
-        type TEXT NOT NULL,
-        created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-        completed_at DATETIME,
-        metadata TEXT
-      );
-
-      -- Task: Individual units of work
-      CREATE TABLE IF NOT EXISTS task (
-        id TEXT PRIMARY KEY,
-        batch_id TEXT REFERENCES batch(id) ON DELETE CASCADE,
-        type TEXT NOT NULL,
-        status TEXT NOT NULL CHECK(status IN ('pending', 'running', 'completed', 'failed')),
-        payload TEXT NOT NULL,
-        result TEXT,
-        error TEXT,
-        attempt INTEGER NOT NULL DEFAULT 0,
-        max_attempt INTEGER NOT NULL DEFAULT 3,
-        claimed_at DATETIME,
-        completed_at DATETIME,
-        version INTEGER NOT NULL DEFAULT 0,
-        created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
-      );
-
-      -- Indexes for performance
-      CREATE INDEX IF NOT EXISTS idx_batch_code ON batch(code);
-      CREATE INDEX IF NOT EXISTS idx_batch_type ON batch(type);
-      CREATE INDEX IF NOT EXISTS idx_task_batch_id ON task(batch_id);
-      CREATE INDEX IF NOT EXISTS idx_task_status ON task(status);
-      CREATE INDEX IF NOT EXISTS idx_task_type ON task(type);
-      CREATE INDEX IF NOT EXISTS idx_task_claim ON task(status, claimed_at);
-      CREATE INDEX IF NOT EXISTS idx_task_pending ON task(status, created_at) WHERE status = 'pending';
-    `;
-
-    this.transaction(() => {
-      this.db.exec(schema);
-      this.db
-        .query('INSERT INTO _migration (name) VALUES ($name)')
-        .run({ $name: '001_initial_schema' });
-    });
-  }
-
-  private applyBatchInterruptionMigration(): void {
-    const migration = `
-      -- Add status to batch table
-      ALTER TABLE batch ADD COLUMN status TEXT NOT NULL DEFAULT 'active'
-        CHECK(status IN ('active', 'interrupted', 'completed'));
-
-      -- Add interruption criteria storage (JSON)
-      ALTER TABLE batch ADD COLUMN interruption_criteria TEXT;
-
-      -- Index for quickly finding active batches
-      CREATE INDEX IF NOT EXISTS idx_batch_status ON batch(status);
-
-      -- New table: interruption log
-      CREATE TABLE IF NOT EXISTS batch_interrupt_log (
-        id TEXT PRIMARY KEY,
-        batch_id TEXT NOT NULL REFERENCES batch(id) ON DELETE CASCADE,
-        reason TEXT NOT NULL,
-        message TEXT NOT NULL,
-        stats_snapshot TEXT NOT NULL, -- JSON of BatchStats
-        created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_interrupt_log_batch_id ON batch_interrupt_log(batch_id);
-    `;
-
-    this.transaction(() => {
-      this.db.exec(migration);
-      this.db
-        .query('INSERT INTO _migration (name) VALUES ($name)')
-        .run({ $name: '002_batch_interruption' });
-    });
+    this.db.run(schema);
   }
 
   query<T = unknown>(sql: string, params?: SQLQueryBindings[]): T[] {

package/src/database/schema.sql

@@ -1,5 +1,6 @@
 -- TEM Database Schema
 -- SQLite with WAL mode
+-- Complete schema - single source of truth for new databases
 
 -- Migration tracking
 CREATE TABLE IF NOT EXISTS _migration (
@@ -13,9 +14,12 @@ CREATE TABLE IF NOT EXISTS batch (
   id TEXT PRIMARY KEY,
   code TEXT NOT NULL UNIQUE,
   type TEXT NOT NULL,
+  status TEXT NOT NULL DEFAULT 'active'
+    CHECK(status IN ('active', 'interrupted', 'completed')),
   created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
   completed_at DATETIME,
-  metadata TEXT -- JSON object
+  metadata TEXT, -- JSON object
+  interruption_criteria TEXT -- JSON object
 );
 
 -- Task: Individual units of work
@@ -35,11 +39,23 @@ CREATE TABLE IF NOT EXISTS task (
   created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
 );
 
+-- Interruption log: Records batch interruption events
+CREATE TABLE IF NOT EXISTS batch_interrupt_log (
+  id TEXT PRIMARY KEY,
+  batch_id TEXT NOT NULL REFERENCES batch(id) ON DELETE CASCADE,
+  reason TEXT NOT NULL,
+  message TEXT NOT NULL,
+  stats_snapshot TEXT NOT NULL, -- JSON of BatchStats
+  created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
 -- Indexes for performance
 CREATE INDEX IF NOT EXISTS idx_batch_code ON batch(code);
 CREATE INDEX IF NOT EXISTS idx_batch_type ON batch(type);
+CREATE INDEX IF NOT EXISTS idx_batch_status ON batch(status);
 CREATE INDEX IF NOT EXISTS idx_task_batch_id ON task(batch_id);
 CREATE INDEX IF NOT EXISTS idx_task_status ON task(status);
 CREATE INDEX IF NOT EXISTS idx_task_type ON task(type);
 CREATE INDEX IF NOT EXISTS idx_task_claim ON task(status, claimed_at);
 CREATE INDEX IF NOT EXISTS idx_task_pending ON task(status, created_at) WHERE status = 'pending';
+CREATE INDEX IF NOT EXISTS idx_interrupt_log_batch_id ON batch_interrupt_log(batch_id);

package/src/interfaces/index.ts

@@ -105,6 +105,9 @@ export interface TEMConfig {
 
   // Polling
   pollIntervalMs: number;
+
+  // Default interruption criteria for all batches (batch-level overrides these)
+  defaultInterruptionCriteria?: BatchInterruptionCriteria;
 }
 
 // ============================================================================

package/src/services/batch-interruption.ts

@@ -13,7 +13,8 @@ export interface BatchInterruptionRow {
 export class BatchInterruptionService implements i.BatchInterruptionService {
   constructor(
     private db: Database,
-    private batchService: BatchService
+    private batchService: BatchService,
+    private defaultCriteria?: i.BatchInterruptionCriteria
   ) {}
 
   /**
@@ -30,13 +31,18 @@ export class BatchInterruptionService implements i.BatchInterruptionService {
     }
   ): Promise<boolean> {
     // Fetch batch with its interruption criteria
-    const { batch, criteria } = await this.batchService.getWithCriteria(batchId);
+    const { batch, criteria: batchCriteria } = await this.batchService.getWithCriteria(batchId);
 
     // If already interrupted or completed, no need to check
     if (batch.status !== 'active') {
       return false;
     }
 
+    // Merge criteria: TEM-level (default) overrides batch-level
+    const criteria: i.BatchInterruptionCriteria | undefined = batchCriteria || this.defaultCriteria
+      ? { ...batchCriteria, ...this.defaultCriteria }
+      : undefined;
+
     // If no criteria set, never interrupt
     if (!criteria) {
       return false;