@vipin733/nodescope 0.1.0

package/dist/chunk-6KBKW63X.js

@@ -0,0 +1,145 @@
+import {
+  defaultEntryCounts
+} from "./chunk-OF6NKXP5.js";
+
+// src/storage/memory.ts
+var MemoryStorage = class {
+  entries = /* @__PURE__ */ new Map();
+  entriesByBatch = /* @__PURE__ */ new Map();
+  entriesByType = /* @__PURE__ */ new Map();
+  maxEntries;
+  constructor(options = {}) {
+    this.maxEntries = options.maxEntries ?? 1e3;
+  }
+  async initialize() {
+  }
+  async save(entry) {
+    if (this.entries.size >= this.maxEntries) {
+      const toRemove = Math.floor(this.maxEntries * 0.1);
+      const iterator = this.entries.keys();
+      for (let i = 0; i < toRemove; i++) {
+        const oldestKey = iterator.next().value;
+        if (oldestKey) {
+          const oldEntry = this.entries.get(oldestKey);
+          if (oldEntry) {
+            this.removeFromIndexes(oldEntry);
+          }
+          this.entries.delete(oldestKey);
+        }
+      }
+    }
+    this.entries.set(entry.id, entry);
+    this.addToIndexes(entry);
+  }
+  async saveBatch(entries) {
+    for (const entry of entries) {
+      await this.save(entry);
+    }
+  }
+  async find(id) {
+    return this.entries.get(id) ?? null;
+  }
+  async list(options = {}) {
+    const { type, batchId, tags, search, before, after, limit = 50, offset = 0 } = options;
+    let results = [];
+    if (type) {
+      const typeIds = this.entriesByType.get(type);
+      if (typeIds) {
+        results = Array.from(typeIds).map((id) => this.entries.get(id)).filter((e) => e !== void 0);
+      }
+    } else if (batchId) {
+      const batchIds = this.entriesByBatch.get(batchId);
+      if (batchIds) {
+        results = Array.from(batchIds).map((id) => this.entries.get(id)).filter((e) => e !== void 0);
+      }
+    } else {
+      results = Array.from(this.entries.values());
+    }
+    if (tags && tags.length > 0) {
+      results = results.filter((e) => tags.some((t) => e.tags.includes(t)));
+    }
+    if (search) {
+      const searchLower = search.toLowerCase();
+      results = results.filter(
+        (e) => JSON.stringify(e.content).toLowerCase().includes(searchLower)
+      );
+    }
+    if (before) {
+      results = results.filter((e) => e.createdAt < before);
+    }
+    if (after) {
+      results = results.filter((e) => e.createdAt > after);
+    }
+    results.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+    const total = results.length;
+    const paginatedResults = results.slice(offset, offset + limit);
+    return {
+      data: paginatedResults,
+      total,
+      limit,
+      offset,
+      hasMore: offset + limit < total
+    };
+  }
+  async findByBatch(batchId) {
+    const ids = this.entriesByBatch.get(batchId);
+    if (!ids) return [];
+    return Array.from(ids).map((id) => this.entries.get(id)).filter((e) => e !== void 0).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+  }
+  async prune(beforeDate) {
+    let pruned = 0;
+    for (const [id, entry] of this.entries) {
+      if (entry.createdAt < beforeDate) {
+        this.removeFromIndexes(entry);
+        this.entries.delete(id);
+        pruned++;
+      }
+    }
+    return pruned;
+  }
+  async clear() {
+    this.entries.clear();
+    this.entriesByBatch.clear();
+    this.entriesByType.clear();
+  }
+  async stats() {
+    const entriesByType = defaultEntryCounts();
+    let oldestEntry;
+    let newestEntry;
+    for (const entry of this.entries.values()) {
+      entriesByType[entry.type]++;
+      if (!oldestEntry || entry.createdAt < oldestEntry) {
+        oldestEntry = entry.createdAt;
+      }
+      if (!newestEntry || entry.createdAt > newestEntry) {
+        newestEntry = entry.createdAt;
+      }
+    }
+    return {
+      totalEntries: this.entries.size,
+      entriesByType,
+      oldestEntry,
+      newestEntry
+    };
+  }
+  async close() {
+  }
+  addToIndexes(entry) {
+    if (!this.entriesByBatch.has(entry.batchId)) {
+      this.entriesByBatch.set(entry.batchId, /* @__PURE__ */ new Set());
+    }
+    this.entriesByBatch.get(entry.batchId).add(entry.id);
+    if (!this.entriesByType.has(entry.type)) {
+      this.entriesByType.set(entry.type, /* @__PURE__ */ new Set());
+    }
+    this.entriesByType.get(entry.type).add(entry.id);
+  }
+  removeFromIndexes(entry) {
+    this.entriesByBatch.get(entry.batchId)?.delete(entry.id);
+    this.entriesByType.get(entry.type)?.delete(entry.id);
+  }
+};
+
+export {
+  MemoryStorage
+};

package/dist/chunk-BOBKU5LG.js

@@ -0,0 +1,163 @@
+import {
+  defaultEntryCounts
+} from "./chunk-OF6NKXP5.js";
+
+// src/storage/sqlite.ts
+var SQLiteStorage = class {
+  db;
+  dbPath;
+  constructor(dbPath) {
+    this.dbPath = dbPath;
+  }
+  async initialize() {
+    const Database = (await import("better-sqlite3")).default;
+    this.db = new Database(this.dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS entries (
+        id TEXT PRIMARY KEY,
+        batch_id TEXT NOT NULL,
+        type TEXT NOT NULL,
+        content TEXT NOT NULL,
+        tags TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        duration INTEGER,
+        memory_usage INTEGER
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_entries_batch_id ON entries(batch_id);
+      CREATE INDEX IF NOT EXISTS idx_entries_type ON entries(type);
+      CREATE INDEX IF NOT EXISTS idx_entries_created_at ON entries(created_at);
+    `);
+  }
+  async save(entry) {
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO entries (id, batch_id, type, content, tags, created_at, duration, memory_usage)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      entry.id,
+      entry.batchId,
+      entry.type,
+      JSON.stringify(entry.content),
+      JSON.stringify(entry.tags),
+      entry.createdAt.toISOString(),
+      entry.duration ?? null,
+      entry.memoryUsage ?? null
+    );
+  }
+  async saveBatch(entries) {
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO entries (id, batch_id, type, content, tags, created_at, duration, memory_usage)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    const insertMany = this.db.transaction((entries2) => {
+      for (const entry of entries2) {
+        stmt.run(
+          entry.id,
+          entry.batchId,
+          entry.type,
+          JSON.stringify(entry.content),
+          JSON.stringify(entry.tags),
+          entry.createdAt.toISOString(),
+          entry.duration ?? null,
+          entry.memoryUsage ?? null
+        );
+      }
+    });
+    insertMany(entries);
+  }
+  async find(id) {
+    const row = this.db.prepare("SELECT * FROM entries WHERE id = ?").get(id);
+    if (!row) return null;
+    return this.rowToEntry(row);
+  }
+  async list(options = {}) {
+    const { type, batchId, tags, search, before, after, limit = 50, offset = 0 } = options;
+    let where = "1=1";
+    const params = [];
+    if (type) {
+      where += " AND type = ?";
+      params.push(type);
+    }
+    if (batchId) {
+      where += " AND batch_id = ?";
+      params.push(batchId);
+    }
+    if (before) {
+      where += " AND created_at < ?";
+      params.push(before.toISOString());
+    }
+    if (after) {
+      where += " AND created_at > ?";
+      params.push(after.toISOString());
+    }
+    if (search) {
+      where += " AND content LIKE ?";
+      params.push(`%${search}%`);
+    }
+    const countRow = this.db.prepare(`SELECT COUNT(*) as count FROM entries WHERE ${where}`).get(...params);
+    const total = countRow.count;
+    const rows = this.db.prepare(
+      `SELECT * FROM entries WHERE ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`
+    ).all(...params, limit, offset);
+    const data = rows.map((row) => this.rowToEntry(row));
+    let filteredData = data;
+    if (tags && tags.length > 0) {
+      filteredData = data.filter((e) => tags.some((t) => e.tags.includes(t)));
+    }
+    return {
+      data: filteredData,
+      total,
+      limit,
+      offset,
+      hasMore: offset + limit < total
+    };
+  }
+  async findByBatch(batchId) {
+    const rows = this.db.prepare("SELECT * FROM entries WHERE batch_id = ? ORDER BY created_at ASC").all(batchId);
+    return rows.map((row) => this.rowToEntry(row));
+  }
+  async prune(beforeDate) {
+    const result = this.db.prepare("DELETE FROM entries WHERE created_at < ?").run(beforeDate.toISOString());
+    return result.changes;
+  }
+  async clear() {
+    this.db.prepare("DELETE FROM entries").run();
+  }
+  async stats() {
+    const entriesByType = defaultEntryCounts();
+    const typeRows = this.db.prepare("SELECT type, COUNT(*) as count FROM entries GROUP BY type").all();
+    for (const row of typeRows) {
+      entriesByType[row.type] = row.count;
+    }
+    const totalRow = this.db.prepare("SELECT COUNT(*) as count FROM entries").get();
+    const oldestRow = this.db.prepare("SELECT MIN(created_at) as oldest FROM entries").get();
+    const newestRow = this.db.prepare("SELECT MAX(created_at) as newest FROM entries").get();
+    return {
+      totalEntries: totalRow.count,
+      entriesByType,
+      oldestEntry: oldestRow.oldest ? new Date(oldestRow.oldest) : void 0,
+      newestEntry: newestRow.newest ? new Date(newestRow.newest) : void 0
+    };
+  }
+  async close() {
+    this.db.close();
+  }
+  rowToEntry(row) {
+    return {
+      id: row.id,
+      batchId: row.batch_id,
+      type: row.type,
+      content: JSON.parse(row.content),
+      tags: JSON.parse(row.tags),
+      createdAt: new Date(row.created_at),
+      duration: row.duration ?? void 0,
+      memoryUsage: row.memory_usage ?? void 0
+    };
+  }
+};
+
+export {
+  SQLiteStorage
+};

package/dist/chunk-OF6NKXP5.js

@@ -0,0 +1,44 @@
+// src/storage/adapter.ts
+async function createStorageAdapter(driver, options) {
+  switch (driver) {
+    case "memory":
+      const { MemoryStorage } = await import("./memory-5GF7O2HJ.js");
+      return new MemoryStorage();
+    case "sqlite":
+      const { SQLiteStorage } = await import("./sqlite-DMOIPBIO.js");
+      return new SQLiteStorage(options?.databaseUrl || "./nodescope.db");
+    case "postgresql":
+      const { PostgreSQLStorage } = await import("./postgresql-XD7N5SFI.js");
+      if (!options?.databaseUrl) {
+        throw new Error("PostgreSQL requires a databaseUrl");
+      }
+      return new PostgreSQLStorage(options.databaseUrl);
+    case "mysql":
+      const { MySQLStorage } = await import("./mysql-KNBA3N7P.js");
+      if (!options?.databaseUrl) {
+        throw new Error("MySQL requires a databaseUrl");
+      }
+      return new MySQLStorage(options.databaseUrl);
+    default:
+      throw new Error(`Unknown storage driver: ${driver}`);
+  }
+}
+function defaultEntryCounts() {
+  return {
+    request: 0,
+    query: 0,
+    cache: 0,
+    log: 0,
+    exception: 0,
+    http_client: 0,
+    event: 0,
+    job: 0,
+    schedule: 0,
+    dump: 0
+  };
+}
+
+export {
+  createStorageAdapter,
+  defaultEntryCounts
+};

package/dist/chunk-V5BR4MSS.js

@@ -0,0 +1,195 @@
+import {
+  defaultEntryCounts
+} from "./chunk-OF6NKXP5.js";
+
+// src/storage/mysql.ts
+var MySQLStorage = class {
+  pool;
+  connectionString;
+  constructor(connectionString) {
+    this.connectionString = connectionString;
+  }
+  async initialize() {
+    const mysql = await import("mysql2/promise");
+    this.pool = mysql.createPool(this.connectionString);
+    await this.pool.execute(`
+      CREATE TABLE IF NOT EXISTS nodescope_entries (
+        id VARCHAR(36) PRIMARY KEY,
+        batch_id VARCHAR(36) NOT NULL,
+        type VARCHAR(50) NOT NULL,
+        content JSON NOT NULL,
+        tags JSON NOT NULL,
+        created_at DATETIME(3) NOT NULL,
+        duration INT,
+        memory_usage INT,
+        INDEX idx_batch_id (batch_id),
+        INDEX idx_type (type),
+        INDEX idx_created_at (created_at)
+      )
+    `);
+  }
+  async save(entry) {
+    await this.pool.execute(
+      `INSERT INTO nodescope_entries (id, batch_id, type, content, tags, created_at, duration, memory_usage)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+       ON DUPLICATE KEY UPDATE
+         content = VALUES(content),
+         tags = VALUES(tags),
+         duration = VALUES(duration),
+         memory_usage = VALUES(memory_usage)`,
+      [
+        entry.id,
+        entry.batchId,
+        entry.type,
+        JSON.stringify(entry.content),
+        JSON.stringify(entry.tags),
+        entry.createdAt,
+        entry.duration ?? null,
+        entry.memoryUsage ?? null
+      ]
+    );
+  }
+  async saveBatch(entries) {
+    const connection = await this.pool.getConnection();
+    try {
+      await connection.beginTransaction();
+      for (const entry of entries) {
+        await connection.execute(
+          `INSERT INTO nodescope_entries (id, batch_id, type, content, tags, created_at, duration, memory_usage)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+           ON DUPLICATE KEY UPDATE
+             content = VALUES(content),
+             tags = VALUES(tags),
+             duration = VALUES(duration),
+             memory_usage = VALUES(memory_usage)`,
+          [
+            entry.id,
+            entry.batchId,
+            entry.type,
+            JSON.stringify(entry.content),
+            JSON.stringify(entry.tags),
+            entry.createdAt,
+            entry.duration ?? null,
+            entry.memoryUsage ?? null
+          ]
+        );
+      }
+      await connection.commit();
+    } catch (error) {
+      await connection.rollback();
+      throw error;
+    } finally {
+      connection.release();
+    }
+  }
+  async find(id) {
+    const [rows] = await this.pool.execute(
+      "SELECT * FROM nodescope_entries WHERE id = ?",
+      [id]
+    );
+    if (rows.length === 0) return null;
+    return this.rowToEntry(rows[0]);
+  }
+  async list(options = {}) {
+    const { type, batchId, tags, search, before, after, limit = 50, offset = 0 } = options;
+    let where = "1=1";
+    const params = [];
+    if (type) {
+      where += " AND type = ?";
+      params.push(type);
+    }
+    if (batchId) {
+      where += " AND batch_id = ?";
+      params.push(batchId);
+    }
+    if (before) {
+      where += " AND created_at < ?";
+      params.push(before);
+    }
+    if (after) {
+      where += " AND created_at > ?";
+      params.push(after);
+    }
+    if (search) {
+      where += ' AND JSON_SEARCH(content, "one", ?) IS NOT NULL';
+      params.push(`%${search}%`);
+    }
+    const [countRows] = await this.pool.execute(
+      `SELECT COUNT(*) as count FROM nodescope_entries WHERE ${where}`,
+      params
+    );
+    const total = countRows[0].count;
+    const [dataRows] = await this.pool.execute(
+      `SELECT * FROM nodescope_entries WHERE ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`,
+      [...params, limit, offset]
+    );
+    let data = dataRows.map((row) => this.rowToEntry(row));
+    if (tags && tags.length > 0) {
+      data = data.filter((e) => tags.some((t) => e.tags.includes(t)));
+    }
+    return {
+      data,
+      total,
+      limit,
+      offset,
+      hasMore: offset + limit < total
+    };
+  }
+  async findByBatch(batchId) {
+    const [rows] = await this.pool.execute(
+      "SELECT * FROM nodescope_entries WHERE batch_id = ? ORDER BY created_at ASC",
+      [batchId]
+    );
+    return rows.map((row) => this.rowToEntry(row));
+  }
+  async prune(beforeDate) {
+    const [result] = await this.pool.execute(
+      "DELETE FROM nodescope_entries WHERE created_at < ?",
+      [beforeDate]
+    );
+    return result.affectedRows;
+  }
+  async clear() {
+    await this.pool.execute("DELETE FROM nodescope_entries");
+  }
+  async stats() {
+    const entriesByType = defaultEntryCounts();
+    const [typeRows] = await this.pool.execute(
+      "SELECT type, COUNT(*) as count FROM nodescope_entries GROUP BY type"
+    );
+    for (const row of typeRows) {
+      entriesByType[row.type] = row.count;
+    }
+    const [totalRows] = await this.pool.execute(
+      "SELECT COUNT(*) as count FROM nodescope_entries"
+    );
+    const [rangeRows] = await this.pool.execute(
+      "SELECT MIN(created_at) as oldest, MAX(created_at) as newest FROM nodescope_entries"
+    );
+    return {
+      totalEntries: totalRows[0].count,
+      entriesByType,
+      oldestEntry: rangeRows[0].oldest ? new Date(rangeRows[0].oldest) : void 0,
+      newestEntry: rangeRows[0].newest ? new Date(rangeRows[0].newest) : void 0
+    };
+  }
+  async close() {
+    await this.pool.end();
+  }
+  rowToEntry(row) {
+    return {
+      id: row.id,
+      batchId: row.batch_id,
+      type: row.type,
+      content: typeof row.content === "string" ? JSON.parse(row.content) : row.content,
+      tags: typeof row.tags === "string" ? JSON.parse(row.tags) : row.tags,
+      createdAt: new Date(row.created_at),
+      duration: row.duration ?? void 0,
+      memoryUsage: row.memory_usage ?? void 0
+    };
+  }
+};
+
+export {
+  MySQLStorage
+};