clawlet 0.3.0 → 0.4.0

package/src/storage.ts

@@ -5,10 +5,16 @@ export class LibSqlKeyValueStorage {
   private client: Client;
   private tableName: string;
 
-  constructor(url: string, authToken?: string, tableName = 'kv_store') {
+
+  private constructor(url: string, authToken?: string, tableName = 'kv_store') {
+    this.client = authToken ? createClient({ url, authToken }) : createClient({ url });
     this.tableName = tableName;
-    this.client = createClient({ url, authToken });
-    this.init();
+  }
+
+  static async create<T>(url: string, authToken?: string, tableName = 'kv_store') {
+    const s = new LibSqlKeyValueStorage(url, authToken, tableName);
+    await s.init();
+    return s;
   }
 
   private async init() {
@@ -61,130 +67,176 @@ export class LibSqlKeyValueStorage {
 // --- B. List Storage (für History/Logs) ---
 export class LibSqlListStorage<T = any> {
   private client: Client;
-  private tableName: string;
-
-  constructor(url: string, authToken?: string, tableName = 'list_store') {
-    this.tableName = tableName;
-    this.client = createClient({ url, authToken });
-    this.init();
-  }
-
-  private async init() {
-    await this.client.execute(`
-      CREATE TABLE IF NOT EXISTS ${this.tableName} (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        item TEXT,
-        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
-      )
-    `);
-  }
-
-  async push(item: T) {
-    await this.client.execute({
-      sql: `INSERT INTO ${this.tableName} (item) VALUES (?)`,
-      args: [JSON.stringify(item)]
-    });
-  }
-
-  // Bulk Insert für Performance
-  async pushMany(items: T[]) {
-    const promises = items.map(item => this.client.execute({
-        sql: `INSERT INTO ${this.tableName} (item) VALUES (?)`,
-        args: [JSON.stringify(item)]
-    }));
-    await Promise.all(promises);
-  }
-
-  async getAll(): Promise<T[]> {
-    const rs = await this.client.execute(
-      `SELECT item FROM ${this.tableName} ORDER BY id ASC`
-    );
-    return rs.rows.map(row => JSON.parse(row.item as string));
-  }
-  
-  // Optional: Nur die letzten N Nachrichten holen (Kontext-Fenster!)
-  async getRecent(limit: number): Promise<T[]> {
-     // Trick: Erst sortieren DESC (neueste), limitieren, dann wieder ASC sortieren
-     const rs = await this.client.execute({
-        sql: `SELECT * FROM (
-                SELECT item, id FROM ${this.tableName} ORDER BY id DESC LIMIT ?
-              ) ORDER BY id ASC`,
-        args: [limit]
-     });
-     return rs.rows.map(row => JSON.parse(row.item as string));
-  }
-
-  async count(): Promise<number> {
-    const rs = await this.client.execute(
-      `SELECT COUNT(*) as cnt FROM ${this.tableName}`
-    );
-    return Number(rs.rows[0]?.cnt ?? 0);
-  }
+  private tableName = 'list_items';
 
-  async clear() {
-    await this.client.execute(`DELETE FROM ${this.tableName}`);
-    // Reset autoincrement so IDs stay clean
-    await this.client.execute(
-      `DELETE FROM sqlite_sequence WHERE name = '${this.tableName}'`
-    );
+  private constructor(url: string, authToken?: string) {
+    this.client = authToken ? createClient({ url, authToken }) : createClient({ url });
   }
-}
 
-// --- C. Skill History Storage (single table, partitioned by skill name) ---
-export class SkillHistoryStorage<T = any> {
-  private client: Client;
-
-  constructor(url: string, authToken?: string) {
-    this.client = createClient({ url, authToken });
-    this.init();
+  static async create<T>(url: string, authToken?: string) {
+    const s = new LibSqlListStorage(url, authToken);
+    await s.init();
+    return s;
   }
 
   private async init() {
     await this.client.execute(`
-      CREATE TABLE IF NOT EXISTS skill_history (
+      CREATE TABLE IF NOT EXISTS ${this.tableName} (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         name TEXT NOT NULL,
-        item TEXT,
+        item TEXT NOT NULL,
         created_at DATETIME DEFAULT CURRENT_TIMESTAMP
       )
     `);
   }
 
-  async push(name: string, item: T) {
+  async push(name: string, item: T): Promise<void> {
     await this.client.execute({
-      sql: `INSERT INTO skill_history (name, item) VALUES (?, ?)`,
+      sql: `INSERT INTO ${this.tableName} (name, item) VALUES (?, ?)`,
       args: [name, JSON.stringify(item)]
     });
   }
 
-  async pushMany(name: string, items: T[]) {
-    const promises = items.map(item => this.client.execute({
-      sql: `INSERT INTO skill_history (name, item) VALUES (?, ?)`,
-      args: [name, JSON.stringify(item)]
-    }));
-    await Promise.all(promises);
+  async pushMany(name: string, items: T[]): Promise<void> {
+    for (const item of items) {
+      this.push(name, item);
+    }
+  }
+
+  async replaceAll(name: string, items: T[]): Promise<void> {
+    const tx = await this.client.transaction();
+    try {
+        await tx.execute({
+            sql: `DELETE FROM ${this.tableName} WHERE name = ?`,
+            args: [name],
+        });
+        for (const item of items) {
+            await tx.execute({
+                sql: `INSERT INTO ${this.tableName} (name, item) VALUES (?, ?)`,
+                args: [name, JSON.stringify(item)]
+            });
+        }
+        await tx.commit();
+    } catch (e) {
+        await tx.rollback();
+        throw e;
+    }
   }
 
   async getAll(name: string): Promise<T[]> {
     const rs = await this.client.execute({
-      sql: `SELECT item FROM skill_history WHERE name = ? ORDER BY id ASC`,
+      sql: `SELECT item FROM ${this.tableName} WHERE name = ? ORDER BY id ASC`,
       args: [name]
     });
     return rs.rows.map(row => JSON.parse(row.item as string));
   }
-
-  async clear(name: string) {
-    await this.client.execute({
-      sql: `DELETE FROM skill_history WHERE name = ?`,
+  
+  async count(name: string): Promise<number> {
+    const rs = await this.client.execute({
+      sql: `SELECT COUNT(*) as cnt FROM ${this.tableName} WHERE name = ?`,
       args: [name]
     });
+    return Number(rs.rows[0]?.cnt ?? 0);
   }
 
-  async count(name: string): Promise<number> {
-    const rs = await this.client.execute({
-      sql: `SELECT COUNT(*) as cnt FROM skill_history WHERE name = ?`,
+  async clear(name: string): Promise<void> {
+    await this.client.execute({
+      sql: `DELETE FROM ${this.tableName} WHERE name = ?`,
       args: [name]
     });
-    return Number(rs.rows[0]?.cnt ?? 0);
   }
 }
+
+
+export class LibSqlFiFoStorage<T> {
+    private client: Client;
+    private tableName = 'queue_items';
+
+    constructor(url: string, authToken?: string) {
+        this.client = authToken ? createClient({ url, authToken }) : createClient({ url });
+        this.init();
+    }
+
+    private async init(): Promise<void> {
+        await this.client.execute(`
+            CREATE TABLE IF NOT EXISTS ${this.tableName} (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                queue_name TEXT NOT NULL,
+                value TEXT NOT NULL,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            );
+        `);
+    }
+
+    public async push(queue: string, item: T): Promise<void> {
+        await this.client.execute({
+            sql: `INSERT INTO ${this.tableName} (queue_name, value) VALUES (?, ?)`,
+            args: [queue, JSON.stringify(item)],
+        });
+    }
+
+    public async pushMany(queue: string, items: T[]): Promise<void> {
+        const tx = await this.client.transaction();
+        try {
+            for (const item of items) {
+                await tx.execute({
+                    sql: `INSERT INTO ${this.tableName} (queue_name, value) VALUES (?, ?)`,
+                    args: [queue, JSON.stringify(item)],
+                });
+            }
+            await tx.commit();
+        } catch (e) {
+            await tx.rollback();
+            throw e;
+        }
+    }
+
+    public async empty(queue: string): Promise<boolean> {
+        return (await this.count(queue)) === 0;
+    }
+
+    public async pop(queue: string): Promise<T | null> {
+        const tx = await this.client.transaction();
+        try {
+            const rs = await tx.execute({
+                sql: `SELECT id, value FROM ${this.tableName} WHERE queue_name = ? ORDER BY id ASC LIMIT 1`,
+                args: [queue],
+            });
+
+            if (rs.rows.length === 0) {
+                await tx.commit();
+                return null;
+            }
+
+            const row = rs.rows[0] as any;
+            const id = row.id;
+
+            await tx.execute({
+                sql: `DELETE FROM ${this.tableName} WHERE id = ?`,
+                args: [id!],
+            });
+
+            await tx.commit();
+
+            return JSON.parse(row.value as string) as T;
+        } catch (e) {
+            await tx.rollback();
+            throw e;
+        }
+    }
+
+    public async count(queue: string): Promise<number> {
+        const rs = await this.client.execute({
+            sql: `SELECT COUNT(*) as count FROM ${this.tableName} WHERE queue_name = ?`,
+            args: [queue],
+        });
+        return (rs.rows[0]?.count as number) ?? 0;
+    }
+
+    public async clear(queue: string): Promise<void> {
+        await this.client.execute({
+            sql: `DELETE FROM ${this.tableName} WHERE queue_name = ?`,
+            args: [queue],
+        });
+    }
+}