@furlow/pipes 1.0.2 → 1.0.4

package/dist/index.js

@@ -159,6 +159,7 @@ var WebSocketPipe = class {
   config;
   reconnectAttempts = 0;
   reconnecting = false;
+  reconnectTimer = null;
   heartbeatInterval = null;
   messageHandlers = /* @__PURE__ */ new Map();
   connected = false;
@@ -206,6 +207,10 @@ var WebSocketPipe = class {
   async disconnect() {
     this.stopHeartbeat();
     this.reconnecting = false;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
     if (this.ws) {
       this.ws.close();
       this.ws = null;
@@ -238,13 +243,21 @@ var WebSocketPipe = class {
       return { success: false, error: "Not connected" };
     }
     return new Promise((resolve) => {
-      const timer = setTimeout(() => {
+      let resolved = false;
+      const cleanup = () => {
         this.off(responseEvent, handler);
+      };
+      const timer = setTimeout(() => {
+        if (resolved) return;
+        resolved = true;
+        cleanup();
         resolve({ success: false, error: "Request timeout" });
       }, timeout);
       const handler = (response) => {
+        if (resolved) return;
+        resolved = true;
         clearTimeout(timer);
-        this.off(responseEvent, handler);
+        cleanup();
         resolve({ success: true, data: response });
       };
       this.on(responseEvent, handler);
@@ -276,7 +289,12 @@ var WebSocketPipe = class {
     const handlers = this.messageHandlers.get(event) ?? [];
     for (const handler of handlers) {
       try {
-        handler(data);
+        const result = handler(data);
+        if (result instanceof Promise) {
+          result.catch((error) => {
+            console.error(`WebSocket async handler error for "${event}":`, error);
+          });
+        }
       } catch (error) {
         console.error(`WebSocket handler error for "${event}":`, error);
       }
@@ -314,14 +332,14 @@ var WebSocketPipe = class {
     }
     this.reconnecting = true;
     this.reconnectAttempts++;
-    setTimeout(async () => {
-      try {
-        await this.connect();
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.connect().then(() => {
         this.emit("reconnected", { attempts: this.reconnectAttempts });
-      } catch {
+      }).catch(() => {
         this.reconnecting = false;
         this.handleDisconnect();
-      }
+      });
     }, delay);
   }
   /**
@@ -454,10 +472,14 @@ var WebhookPipe = class {
         return receivedSignature === secret;
       }
       case "signature": {
-        return true;
+        const signatureValue = headers[signatureHeader.toLowerCase()];
+        if (!signatureValue) {
+          return false;
+        }
+        return this.timingSafeEqual(signatureValue, secret);
       }
       default:
-        return true;
+        return false;
     }
   }
   /**
@@ -722,7 +744,12 @@ var MqttPipe = class {
     const handlers = this.messageHandlers.get(event) ?? [];
     for (const handler of handlers) {
       try {
-        handler(event, data, {});
+        const result = handler(event, data, {});
+        if (result instanceof Promise) {
+          result.catch((error) => {
+            console.error(`MQTT async handler error for "${event}":`, error);
+          });
+        }
       } catch (error) {
         console.error(`MQTT handler error for "${event}":`, error);
       }
@@ -742,7 +769,12 @@ var MqttPipe = class {
     const exactHandlers = this.messageHandlers.get(topic) ?? [];
     for (const handler of exactHandlers) {
       try {
-        handler(topic, parsedPayload, packet);
+        const result = handler(topic, parsedPayload, packet);
+        if (result instanceof Promise) {
+          result.catch((error) => {
+            console.error(`MQTT async handler error for topic "${topic}":`, error);
+          });
+        }
       } catch (error) {
         console.error(`MQTT handler error for topic "${topic}":`, error);
       }
@@ -751,7 +783,12 @@ var MqttPipe = class {
       if (this.topicMatches(pattern, topic)) {
         for (const handler of handlers) {
           try {
-            handler(topic, parsedPayload, packet);
+            const result = handler(topic, parsedPayload, packet);
+            if (result instanceof Promise) {
+              result.catch((error) => {
+                console.error(`MQTT async wildcard handler error for pattern "${pattern}":`, error);
+              });
+            }
           } catch (error) {
             console.error(`MQTT wildcard handler error for pattern "${pattern}":`, error);
           }
@@ -975,7 +1012,12 @@ var UdpPipe = class {
     const handlers = this.eventHandlers.get(event) ?? [];
     for (const handler of handlers) {
       try {
-        handler(data);
+        const result = handler(data);
+        if (result instanceof Promise) {
+          result.catch((error) => {
+            console.error(`UDP async handler error for "${event}":`, error);
+          });
+        }
       } catch (error) {
         console.error(`UDP handler error for "${event}":`, error);
       }
@@ -988,7 +1030,12 @@ var UdpPipe = class {
     const msg = { data, rinfo };
     for (const handler of this.messageHandlers) {
       try {
-        handler(msg);
+        const result = handler(msg);
+        if (result instanceof Promise) {
+          result.catch((error) => {
+            console.error("UDP async message handler error:", error);
+          });
+        }
       } catch (error) {
         console.error("UDP message handler error:", error);
       }
@@ -1010,6 +1057,7 @@ var TcpPipe = class {
   connected = false;
   reconnectAttempts = 0;
   reconnecting = false;
+  reconnectTimer = null;
   dataHandlers = [];
   eventHandlers = /* @__PURE__ */ new Map();
   constructor(options) {
@@ -1091,6 +1139,10 @@ var TcpPipe = class {
    */
   async disconnect() {
     this.reconnecting = false;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
     return new Promise((resolve) => {
       if (this.socket) {
         this.socket.end(() => {
@@ -1142,13 +1194,21 @@ var TcpPipe = class {
       return { success: false, error: "Not connected" };
     }
     return new Promise((resolve) => {
-      const timer = setTimeout(() => {
+      let resolved = false;
+      const cleanup = () => {
         this.offData(handler);
+      };
+      const timer = setTimeout(() => {
+        if (resolved) return;
+        resolved = true;
+        cleanup();
         resolve({ success: false, error: "Request timeout" });
       }, timeout);
       const handler = (response) => {
+        if (resolved) return;
+        resolved = true;
         clearTimeout(timer);
-        this.offData(handler);
+        cleanup();
         resolve({ success: true, data: response });
       };
       this.onData(handler);
@@ -1195,7 +1255,12 @@ var TcpPipe = class {
     const handlers = this.eventHandlers.get(event) ?? [];
     for (const handler of handlers) {
       try {
-        handler(data);
+        const result = handler(data);
+        if (result instanceof Promise) {
+          result.catch((error) => {
+            console.error(`TCP async handler error for "${event}":`, error);
+          });
+        }
       } catch (error) {
         console.error(`TCP handler error for "${event}":`, error);
       }
@@ -1207,7 +1272,12 @@ var TcpPipe = class {
   handleData(data) {
     for (const handler of this.dataHandlers) {
       try {
-        handler(data);
+        const result = handler(data);
+        if (result instanceof Promise) {
+          result.catch((error) => {
+            console.error("TCP async data handler error:", error);
+          });
+        }
       } catch (error) {
         console.error("TCP data handler error:", error);
       }
@@ -1229,14 +1299,14 @@ var TcpPipe = class {
     }
     this.reconnecting = true;
     this.reconnectAttempts++;
-    setTimeout(async () => {
-      try {
-        await this.connect();
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.connect().then(() => {
         this.emit("reconnected", { attempts: this.reconnectAttempts });
-      } catch {
+      }).catch(() => {
         this.reconnecting = false;
         this.handleDisconnect();
-      }
+      });
     }, delay);
   }
   /**
@@ -1266,6 +1336,12 @@ function createTcpPipe(options) {
 }
 
 // src/database/index.ts
+function escapeIdentifier(name) {
+  if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
+    throw new Error(`Invalid SQL identifier: ${name}`);
+  }
+  return `"${name}"`;
+}
 var DatabasePipe = class {
   name;
   type = "database";
@@ -1289,6 +1365,18 @@ var DatabasePipe = class {
         const BetterSqlite3 = (await import("better-sqlite3")).default;
         const connectionString = typeof this.config.connection === "string" ? this.config.connection : ":memory:";
         this.db = new BetterSqlite3(connectionString);
+      } else if (this.config.adapter === "postgres") {
+        const pgModuleName = "pg";
+        const pg = await new Function("m", "return import(m)")(pgModuleName).catch(() => null);
+        if (!pg) {
+          throw new Error('PostgreSQL adapter requires the "pg" package. Install it with: npm install pg');
+        }
+        const { Pool } = pg;
+        const connectionString = typeof this.config.connection === "string" ? this.config.connection : void 0;
+        const connectionOptions = typeof this.config.connection === "object" ? this.config.connection : void 0;
+        this.db = new PostgresWrapper(
+          connectionString ? new Pool({ connectionString }) : new Pool(connectionOptions)
+        );
       } else if (this.config.adapter === "memory") {
         this.db = new MemoryDatabase();
       } else {
@@ -1315,6 +1403,8 @@ var DatabasePipe = class {
     try {
       if (this.config.adapter === "sqlite" && this.db) {
         this.db.close();
+      } else if (this.config.adapter === "postgres" && this.db) {
+        await this.db.close();
       }
       this.db = null;
       this.connected = false;
@@ -1351,6 +1441,9 @@ var DatabasePipe = class {
           const result = stmt.run(...params);
           return { success: true, data: result };
         }
+      } else if (this.config.adapter === "postgres") {
+        const result = await this.db.query(sql, params);
+        return { success: true, data: result };
       } else if (this.config.adapter === "memory") {
         const result = this.db.query(sql, params);
         return { success: true, data: result };
@@ -1372,11 +1465,15 @@ var DatabasePipe = class {
       const columns = Object.keys(data);
       const values = Object.values(data);
       const placeholders = columns.map(() => "?").join(", ");
-      const sql = `INSERT INTO ${table} (${columns.join(", ")}) VALUES (${placeholders})`;
+      const escapedTable = escapeIdentifier(table);
+      const escapedColumns = columns.map((c) => escapeIdentifier(c)).join(", ");
+      const sql = `INSERT INTO ${escapedTable} (${escapedColumns}) VALUES (${placeholders})`;
       let result = {};
       if (this.config.adapter === "sqlite") {
         const stmt = this.db.prepare(sql);
         result = stmt.run(...values);
+      } else if (this.config.adapter === "postgres") {
+        result = await this.db.insert(table, data);
       } else if (this.config.adapter === "memory") {
         result = this.db.insert(table, data);
       }
@@ -1401,14 +1498,17 @@ var DatabasePipe = class {
       return { success: false, error: "Not connected" };
     }
     try {
-      const setClauses = Object.keys(data).map((key) => `${key} = ?`).join(", ");
-      const whereClauses = Object.keys(where).map((key) => `${key} = ?`).join(" AND ");
-      const sql = `UPDATE ${table} SET ${setClauses} WHERE ${whereClauses}`;
+      const escapedTable = escapeIdentifier(table);
+      const setClauses = Object.keys(data).map((key) => `${escapeIdentifier(key)} = ?`).join(", ");
+      const whereClauses = Object.keys(where).map((key) => `${escapeIdentifier(key)} = ?`).join(" AND ");
+      const sql = `UPDATE ${escapedTable} SET ${setClauses} WHERE ${whereClauses}`;
       const params = [...Object.values(data), ...Object.values(where)];
       let result = {};
       if (this.config.adapter === "sqlite") {
         const stmt = this.db.prepare(sql);
         result = stmt.run(...params);
+      } else if (this.config.adapter === "postgres") {
+        result = await this.db.update(table, where, data);
       } else if (this.config.adapter === "memory") {
         result = this.db.update(table, where, data);
       }
@@ -1434,13 +1534,16 @@ var DatabasePipe = class {
       return { success: false, error: "Not connected" };
     }
     try {
-      const whereClauses = Object.keys(where).map((key) => `${key} = ?`).join(" AND ");
-      const sql = `DELETE FROM ${table} WHERE ${whereClauses}`;
+      const escapedTable = escapeIdentifier(table);
+      const whereClauses = Object.keys(where).map((key) => `${escapeIdentifier(key)} = ?`).join(" AND ");
+      const sql = `DELETE FROM ${escapedTable} WHERE ${whereClauses}`;
       const params = Object.values(where);
       let result = {};
       if (this.config.adapter === "sqlite") {
         const stmt = this.db.prepare(sql);
         result = stmt.run(...params);
+      } else if (this.config.adapter === "postgres") {
+        result = await this.db.delete(table, where);
       } else if (this.config.adapter === "memory") {
         result = this.db.delete(table, where);
       }
@@ -1492,14 +1595,68 @@ var DatabasePipe = class {
 var MemoryDatabase = class {
   tables = /* @__PURE__ */ new Map();
   autoIncrements = /* @__PURE__ */ new Map();
-  query(sql, _params) {
-    const selectMatch = sql.match(/SELECT \* FROM (\w+)/i);
+  query(sql, params) {
+    const selectMatch = sql.match(
+      /SELECT\s+(\*|[\w,\s]+)\s+FROM\s+["']?(\w+)["']?(?:\s+WHERE\s+(.+?))?(?:\s+ORDER\s+BY\s+([\w\s,]+?)(?:\s+(ASC|DESC))?)?(?:\s+LIMIT\s+(\d+))?(?:\s+OFFSET\s+(\d+))?$/i
+    );
     if (selectMatch) {
-      const table = selectMatch[1];
-      return this.tables.get(table) ?? [];
+      const [, columns, table, whereClause, orderBy, orderDir, limitStr, offsetStr] = selectMatch;
+      let rows = [...this.tables.get(table) ?? []];
+      if (whereClause) {
+        const where = this.parseWhereClause(whereClause, params);
+        rows = rows.filter((row) => this.matchesWhere(row, where));
+      }
+      if (orderBy) {
+        const col = orderBy.trim();
+        const direction = orderDir?.toUpperCase() === "DESC" ? -1 : 1;
+        rows.sort((a, b) => {
+          const aVal = a[col];
+          const bVal = b[col];
+          if (aVal === bVal) return 0;
+          if (aVal === null || aVal === void 0) return direction;
+          if (bVal === null || bVal === void 0) return -direction;
+          return (aVal < bVal ? -1 : 1) * direction;
+        });
+      }
+      if (offsetStr) {
+        const offset = parseInt(offsetStr, 10);
+        rows = rows.slice(offset);
+      }
+      if (limitStr) {
+        const limit = parseInt(limitStr, 10);
+        rows = rows.slice(0, limit);
+      }
+      if (columns !== "*") {
+        const cols = columns.split(",").map((c) => c.trim());
+        rows = rows.map((row) => {
+          const result = {};
+          for (const col of cols) {
+            result[col] = row[col];
+          }
+          return result;
+        });
+      }
+      return rows;
     }
+    console.warn(`MemoryDatabase: Unsupported query: ${sql}`);
     return [];
   }
+  /**
+   * Parse a simple WHERE clause into key-value pairs
+   * Supports: col = ? AND col2 = ?
+   */
+  parseWhereClause(whereClause, params) {
+    const where = {};
+    let paramIndex = 0;
+    const conditions = whereClause.split(/\s+AND\s+/i);
+    for (const condition of conditions) {
+      const match = condition.match(/["']?(\w+)["']?\s*=\s*\?/);
+      if (match) {
+        where[match[1]] = params[paramIndex++];
+      }
+    }
+    return where;
+  }
   insert(table, data) {
     if (!this.tables.has(table)) {
       this.tables.set(table, []);
@@ -1537,6 +1694,54 @@ var MemoryDatabase = class {
     return true;
   }
 };
+var PostgresWrapper = class {
+  pool;
+  constructor(pool) {
+    this.pool = pool;
+  }
+  async query(sql, params) {
+    let paramIndex = 0;
+    const pgSql = sql.replace(/\?/g, () => `$${++paramIndex}`);
+    const result = await this.pool.query(pgSql, params);
+    return result.rows;
+  }
+  async insert(table, data) {
+    const columns = Object.keys(data);
+    const values = Object.values(data);
+    const placeholders = columns.map((_, i) => `$${i + 1}`).join(", ");
+    const escapedTable = escapeIdentifier(table);
+    const escapedColumns = columns.map((c) => escapeIdentifier(c)).join(", ");
+    const result = await this.pool.query(
+      `INSERT INTO ${escapedTable} (${escapedColumns}) VALUES (${placeholders}) RETURNING id`,
+      values
+    );
+    const row = result.rows[0];
+    return { lastInsertRowid: row?.id };
+  }
+  async update(table, where, data) {
+    const escapedTable = escapeIdentifier(table);
+    const setClauses = Object.keys(data).map((key, i) => `${escapeIdentifier(key)} = $${i + 1}`).join(", ");
+    const whereClauses = Object.keys(where).map((key, i) => `${escapeIdentifier(key)} = $${Object.keys(data).length + i + 1}`).join(" AND ");
+    const params = [...Object.values(data), ...Object.values(where)];
+    const result = await this.pool.query(
+      `UPDATE ${escapedTable} SET ${setClauses} WHERE ${whereClauses}`,
+      params
+    );
+    return { changes: result.rowCount ?? 0 };
+  }
+  async delete(table, where) {
+    const escapedTable = escapeIdentifier(table);
+    const whereClauses = Object.keys(where).map((key, i) => `${escapeIdentifier(key)} = $${i + 1}`).join(" AND ");
+    const result = await this.pool.query(
+      `DELETE FROM ${escapedTable} WHERE ${whereClauses}`,
+      Object.values(where)
+    );
+    return { changes: result.rowCount ?? 0 };
+  }
+  async close() {
+    await this.pool.end();
+  }
+};
 function createDatabasePipe(options) {
   return new DatabasePipe(options);
 }