@lensjs/core 1.0.1

package/src/watchers/request_watcher.ts

@@ -0,0 +1,27 @@
+import { getStore } from "../context/context";
+import Watcher from "../core/watcher";
+import { WatcherTypeEnum, type RequestEntry } from "../types/index";
+
+export default class RequestWatcher extends Watcher {
+  name = WatcherTypeEnum.REQUEST;
+
+  async log(data: RequestEntry) {
+    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,
+      },
+    });
+  }
+}

package/tests/core/lens.test.ts

@@ -0,0 +1,89 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import Lens from '../../src/core/lens';
+import Store from '../../src/abstracts/store';
+import Adapter from '../../src/abstracts/adapter';
+import Watcher from '../../src/core/watcher';
+import { WatcherTypeEnum } from '../../src/types';
+
+// Mock implementations
+class MockStore extends Store {
+  initialize = vi.fn();
+  save = vi.fn();
+  getAllRequests = vi.fn();
+  getAllQueries = vi.fn();
+  allByRequestId = vi.fn();
+  find = vi.fn();
+  truncate = vi.fn();
+  paginate = vi.fn();
+  count = vi.fn();
+}
+
+class MockAdapter extends Adapter {
+  setup = vi.fn();
+  registerRoutes = vi.fn();
+  serveUI = vi.fn();
+  override setWatchers = vi.fn().mockReturnThis();
+}
+
+class MockWatcher extends Watcher {
+  name = WatcherTypeEnum.QUERY;
+  log = vi.fn();
+}
+
+describe('Lens', () => {
+  let mockStore: MockStore;
+  let mockAdapter: MockAdapter;
+  let mockWatcher: MockWatcher;
+
+  beforeEach(() => {
+    mockStore = new MockStore();
+    mockAdapter = new MockAdapter();
+    mockWatcher = new MockWatcher();
+    
+    // Reset static properties of Lens
+    Lens['watchers'].clear();
+    Lens['store'] = undefined as any;
+    Lens['adapter'] = undefined as any;
+  });
+
+  it('should set and get a store', async () => {
+    Lens.setStore(mockStore);
+    const store = await Lens.getStore();
+    expect(store).toBe(mockStore);
+  });
+
+  it('should set and get an adapter', () => {
+    Lens.setAdapter(mockAdapter);
+    const adapter = Lens.getAdapter();
+    expect(adapter).toBe(mockAdapter);
+  });
+
+  it('should throw an error if adapter is not set', () => {
+    expect(() => Lens.getAdapter()).toThrow('No adapter has been set');
+  });
+
+  it('should add a watcher', () => {
+    Lens.watch(mockWatcher);
+    expect(Lens['watchers'].get(WatcherTypeEnum.QUERY)).toBe(mockWatcher);
+  });
+
+  it('should start and configure the adapter', async () => {
+    Lens.setStore(mockStore);
+    Lens.setAdapter(mockAdapter);
+    Lens.watch(mockWatcher);
+
+    await Lens.start({ basePath: 'test', appName: 'TestApp', enabled: true });
+
+    expect(mockAdapter.setWatchers).toHaveBeenCalledWith([mockWatcher]);
+    expect(mockAdapter.setup).toHaveBeenCalled();
+    expect(mockAdapter.registerRoutes).toHaveBeenCalled();
+    expect(mockAdapter.serveUI).toHaveBeenCalled();
+  });
+
+  it('should not start if not enabled', async () => {
+    Lens.setAdapter(mockAdapter);
+    await Lens.start({ basePath: 'test', appName: 'TestApp', enabled: false });
+
+    expect(mockAdapter.setup).not.toHaveBeenCalled();
+  });
+});

package/tests/stores/better_sqlite.test.ts

@@ -0,0 +1,168 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import BetterSqliteStore from "../../src/stores/better_sqlite";
+import { WatcherTypeEnum } from "../../src/types";
+import Database from "libsql";
+
+class TestBetterSqliteStore extends BetterSqliteStore {
+  public override async initialize() {
+    this.connection = new Database(":memory:");
+    this.setupSchemaForTesting();
+  }
+
+  public setupSchemaForTesting() {
+    const createTable = `
+      CREATE TABLE IF NOT EXISTS lens_entries (
+        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 lens_entries (id, type);
+    `;
+
+    this.connection.exec(createTable);
+    this.connection.exec(createIndex);
+  }
+}
+
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+describe("BetterSqliteStore", () => {
+  let store: TestBetterSqliteStore;
+
+  beforeEach(async () => {
+    store = new TestBetterSqliteStore();
+    await store.initialize();
+  });
+
+  it("should save and find an entry", async () => {
+    const entry = {
+      id: "test-entry-1",
+      type: WatcherTypeEnum.REQUEST,
+      data: { message: "hello" },
+      minimal_data: { message: "hello" },
+    };
+    await store.save(entry);
+
+    const count = await store.count(WatcherTypeEnum.REQUEST);
+    expect(count).toBe(1);
+  });
+
+  it("should truncate the database", async () => {
+    const entry = {
+      type: WatcherTypeEnum.REQUEST,
+      data: { message: "hello" },
+    };
+    await store.save(entry);
+    let count = await store.count(WatcherTypeEnum.REQUEST);
+    expect(count).toBe(1);
+
+    await store.truncate();
+    count = await store.count(WatcherTypeEnum.REQUEST);
+    expect(count).toBe(0);
+  });
+
+  it("should paginate requests", async () => {
+    for (let i = 0; i < 15; i++) {
+      await store.save({
+        type: WatcherTypeEnum.REQUEST,
+        data: { index: i },
+        minimal_data: { index: i },
+      });
+      await sleep(1);
+    }
+
+    const paginator = await store.getAllRequests({ page: 2, perPage: 5 });
+    expect(paginator.data.length).toBe(5);
+    expect(paginator.meta.total).toBe(15);
+    expect(paginator.meta.currentPage).toBe(2);
+    expect(paginator.meta.lastPage).toBe(3);
+    // Check that the full data is not included
+
+    // @ts-ignore
+    expect(paginator.data[0].data).toEqual({ index: 9 });
+  });
+
+  it("should paginate queries", async () => {
+    for (let i = 0; i < 15; i++) {
+      await store.save({
+        type: WatcherTypeEnum.QUERY,
+        data: { query: `SELECT ${i}` },
+      });
+      await sleep(1);
+    }
+
+    const paginator = await store.getAllQueries({ page: 1, perPage: 7 });
+    expect(paginator.data.length).toBe(7);
+    expect(paginator.meta.total).toBe(15);
+    expect(paginator.meta.currentPage).toBe(1);
+    expect(paginator.meta.lastPage).toBe(3);
+    paginator.data[0] &&
+      expect(paginator.data[0].data).toEqual({ query: "SELECT 14" });
+  });
+
+  it("should find an entry by id", async () => {
+    const entry = {
+      id: "test-id",
+      type: WatcherTypeEnum.REQUEST,
+      data: { message: "hello" },
+    };
+    await store.save(entry);
+
+    const foundEntry = await store.find(WatcherTypeEnum.REQUEST, "test-id");
+    expect(foundEntry).not.toBeNull();
+    expect(foundEntry?.id).toBe("test-id");
+    expect(foundEntry?.data).toEqual({ message: "hello" });
+  });
+
+  it("should return null if entry is not found", async () => {
+    const foundEntry = await store.find(
+      WatcherTypeEnum.REQUEST,
+      "non-existent-id",
+    );
+    expect(foundEntry).toBeNull();
+  });
+
+  it("should retrieve all entries by request id", async () => {
+    const requestId = "request-1";
+    await store.save({
+      id: requestId,
+      type: WatcherTypeEnum.REQUEST,
+      data: { url: "/users" },
+    });
+    await sleep(1);
+    await store.save({
+      requestId: requestId,
+      type: WatcherTypeEnum.QUERY,
+      data: { query: "SELECT * FROM users" },
+    });
+    await sleep(1);
+    await store.save({
+      requestId: requestId,
+      type: WatcherTypeEnum.QUERY,
+      data: { query: "SELECT * FROM posts" },
+    });
+    await sleep(1);
+    await store.save({
+      type: WatcherTypeEnum.REQUEST,
+      data: { url: "/products" },
+    });
+
+    const entries = await store.allByRequestId(
+      requestId,
+      WatcherTypeEnum.QUERY,
+    );
+    expect(entries.length).toBe(2);
+    entries[0] &&
+      expect(entries[0].data).toEqual({ query: "SELECT * FROM posts" });
+    entries[1] &&
+      expect(entries[1].data).toEqual({ query: "SELECT * FROM users" });
+  });
+});

package/tests/utils/index.test.ts

@@ -0,0 +1,182 @@
+import { describe, it, expect } from "vitest";
+import {
+  interpolateQuery,
+  formatSqlQuery,
+  sqlDateTime,
+  isStaticFile,
+  stripBeforeAssetsPath,
+  prepareIgnoredPaths,
+  prettyHrTime,
+} from "../../src/utils/index";
+import { DateTime } from "luxon";
+
+describe("utils", () => {
+  describe("interpolateQuery", () => {
+    // Array-based ?
+    it("should replace ? placeholders with array values", () => {
+      const query = "SELECT * FROM users WHERE id = ? AND name = ?";
+      const bindings = [1, "John Doe"];
+      const expected = "SELECT * FROM users WHERE id = 1 AND name = 'John Doe'";
+      expect(interpolateQuery(query, bindings)).toBe(expected);
+    });
+
+    it("should throw if not enough array bindings", () => {
+      const query = "SELECT * FROM users WHERE id = ? AND name = ?";
+      const bindings = [1];
+      expect(() => interpolateQuery(query, bindings)).toThrow(
+        "Not enough bindings for placeholders",
+      );
+    });
+
+    it("should handle null and undefined", () => {
+      const query = "SELECT * FROM users WHERE id = ? AND name = ?";
+      const bindings = [null, undefined];
+      const expected = "SELECT * FROM users WHERE id = NULL AND name = NULL";
+      expect(interpolateQuery(query, bindings)).toBe(expected);
+    });
+
+    it("should handle DateTime and Date objects", () => {
+      const query =
+        "SELECT * FROM users WHERE created_at > ? AND updated_at > ?";
+      const dateTime = DateTime.fromISO("2025-01-01T00:00:00.000Z");
+      const date = new Date("2025-01-02T00:00:00.000Z");
+      const bindings = [dateTime, date];
+      const expected = `SELECT * FROM users WHERE created_at > '${dateTime.toISO()}' AND updated_at > '${date.toISOString()}'`;
+      expect(interpolateQuery(query, bindings)).toBe(expected);
+    });
+
+    it("should handle arrays", () => {
+      const query = "SELECT * FROM users WHERE id IN (?)";
+      const bindings = [[1, 2, 3]];
+      const expected = "SELECT * FROM users WHERE id IN (1, 2, 3)";
+      expect(interpolateQuery(query, bindings)).toBe(expected);
+    });
+
+    it("should handle objects", () => {
+      const query = "SELECT * FROM users WHERE meta = ?";
+      const bindings = [{ key: "value" }];
+      const expected = `SELECT * FROM users WHERE meta = '${JSON.stringify({ key: "value" })}'`;
+      expect(interpolateQuery(query, bindings)).toBe(expected);
+    });
+
+    // Named / numeric placeholders
+    it("should replace $1 numeric placeholder", () => {
+      const query = "INSERT INTO users (id, name) VALUES (NULL, $1);";
+      const bindings = { $1: "John Doe" };
+      const expected =
+        "INSERT INTO users (id, name) VALUES (NULL, 'John Doe');";
+      expect(interpolateQuery(query, bindings)).toBe(expected);
+    });
+
+    it("should replace $name named placeholder", () => {
+      const query = "UPDATE users SET name = $name WHERE id = $id;";
+      const bindings = { name: "Alice", id: 42 };
+      const expected = "UPDATE users SET name = 'Alice' WHERE id = 42;";
+      expect(interpolateQuery(query, bindings)).toBe(expected);
+    });
+
+    it("should replace :name named placeholder", () => {
+      const query = "DELETE FROM users WHERE id = :id;";
+      const bindings = { id: 7 };
+      const expected = "DELETE FROM users WHERE id = 7;";
+      expect(interpolateQuery(query, bindings)).toBe(expected);
+    });
+
+    it("should throw if named placeholder is missing", () => {
+      const query = "SELECT * FROM users WHERE id = :id;";
+      const bindings = {};
+      expect(() => interpolateQuery(query, bindings)).toThrow(
+        "Missing binding for :id",
+      );
+    });
+  });
+
+  describe("formatSqlQuery", () => {
+    it("should format the SQL query", () => {
+      const query = "select * from users where id = 1";
+      const expected = "SELECT\n  *\nFROM\n  users\nWHERE\n  id = 1";
+      expect(formatSqlQuery(query, "mysql")).toBe(expected);
+    });
+  });
+
+  describe("sqlDateTime", () => {
+    it("should return the current time in SQL format if no time is provided", () => {
+      const now = DateTime.now();
+      const expected = now.toSQL({ includeOffset: false });
+      // Since the exact time will differ, we check the format and length
+      expect(sqlDateTime()).toMatch(
+        /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3}$/,
+      );
+      expect(sqlDateTime()?.length).toBe(expected?.length);
+    });
+
+    it("should return the provided time in SQL format", () => {
+      const dateTime = DateTime.fromISO("2025-01-01T00:00:00.000Z", {
+        zone: "utc",
+      });
+      const expected = "2025-01-01 00:00:00.000";
+      expect(sqlDateTime(dateTime)).toBe(expected);
+    });
+  });
+
+  describe("isStaticFile", () => {
+    it('should return true if "assets" is in the params', () => {
+      expect(isStaticFile(["users", "1", "assets"])).toBe(true);
+    });
+
+    it('should return false if "assets" is not in the params', () => {
+      expect(isStaticFile(["users", "1", "profile"])).toBe(false);
+    });
+  });
+
+  describe("stripBeforeAssetsPath", () => {
+    it('should return the path from "assets" onwards', () => {
+      const url = "/users/1/assets/image.png";
+      const expected = "assets/image.png";
+      expect(stripBeforeAssetsPath(url)).toBe(expected);
+    });
+
+    it('should return the original url if "assets" is not present', () => {
+      const url = "/users/1/profile";
+      expect(stripBeforeAssetsPath(url)).toBe(url);
+    });
+  });
+
+  describe("prepareIgnoredPaths", () => {
+    it("should return the normalized path and the ignored paths", () => {
+      const path = "/api";
+      const ignoredPaths = [/^\/admin/];
+      const { normalizedPath, ignoredPaths: newIgnoredPaths } =
+        prepareIgnoredPaths(path, ignoredPaths);
+      expect(normalizedPath).toBe("api");
+      expect(newIgnoredPaths).toHaveLength(4);
+      newIgnoredPaths[0] &&
+        expect(newIgnoredPaths[0].toString()).toBe("/^\\/admin/");
+      newIgnoredPaths[1] &&
+        expect(newIgnoredPaths[1].toString()).toBe("/^\\/?api(\\/|$)/");
+    });
+  });
+
+  describe("prettyHrTime", () => {
+    it("should format high-resolution time in milliseconds", () => {
+      const hrtime: [number, number] = [0, 123456789]; // ~123.45 ms
+      expect(prettyHrTime(hrtime)).toBe("123 ms");
+    });
+
+    it("should format high-resolution time in seconds", () => {
+      const hrtime: [number, number] = [1, 500000000]; // 1.5s
+      expect(prettyHrTime(hrtime)).toBe("1.5 s");
+    });
+
+    it("should format high-resolution time verbosely", () => {
+      const hrtime: [number, number] = [0, 123456789]; // ~123.45 ms
+      expect(prettyHrTime(hrtime, true)).toBe("123.457 ms");
+
+      const secondsHrTime: [number, number] = [2, 123456789];
+      expect(prettyHrTime(secondsHrTime, true)).toBe("2.12s");
+
+      const minutesHrTime: [number, number] = [65, 123456789];
+      expect(prettyHrTime(minutesHrTime, true)).toBe("1m 5s");
+    });
+  });
+});

package/tests/watchers/query_watcher.test.ts

@@ -0,0 +1,35 @@
+import { describe, it, expect, vi } from 'vitest';
+import QueryWatcher from '../../src/watchers/query_watcher';
+import { WatcherTypeEnum, type QueryEntry } from '../../src/types';
+import Store from '../../src/abstracts/store';
+
+const mockStore = {
+  save: vi.fn(),
+} as unknown as Store;
+
+vi.mock('../../src/context/context', () => ({
+  getStore: () => mockStore,
+}));
+
+describe('QueryWatcher', () => {
+  it('should log a query entry to the store', async () => {
+    const watcher = new QueryWatcher();
+    const queryEntry: QueryEntry = {
+      data: {
+        type: 'sql',
+        duration: '10 ms',
+        query: 'SELECT * FROM users',
+        createdAt: '2025-01-01T00:00:00.000Z',
+      },
+      requestId: 'request-1',
+    };
+
+    await watcher.log(queryEntry);
+
+    expect(mockStore.save).toHaveBeenCalledWith({
+      type: WatcherTypeEnum.QUERY,
+      data: queryEntry.data,
+      requestId: 'request-1',
+    });
+  });
+});

package/tests/watchers/request_watcher.test.ts

@@ -0,0 +1,59 @@
+import { describe, it, expect, vi } from "vitest";
+import RequestWatcher from "../../src/watchers/request_watcher";
+import { WatcherTypeEnum, type RequestEntry } from "../../src/types";
+import Store from "../../src/abstracts/store";
+
+const mockStore = {
+  save: vi.fn(),
+} as unknown as Store;
+
+vi.mock("../../src/context/context", () => ({
+  getStore: () => mockStore,
+}));
+
+describe("RequestWatcher", () => {
+  it("should log a request entry to the store", async () => {
+    const watcher = new RequestWatcher();
+    const requestEntry: RequestEntry = {
+      request: {
+        body: {},
+        id: "request-1",
+        method: "GET",
+        path: "/users",
+        duration: "200 ms",
+        createdAt: "2025-01-01T00:00:00.000Z",
+        status: 200,
+        ip: "127.0.0.1",
+        headers: {},
+      },
+      user: { id: "user-1", name: "John Doe", email: "john@example.com" },
+      response: {
+        json: {},
+        headers: {},
+      },
+    };
+
+    await watcher.log(requestEntry);
+
+    expect(mockStore.save).toHaveBeenCalledWith({
+      id: "request-1",
+      type: WatcherTypeEnum.REQUEST,
+      minimal_data: {
+        id: "request-1",
+        method: "GET",
+        path: "/users",
+        duration: '200 ms',
+        createdAt: "2025-01-01T00:00:00.000Z",
+        status: 200,
+      },
+      data: {
+        ...requestEntry.request,
+        user: { id: "user-1", name: "John Doe", email: "john@example.com" },
+        response: {
+          json: {},
+          headers: {},
+        },
+      },
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../tsconfig.base.json",
+}

package/tsup.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: ["src/**/*.ts", "!src/ui/**/*"],
+  outDir: "dist",
+  format: ["esm", "cjs"],
+  dts: true,
+  bundle: true,
+  target: "node18",
+  splitting: true,
+  clean: true,
+  shims: false,
+  // shims: true,
+  skipNodeModulesBundle: true,
+});

package/vitest.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['tests/**/*.test.ts'],
+  },
+});