@lensjs/core 2.2.2 → 2.3.1

package/dist/{index-CMvlRWcQ.d.cts → index-CZsa0Zcm.d.ts}

@@ -1,4 +1,5 @@
 import { SqlLanguage } from 'sql-formatter';
+import { compose } from './utils/compose.js';
 
 declare const generateRandomUuid: () => `${string}-${string}-${string}-${string}-${string}`;
 /**
@@ -24,6 +25,7 @@ declare function shouldIgnoreCurrentPath(path: string, ignoredPaths: RegExp[], o
 declare function prettyHrTime(hrtime: [number, number], verbose?: boolean): string;
 declare function normalizePath(path: string): string;
 
+declare const index_compose: typeof compose;
 declare const index_formatSqlQuery: typeof formatSqlQuery;
 declare const index_generateRandomUuid: typeof generateRandomUuid;
 declare const index_getMeta: typeof getMeta;
@@ -35,7 +37,7 @@ declare const index_prettyHrTime: typeof prettyHrTime;
 declare const index_shouldIgnoreCurrentPath: typeof shouldIgnoreCurrentPath;
 declare const index_stripBeforeAssetsPath: typeof stripBeforeAssetsPath;
 declare namespace index {
-  export { index_formatSqlQuery as formatSqlQuery, index_generateRandomUuid as generateRandomUuid, index_getMeta as getMeta, index_interpolateQuery as interpolateQuery, index_isStaticFile as isStaticFile, index_normalizePath as normalizePath, index_prepareIgnoredPaths as prepareIgnoredPaths, index_prettyHrTime as prettyHrTime, index_shouldIgnoreCurrentPath as shouldIgnoreCurrentPath, index_stripBeforeAssetsPath as stripBeforeAssetsPath };
+  export { index_compose as compose, index_formatSqlQuery as formatSqlQuery, index_generateRandomUuid as generateRandomUuid, index_getMeta as getMeta, index_interpolateQuery as interpolateQuery, index_isStaticFile as isStaticFile, index_normalizePath as normalizePath, index_prepareIgnoredPaths as prepareIgnoredPaths, index_prettyHrTime as prettyHrTime, index_shouldIgnoreCurrentPath as shouldIgnoreCurrentPath, index_stripBeforeAssetsPath as stripBeforeAssetsPath };
 }
 
 export { interpolateQuery as a, getMeta as b, isStaticFile as c, shouldIgnoreCurrentPath as d, prettyHrTime as e, formatSqlQuery as f, generateRandomUuid as g, index as i, normalizePath as n, prepareIgnoredPaths as p, stripBeforeAssetsPath as s };

package/dist/{index-CMvlRWcQ.d.ts → index-QmOJr0K-.d.cts}

@@ -1,4 +1,5 @@
 import { SqlLanguage } from 'sql-formatter';
+import { compose } from './utils/compose.cjs';
 
 declare const generateRandomUuid: () => `${string}-${string}-${string}-${string}-${string}`;
 /**
@@ -24,6 +25,7 @@ declare function shouldIgnoreCurrentPath(path: string, ignoredPaths: RegExp[], o
 declare function prettyHrTime(hrtime: [number, number], verbose?: boolean): string;
 declare function normalizePath(path: string): string;
 
+declare const index_compose: typeof compose;
 declare const index_formatSqlQuery: typeof formatSqlQuery;
 declare const index_generateRandomUuid: typeof generateRandomUuid;
 declare const index_getMeta: typeof getMeta;
@@ -35,7 +37,7 @@ declare const index_prettyHrTime: typeof prettyHrTime;
 declare const index_shouldIgnoreCurrentPath: typeof shouldIgnoreCurrentPath;
 declare const index_stripBeforeAssetsPath: typeof stripBeforeAssetsPath;
 declare namespace index {
-  export { index_formatSqlQuery as formatSqlQuery, index_generateRandomUuid as generateRandomUuid, index_getMeta as getMeta, index_interpolateQuery as interpolateQuery, index_isStaticFile as isStaticFile, index_normalizePath as normalizePath, index_prepareIgnoredPaths as prepareIgnoredPaths, index_prettyHrTime as prettyHrTime, index_shouldIgnoreCurrentPath as shouldIgnoreCurrentPath, index_stripBeforeAssetsPath as stripBeforeAssetsPath };
+  export { index_compose as compose, index_formatSqlQuery as formatSqlQuery, index_generateRandomUuid as generateRandomUuid, index_getMeta as getMeta, index_interpolateQuery as interpolateQuery, index_isStaticFile as isStaticFile, index_normalizePath as normalizePath, index_prepareIgnoredPaths as prepareIgnoredPaths, index_prettyHrTime as prettyHrTime, index_shouldIgnoreCurrentPath as shouldIgnoreCurrentPath, index_stripBeforeAssetsPath as stripBeforeAssetsPath };
 }
 
 export { interpolateQuery as a, getMeta as b, isStaticFile as c, shouldIgnoreCurrentPath as d, prettyHrTime as e, formatSqlQuery as f, generateRandomUuid as g, index as i, normalizePath as n, prepareIgnoredPaths as p, stripBeforeAssetsPath as s };

package/dist/index.cjs

@@ -38,6 +38,7 @@ __export(index_exports, {
   LensStore: () => Store,
   LensWatcher: () => Watcher,
   QueryWatcher: () => QueryWatcher,
+  QueuedSqliteStore: () => QueuedSqliteStore,
   RequestWatcher: () => RequestWatcher,
   WatcherTypeEnum: () => WatcherTypeEnum,
   createEmittery: () => createEmittery,
@@ -229,6 +230,9 @@ var path2 = __toESM(require("path"), 1);
 
 // src/abstracts/store.ts
 var Store = class {
+  storeConfig;
+  constructor(...args) {
+  }
   getAllExceptions(_paginationParams) {
     return this.defaultMinimalPaginate();
   }
@@ -259,6 +263,8 @@ var import_crypto = require("crypto");
 var import_libsql = __toESM(require("libsql"), 1);
 var import_date = require("@lensjs/date");
 var TABLE_NAME = "lens_entries";
+var BYTES_IN_GB = 1024 * 1024 * 1024;
+var PRUNE_BATCH_SIZE = 1e3;
 var BetterSqliteStore = class extends Store {
   connection;
   async initialize() {
@@ -280,6 +286,7 @@ var BetterSqliteStore = class extends Store {
       lens_entry_id: entry.requestId || null,
       minimalData: this.stringifyData(entry.minimal_data ?? {})
     });
+    this.maybePruneDatabase();
   }
   async getAllQueries(pagination) {
     return await this.paginate("query" /* QUERY */, pagination);
@@ -355,6 +362,36 @@ var BetterSqliteStore = class extends Store {
     this.connection.exec(createIndex);
     this.connection.exec(lensEntryIdIndex);
   }
+  maybePruneDatabase() {
+    const maxGb = this.storeConfig?.dbMaxSizeGb;
+    const pruneGb = this.storeConfig?.dbPruneSizeGb;
+    if (!maxGb || !pruneGb) return;
+    const maxBytes = maxGb * BYTES_IN_GB;
+    const pruneBytes = pruneGb * BYTES_IN_GB;
+    if (maxBytes <= 0 || pruneBytes <= 0) return;
+    const targetBytes = Math.max(0, maxBytes - pruneBytes);
+    let usedBytes = this.getDatabaseUsedBytes();
+    if (usedBytes < maxBytes) return;
+    while (usedBytes > targetBytes) {
+      const deletedRows = this.deleteOldestEntries(PRUNE_BATCH_SIZE);
+      if (deletedRows === 0) break;
+      usedBytes = this.getDatabaseUsedBytes();
+    }
+    this.connection.exec("PRAGMA wal_checkpoint(TRUNCATE);");
+  }
+  getDatabaseUsedBytes() {
+    const pageSizeResult = this.connection.prepare("PRAGMA page_size;").get();
+    const pageCountResult = this.connection.prepare("PRAGMA page_count;").get();
+    const freelistCountResult = this.connection.prepare("PRAGMA freelist_count;").get();
+    const usedPages = pageCountResult.page_count - freelistCountResult.freelist_count;
+    return usedPages * pageSizeResult.page_size;
+  }
+  deleteOldestEntries(batchSize) {
+    const result = this.connection.prepare(
+      `DELETE FROM ${TABLE_NAME} WHERE id IN (SELECT id FROM ${TABLE_NAME} ORDER BY created_at ASC LIMIT ?)`
+    ).run(batchSize);
+    return Number(result.changes ?? 0);
+  }
   mapRow(row, includeFullData = true) {
     let data = includeFullData ? JSON.parse(row.data) : {};
     if (!includeFullData) {
@@ -380,9 +417,99 @@ var BetterSqliteStore = class extends Store {
   }
 };
 
+// src/mixins/queued_store.ts
+var import_denque = __toESM(require("denque"), 1);
+function QueuedStore(Base) {
+  return class Queued extends Base {
+    queue;
+    processingInterval = null;
+    BATCH_SIZE;
+    PROCESS_INTERVAL_MS;
+    WARN_THRESHOLD;
+    PREALLOCATE;
+    constructor(...args) {
+      super(...args);
+      const config = args[0] || {};
+      this.storeConfig = config;
+      this.BATCH_SIZE = config.batchSize ?? 100;
+      this.PROCESS_INTERVAL_MS = config.processIntervalMs ?? 100;
+      this.WARN_THRESHOLD = config.warnThreshold ?? 1e5;
+      this.PREALLOCATE = config.preallocate ?? true;
+      this.queue = this.PREALLOCATE ? new import_denque.default([], { capacity: this.WARN_THRESHOLD * 2 }) : new import_denque.default();
+    }
+    async initialize() {
+      if (super["initialize"]) {
+        await super["initialize"].call(this);
+      }
+      this.startProcessingQueue();
+      process.on("SIGINT", () => this.shutdown());
+      process.on("SIGTERM", () => this.shutdown());
+    }
+    async truncate() {
+      this.queue.clear();
+      if (super["truncate"]) {
+        await super["truncate"].call(this);
+      }
+    }
+    async save(entry) {
+      this.queue.push(entry);
+      if (this.queue.length > this.WARN_THRESHOLD) {
+        console.warn(`\u26A0\uFE0F LensJs Queue size very large: ${this.queue.length}`);
+      }
+    }
+    startProcessingQueue() {
+      if (this.processingInterval) clearInterval(this.processingInterval);
+      this.processingInterval = setInterval(
+        () => this.processQueue(),
+        this.PROCESS_INTERVAL_MS
+      );
+    }
+    async processQueue() {
+      if (this.queue.isEmpty()) return;
+      const batchSize = Math.min(
+        this.BATCH_SIZE,
+        Math.max(10, Math.floor(this.queue.length / 10))
+      );
+      const entriesToProcess = this.queue.remove(0, batchSize);
+      if (!entriesToProcess.length) return;
+      for (const entry of entriesToProcess) {
+        super["save"]?.call(this, entry).catch((error) => {
+          console.error("Error saving queued entry:", error);
+        });
+      }
+    }
+    async stopProcessingQueue() {
+      if (this.processingInterval) {
+        clearInterval(this.processingInterval);
+        this.processingInterval = null;
+      }
+      if (!this.queue.isEmpty()) {
+        await this.processQueue();
+      }
+    }
+    async shutdown() {
+      await this.stopProcessingQueue();
+      process.exit(0);
+    }
+  };
+}
+
+// src/utils/compose.ts
+function compose(superclass, ...mixins) {
+  return mixins.reduce((c, mixin) => mixin(c), superclass);
+}
+
+// src/stores/queued_sqlite.ts
+var QueuedSqliteStore = class extends compose(
+  BetterSqliteStore,
+  QueuedStore
+) {
+};
+
 // src/utils/index.ts
 var utils_exports = {};
 __export(utils_exports, {
+  compose: () => compose,
   formatSqlQuery: () => formatSqlQuery,
   generateRandomUuid: () => generateRandomUuid,
   getMeta: () => getMeta,
@@ -457,7 +584,7 @@ var formatSqlQuery = (query, language) => {
   });
 };
 function getMeta(metaUrl) {
-  const isESM = typeof __dirname === "undefined";
+  const isESM = typeof __dirname === "undefined" || typeof __filename === "undefined";
   if (isESM) {
     if (!metaUrl) {
       throw new Error("In ESM, you must pass import.meta.url to getMeta()");
@@ -523,6 +650,7 @@ var Lens = class {
   static watchers = /* @__PURE__ */ new Map();
   static store;
   static adapter;
+  static config;
   static watch(watcher) {
     this.watchers.set(watcher.name, watcher);
     return this;
@@ -532,22 +660,23 @@ var Lens = class {
     return this;
   }
   static async start(config = {
-    basePath: "lens",
+    path: "lens",
     appName: "Lens",
     enabled: true
   }) {
     if (!config.enabled) {
       return;
     }
-    await this.bindContainerDeps(config);
+    this.config = config;
+    await this.bindContainerDeps();
     let adapter = this.getAdapter();
     adapter.setWatchers(Array.from(this.watchers.values())).setup();
     const { apiRoutes } = this.getRoutes({
-      basePath: config.basePath
+      path: config.path
     });
     adapter.registerRoutes(apiRoutes);
     const uiPath = this.getUiPath();
-    adapter.serveUI(uiPath, config.basePath, getUiConfig());
+    adapter.serveUI(uiPath, config.path, getUiConfig());
   }
   static setStore(store) {
     this.store = store;
@@ -570,7 +699,7 @@ var Lens = class {
     const { __dirname: __dirname2 } = getMeta(import_meta.url);
     return path2.resolve(this.normalizeDirName(__dirname2), "ui");
   }
-  static getRoutes({ basePath }) {
+  static getRoutes({ path: path4 }) {
     const apiRoutes = [
       {
         method: "GET",
@@ -579,71 +708,71 @@ var Lens = class {
       },
       {
         method: "GET",
-        path: `/${basePath}/api/requests`,
+        path: `/${path4}/api/requests`,
         handler: async (data) => await ApiController.getRequests(data)
       },
       {
         method: "GET",
-        path: `/${basePath}/api/requests/:id`,
+        path: `/${path4}/api/requests/:id`,
         handler: async (data) => await ApiController.getRequest(data)
       },
       {
         method: "GET",
-        path: `/${basePath}/api/queries`,
+        path: `/${path4}/api/queries`,
         handler: async (data) => await ApiController.getQueries(data)
       },
       {
         method: "GET",
-        path: `/${basePath}/api/queries/:id`,
+        path: `/${path4}/api/queries/:id`,
         handler: async (data) => await ApiController.getQuery(data)
       },
       {
         method: "GET",
-        path: `/${basePath}/api/cache`,
+        path: `/${path4}/api/cache`,
         handler: async (data) => await ApiController.getCacheEntries(data)
       },
       {
         method: "GET",
-        path: `/${basePath}/api/cache/:id`,
+        path: `/${path4}/api/cache/:id`,
         handler: async (data) => await ApiController.getCacheEntry(data)
       },
       {
         method: "GET",
-        path: `/${basePath}/api/exceptions`,
+        path: `/${path4}/api/exceptions`,
         handler: async (data) => await ApiController.getExceptions(data)
       },
       {
         method: "GET",
-        path: `/${basePath}/api/exceptions/:id`,
+        path: `/${path4}/api/exceptions/:id`,
         handler: async (data) => await ApiController.getException(data)
       },
       {
         method: "DELETE",
-        path: `/${basePath}/api/truncate`,
+        path: `/${path4}/api/truncate`,
         handler: async () => await ApiController.truncate()
       }
     ];
     return { apiRoutes };
   }
-  static async bindContainerDeps(config) {
+  static async bindContainerDeps() {
     const dbStore = await this.getStore();
     Container.singleton("store", () => dbStore);
     Container.singleton("uiConfig", () => {
       return {
-        appName: config.appName,
-        path: `/${config.basePath}`,
+        appName: this.config.appName,
+        path: `/${this.config.path}`,
         api: {
-          requests: `/${config.basePath}/api/requests`,
-          queries: `/${config.basePath}/api/queries`,
-          cache: `/${config.basePath}/api/cache`,
-          exceptions: `/${config.basePath}/api/exceptions`,
-          truncate: `/${config.basePath}/api/truncate`
+          requests: `/${this.config.path}/api/requests`,
+          queries: `/${this.config.path}/api/queries`,
+          cache: `/${this.config.path}/api/cache`,
+          exceptions: `/${this.config.path}/api/exceptions`,
+          truncate: `/${this.config.path}/api/truncate`
         }
       };
     });
   }
   static async getDefaultStore() {
-    const store = new BetterSqliteStore();
+    const store = new QueuedSqliteStore(this.config.storeQueueConfig);
     await store.initialize();
     return store;
   }
@@ -669,10 +798,19 @@ var QueryWatcher = class extends Watcher {
 };
 
 // src/watchers/request_watcher.ts
-var RequestWatcher = class extends Watcher {
+var RequestWatcher = class _RequestWatcher extends Watcher {
   name = "request" /* REQUEST */;
-  async log(data) {
-    await getStore().save({
+  static DEFAULT_HIDDEN_HEADERS = ["Authorization", "Basic"];
+  static DEFAULT_HIDDEN_BODY_PARAMS = [
+    "password",
+    "passwordConfirmation",
+    "secret",
+    "password_confirmation"
+  ];
+  async log(data, hidden = {}) {
+    const headersToHide = (hidden.headers?.length ? hidden.headers : _RequestWatcher.DEFAULT_HIDDEN_HEADERS).map((header) => header.toLowerCase());
+    const bodyParamsToHide = hidden.bodyParams?.length ? hidden.bodyParams : _RequestWatcher.DEFAULT_HIDDEN_BODY_PARAMS;
+    const payload = {
       id: data.request.id,
       type: this.name,
       minimal_data: {
@@ -686,9 +824,40 @@ var RequestWatcher = class extends Watcher {
       data: {
         ...data.request,
         user: data.user,
-        response: data.response
+        response: data.response || {}
       }
-    });
+    };
+    payload.data.headers = this.hideSensitive(
+      this.normalizeHeaders(payload.data.headers),
+      headersToHide
+    );
+    payload.data.response.headers = this.hideSensitive(
+      this.normalizeHeaders(payload.data.response?.headers),
+      headersToHide
+    );
+    payload.data.body = this.hideSensitive(payload.data.body, bodyParamsToHide, false);
+    await getStore().save(payload);
+  }
+  /**
+   * Normalize headers: converts keys to lowercase.
+   */
+  normalizeHeaders(headers) {
+    if (!headers || typeof headers !== "object") return {};
+    return Object.fromEntries(
+      Object.entries(headers).map(([k, v]) => [k.toLowerCase(), v])
+    );
+  }
+  hideSensitive(obj, keysToHide = [], isObjHeaders = true) {
+    if (!obj || typeof obj !== "object") {
+      return isObjHeaders ? {} : obj;
+    }
+    const clone = { ...obj };
+    for (const key of keysToHide) {
+      if (key in clone) {
+        clone[key] = "*******";
+      }
+    }
+    return clone;
   }
 };
 
@@ -919,6 +1088,7 @@ var handleUncaughExceptions = (logger) => {
   LensStore,
   LensWatcher,
   QueryWatcher,
+  QueuedSqliteStore,
   RequestWatcher,
   WatcherTypeEnum,
   createEmittery,

package/dist/index.d.cts

@@ -1,19 +1,22 @@
 export { default as Lens } from './core/lens.cjs';
 export { default as BetterSqliteStore } from './stores/better_sqlite.cjs';
+export { default as QueuedSqliteStore } from './stores/queued_sqlite.cjs';
 export { default as QueryWatcher } from './watchers/query_watcher.cjs';
 export { default as RequestWatcher } from './watchers/request_watcher.cjs';
 export { default as CacheWatcher } from './watchers/cache_watcher.cjs';
 export { default as ExceptionWatcher } from './watchers/exception_watcher.cjs';
-export { ApiResponse, CacheAction, CacheEntry, Entry, ExceptionEntry, HttpMethod, LensConfig, LensEntry, PaginationParams, Paginator, QueryEntry, QueryType, RequestEntry, RouteDefinition, RouteDefinitionHandler, RouteHttpMethod, SqlQueryType, UserEntry, WatcherTypeEnum } from './types/index.cjs';
+export { ApiResponse, CacheAction, CacheEntry, Constructor, Entry, ExceptionEntry, HttpMethod, LensConfig, LensEntry, PaginationParams, Paginator, QueryEntry, QueryType, QueuedStoreConfig, RequestEntry, RouteDefinition, RouteDefinitionHandler, RouteHttpMethod, SqlQueryType, UserEntry, WatcherTypeEnum } from './types/index.cjs';
 export { default as LensAdapter } from './abstracts/adapter.cjs';
 export { default as LensStore } from './abstracts/store.cjs';
 export { default as LensWatcher } from './core/watcher.cjs';
 export { getStore as getLensStore } from './context/context.cjs';
-export { i as lensUtils } from './index-CMvlRWcQ.cjs';
+export { i as lensUtils } from './index-QmOJr0K-.cjs';
 export { e as lensExceptionUtils } from './exception-C69UCHPk.cjs';
 export { createEmittery, lensEmitter } from './utils/event_emitter.cjs';
 export { handleUncaughExceptions, lensContext } from './utils/async_context.cjs';
 import 'libsql';
+import 'denque';
 import 'sql-formatter';
+import './utils/compose.cjs';
 import 'events';
 import 'async_hooks';

package/dist/index.d.ts

@@ -1,19 +1,22 @@
 export { default as Lens } from './core/lens.js';
 export { default as BetterSqliteStore } from './stores/better_sqlite.js';
+export { default as QueuedSqliteStore } from './stores/queued_sqlite.js';
 export { default as QueryWatcher } from './watchers/query_watcher.js';
 export { default as RequestWatcher } from './watchers/request_watcher.js';
 export { default as CacheWatcher } from './watchers/cache_watcher.js';
 export { default as ExceptionWatcher } from './watchers/exception_watcher.js';
-export { ApiResponse, CacheAction, CacheEntry, Entry, ExceptionEntry, HttpMethod, LensConfig, LensEntry, PaginationParams, Paginator, QueryEntry, QueryType, RequestEntry, RouteDefinition, RouteDefinitionHandler, RouteHttpMethod, SqlQueryType, UserEntry, WatcherTypeEnum } from './types/index.js';
+export { ApiResponse, CacheAction, CacheEntry, Constructor, Entry, ExceptionEntry, HttpMethod, LensConfig, LensEntry, PaginationParams, Paginator, QueryEntry, QueryType, QueuedStoreConfig, RequestEntry, RouteDefinition, RouteDefinitionHandler, RouteHttpMethod, SqlQueryType, UserEntry, WatcherTypeEnum } from './types/index.js';
 export { default as LensAdapter } from './abstracts/adapter.js';
 export { default as LensStore } from './abstracts/store.js';
 export { default as LensWatcher } from './core/watcher.js';
 export { getStore as getLensStore } from './context/context.js';
-export { i as lensUtils } from './index-CMvlRWcQ.js';
+export { i as lensUtils } from './index-CZsa0Zcm.js';
 export { e as lensExceptionUtils } from './exception-3AZsPtAg.js';
 export { createEmittery, lensEmitter } from './utils/event_emitter.js';
 export { handleUncaughExceptions, lensContext } from './utils/async_context.js';
 import 'libsql';
+import 'denque';
 import 'sql-formatter';
+import './utils/compose.js';
 import 'events';
 import 'async_hooks';