@lensjs/core 1.0.12 → 2.1.0

package/dist/index.cjs

@@ -31,6 +31,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   BetterSqliteStore: () => BetterSqliteStore,
+  CacheWatcher: () => CacheWatcher,
+  ExceptionWatcher: () => ExceptionWatcher,
   Lens: () => Lens,
   LensAdapter: () => Adapter,
   LensStore: () => Store,
@@ -40,6 +42,10 @@ __export(index_exports, {
   WatcherTypeEnum: () => WatcherTypeEnum,
   createEmittery: () => createEmittery,
   getLensStore: () => getStore,
+  handleUncaughExceptions: () => handleUncaughExceptions,
+  lensContext: () => lensContext,
+  lensEmitter: () => lensEmitter,
+  lensExceptionUtils: () => exception_exports,
   lensUtils: () => utils_exports
 });
 module.exports = __toCommonJS(index_exports);
@@ -91,6 +97,8 @@ var getUiConfig = () => {
 var WatcherTypeEnum = /* @__PURE__ */ ((WatcherTypeEnum2) => {
   WatcherTypeEnum2["REQUEST"] = "request";
   WatcherTypeEnum2["QUERY"] = "query";
+  WatcherTypeEnum2["CACHE"] = "cache";
+  WatcherTypeEnum2["EXCEPTION"] = "exception";
   return WatcherTypeEnum2;
 })(WatcherTypeEnum || {});
 
@@ -101,14 +109,30 @@ var ApiController = class {
       await getStore().getAllRequests(this.extractPaginationParams(qs))
     );
   }
-  static async getRequest({
-    params
-  }) {
+  static async getRequest({ params }) {
     const request = await getStore().find("request" /* REQUEST */, params.id);
     if (!request) {
       return this.notFoundResponse();
     }
-    return this.resourceResponse(request);
+    const queries = await getStore().allByRequestId(
+      request.id,
+      "query" /* QUERY */
+    );
+    const cacheEntries = await getStore().allByRequestId(
+      request.id,
+      "cache" /* CACHE */
+    );
+    const exceptions = await getStore().allByRequestId(
+      request.id,
+      "exception" /* EXCEPTION */,
+      false
+    );
+    return this.resourceResponse({
+      request,
+      queries,
+      cacheEntries,
+      exceptions
+    });
   }
   static async getQueries({
     qs
@@ -127,6 +151,33 @@ var ApiController = class {
     }
     return this.resourceResponse(query);
   }
+  static async getCacheEntries({ qs }) {
+    return this.paginatedResponse(
+      await getStore().getAllCacheEntries(this.extractPaginationParams(qs))
+    );
+  }
+  static async getCacheEntry({ params }) {
+    const cacheEntry = await getStore().find("cache" /* CACHE */, params.id);
+    if (!cacheEntry) {
+      return this.notFoundResponse();
+    }
+    return this.resourceResponse(cacheEntry);
+  }
+  static async getExceptions({ qs }) {
+    return this.paginatedResponse(
+      await getStore().getAllExceptions(this.extractPaginationParams(qs))
+    );
+  }
+  static async getException({ params }) {
+    const exception = await getStore().find(
+      "exception" /* EXCEPTION */,
+      params.id
+    );
+    if (!exception) {
+      return this.notFoundResponse();
+    }
+    return this.resourceResponse(exception);
+  }
   static async truncate() {
     await getStore().truncate();
     return this.baseResponse({}, 200, "All entries cleared");
@@ -178,6 +229,29 @@ var path2 = __toESM(require("path"), 1);
 
 // src/abstracts/store.ts
 var Store = class {
+  getAllExceptions(_paginationParams) {
+    return this.defaultMinimalPaginate();
+  }
+  stringifyData(data) {
+    if (typeof data === "string") {
+      return data;
+    }
+    try {
+      return JSON.stringify(data);
+    } catch (e) {
+      console.error(`Failed to stringify lens data: ${e}`);
+    }
+  }
+  defaultMinimalPaginate() {
+    return Promise.resolve({
+      data: [],
+      meta: {
+        currentPage: 0,
+        lastPage: 0,
+        total: 0
+      }
+    });
+  }
 };
 
 // src/stores/better_sqlite.ts
@@ -200,11 +274,11 @@ var BetterSqliteStore = class extends Store {
       `INSERT INTO ${TABLE_NAME} (id, data, type, created_at, lens_entry_id, minimal_data) values($id, $data, $type, $created_at, $lens_entry_id, $minimalData)`
     ).run({
       id: entry.id ?? (0, import_crypto.randomUUID)(),
-      data: JSON.stringify(entry.data),
+      data: this.stringifyData(entry.data),
       type: entry.type,
-      created_at: entry.timestamp ?? (0, import_date.sqlDateTime)(),
+      created_at: entry.timestamp ?? (0, import_date.nowISO)(),
       lens_entry_id: entry.requestId || null,
-      minimalData: JSON.stringify(entry.minimal_data ?? {})
+      minimalData: this.stringifyData(entry.minimal_data ?? {})
     });
   }
   async getAllQueries(pagination) {
@@ -213,11 +287,17 @@ var BetterSqliteStore = class extends Store {
   async getAllRequests(pagination) {
     return await this.paginate("request" /* REQUEST */, pagination, false);
   }
-  async allByRequestId(requestId, type) {
+  async getAllCacheEntries(pagination) {
+    return await this.paginate("cache" /* CACHE */, pagination);
+  }
+  async getAllExceptions(pagination) {
+    return await this.paginate("exception" /* EXCEPTION */, pagination, false);
+  }
+  async allByRequestId(requestId, type, includeFullData = true) {
     const rows = this.connection.prepare(
-      `${this.getSelectedColumns()} FROM ${TABLE_NAME} WHERE type = $type AND lens_entry_id = $requestId ORDER BY created_at DESC`
+      `${this.getSelectedColumns(includeFullData)} FROM ${TABLE_NAME} WHERE type = $type AND lens_entry_id = $requestId ORDER BY created_at DESC`
     ).all({ type, requestId });
-    return this.mapRows(rows);
+    return this.mapRows(rows, includeFullData);
   }
   async paginate(type, { page, perPage }, includeFullData = true) {
     const offset = (page - 1) * perPage;
@@ -265,8 +345,13 @@ var BetterSqliteStore = class extends Store {
       CREATE INDEX IF NOT EXISTS lens_entries_id_type_index
       ON ${TABLE_NAME} (id, type);
     `;
+    const lensEntryIdIndex = `
+      CREATE INDEX IF NOT EXISTS lens_entry_id_index
+      ON ${TABLE_NAME} (lens_entry_id);
+    `;
     this.connection.exec(createTable);
     this.connection.exec(createIndex);
+    this.connection.exec(lensEntryIdIndex);
   }
   mapRow(row, includeFullData = true) {
     let data = includeFullData ? JSON.parse(row.data) : {};
@@ -378,8 +463,8 @@ function stripBeforeAssetsPath(url) {
   const match = url.match(/assets.*/);
   return match ? match[0] : url;
 }
-function prepareIgnoredPaths(path3, ignoredPaths) {
-  const normalizedPath = path3.replace(/^\/+|\/+$/g, "");
+function prepareIgnoredPaths(path4, ignoredPaths) {
+  const normalizedPath = path4.replace(/^\/+|\/+$/g, "");
   ignoredPaths = [
     ...ignoredPaths,
     new RegExp(`^/?${normalizedPath}(/|$)`),
@@ -388,11 +473,11 @@ function prepareIgnoredPaths(path3, ignoredPaths) {
   ];
   return { ignoredPaths, normalizedPath };
 }
-function shouldIgnoreCurrentPath(path3, ignoredPaths, onlyPaths) {
+function shouldIgnoreCurrentPath(path4, ignoredPaths, onlyPaths) {
   if (onlyPaths.length > 0) {
-    return !onlyPaths.some((pattern) => pattern.test(path3));
+    return !onlyPaths.some((pattern) => pattern.test(path4));
   }
-  return ignoredPaths.some((pattern) => pattern.test(path3));
+  return ignoredPaths.some((pattern) => pattern.test(path4));
 }
 function prettyHrTime(hrtime, verbose = false) {
   const seconds = hrtime[0];
@@ -475,6 +560,8 @@ var Lens = class {
         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`
         }
       };
@@ -507,6 +594,26 @@ var Lens = class {
         path: `${basePath}/api/queries/:id`,
         handler: async (data) => await ApiController.getQuery(data)
       },
+      {
+        method: "GET",
+        path: `${basePath}/api/cache`,
+        handler: async (data) => await ApiController.getCacheEntries(data)
+      },
+      {
+        method: "GET",
+        path: `${basePath}/api/cache/:id`,
+        handler: async (data) => await ApiController.getCacheEntry(data)
+      },
+      {
+        method: "GET",
+        path: `${basePath}/api/exceptions`,
+        handler: async (data) => await ApiController.getExceptions(data)
+      },
+      {
+        method: "GET",
+        path: `${basePath}/api/exceptions/:id`,
+        handler: async (data) => await ApiController.getException(data)
+      },
       {
         method: "DELETE",
         path: `${basePath}/api/truncate`,
@@ -520,8 +627,8 @@ var Lens = class {
     await store.initialize();
     return store;
   }
-  static normalizeDirName(path3) {
-    return path3.replace(/(\/packages\/)[^/]+(?=\/dist)/, "$1core");
+  static normalizeDirName(path4) {
+    return path4.replace(/(\/packages\/)[^/]+(?=\/dist)/, "$1core");
   }
 };
 
@@ -565,6 +672,63 @@ var RequestWatcher = class extends Watcher {
   }
 };
 
+// src/watchers/cache_watcher.ts
+var CacheWatcher = class extends Watcher {
+  name = "cache" /* CACHE */;
+  async log(data) {
+    const payload = {
+      action: data.action,
+      data: this.normalizePayload(data),
+      requestId: data.requestId ?? "",
+      createdAt: data.createdAt
+    };
+    await getStore().save({
+      requestId: data.requestId ?? "",
+      type: this.name,
+      data: payload,
+      minimal_data: {
+        action: data.action,
+        key: payload.data.key,
+        createdAt: payload.createdAt
+      }
+    });
+  }
+  normalizePayload(data) {
+    let key = "";
+    let value = "";
+    if ("data" in data && typeof data.data === "object" && data.data !== null) {
+      if ("key" in data.data) {
+        key = String(data.data.key);
+      }
+      if ("value" in data.data) {
+        value = data.data.value;
+      }
+    } else if (typeof data.data === "string") {
+      value = data.data;
+    }
+    return { key, value };
+  }
+};
+
+// src/watchers/exception_watcher.ts
+var ExceptionWatcher = class extends Watcher {
+  name = "exception" /* EXCEPTION */;
+  async log(payload) {
+    await getStore().save({
+      id: generateRandomUuid(),
+      type: "exception" /* EXCEPTION */,
+      requestId: payload.requestId,
+      timestamp: payload.createdAt,
+      data: payload,
+      minimal_data: {
+        name: payload.name,
+        message: payload.message,
+        createdAt: payload.createdAt
+      }
+    });
+  }
+};
+
 // src/abstracts/adapter.ts
 var Adapter = class {
   watchers = [];
@@ -585,19 +749,133 @@ var Adapter = class {
   getWatchers() {
     return this.watchers;
   }
-  shouldIgnorePath(path3) {
-    return shouldIgnoreCurrentPath(path3, this.ignoredPaths, this.onlyPaths);
+  shouldIgnorePath(path4) {
+    return shouldIgnoreCurrentPath(path4, this.ignoredPaths, this.onlyPaths);
   }
 };
 
+// src/utils/exception.ts
+var exception_exports = {};
+__export(exception_exports, {
+  cleanStack: () => cleanStack,
+  constructErrorObject: () => constructErrorObject,
+  extractCodeFrame: () => extractCodeFrame,
+  getFileInfo: () => getFileInfo,
+  getStackTrace: () => getStackTrace
+});
+var import_stack_utils = __toESM(require("stack-utils"), 1);
+var import_node_path = __toESM(require("path"), 1);
+var import_node_fs = require("fs");
+var import_date2 = require("@lensjs/date");
+var stackUtils = new import_stack_utils.default({
+  cwd: process.cwd(),
+  internals: import_stack_utils.default.nodeInternals()
+});
+function cleanStack(stack) {
+  if (!stack) return "";
+  return stackUtils.clean(stack);
+}
+function getFileInfo(stack) {
+  if (!stack) {
+    return { file: "", line: 0, column: 0, function: "" };
+  }
+  const firstLine = stack.split("\n")[1] ?? "";
+  const fileInfo = stackUtils.parseLine(firstLine) ?? {
+    file: "",
+    line: 0,
+    column: 0,
+    function: ""
+  };
+  return {
+    file: fileInfo.file ? import_node_path.default.resolve(process.cwd(), fileInfo.file) : "",
+    line: fileInfo.line ?? 0,
+    column: fileInfo.column ?? 0,
+    function: fileInfo.function ?? ""
+  };
+}
+function getStackTrace(stack) {
+  if (!stack) return [];
+  return cleanStack(stack).split("\n").filter((frame) => Boolean(frame));
+}
+function extractCodeFrame({
+  file,
+  line,
+  column,
+  contextLines = 6
+}) {
+  if (!file) return null;
+  const fullPath = import_node_path.default.isAbsolute(file) ? file : import_node_path.default.resolve(process.cwd(), file);
+  if (!(0, import_node_fs.existsSync)(fullPath)) return null;
+  const fileContent = (0, import_node_fs.readFileSync)(fullPath, "utf-8");
+  const lines = fileContent.split(/\r?\n/);
+  if (line < 1 || line > lines.length) return null;
+  const start = Math.max(0, line - 1 - contextLines);
+  const end = Math.min(lines.length, line - 1 + contextLines + 1);
+  const snippet = lines.slice(start, end);
+  const relativeLine = line - 1 - start;
+  const errorLine = lines[line - 1] ?? "";
+  return {
+    file: fullPath,
+    line,
+    column,
+    context: {
+      pre: snippet.slice(0, relativeLine),
+      error: errorLine,
+      post: snippet.slice(relativeLine + 1)
+    }
+  };
+}
+function constructErrorObject(err) {
+  const fileInfo = getFileInfo(err.stack);
+  const codeFrame = extractCodeFrame({
+    file: fileInfo.file,
+    line: fileInfo.line,
+    column: fileInfo.column
+  });
+  return {
+    name: err.name,
+    message: err.message,
+    createdAt: (0, import_date2.nowISO)(),
+    fileInfo: {
+      file: fileInfo.file,
+      function: fileInfo.function
+    },
+    cause: err.cause ?? null,
+    trace: getStackTrace(err.stack),
+    codeFrame,
+    originalStack: codeFrame === null ? cleanStack(err.stack) : null
+  };
+}
+
 // src/utils/event_emitter.ts
 var import_emittery = __toESM(require("emittery"), 1);
 var createEmittery = () => {
   return new import_emittery.default();
 };
+var lensEmitter = createEmittery();
+
+// src/utils/async_context.ts
+var import_async_hooks = require("async_hooks");
+var lensContext = new import_async_hooks.AsyncLocalStorage();
+var handleUncaughExceptions = (logger) => {
+  process.on("uncaughtExceptionMonitor", async (err) => {
+    await logger.log({
+      ...constructErrorObject(err),
+      requestId: lensContext.getStore()?.requestId
+    });
+  });
+  process.on("uncaughtException", async (err) => {
+    await logger.log({
+      ...constructErrorObject(err),
+      requestId: lensContext.getStore()?.requestId
+    });
+  });
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BetterSqliteStore,
+  CacheWatcher,
+  ExceptionWatcher,
   Lens,
   LensAdapter,
   LensStore,
@@ -607,5 +885,9 @@ var createEmittery = () => {
   WatcherTypeEnum,
   createEmittery,
   getLensStore,
+  handleUncaughExceptions,
+  lensContext,
+  lensEmitter,
+  lensExceptionUtils,
   lensUtils
 });

package/dist/index.d.cts

@@ -2,13 +2,18 @@ export { default as Lens } from './core/lens.cjs';
 export { default as BetterSqliteStore } from './stores/better_sqlite.cjs';
 export { default as QueryWatcher } from './watchers/query_watcher.cjs';
 export { default as RequestWatcher } from './watchers/request_watcher.cjs';
-export { ApiResponse, Entry, HttpMethod, LensConfig, LensEntry, PaginationParams, Paginator, QueryEntry, QueryType, RequestEntry, RouteDefinition, RouteDefinitionHandler, RouteHttpMethod, SqlQueryType, UserEntry, WatcherTypeEnum } from './types/index.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 { 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-DiLfwsvc.cjs';
-export { createEmittery } from './utils/event_emitter.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 'sql-formatter';
 import 'emittery';
+import 'async_hooks';

package/dist/index.d.ts

@@ -2,13 +2,18 @@ export { default as Lens } from './core/lens.js';
 export { default as BetterSqliteStore } from './stores/better_sqlite.js';
 export { default as QueryWatcher } from './watchers/query_watcher.js';
 export { default as RequestWatcher } from './watchers/request_watcher.js';
-export { ApiResponse, Entry, HttpMethod, LensConfig, LensEntry, PaginationParams, Paginator, QueryEntry, QueryType, RequestEntry, RouteDefinition, RouteDefinitionHandler, RouteHttpMethod, SqlQueryType, UserEntry, WatcherTypeEnum } from './types/index.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 { 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-DiLfwsvc.js';
-export { createEmittery } from './utils/event_emitter.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 'sql-formatter';
 import 'emittery';
+import 'async_hooks';