@lensjs/core 2.0.0 → 2.1.1

package/dist/index.cjs

@@ -32,6 +32,7 @@ var index_exports = {};
 __export(index_exports, {
   BetterSqliteStore: () => BetterSqliteStore,
   CacheWatcher: () => CacheWatcher,
+  ExceptionWatcher: () => ExceptionWatcher,
   Lens: () => Lens,
   LensAdapter: () => Adapter,
   LensStore: () => Store,
@@ -41,8 +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);
@@ -95,6 +98,7 @@ var WatcherTypeEnum = /* @__PURE__ */ ((WatcherTypeEnum2) => {
   WatcherTypeEnum2["REQUEST"] = "request";
   WatcherTypeEnum2["QUERY"] = "query";
   WatcherTypeEnum2["CACHE"] = "cache";
+  WatcherTypeEnum2["EXCEPTION"] = "exception";
   return WatcherTypeEnum2;
 })(WatcherTypeEnum || {});
 
@@ -118,10 +122,16 @@ var ApiController = class {
       request.id,
       "cache" /* CACHE */
     );
+    const exceptions = await getStore().allByRequestId(
+      request.id,
+      "exception" /* EXCEPTION */,
+      false
+    );
     return this.resourceResponse({
       request,
       queries,
-      cacheEntries
+      cacheEntries,
+      exceptions
     });
   }
   static async getQueries({
@@ -153,6 +163,21 @@ var ApiController = class {
     }
     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");
@@ -204,6 +229,9 @@ 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;
@@ -214,6 +242,16 @@ var Store = class {
       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
@@ -252,11 +290,14 @@ var BetterSqliteStore = class extends Store {
   async getAllCacheEntries(pagination) {
     return await this.paginate("cache" /* CACHE */, pagination);
   }
-  async allByRequestId(requestId, type) {
+  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;
@@ -422,21 +463,22 @@ 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}(/|$)`),
     /^\/?lens-config$/,
+    /^\/?favicon\.ico$/,
     /^\/\.well-known\//
   ];
   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];
@@ -520,6 +562,7 @@ var Lens = class {
           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`
         }
       };
@@ -562,6 +605,16 @@ var Lens = class {
         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`,
@@ -575,8 +628,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");
   }
 };
 
@@ -642,23 +695,38 @@ var CacheWatcher = class extends Watcher {
     });
   }
   normalizePayload(data) {
-    let normalizedData = "data" in data ? data.data : {
-      key: "",
-      value: ""
-    };
-    if (!normalizedData || typeof normalizedData === "object" && Object.keys(normalizedData).length === 0) {
-      normalizedData = {
-        key: "",
-        value: ""
-      };
-    }
-    if (!normalizedData["key"]) {
-      normalizedData.key = "";
-    }
-    if (!normalizedData["value"]) {
-      normalizedData["value"] = "";
+    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 normalizedData;
+    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
+      }
+    });
   }
 };
 
@@ -682,11 +750,104 @@ 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 = () => {
@@ -697,10 +858,25 @@ 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,
@@ -710,7 +886,9 @@ var lensContext = new import_async_hooks.AsyncLocalStorage();
   WatcherTypeEnum,
   createEmittery,
   getLensStore,
+  handleUncaughExceptions,
   lensContext,
   lensEmitter,
+  lensExceptionUtils,
   lensUtils
 });

package/dist/index.d.cts

@@ -3,14 +3,16 @@ 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 { default as CacheWatcher } from './watchers/cache_watcher.cjs';
-export { ApiResponse, CacheAction, CacheEntry, Entry, HttpMethod, LensConfig, LensEntry, PaginationParams, Paginator, QueryEntry, QueryType, RequestEntry, RouteDefinition, RouteDefinitionHandler, RouteHttpMethod, SqlQueryType, UserEntry, WatcherTypeEnum } from './types/index.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 { e as lensExceptionUtils } from './exception-C69UCHPk.cjs';
 export { createEmittery, lensEmitter } from './utils/event_emitter.cjs';
-export { lensContext } from './utils/async_context.cjs';
+export { handleUncaughExceptions, lensContext } from './utils/async_context.cjs';
 import 'libsql';
 import 'sql-formatter';
 import 'emittery';

package/dist/index.d.ts

@@ -3,14 +3,16 @@ 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 { default as CacheWatcher } from './watchers/cache_watcher.js';
-export { ApiResponse, CacheAction, CacheEntry, Entry, HttpMethod, LensConfig, LensEntry, PaginationParams, Paginator, QueryEntry, QueryType, RequestEntry, RouteDefinition, RouteDefinitionHandler, RouteHttpMethod, SqlQueryType, UserEntry, WatcherTypeEnum } from './types/index.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 { e as lensExceptionUtils } from './exception-3AZsPtAg.js';
 export { createEmittery, lensEmitter } from './utils/event_emitter.js';
-export { lensContext } from './utils/async_context.js';
+export { handleUncaughExceptions, lensContext } from './utils/async_context.js';
 import 'libsql';
 import 'sql-formatter';
 import 'emittery';