@lensjs/core 1.0.1 → 1.0.3

package/dist/abstracts/adapter.cjs

@@ -0,0 +1,8 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkBFFOUTTEcjs = require('../chunk-BFFOUTTE.cjs');
+require('../chunk-WU6IZUEV.cjs');
+require('../chunk-75ZPJI57.cjs');
+
+
+exports.default = _chunkBFFOUTTEcjs.Adapter;

package/dist/abstracts/adapter.d.cts

@@ -0,0 +1,19 @@
+import Watcher from '../core/watcher.cjs';
+import { RouteDefinition } from '../types/index.cjs';
+import 'sql-formatter';
+
+declare abstract class Adapter {
+    private watchers;
+    protected ignoredPaths: RegExp[];
+    protected onlyPaths: RegExp[];
+    abstract setup(): void;
+    setWatchers(watchers: Watcher[]): this;
+    setIgnoredPaths(paths: RegExp[]): this;
+    setOnlyPaths(paths: RegExp[]): this;
+    getWatchers(): Watcher[];
+    shouldIgnorePath(path: string): boolean;
+    abstract registerRoutes(routes: RouteDefinition[]): void;
+    abstract serveUI(uiPath: string, spaRoute: string, dataToInject: Record<string, any>): void;
+}
+
+export { Adapter as default };

package/dist/abstracts/adapter.d.ts

@@ -0,0 +1,19 @@
+import Watcher from '../core/watcher.js';
+import { RouteDefinition } from '../types/index.js';
+import 'sql-formatter';
+
+declare abstract class Adapter {
+    private watchers;
+    protected ignoredPaths: RegExp[];
+    protected onlyPaths: RegExp[];
+    abstract setup(): void;
+    setWatchers(watchers: Watcher[]): this;
+    setIgnoredPaths(paths: RegExp[]): this;
+    setOnlyPaths(paths: RegExp[]): this;
+    getWatchers(): Watcher[];
+    shouldIgnorePath(path: string): boolean;
+    abstract registerRoutes(routes: RouteDefinition[]): void;
+    abstract serveUI(uiPath: string, spaRoute: string, dataToInject: Record<string, any>): void;
+}
+
+export { Adapter as default };

package/dist/abstracts/adapter.js

@@ -0,0 +1,8 @@
+import {
+  Adapter
+} from "../chunk-TPUVRGYT.js";
+import "../chunk-EJ5BW35V.js";
+import "../chunk-MLKGABMK.js";
+export {
+  Adapter as default
+};

package/dist/abstracts/store.cjs

@@ -0,0 +1,7 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkEHOWCXZVcjs = require('../chunk-EHOWCXZV.cjs');
+require('../chunk-75ZPJI57.cjs');
+
+
+exports.default = _chunkEHOWCXZVcjs.Store;

package/dist/abstracts/store.d.cts

@@ -0,0 +1,23 @@
+import { WatcherTypeEnum, PaginationParams, Paginator, LensEntry } from '../types/index.cjs';
+import 'sql-formatter';
+
+declare abstract class Store {
+    abstract initialize(): Promise<void>;
+    abstract save(entry: {
+        id?: string;
+        data: Record<string, any>;
+        minimal_data?: Record<string, any>;
+        type: WatcherTypeEnum;
+        timestamp?: string;
+        requestId?: string;
+    }): Promise<void>;
+    abstract getAllRequests(paginationParams: PaginationParams): Promise<Paginator<Omit<LensEntry, "data">[]>>;
+    abstract getAllQueries(paginationParams: PaginationParams): Promise<Paginator<LensEntry[]>>;
+    abstract allByRequestId(requestId: string, type: WatcherTypeEnum): Promise<LensEntry[]>;
+    abstract find(type: WatcherTypeEnum, id: string): Promise<LensEntry | null>;
+    abstract truncate(): Promise<void>;
+    abstract paginate<T>(type: WatcherTypeEnum, pagination: PaginationParams): Promise<Paginator<T>>;
+    abstract count(type: WatcherTypeEnum): Promise<number>;
+}
+
+export { Store as default };

package/dist/abstracts/store.d.ts

@@ -0,0 +1,23 @@
+import { WatcherTypeEnum, PaginationParams, Paginator, LensEntry } from '../types/index.js';
+import 'sql-formatter';
+
+declare abstract class Store {
+    abstract initialize(): Promise<void>;
+    abstract save(entry: {
+        id?: string;
+        data: Record<string, any>;
+        minimal_data?: Record<string, any>;
+        type: WatcherTypeEnum;
+        timestamp?: string;
+        requestId?: string;
+    }): Promise<void>;
+    abstract getAllRequests(paginationParams: PaginationParams): Promise<Paginator<Omit<LensEntry, "data">[]>>;
+    abstract getAllQueries(paginationParams: PaginationParams): Promise<Paginator<LensEntry[]>>;
+    abstract allByRequestId(requestId: string, type: WatcherTypeEnum): Promise<LensEntry[]>;
+    abstract find(type: WatcherTypeEnum, id: string): Promise<LensEntry | null>;
+    abstract truncate(): Promise<void>;
+    abstract paginate<T>(type: WatcherTypeEnum, pagination: PaginationParams): Promise<Paginator<T>>;
+    abstract count(type: WatcherTypeEnum): Promise<number>;
+}
+
+export { Store as default };

package/dist/abstracts/store.js

@@ -0,0 +1,7 @@
+import {
+  Store
+} from "../chunk-FKMBNWX4.js";
+import "../chunk-MLKGABMK.js";
+export {
+  Store as default
+};

package/dist/chunk-2HRVJRKV.cjs

@@ -0,0 +1,10 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/types/index.ts
+var WatcherTypeEnum = /* @__PURE__ */ ((WatcherTypeEnum2) => {
+  WatcherTypeEnum2["REQUEST"] = "request";
+  WatcherTypeEnum2["QUERY"] = "query";
+  return WatcherTypeEnum2;
+})(WatcherTypeEnum || {});
+
+
+
+exports.WatcherTypeEnum = WatcherTypeEnum;

package/dist/chunk-3R5QARPT.cjs

@@ -0,0 +1,14 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }// src/utils/event_emitter.ts
+var _async_hooks = require('async_hooks');
+var _emittery = require('emittery'); var _emittery2 = _interopRequireDefault(_emittery);
+var createEmittery = () => {
+  return new (0, _emittery2.default)();
+};
+var lensResource = new (0, _async_hooks.AsyncResource)("lens-emitter");
+var lensEmitter = new (0, _emittery2.default)();
+
+
+
+
+
+exports.createEmittery = createEmittery; exports.lensResource = lensResource; exports.lensEmitter = lensEmitter;

package/{src/watchers/request_watcher.ts → dist/chunk-4HLDYZJA.js}

@@ -1,11 +1,14 @@
-import { getStore } from "../context/context";
-import Watcher from "../core/watcher";
-import { WatcherTypeEnum, type RequestEntry } from "../types/index";
+import {
+  getStore
+} from "./chunk-XYXPHWEI.js";
+import {
+  Watcher
+} from "./chunk-CQ2Z4TCR.js";
 
-export default class RequestWatcher extends Watcher {
-  name = WatcherTypeEnum.REQUEST;
-
-  async log(data: RequestEntry) {
+// src/watchers/request_watcher.ts
+var RequestWatcher = class extends Watcher {
+  name = "request" /* REQUEST */;
+  async log(data) {
     await getStore().save({
       id: data.request.id,
       type: this.name,
@@ -15,13 +18,17 @@ export default class RequestWatcher extends Watcher {
         path: data.request.path,
         duration: data.request.duration,
         createdAt: data.request.createdAt,
-        status: data.request.status,
+        status: data.request.status
       },
       data: {
         ...data.request,
         user: data.user,
-        response: data.response,
-      },
+        response: data.response
+      }
     });
   }
-}
+};
+
+export {
+  RequestWatcher
+};

package/dist/chunk-5PYQWLAZ.js

@@ -0,0 +1,129 @@
+import {
+  BetterSqliteStore
+} from "./chunk-IPMTMCFP.js";
+import {
+  getMeta
+} from "./chunk-EJ5BW35V.js";
+import {
+  ApiController
+} from "./chunk-TJDE6AZM.js";
+import {
+  getUiConfig
+} from "./chunk-XYXPHWEI.js";
+import {
+  Container
+} from "./chunk-YC6T4XWI.js";
+
+// src/core/lens.ts
+import * as path from "path";
+var Lens = class {
+  static watchers = /* @__PURE__ */ new Map();
+  static store;
+  static adapter;
+  static watch(watcher) {
+    this.watchers.set(watcher.name, watcher);
+    return this;
+  }
+  static setWatchers(watchers) {
+    this.watchers = new Map(watchers.map((watcher) => [watcher.name, watcher]));
+    return this;
+  }
+  static async start(config = {
+    basePath: "lens",
+    appName: "Lens",
+    enabled: true
+  }) {
+    if (!config.enabled) {
+      return;
+    }
+    await this.bindContainerDeps(config);
+    let adapter = this.getAdapter();
+    adapter.setWatchers(Array.from(this.watchers.values())).setup();
+    const { apiRoutes } = this.getRoutes({
+      basePath: config.basePath
+    });
+    adapter.registerRoutes(apiRoutes);
+    const { __dirname } = getMeta(import.meta.url);
+    const uiPath = path.resolve(this.normalizeDirName(__dirname), "ui");
+    adapter.serveUI(uiPath, config.basePath, getUiConfig());
+  }
+  static setStore(store) {
+    this.store = store;
+    return this;
+  }
+  static async getStore() {
+    return this.store ?? await this.getDefaultStore();
+  }
+  static setAdapter(adapter) {
+    this.adapter = adapter;
+    return this;
+  }
+  static getAdapter() {
+    if (!this.adapter) {
+      throw new Error("No adapter has been set");
+    }
+    return this.adapter;
+  }
+  static async bindContainerDeps(config) {
+    const dbStore = await this.getStore();
+    Container.singleton("store", () => dbStore);
+    Container.singleton("uiConfig", () => {
+      return {
+        appName: config.appName,
+        path: `/${config.basePath}`,
+        api: {
+          requests: `/${config.basePath}/api/requests`,
+          queries: `/${config.basePath}/api/queries`,
+          truncate: `/${config.basePath}/api/truncate`
+        }
+      };
+    });
+  }
+  static getRoutes({ basePath }) {
+    const apiRoutes = [
+      {
+        method: "GET",
+        path: `/lens-config`,
+        handler: () => ApiController.fetchUiConfig()
+      },
+      {
+        method: "GET",
+        path: `${basePath}/api/requests`,
+        handler: async (data) => await ApiController.getRequests(data)
+      },
+      {
+        method: "GET",
+        path: `${basePath}/api/requests/:id`,
+        handler: async (data) => await ApiController.getRequest(data)
+      },
+      {
+        method: "GET",
+        path: `${basePath}/api/queries`,
+        handler: async (data) => await ApiController.getQueries(data)
+      },
+      {
+        method: "GET",
+        path: `${basePath}/api/queries/:id`,
+        handler: async (data) => await ApiController.getQuery(data)
+      },
+      {
+        method: "DELETE",
+        path: `${basePath}/api/truncate`,
+        handler: async () => await ApiController.truncate()
+      }
+    ];
+    return { apiRoutes };
+  }
+  static async getDefaultStore() {
+    const store = new BetterSqliteStore();
+    await store.initialize();
+    return store;
+  }
+  static normalizeDirName(path2) {
+    return path2.replace(/(\/packages\/)[^/]+(?=\/dist)/, "$1core");
+  }
+};
+
+export {
+  Lens
+};

package/dist/chunk-75ZPJI57.cjs

@@ -0,0 +1,9 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+
+
+exports.__export = __export;

package/dist/chunk-7EKM5HB5.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/chunk-AUDSBNLF.cjs

@@ -0,0 +1,122 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkWU6IZUEVcjs = require('./chunk-WU6IZUEV.cjs');
+
+
+var _chunkEHOWCXZVcjs = require('./chunk-EHOWCXZV.cjs');
+
+// src/stores/better_sqlite.ts
+var _crypto = require('crypto');
+var _libsql = require('libsql'); var _libsql2 = _interopRequireDefault(_libsql);
+var TABLE_NAME = "lens_entries";
+var BetterSqliteStore = class extends _chunkEHOWCXZVcjs.Store {
+  
+  async initialize() {
+    this.connection = new (0, _libsql2.default)("lens.db");
+    this.setupSchema();
+    console.log("Connected to Lens (SQLite) database.");
+  }
+  async truncate() {
+    this.connection.prepare(`DELETE FROM ${TABLE_NAME};`).run();
+  }
+  async save(entry) {
+    this.connection.prepare(
+      `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: _nullishCoalesce(entry.id, () => ( _crypto.randomUUID.call(void 0, ))),
+      data: JSON.stringify(entry.data),
+      type: entry.type,
+      created_at: _nullishCoalesce(entry.timestamp, () => ( _chunkWU6IZUEVcjs.sqlDateTime.call(void 0, ))),
+      lens_entry_id: entry.requestId || null,
+      minimalData: JSON.stringify(_nullishCoalesce(entry.minimal_data, () => ( {})))
+    });
+  }
+  async getAllQueries(pagination) {
+    return await this.paginate("query" /* QUERY */, pagination);
+  }
+  async getAllRequests(pagination) {
+    return await this.paginate("request" /* REQUEST */, pagination, false);
+  }
+  async allByRequestId(requestId, type) {
+    const rows = this.connection.prepare(
+      `${this.getSelectedColumns()} FROM ${TABLE_NAME} WHERE type = $type AND lens_entry_id = $requestId ORDER BY created_at DESC`
+    ).all({ type, requestId });
+    return this.mapRows(rows);
+  }
+  async paginate(type, { page, perPage }, includeFullData = true) {
+    const offset = (page - 1) * perPage;
+    const query = `${this.getSelectedColumns(
+      includeFullData
+    )} FROM ${TABLE_NAME} WHERE type = ? ORDER BY created_at DESC LIMIT ? OFFSET ?`;
+    const count = await this.count(type);
+    const rows = this.connection.prepare(query).all(type, perPage, offset);
+    const mappedRows = this.mapRows(rows, includeFullData);
+    return {
+      meta: {
+        total: count,
+        lastPage: Math.ceil(count / perPage),
+        currentPage: page
+      },
+      data: mappedRows
+    };
+  }
+  async count(type) {
+    const result = this.connection.prepare(`SELECT count(*) as count FROM ${TABLE_NAME} WHERE type = ?`).get(type);
+    return Number(result.count);
+  }
+  async find(type, id) {
+    const row = this.connection.prepare(
+      `${this.getSelectedColumns()} FROM ${TABLE_NAME} WHERE id = ? AND type = ? LIMIT 1`
+    ).get(id, type);
+    if (!row) {
+      return null;
+    }
+    return this.mapRow(row, true);
+  }
+  setupSchema() {
+    const createTable = `
+      CREATE TABLE IF NOT EXISTS ${TABLE_NAME} (
+        id TEXT PRIMARY KEY,
+        minimal_data TEXT,
+        data TEXT NOT NULL,
+        type TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT,
+        lens_entry_id TEXT NULL
+      );
+    `;
+    const createIndex = `
+      CREATE INDEX IF NOT EXISTS lens_entries_id_type_index
+      ON ${TABLE_NAME} (id, type);
+    `;
+    this.connection.exec(createTable);
+    this.connection.exec(createIndex);
+  }
+  mapRow(row, includeFullData = true) {
+    let data = includeFullData ? JSON.parse(row.data) : {};
+    if (!includeFullData) {
+      data = JSON.parse(row.minimal_data);
+    }
+    return {
+      id: row.id,
+      type: row.type,
+      created_at: row.created_at,
+      lens_entry_id: row.lens_entry_id,
+      data
+    };
+  }
+  mapRows(rows, includeFullData = true) {
+    let mappedRows = [];
+    for (const row of rows) {
+      mappedRows.push(this.mapRow(row, includeFullData));
+    }
+    return mappedRows;
+  }
+  getSelectedColumns(includeFullData = true) {
+    return `SELECT id, minimal_data, type, created_at, lens_entry_id ${includeFullData ? ",data" : ""}`;
+  }
+};
+
+
+
+exports.BetterSqliteStore = BetterSqliteStore;

package/dist/chunk-BFFOUTTE.cjs

@@ -0,0 +1,32 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); var _class;
+
+var _chunkWU6IZUEVcjs = require('./chunk-WU6IZUEV.cjs');
+
+// src/abstracts/adapter.ts
+var Adapter = (_class = class {constructor() { _class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this); }
+  __init() {this.watchers = []}
+  __init2() {this.ignoredPaths = []}
+  __init3() {this.onlyPaths = []}
+  setWatchers(watchers) {
+    this.watchers = watchers;
+    return this;
+  }
+  setIgnoredPaths(paths) {
+    this.ignoredPaths = paths;
+    return this;
+  }
+  setOnlyPaths(paths) {
+    this.onlyPaths = paths;
+    return this;
+  }
+  getWatchers() {
+    return this.watchers;
+  }
+  shouldIgnorePath(path) {
+    return _chunkWU6IZUEVcjs.shouldIgnoreCurrentPath.call(void 0, path, this.ignoredPaths, this.onlyPaths);
+  }
+}, _class);
+
+
+
+exports.Adapter = Adapter;

package/dist/chunk-BL4Z6JFH.cjs

@@ -0,0 +1,34 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); var _class;
+
+var _chunkQRZUNYF6cjs = require('./chunk-QRZUNYF6.cjs');
+
+
+var _chunkEKG3FVLVcjs = require('./chunk-EKG3FVLV.cjs');
+
+// src/watchers/request_watcher.ts
+var RequestWatcher = (_class = class extends _chunkEKG3FVLVcjs.Watcher {constructor(...args) { super(...args); _class.prototype.__init.call(this); }
+  __init() {this.name = "request"} /* REQUEST */
+  async log(data) {
+    await _chunkQRZUNYF6cjs.getStore.call(void 0, ).save({
+      id: data.request.id,
+      type: this.name,
+      minimal_data: {
+        id: data.request.id,
+        method: data.request.method,
+        path: data.request.path,
+        duration: data.request.duration,
+        createdAt: data.request.createdAt,
+        status: data.request.status
+      },
+      data: {
+        ...data.request,
+        user: data.user,
+        response: data.response
+      }
+    });
+  }
+}, _class);
+
+
+
+exports.RequestWatcher = RequestWatcher;

package/dist/chunk-CQ2Z4TCR.js

@@ -0,0 +1,7 @@
+// src/core/watcher.ts
+var Watcher = class {
+};
+
+export {
+  Watcher
+};

package/dist/chunk-EHOWCXZV.cjs

@@ -0,0 +1,7 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/abstracts/store.ts
+var Store = class {
+};
+
+
+
+exports.Store = Store;