@lensjs/core 1.0.12 → 2.1.0

package/dist/index.js

@@ -51,6 +51,8 @@ var getUiConfig = () => {
 var WatcherTypeEnum = /* @__PURE__ */ ((WatcherTypeEnum2) => {
   WatcherTypeEnum2["REQUEST"] = "request";
   WatcherTypeEnum2["QUERY"] = "query";
+  WatcherTypeEnum2["CACHE"] = "cache";
+  WatcherTypeEnum2["EXCEPTION"] = "exception";
   return WatcherTypeEnum2;
 })(WatcherTypeEnum || {});
 
@@ -61,14 +63,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
@@ -87,6 +105,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");
@@ -138,12 +183,35 @@ import * as path2 from "path";
 
 // 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
 import { randomUUID } from "crypto";
 import Database from "libsql";
-import { sqlDateTime } from "@lensjs/date";
+import { nowISO } from "@lensjs/date";
 var TABLE_NAME = "lens_entries";
 var BetterSqliteStore = class extends Store {
   connection;
@@ -160,11 +228,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 ?? randomUUID(),
-      data: JSON.stringify(entry.data),
+      data: this.stringifyData(entry.data),
       type: entry.type,
-      created_at: entry.timestamp ?? sqlDateTime(),
+      created_at: entry.timestamp ?? nowISO(),
       lens_entry_id: entry.requestId || null,
-      minimalData: JSON.stringify(entry.minimal_data ?? {})
+      minimalData: this.stringifyData(entry.minimal_data ?? {})
     });
   }
   async getAllQueries(pagination) {
@@ -173,11 +241,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;
@@ -225,8 +299,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) : {};
@@ -338,8 +417,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}(/|$)`),
@@ -348,11 +427,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];
@@ -434,6 +513,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`
         }
       };
@@ -466,6 +547,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`,
@@ -479,8 +580,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");
   }
 };
 
@@ -524,6 +625,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 = [];
@@ -544,18 +702,132 @@ 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
+});
+import StackUtils from "stack-utils";
+import path3 from "path";
+import { existsSync, readFileSync } from "fs";
+import { nowISO as nowISO2 } from "@lensjs/date";
+var stackUtils = new StackUtils({
+  cwd: process.cwd(),
+  internals: StackUtils.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 ? path3.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 = path3.isAbsolute(file) ? file : path3.resolve(process.cwd(), file);
+  if (!existsSync(fullPath)) return null;
+  const fileContent = 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: nowISO2(),
+    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
 import Emittery from "emittery";
 var createEmittery = () => {
   return new Emittery();
 };
+var lensEmitter = createEmittery();
+
+// src/utils/async_context.ts
+import { AsyncLocalStorage } from "async_hooks";
+var lensContext = new 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
+    });
+  });
+};
 export {
   BetterSqliteStore,
+  CacheWatcher,
+  ExceptionWatcher,
   Lens,
   Adapter as LensAdapter,
   Store as LensStore,
@@ -565,5 +837,9 @@ export {
   WatcherTypeEnum,
   createEmittery,
   getStore as getLensStore,
+  handleUncaughExceptions,
+  lensContext,
+  lensEmitter,
+  exception_exports as lensExceptionUtils,
   utils_exports as lensUtils
 };

package/dist/stores/better_sqlite.cjs

@@ -36,6 +36,29 @@ module.exports = __toCommonJS(better_sqlite_exports);
 
 // 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
@@ -58,11 +81,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) {
@@ -71,11 +94,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;
@@ -123,8 +152,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) : {};

package/dist/stores/better_sqlite.d.cts

@@ -31,7 +31,23 @@ declare class BetterSqliteStore extends Store {
         };
         data: T;
     }>;
-    allByRequestId(requestId: string, type: WatcherTypeEnum): Promise<LensEntry[]>;
+    getAllCacheEntries<T extends Omit<LensEntry, "data">[]>(pagination: PaginationParams): Promise<{
+        meta: {
+            total: number;
+            lastPage: number;
+            currentPage: number;
+        };
+        data: T;
+    }>;
+    getAllExceptions<T extends Omit<LensEntry, "data">[]>(pagination: PaginationParams): Promise<{
+        meta: {
+            total: number;
+            lastPage: number;
+            currentPage: number;
+        };
+        data: T;
+    }>;
+    allByRequestId(requestId: string, type: WatcherTypeEnum, includeFullData?: boolean): Promise<LensEntry[]>;
     paginate<T>(type: WatcherTypeEnum, { page, perPage }: PaginationParams, includeFullData?: boolean): Promise<{
         meta: {
             total: number;

package/dist/stores/better_sqlite.d.ts

@@ -31,7 +31,23 @@ declare class BetterSqliteStore extends Store {
         };
         data: T;
     }>;
-    allByRequestId(requestId: string, type: WatcherTypeEnum): Promise<LensEntry[]>;
+    getAllCacheEntries<T extends Omit<LensEntry, "data">[]>(pagination: PaginationParams): Promise<{
+        meta: {
+            total: number;
+            lastPage: number;
+            currentPage: number;
+        };
+        data: T;
+    }>;
+    getAllExceptions<T extends Omit<LensEntry, "data">[]>(pagination: PaginationParams): Promise<{
+        meta: {
+            total: number;
+            lastPage: number;
+            currentPage: number;
+        };
+        data: T;
+    }>;
+    allByRequestId(requestId: string, type: WatcherTypeEnum, includeFullData?: boolean): Promise<LensEntry[]>;
     paginate<T>(type: WatcherTypeEnum, { page, perPage }: PaginationParams, includeFullData?: boolean): Promise<{
         meta: {
             total: number;

package/dist/stores/better_sqlite.js

@@ -1,11 +1,34 @@
 // 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
 import { randomUUID } from "crypto";
 import Database from "libsql";
-import { sqlDateTime } from "@lensjs/date";
+import { nowISO } from "@lensjs/date";
 var TABLE_NAME = "lens_entries";
 var BetterSqliteStore = class extends Store {
   connection;
@@ -22,11 +45,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 ?? randomUUID(),
-      data: JSON.stringify(entry.data),
+      data: this.stringifyData(entry.data),
       type: entry.type,
-      created_at: entry.timestamp ?? sqlDateTime(),
+      created_at: entry.timestamp ?? nowISO(),
       lens_entry_id: entry.requestId || null,
-      minimalData: JSON.stringify(entry.minimal_data ?? {})
+      minimalData: this.stringifyData(entry.minimal_data ?? {})
     });
   }
   async getAllQueries(pagination) {
@@ -35,11 +58,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;
@@ -87,8 +116,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) : {};