@lensjs/core 1.0.7 → 1.0.10

package/dist/core/lens.js

@@ -1,15 +1,373 @@
-import {
-  Lens
-} from "../chunk-5PYQWLAZ.js";
-import "../chunk-VD5IMUWL.js";
-import "../chunk-IPMTMCFP.js";
-import "../chunk-EJ5BW35V.js";
-import "../chunk-FKMBNWX4.js";
-import "../chunk-TJDE6AZM.js";
-import "../chunk-FLOVBBFU.js";
-import "../chunk-XYXPHWEI.js";
-import "../chunk-YC6T4XWI.js";
-import "../chunk-MLKGABMK.js";
+// 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/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
+import * as path2 from "path";
+
+// src/abstracts/store.ts
+var Store = class {
+};
+
+// src/stores/better_sqlite.ts
+import { randomUUID } from "crypto";
+import Database from "libsql";
+import { sqlDateTime } from "@lensjs/date";
+var TABLE_NAME = "lens_entries";
+var BetterSqliteStore = class extends Store {
+  connection;
+  async initialize() {
+    this.connection = new Database("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 ?? randomUUID(),
+      data: JSON.stringify(entry.data),
+      type: entry.type,
+      created_at: entry.timestamp ?? 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
+import { DateTime } from "luxon";
+import { format } from "sql-formatter";
+import { randomUUID as randomUUID2 } from "crypto";
+import { fileURLToPath } from "url";
+import * as path from "path";
+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 = fileURLToPath(metaUrl);
+    const __dirname2 = path.dirname(__filename2);
+    return { __filename: __filename2, __dirname: __dirname2 };
+  } else {
+    return { __filename, __dirname };
+  }
+}
+
+// src/core/lens.ts
+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");
+  }
+};
 export {
   Lens as default
 };

package/dist/core/watcher.cjs

@@ -1,7 +1,27 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-var _chunkEKG3FVLVcjs = require('../chunk-EKG3FVLV.cjs');
-require('../chunk-75ZPJI57.cjs');
-
-
-exports.default = _chunkEKG3FVLVcjs.Watcher;
+// src/core/watcher.ts
+var watcher_exports = {};
+__export(watcher_exports, {
+  default: () => Watcher
+});
+module.exports = __toCommonJS(watcher_exports);
+var Watcher = class {
+};

package/dist/core/watcher.js

@@ -1,7 +1,6 @@
-import {
-  Watcher
-} from "../chunk-CQ2Z4TCR.js";
-import "../chunk-MLKGABMK.js";
+// src/core/watcher.ts
+var Watcher = class {
+};
 export {
   Watcher as default
 };

package/dist/{index-D0Vszdac.d.ts → index-DiLfwsvc.d.cts}

@@ -1,4 +1,3 @@
-import { DateTime } from 'luxon';
 import { SqlLanguage } from 'sql-formatter';
 
 declare const generateRandomUuid: () => `${string}-${string}-${string}-${string}-${string}`;
@@ -12,10 +11,6 @@ type Bindings = any[] | Record<string, any>;
  */
 declare function interpolateQuery(query: string, bindings: Bindings): string;
 declare const formatSqlQuery: (query: string, language: SqlLanguage) => string;
-declare function now(): DateTime<true> | DateTime<false>;
-declare function nowISO(): string;
-declare function sqlDateTime(dateTime?: DateTime | null): string | null;
-declare function convertToUTC(dateTime: string): string;
 declare function getMeta(metaUrl?: string): {
     __filename: string;
     __dirname: string;
@@ -29,21 +24,17 @@ declare function prepareIgnoredPaths(path: string, ignoredPaths: RegExp[]): {
 declare function shouldIgnoreCurrentPath(path: string, ignoredPaths: RegExp[], onlyPaths: RegExp[]): boolean;
 declare function prettyHrTime(hrtime: [number, number], verbose?: boolean): string;
 
-declare const index_convertToUTC: typeof convertToUTC;
 declare const index_formatSqlQuery: typeof formatSqlQuery;
 declare const index_generateRandomUuid: typeof generateRandomUuid;
 declare const index_getMeta: typeof getMeta;
 declare const index_interpolateQuery: typeof interpolateQuery;
 declare const index_isStaticFile: typeof isStaticFile;
-declare const index_now: typeof now;
-declare const index_nowISO: typeof nowISO;
 declare const index_prepareIgnoredPaths: typeof prepareIgnoredPaths;
 declare const index_prettyHrTime: typeof prettyHrTime;
 declare const index_shouldIgnoreCurrentPath: typeof shouldIgnoreCurrentPath;
-declare const index_sqlDateTime: typeof sqlDateTime;
 declare const index_stripBeforeAssetsPath: typeof stripBeforeAssetsPath;
 declare namespace index {
-  export { index_convertToUTC as convertToUTC, index_formatSqlQuery as formatSqlQuery, index_generateRandomUuid as generateRandomUuid, index_getMeta as getMeta, index_interpolateQuery as interpolateQuery, index_isStaticFile as isStaticFile, index_now as now, index_nowISO as nowISO, index_prepareIgnoredPaths as prepareIgnoredPaths, index_prettyHrTime as prettyHrTime, index_shouldIgnoreCurrentPath as shouldIgnoreCurrentPath, index_sqlDateTime as sqlDateTime, index_stripBeforeAssetsPath as stripBeforeAssetsPath };
+  export { index_formatSqlQuery as formatSqlQuery, index_generateRandomUuid as generateRandomUuid, index_getMeta as getMeta, index_interpolateQuery as interpolateQuery, index_isStaticFile as isStaticFile, index_prepareIgnoredPaths as prepareIgnoredPaths, index_prettyHrTime as prettyHrTime, index_shouldIgnoreCurrentPath as shouldIgnoreCurrentPath, index_stripBeforeAssetsPath as stripBeforeAssetsPath };
 }
 
-export { interpolateQuery as a, nowISO as b, convertToUTC as c, getMeta as d, isStaticFile as e, formatSqlQuery as f, generateRandomUuid as g, stripBeforeAssetsPath as h, index as i, shouldIgnoreCurrentPath as j, prettyHrTime as k, now as n, prepareIgnoredPaths as p, sqlDateTime as s };
+export { interpolateQuery as a, getMeta as b, isStaticFile as c, shouldIgnoreCurrentPath as d, prettyHrTime as e, formatSqlQuery as f, generateRandomUuid as g, index as i, prepareIgnoredPaths as p, stripBeforeAssetsPath as s };

package/dist/{index-D0Vszdac.d.cts → index-DiLfwsvc.d.ts}

@@ -1,4 +1,3 @@
-import { DateTime } from 'luxon';
 import { SqlLanguage } from 'sql-formatter';
 
 declare const generateRandomUuid: () => `${string}-${string}-${string}-${string}-${string}`;
@@ -12,10 +11,6 @@ type Bindings = any[] | Record<string, any>;
  */
 declare function interpolateQuery(query: string, bindings: Bindings): string;
 declare const formatSqlQuery: (query: string, language: SqlLanguage) => string;
-declare function now(): DateTime<true> | DateTime<false>;
-declare function nowISO(): string;
-declare function sqlDateTime(dateTime?: DateTime | null): string | null;
-declare function convertToUTC(dateTime: string): string;
 declare function getMeta(metaUrl?: string): {
     __filename: string;
     __dirname: string;
@@ -29,21 +24,17 @@ declare function prepareIgnoredPaths(path: string, ignoredPaths: RegExp[]): {
 declare function shouldIgnoreCurrentPath(path: string, ignoredPaths: RegExp[], onlyPaths: RegExp[]): boolean;
 declare function prettyHrTime(hrtime: [number, number], verbose?: boolean): string;
 
-declare const index_convertToUTC: typeof convertToUTC;
 declare const index_formatSqlQuery: typeof formatSqlQuery;
 declare const index_generateRandomUuid: typeof generateRandomUuid;
 declare const index_getMeta: typeof getMeta;
 declare const index_interpolateQuery: typeof interpolateQuery;
 declare const index_isStaticFile: typeof isStaticFile;
-declare const index_now: typeof now;
-declare const index_nowISO: typeof nowISO;
 declare const index_prepareIgnoredPaths: typeof prepareIgnoredPaths;
 declare const index_prettyHrTime: typeof prettyHrTime;
 declare const index_shouldIgnoreCurrentPath: typeof shouldIgnoreCurrentPath;
-declare const index_sqlDateTime: typeof sqlDateTime;
 declare const index_stripBeforeAssetsPath: typeof stripBeforeAssetsPath;
 declare namespace index {
-  export { index_convertToUTC as convertToUTC, index_formatSqlQuery as formatSqlQuery, index_generateRandomUuid as generateRandomUuid, index_getMeta as getMeta, index_interpolateQuery as interpolateQuery, index_isStaticFile as isStaticFile, index_now as now, index_nowISO as nowISO, index_prepareIgnoredPaths as prepareIgnoredPaths, index_prettyHrTime as prettyHrTime, index_shouldIgnoreCurrentPath as shouldIgnoreCurrentPath, index_sqlDateTime as sqlDateTime, index_stripBeforeAssetsPath as stripBeforeAssetsPath };
+  export { index_formatSqlQuery as formatSqlQuery, index_generateRandomUuid as generateRandomUuid, index_getMeta as getMeta, index_interpolateQuery as interpolateQuery, index_isStaticFile as isStaticFile, index_prepareIgnoredPaths as prepareIgnoredPaths, index_prettyHrTime as prettyHrTime, index_shouldIgnoreCurrentPath as shouldIgnoreCurrentPath, index_stripBeforeAssetsPath as stripBeforeAssetsPath };
 }
 
-export { interpolateQuery as a, nowISO as b, convertToUTC as c, getMeta as d, isStaticFile as e, formatSqlQuery as f, generateRandomUuid as g, stripBeforeAssetsPath as h, index as i, shouldIgnoreCurrentPath as j, prettyHrTime as k, now as n, prepareIgnoredPaths as p, sqlDateTime as s };
+export { interpolateQuery as a, getMeta as b, isStaticFile as c, shouldIgnoreCurrentPath as d, prettyHrTime as e, formatSqlQuery as f, generateRandomUuid as g, index as i, prepareIgnoredPaths as p, stripBeforeAssetsPath as s };