@lensjs/core 1.0.7 → 1.0.10

package/dist/index.cjs

@@ -1,55 +1,611 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-
-
-var _chunk3R5QARPTcjs = require('./chunk-3R5QARPT.cjs');
-require('./chunk-7EKM5HB5.cjs');
-
-
-var _chunkSJXZARBJcjs = require('./chunk-SJXZARBJ.cjs');
-
-
-var _chunkBL4Z6JFHcjs = require('./chunk-BL4Z6JFH.cjs');
-
-
-var _chunkBFFOUTTEcjs = require('./chunk-BFFOUTTE.cjs');
-
-
-var _chunkFCMQ3WE3cjs = require('./chunk-FCMQ3WE3.cjs');
-require('./chunk-XZFXXD3A.cjs');
-
-
-var _chunkAUDSBNLFcjs = require('./chunk-AUDSBNLF.cjs');
-
-
-var _chunkWU6IZUEVcjs = require('./chunk-WU6IZUEV.cjs');
-
-
-var _chunkEHOWCXZVcjs = require('./chunk-EHOWCXZV.cjs');
-require('./chunk-JZ2JLQXL.cjs');
-
-
-var _chunk2HRVJRKVcjs = require('./chunk-2HRVJRKV.cjs');
-
-
-var _chunkQRZUNYF6cjs = require('./chunk-QRZUNYF6.cjs');
-require('./chunk-GI7SJDNQ.cjs');
-
-
-var _chunkEKG3FVLVcjs = require('./chunk-EKG3FVLV.cjs');
-require('./chunk-75ZPJI57.cjs');
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-exports.BetterSqliteStore = _chunkAUDSBNLFcjs.BetterSqliteStore; exports.Lens = _chunkFCMQ3WE3cjs.Lens; exports.LensAdapter = _chunkBFFOUTTEcjs.Adapter; exports.LensStore = _chunkEHOWCXZVcjs.Store; exports.LensWatcher = _chunkEKG3FVLVcjs.Watcher; exports.QueryWatcher = _chunkSJXZARBJcjs.QueryWatcher; exports.RequestWatcher = _chunkBL4Z6JFHcjs.RequestWatcher; exports.WatcherTypeEnum = _chunk2HRVJRKVcjs.WatcherTypeEnum; exports.createEmittery = _chunk3R5QARPTcjs.createEmittery; exports.getLensStore = _chunkQRZUNYF6cjs.getStore; exports.lensEmitter = _chunk3R5QARPTcjs.lensEmitter; exports.lensResource = _chunk3R5QARPTcjs.lensResource; exports.lensUtils = _chunkWU6IZUEVcjs.utils_exports;
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BetterSqliteStore: () => BetterSqliteStore,
+  Lens: () => Lens,
+  LensAdapter: () => Adapter,
+  LensStore: () => Store,
+  LensWatcher: () => Watcher,
+  QueryWatcher: () => QueryWatcher,
+  RequestWatcher: () => RequestWatcher,
+  WatcherTypeEnum: () => WatcherTypeEnum,
+  createEmittery: () => createEmittery,
+  getLensStore: () => getStore,
+  lensUtils: () => utils_exports
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/context/container.ts
+var Container = class {
+  static bindings = /* @__PURE__ */ new Map();
+  static singletons = /* @__PURE__ */ new Map();
+  static instances = /* @__PURE__ */ new Map();
+  static bind(key, factory) {
+    this.bindings.set(key, factory);
+  }
+  static singleton(key, factory) {
+    this.singletons.set(key, factory);
+  }
+  static make(key) {
+    if (this.instances.has(key)) {
+      return this.instances.get(key);
+    }
+    if (this.singletons.has(key)) {
+      const instance = this.singletons.get(key)();
+      this.instances.set(key, instance);
+      return instance;
+    }
+    if (this.bindings.has(key)) {
+      return this.bindings.get(key)();
+    }
+    throw new Error(`Service "${key}" is not bound in the container`);
+  }
+  static has(key) {
+    return this.bindings.has(key) || this.singletons.has(key) || this.instances.has(key);
+  }
+  static clear() {
+    this.bindings.clear();
+    this.singletons.clear();
+    this.instances.clear();
+  }
+};
+
+// src/context/context.ts
+var getStore = () => {
+  return Container.make("store");
+};
+var getUiConfig = () => {
+  return Container.make("uiConfig");
+};
+
+// src/types/index.ts
+var WatcherTypeEnum = /* @__PURE__ */ ((WatcherTypeEnum2) => {
+  WatcherTypeEnum2["REQUEST"] = "request";
+  WatcherTypeEnum2["QUERY"] = "query";
+  return WatcherTypeEnum2;
+})(WatcherTypeEnum || {});
+
+// src/core/api_controller.ts
+var ApiController = class {
+  static async getRequests({ qs }) {
+    return this.paginatedResponse(
+      await getStore().getAllRequests(this.extractPaginationParams(qs))
+    );
+  }
+  static async getRequest({
+    params
+  }) {
+    const request = await getStore().find("request" /* REQUEST */, params.id);
+    if (!request) {
+      return this.notFoundResponse();
+    }
+    return this.resourceResponse(request);
+  }
+  static async getQueries({
+    qs
+  }) {
+    const queries = await getStore().getAllQueries(
+      this.extractPaginationParams(qs)
+    );
+    return this.paginatedResponse(queries);
+  }
+  static async getQuery({
+    params
+  }) {
+    const query = await getStore().find("query" /* QUERY */, params.id);
+    if (!query) {
+      return this.notFoundResponse();
+    }
+    return this.resourceResponse(query);
+  }
+  static async truncate() {
+    await getStore().truncate();
+    return this.baseResponse({}, 200, "All entries cleared");
+  }
+  static fetchUiConfig() {
+    return getUiConfig();
+  }
+  static extractPaginationParams(qs) {
+    if (!qs || Object.keys(qs).length === 0) {
+      return { page: 1, perPage: 100 };
+    }
+    let page = Number(qs.page);
+    let perPage = Number(qs.perPage);
+    if (!Number.isInteger(perPage) || perPage > 100 || perPage < 5) {
+      perPage = 100;
+    }
+    if (!Number.isInteger(page) || page < 1) {
+      page = 1;
+    }
+    return { page, perPage };
+  }
+  static resourceResponse(data) {
+    return this.baseResponse(data, 200, "Data fetched successfully");
+  }
+  static notFoundResponse(message = "Could not find the requested resource") {
+    return this.baseResponse(null, 404, message);
+  }
+  static paginatedResponse(data) {
+    return this.baseResponse(data, 200, "Data fetched successfully");
+  }
+  static baseResponse(data, status, message) {
+    if (!data) {
+      return { status, message, data: null };
+    }
+    if ("meta" in data) {
+      return {
+        status,
+        message,
+        data: data.data,
+        meta: data.meta
+      };
+    }
+    return { status, message, data };
+  }
+};
+
+// src/core/lens.ts
+var path2 = __toESM(require("path"), 1);
+
+// src/abstracts/store.ts
+var Store = class {
+};
+
+// src/stores/better_sqlite.ts
+var import_crypto = require("crypto");
+var import_libsql = __toESM(require("libsql"), 1);
+var import_date = require("@lensjs/date");
+var TABLE_NAME = "lens_entries";
+var BetterSqliteStore = class extends Store {
+  connection;
+  async initialize() {
+    this.connection = new import_libsql.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: entry.id ?? (0, import_crypto.randomUUID)(),
+      data: JSON.stringify(entry.data),
+      type: entry.type,
+      created_at: entry.timestamp ?? (0, import_date.sqlDateTime)(),
+      lens_entry_id: entry.requestId || null,
+      minimalData: JSON.stringify(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" : ""}`;
+  }
+};
+
+// src/utils/index.ts
+var utils_exports = {};
+__export(utils_exports, {
+  formatSqlQuery: () => formatSqlQuery,
+  generateRandomUuid: () => generateRandomUuid,
+  getMeta: () => getMeta,
+  interpolateQuery: () => interpolateQuery,
+  isStaticFile: () => isStaticFile,
+  prepareIgnoredPaths: () => prepareIgnoredPaths,
+  prettyHrTime: () => prettyHrTime,
+  shouldIgnoreCurrentPath: () => shouldIgnoreCurrentPath,
+  stripBeforeAssetsPath: () => stripBeforeAssetsPath
+});
+var import_luxon = require("luxon");
+var import_sql_formatter = require("sql-formatter");
+var import_crypto2 = require("crypto");
+var import_url = require("url");
+var path = __toESM(require("path"), 1);
+var generateRandomUuid = () => {
+  return (0, import_crypto2.randomUUID)();
+};
+function interpolateQuery(query, bindings) {
+  const formatValue = (value) => {
+    if (value === null || value === void 0) return "NULL";
+    if (typeof value === "string") return `'${value.replace(/'/g, "''")}'`;
+    if (value instanceof import_luxon.DateTime) return `'${value.toISO()}'`;
+    if (value instanceof Date) return `'${value.toISOString()}'`;
+    if (Array.isArray(value))
+      return value.map((v) => typeof v === "string" ? `'${v.replace(/'/g, "''")}'` : v).join(", ");
+    if (typeof value === "object")
+      return `'${JSON.stringify(value).replace(/'/g, "''")}'`;
+    return value.toString();
+  };
+  if (Array.isArray(bindings)) {
+    let i = 0;
+    return query.replace(/\?/g, () => {
+      if (i >= bindings.length)
+        throw new Error("Not enough bindings for placeholders");
+      return formatValue(bindings[i++]);
+    });
+  }
+  return query.replace(/(\$|\:)(\w+)/g, (match, prefix, keyOrIndex) => {
+    let value;
+    if (prefix === "$" && /^\d+$/.test(keyOrIndex)) {
+      const index = parseInt(keyOrIndex, 10) - 1;
+      const keys = Object.keys(bindings);
+      if (index < 0 || index >= keys.length)
+        throw new Error(`Missing binding for ${match}`);
+      value = bindings[keys[index]];
+    } else {
+      if (!(keyOrIndex in bindings))
+        throw new Error(`Missing binding for ${match}`);
+      value = bindings[keyOrIndex];
+    }
+    return formatValue(value);
+  });
+}
+var formatSqlQuery = (query, language) => {
+  return (0, import_sql_formatter.format)(query, {
+    language,
+    dataTypeCase: "upper",
+    keywordCase: "upper",
+    functionCase: "upper"
+  });
+};
+function getMeta(metaUrl) {
+  const isESM = typeof __dirname === "undefined";
+  if (isESM) {
+    if (!metaUrl) {
+      throw new Error("In ESM, you must pass import.meta.url to getMeta()");
+    }
+    const __filename2 = (0, import_url.fileURLToPath)(metaUrl);
+    const __dirname2 = path.dirname(__filename2);
+    return { __filename: __filename2, __dirname: __dirname2 };
+  } else {
+    return { __filename, __dirname };
+  }
+}
+function isStaticFile(params) {
+  return params.includes("assets");
+}
+function stripBeforeAssetsPath(url) {
+  const match = url.match(/assets.*/);
+  return match ? match[0] : url;
+}
+function prepareIgnoredPaths(path3, ignoredPaths) {
+  const normalizedPath = path3.replace(/^\/+|\/+$/g, "");
+  ignoredPaths = [
+    ...ignoredPaths,
+    new RegExp(`^/?${normalizedPath}(/|$)`),
+    /^\/?lens-config$/,
+    /^\/\.well-known\//
+  ];
+  return { ignoredPaths, normalizedPath };
+}
+function shouldIgnoreCurrentPath(path3, ignoredPaths, onlyPaths) {
+  if (onlyPaths.length > 0) {
+    return !onlyPaths.some((pattern) => pattern.test(path3));
+  }
+  return ignoredPaths.some((pattern) => pattern.test(path3));
+}
+function prettyHrTime(hrtime, verbose = false) {
+  const seconds = hrtime[0];
+  const nanoseconds = hrtime[1];
+  const ms = seconds * 1e3 + nanoseconds / 1e6;
+  if (verbose) {
+    if (seconds > 60) {
+      const minutes = Math.floor(seconds / 60);
+      const remainingSeconds = seconds % 60;
+      return `${minutes}m ${remainingSeconds}s`;
+    }
+    if (seconds >= 1) {
+      return `${seconds}.${Math.floor(nanoseconds / 1e7)}s`;
+    }
+    return `${ms.toFixed(3)} ms`;
+  }
+  if (ms < 1e3) {
+    return `${ms.toFixed(0)} ms`;
+  }
+  return `${(ms / 1e3).toFixed(1)} s`;
+}
+
+// src/core/lens.ts
+var import_meta = {};
+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: __dirname2 } = getMeta(import_meta.url);
+    const uiPath = path2.resolve(this.normalizeDirName(__dirname2), "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(path3) {
+    return path3.replace(/(\/packages\/)[^/]+(?=\/dist)/, "$1core");
+  }
+};
+
+// src/core/watcher.ts
+var Watcher = class {
+};
+
+// src/watchers/query_watcher.ts
+var QueryWatcher = class extends Watcher {
+  name = "query" /* QUERY */;
+  async log(entry) {
+    await getStore().save({
+      type: this.name,
+      data: entry.data,
+      requestId: entry.requestId ?? ""
+    });
+  }
+};
+
+// 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,
+      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
+      }
+    });
+  }
+};
+
+// src/abstracts/adapter.ts
+var Adapter = class {
+  watchers = [];
+  ignoredPaths = [];
+  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(path3) {
+    return shouldIgnoreCurrentPath(path3, this.ignoredPaths, this.onlyPaths);
+  }
+};
+
+// src/utils/event_emitter.ts
+var import_emittery = __toESM(require("emittery"), 1);
+var createEmittery = () => {
+  return new import_emittery.default();
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BetterSqliteStore,
+  Lens,
+  LensAdapter,
+  LensStore,
+  LensWatcher,
+  QueryWatcher,
+  RequestWatcher,
+  WatcherTypeEnum,
+  createEmittery,
+  getLensStore,
+  lensUtils
+});

package/dist/index.d.cts

@@ -7,10 +7,8 @@ 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-D0Vszdac.cjs';
-export { createEmittery, lensEmitter, lensResource } from './utils/event_emitter.cjs';
+export { i as lensUtils } from './index-DiLfwsvc.cjs';
+export { createEmittery } from './utils/event_emitter.cjs';
 import 'libsql';
 import 'sql-formatter';
-import 'luxon';
 import 'emittery';
-import 'node:async_hooks';

package/dist/index.d.ts

@@ -7,10 +7,8 @@ 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-D0Vszdac.js';
-export { createEmittery, lensEmitter, lensResource } from './utils/event_emitter.js';
+export { i as lensUtils } from './index-DiLfwsvc.js';
+export { createEmittery } from './utils/event_emitter.js';
 import 'libsql';
 import 'sql-formatter';
-import 'luxon';
 import 'emittery';
-import 'node:async_hooks';