@furlow/pipes 0.2.1 → 1.0.0

package/dist/index.d.ts

@@ -3,5 +3,7 @@ export { WebSocketMessageHandler, WebSocketPipe, WebSocketPipeOptions, createWeb
 export { WebhookHandler, WebhookPipe, WebhookPipeOptions, WebhookSender, createWebhookPipe } from './webhook/index.js';
 export { MqttMessageHandler, MqttPipe, MqttPipeOptions, createMqttPipe } from './mqtt/index.js';
 export { TcpDataHandler, TcpEventHandler, TcpPipe, TcpPipeOptions, UdpEventHandler, UdpMessage, UdpMessageHandler, UdpPipe, UdpPipeOptions, createTcpPipe, createUdpPipe } from './tcp/index.js';
-export { H as HttpAuthConfig, a as HttpAuthType, b as HttpPipeConfig, c as HttpRateLimitConfig, M as MqttAuthConfig, d as MqttPipeConfig, e as MqttQoS, P as Pipe, f as PipeResponse, T as TcpPipeConfig, U as UdpPipeConfig, W as WebSocketPipeConfig, g as WebhookPipeConfig, h as WebhookVerification } from './types-BW9r2ksN.js';
+export { DatabaseEventHandler, DatabasePipe, DatabasePipeOptions, createDatabasePipe } from './database/index.js';
+export { FileEventHandler, FilePipe, FilePipeOptions, createFilePipe } from './file/index.js';
+export { D as DatabaseAdapter, a as DatabaseEvent, b as DatabaseEventType, c as DatabasePipeConfig, F as FileEvent, d as FileEventType, e as FilePipeConfig, H as HttpAuthConfig, f as HttpAuthType, g as HttpPipeConfig, h as HttpRateLimitConfig, M as MqttAuthConfig, i as MqttPipeConfig, j as MqttQoS, P as Pipe, k as PipeResponse, T as TcpPipeConfig, U as UdpPipeConfig, W as WebSocketPipeConfig, l as WebhookPipeConfig, m as WebhookVerification } from './types-B6Zdv6jc.js';
 import 'dgram';

package/dist/index.js

@@ -1264,7 +1264,470 @@ var TcpPipe = class {
 function createTcpPipe(options) {
   return new TcpPipe(options);
 }
+
+// src/database/index.ts
+var DatabasePipe = class {
+  name;
+  type = "database";
+  config;
+  connected = false;
+  db = null;
+  eventHandlers = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.name = options.name;
+    this.config = options.config;
+  }
+  /**
+   * Connect to the database
+   */
+  async connect() {
+    if (this.connected) {
+      return;
+    }
+    try {
+      if (this.config.adapter === "sqlite") {
+        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 === "memory") {
+        this.db = new MemoryDatabase();
+      } else {
+        throw new Error(`Unsupported adapter: ${this.config.adapter}`);
+      }
+      this.connected = true;
+      this.emit("connected", {
+        type: "insert",
+        table: "",
+        data: {}
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to connect to database: ${message}`);
+    }
+  }
+  /**
+   * Disconnect from the database
+   */
+  async disconnect() {
+    if (!this.connected) {
+      return;
+    }
+    try {
+      if (this.config.adapter === "sqlite" && this.db) {
+        this.db.close();
+      }
+      this.db = null;
+      this.connected = false;
+      this.emit("disconnected", {
+        type: "delete",
+        table: "",
+        data: {}
+      });
+    } catch {
+      this.db = null;
+      this.connected = false;
+    }
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.connected;
+  }
+  /**
+   * Execute a raw SQL query
+   */
+  async query(sql, params = []) {
+    if (!this.isConnected()) {
+      return { success: false, error: "Not connected" };
+    }
+    try {
+      if (this.config.adapter === "sqlite") {
+        const stmt = this.db.prepare(sql);
+        if (sql.trim().toUpperCase().startsWith("SELECT")) {
+          const rows = stmt.all(...params);
+          return { success: true, data: rows };
+        } else {
+          const result = stmt.run(...params);
+          return { success: true, data: result };
+        }
+      } else if (this.config.adapter === "memory") {
+        const result = this.db.query(sql, params);
+        return { success: true, data: result };
+      }
+      return { success: false, error: "Unsupported adapter" };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return { success: false, error: message };
+    }
+  }
+  /**
+   * Insert a row into a table
+   */
+  async insert(table, data) {
+    if (!this.isConnected()) {
+      return { success: false, error: "Not connected" };
+    }
+    try {
+      const columns = Object.keys(data);
+      const values = Object.values(data);
+      const placeholders = columns.map(() => "?").join(", ");
+      const sql = `INSERT INTO ${table} (${columns.join(", ")}) VALUES (${placeholders})`;
+      let result = {};
+      if (this.config.adapter === "sqlite") {
+        const stmt = this.db.prepare(sql);
+        result = stmt.run(...values);
+      } else if (this.config.adapter === "memory") {
+        result = this.db.insert(table, data);
+      }
+      const event = {
+        type: "insert",
+        table,
+        data
+      };
+      this.emit("insert", event);
+      this.emit("change", event);
+      return { success: true, data: result };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return { success: false, error: message };
+    }
+  }
+  /**
+   * Update rows in a table
+   */
+  async update(table, where, data) {
+    if (!this.isConnected()) {
+      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 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 === "memory") {
+        result = this.db.update(table, where, data);
+      }
+      const event = {
+        type: "update",
+        table,
+        data,
+        oldData: where
+      };
+      this.emit("update", event);
+      this.emit("change", event);
+      return { success: true, data: result };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return { success: false, error: message };
+    }
+  }
+  /**
+   * Delete rows from a table
+   */
+  async delete(table, where) {
+    if (!this.isConnected()) {
+      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 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 === "memory") {
+        result = this.db.delete(table, where);
+      }
+      const event = {
+        type: "delete",
+        table,
+        data: where
+      };
+      this.emit("delete", event);
+      this.emit("change", event);
+      return { success: true, data: result };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return { success: false, error: message };
+    }
+  }
+  /**
+   * Register an event handler
+   */
+  on(event, handler) {
+    const handlers = this.eventHandlers.get(event) ?? [];
+    handlers.push(handler);
+    this.eventHandlers.set(event, handlers);
+  }
+  /**
+   * Remove an event handler
+   */
+  off(event, handler) {
+    const handlers = this.eventHandlers.get(event) ?? [];
+    const index = handlers.indexOf(handler);
+    if (index !== -1) {
+      handlers.splice(index, 1);
+    }
+  }
+  /**
+   * Emit an event
+   */
+  emit(event, data) {
+    const handlers = this.eventHandlers.get(event) ?? [];
+    for (const handler of handlers) {
+      try {
+        handler(data);
+      } catch (error) {
+        console.error(`Database handler error for "${event}":`, error);
+      }
+    }
+  }
+};
+var MemoryDatabase = class {
+  tables = /* @__PURE__ */ new Map();
+  autoIncrements = /* @__PURE__ */ new Map();
+  query(sql, _params) {
+    const selectMatch = sql.match(/SELECT \* FROM (\w+)/i);
+    if (selectMatch) {
+      const table = selectMatch[1];
+      return this.tables.get(table) ?? [];
+    }
+    return [];
+  }
+  insert(table, data) {
+    if (!this.tables.has(table)) {
+      this.tables.set(table, []);
+    }
+    const id = (this.autoIncrements.get(table) ?? 0) + 1;
+    this.autoIncrements.set(table, id);
+    const row = { id, ...data };
+    this.tables.get(table).push(row);
+    return { lastInsertRowid: id };
+  }
+  update(table, where, data) {
+    const rows = this.tables.get(table) ?? [];
+    let changes = 0;
+    for (const row of rows) {
+      if (this.matchesWhere(row, where)) {
+        Object.assign(row, data);
+        changes++;
+      }
+    }
+    return { changes };
+  }
+  delete(table, where) {
+    const rows = this.tables.get(table) ?? [];
+    const initialLength = rows.length;
+    const remaining = rows.filter((row) => !this.matchesWhere(row, where));
+    this.tables.set(table, remaining);
+    return { changes: initialLength - remaining.length };
+  }
+  matchesWhere(row, where) {
+    for (const [key, value] of Object.entries(where)) {
+      if (row[key] !== value) {
+        return false;
+      }
+    }
+    return true;
+  }
+};
+function createDatabasePipe(options) {
+  return new DatabasePipe(options);
+}
+
+// src/file/index.ts
+import chokidar from "chokidar";
+var FilePipe = class {
+  name;
+  type = "file";
+  watcher = null;
+  config;
+  watching = false;
+  eventHandlers = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.name = options.name;
+    this.config = options.config;
+  }
+  /**
+   * Start watching files (alias for connect)
+   */
+  async watch() {
+    return this.connect();
+  }
+  /**
+   * Start watching files
+   */
+  async connect() {
+    if (this.watching) {
+      return;
+    }
+    return new Promise((resolve, reject) => {
+      try {
+        this.watcher = chokidar.watch(this.config.paths, {
+          ignored: this.config.ignore,
+          persistent: this.config.persistent ?? true,
+          usePolling: this.config.usePolling ?? false,
+          ignoreInitial: true
+        });
+        this.watcher.on("ready", () => {
+          this.watching = true;
+          resolve();
+        });
+        this.watcher.on("error", (error) => {
+          if (!this.watching) {
+            reject(error);
+          }
+          this.emit("error", {
+            type: "change",
+            path: ""
+          });
+        });
+        this.watcher.on("add", (path, stats) => {
+          const event = {
+            type: "add",
+            path,
+            stats: stats ? {
+              size: stats.size,
+              mtime: stats.mtime,
+              isDirectory: stats.isDirectory()
+            } : void 0
+          };
+          this.emit("add", event);
+          this.emit("all", event);
+        });
+        this.watcher.on("change", (path, stats) => {
+          const event = {
+            type: "change",
+            path,
+            stats: stats ? {
+              size: stats.size,
+              mtime: stats.mtime,
+              isDirectory: stats.isDirectory()
+            } : void 0
+          };
+          this.emit("change", event);
+          this.emit("all", event);
+        });
+        this.watcher.on("unlink", (path) => {
+          const event = {
+            type: "unlink",
+            path
+          };
+          this.emit("unlink", event);
+          this.emit("all", event);
+        });
+        this.watcher.on("addDir", (path, stats) => {
+          const event = {
+            type: "addDir",
+            path,
+            stats: stats ? {
+              size: stats.size,
+              mtime: stats.mtime,
+              isDirectory: true
+            } : void 0
+          };
+          this.emit("addDir", event);
+          this.emit("all", event);
+        });
+        this.watcher.on("unlinkDir", (path) => {
+          const event = {
+            type: "unlinkDir",
+            path
+          };
+          this.emit("unlinkDir", event);
+          this.emit("all", event);
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Stop watching files
+   */
+  async disconnect() {
+    if (!this.watcher) {
+      return;
+    }
+    await this.watcher.close();
+    this.watcher = null;
+    this.watching = false;
+  }
+  /**
+   * Check if watching
+   */
+  isConnected() {
+    return this.watching;
+  }
+  /**
+   * Add paths to watch
+   */
+  add(paths) {
+    if (this.watcher) {
+      this.watcher.add(paths);
+    }
+  }
+  /**
+   * Stop watching specific paths
+   */
+  unwatch(paths) {
+    if (this.watcher) {
+      this.watcher.unwatch(paths);
+    }
+  }
+  /**
+   * Get watched paths
+   */
+  getWatched() {
+    if (this.watcher) {
+      return this.watcher.getWatched();
+    }
+    return {};
+  }
+  /**
+   * Register an event handler
+   */
+  on(event, handler) {
+    const handlers = this.eventHandlers.get(event) ?? [];
+    handlers.push(handler);
+    this.eventHandlers.set(event, handlers);
+  }
+  /**
+   * Remove an event handler
+   */
+  off(event, handler) {
+    const handlers = this.eventHandlers.get(event) ?? [];
+    const index = handlers.indexOf(handler);
+    if (index !== -1) {
+      handlers.splice(index, 1);
+    }
+  }
+  /**
+   * Emit an event
+   */
+  emit(event, data) {
+    const handlers = this.eventHandlers.get(event) ?? [];
+    for (const handler of handlers) {
+      try {
+        handler(data);
+      } catch (error) {
+        console.error(`File handler error for "${event}":`, error);
+      }
+    }
+  }
+};
+function createFilePipe(options) {
+  return new FilePipe(options);
+}
 export {
+  DatabasePipe,
+  FilePipe,
   HttpPipe,
   MqttPipe,
   TcpPipe,
@@ -1272,6 +1735,8 @@ export {
   WebSocketPipe,
   WebhookPipe,
   WebhookSender,
+  createDatabasePipe,
+  createFilePipe,
   createHttpPipe,
   createMqttPipe,
   createTcpPipe,