@lensjs/core 1.0.1

package/README.md

@@ -0,0 +1 @@
+// README.md

package/copy-front-build.cjs

@@ -0,0 +1,16 @@
+const { execSync } = require("child_process");
+const { platform } = require("os");
+
+try {
+  if (platform() === "win32") {
+    console.log("Copying files for Windows...");
+    execSync('xcopy /E /I /Y "src/ui/dist" "dist/ui\\"', { stdio: "inherit" });
+  } else {
+    console.log("Copying files for Unix/Linux...");
+    execSync("cp -r src/ui/dist/ dist/ui --force", { stdio: "inherit" });
+  }
+  console.log("Files copied successfully!");
+} catch (error) {
+  console.error("Error copying files:", error);
+  process.exit(1);
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@lensjs/core",
+  "version": "1.0.1",
+  "type": "module",
+  "private": false,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup --clean && npm run build:ui",
+    "build:ui": "npm --prefix src/ui run build",
+    "clean": "rm -rf dist",
+    "postbuild": "node copy-front-build.cjs",
+    "format": "prettier --write .",
+    "test": "vitest"
+  },
+  "devDependencies": {
+    "@tailwindcss/vite": "^4.1.11",
+    "@types/luxon": "^3.7.1",
+    "cross-env": "^10.0.0",
+    "luxon": "^3.7.1",
+    "prettier": "^3.0.0",
+    "vitest": "^3.2.4"
+  },
+  "dependencies": {
+    "emittery": "^1.2.0",
+    "libsql": "^0.5.17",
+    "sql-formatter": "^15.6.6",
+    "tailwind-merge": "^3.3.1"
+  },
+  "gitHead": "a229fde5700970ec290ff31f1e3b7d84cc56d325"
+}

package/src/abstracts/adapter.ts

@@ -0,0 +1,41 @@
+import type Watcher from "../core/watcher";
+import type { RouteDefinition } from "../types";
+import { shouldIgnoreCurrentPath } from "../utils";
+
+export default abstract class Adapter {
+  private watchers: Watcher[] = [];
+  protected ignoredPaths: RegExp[] = [];
+  protected onlyPaths: RegExp[] = [];
+
+  abstract setup(): void;
+
+  setWatchers(watchers: Watcher[]) {
+    this.watchers = watchers;
+    return this;
+  }
+
+  setIgnoredPaths(paths: RegExp[]) {
+    this.ignoredPaths = paths;
+    return this;
+  }
+
+  setOnlyPaths(paths: RegExp[]) {
+    this.onlyPaths = paths;
+    return this;
+  }
+
+  getWatchers() {
+    return this.watchers;
+  }
+
+  shouldIgnorePath(path: string) {
+    return shouldIgnoreCurrentPath(path, this.ignoredPaths, this.onlyPaths);
+  }
+
+  abstract registerRoutes(routes: RouteDefinition[]): void;
+  abstract serveUI(
+    uiPath: string,
+    spaRoute: string,
+    dataToInject: Record<string, any>,
+  ): void;
+}

package/src/abstracts/store.ts

@@ -0,0 +1,36 @@
+import type {
+  PaginationParams,
+  Paginator,
+  LensEntry,
+  WatcherTypeEnum,
+} from "../types";
+
+export default 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>;
+}

package/src/context/container.ts

@@ -0,0 +1,67 @@
+import type Store from "../abstracts/store";
+
+type Factory<T = any> = () => T;
+
+type ContextStore = {
+  store: Store;
+  uiConfig: {
+    appName: string;
+    path: string;
+    api: {
+      requests: string;
+      queries: string;
+    };
+  };
+};
+
+export default class Container {
+  private static bindings = new Map<keyof ContextStore, Factory>();
+  private static singletons = new Map<keyof ContextStore, Factory>();
+  private static instances = new Map<keyof ContextStore, any>();
+
+  static bind<K extends keyof ContextStore>(
+    key: K,
+    factory: Factory<ContextStore[K]>,
+  ) {
+    this.bindings.set(key, factory);
+  }
+
+  static singleton<K extends keyof ContextStore>(
+    key: K,
+    factory: Factory<ContextStore[K]>,
+  ) {
+    this.singletons.set(key, factory);
+  }
+
+  static make<K extends keyof ContextStore>(key: K): ContextStore[K] {
+    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: keyof ContextStore): boolean {
+    return (
+      this.bindings.has(key) ||
+      this.singletons.has(key) ||
+      this.instances.has(key)
+    );
+  }
+
+  static clear(): void {
+    this.bindings.clear();
+    this.singletons.clear();
+    this.instances.clear();
+  }
+}

package/src/context/context.ts

@@ -0,0 +1,9 @@
+import Container from "./container";
+
+export const getStore = () => {
+  return Container.make("store");
+};
+
+export const getUiConfig = () => {
+  return Container.make("uiConfig");
+};

package/src/core/api_controller.ts

@@ -0,0 +1,116 @@
+import { getStore, getUiConfig } from "../context/context";
+import { WatcherTypeEnum } from "../types";
+import type {
+  ApiResponse,
+  LensEntry as LensEntry,
+  Paginator,
+  RouteDefinitionHandler,
+} from "../types";
+
+export class ApiController {
+  static async getRequests({ qs }: RouteDefinitionHandler) {
+    return this.paginatedResponse(
+      await getStore().getAllRequests(this.extractPaginationParams(qs)),
+    );
+  }
+
+  static async getRequest({
+    params,
+  }: RouteDefinitionHandler): Promise<ApiResponse<LensEntry>> {
+    const request = await getStore().find(WatcherTypeEnum.REQUEST, params.id);
+
+    if (!request) {
+      return this.notFoundResponse();
+    }
+
+    return this.resourceResponse(request);
+  }
+
+  static async getQueries({
+    qs,
+  }: RouteDefinitionHandler): Promise<ApiResponse<LensEntry[]>> {
+    const queries = await getStore().getAllQueries(
+      this.extractPaginationParams(qs),
+    );
+
+    return this.paginatedResponse(queries);
+  }
+
+  static async getQuery({
+    params,
+  }: RouteDefinitionHandler): Promise<ApiResponse<LensEntry>> {
+    const query = await getStore().find(WatcherTypeEnum.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();
+  }
+
+  private static extractPaginationParams(qs?: Record<string, any>) {
+    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 };
+  }
+
+  private static resourceResponse<T extends Object>(data: T): ApiResponse<T> {
+    return this.baseResponse<T>(data, 200, "Data fetched successfully");
+  }
+
+  private static notFoundResponse<T extends Object>(
+    message = "Could not find the requested resource",
+  ): ApiResponse<T> {
+    return this.baseResponse<T>(null, 404, message);
+  }
+
+  private static paginatedResponse<T extends Object>(
+    data: Paginator<T>,
+  ): ApiResponse<T> {
+    return this.baseResponse<T>(data, 200, "Data fetched successfully");
+  }
+
+  private static baseResponse<T extends Object>(
+    data: Paginator<T> | T | null,
+    status: number,
+    message: string,
+  ): ApiResponse<T> {
+    if (!data) {
+      return { status, message, data: null };
+    }
+
+    if ("meta" in data) {
+      return {
+        status,
+        message,
+        data: data.data,
+        meta: data.meta,
+      };
+    }
+
+    return { status, message, data };
+  }
+}

package/src/core/lens.ts

@@ -0,0 +1,147 @@
+import type Store from "../abstracts/store";
+import type Adapter from "../abstracts/adapter";
+import Watcher from "./watcher";
+import { ApiController } from "./api_controller";
+import * as path from "node:path";
+import type {
+  LensConfig,
+  RouteDefinitionHandler,
+  WatcherTypeEnum,
+} from "../types/index.ts";
+import { getUiConfig } from "../context/context";
+import Container from "../context/container";
+import { BetterSqliteStore } from "../stores/index";
+import { getMeta } from "../utils/index";
+
+export default class Lens {
+  private static watchers: Map<WatcherTypeEnum, Watcher> = new Map();
+  private static store: Store;
+  private static adapter: Adapter;
+
+  static watch(watcher: Watcher): typeof Lens {
+    this.watchers.set(watcher.name, watcher);
+    return this;
+  }
+
+  static setWatchers(watchers: Watcher[]): typeof Lens {
+    this.watchers = new Map(watchers.map((watcher) => [watcher.name, watcher]));
+    return this;
+  }
+
+  static async start(
+    config: LensConfig = {
+      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: Store): typeof Lens {
+    this.store = store;
+    return this;
+  }
+
+  static async getStore(): Promise<Store> {
+    return this.store ?? (await this.getDefaultStore());
+  }
+
+  static setAdapter(adapter: Adapter): typeof Lens {
+    this.adapter = adapter;
+    return this;
+  }
+
+  static getAdapter(): Adapter {
+    if (!this.adapter) {
+      throw new Error("No adapter has been set");
+    }
+
+    return this.adapter;
+  }
+
+  private static async bindContainerDeps(config: LensConfig) {
+    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`,
+        },
+      };
+    });
+  }
+
+  private static getRoutes({ basePath }: { basePath: string }) {
+    const apiRoutes = [
+      {
+        method: "GET" as const,
+        path: `/lens-config`,
+        handler: () => ApiController.fetchUiConfig(),
+      },
+      {
+        method: "GET" as const,
+        path: `${basePath}/api/requests`,
+        handler: async (data: RouteDefinitionHandler) =>
+          await ApiController.getRequests(data),
+      },
+      {
+        method: "GET" as const,
+        path: `${basePath}/api/requests/:id`,
+        handler: async (data: RouteDefinitionHandler) =>
+          await ApiController.getRequest(data),
+      },
+      {
+        method: "GET" as const,
+        path: `${basePath}/api/queries`,
+        handler: async (data: RouteDefinitionHandler) =>
+          await ApiController.getQueries(data),
+      },
+      {
+        method: "GET" as const,
+        path: `${basePath}/api/queries/:id`,
+        handler: async (data: RouteDefinitionHandler) =>
+          await ApiController.getQuery(data),
+      },
+      {
+        method: "DELETE" as const,
+        path: `${basePath}/api/truncate`,
+        handler: async () => await ApiController.truncate(),
+      },
+    ];
+
+    return { apiRoutes };
+  }
+
+  private static async getDefaultStore(): Promise<Store> {
+    const store = new BetterSqliteStore();
+    await store.initialize();
+
+    return store;
+  }
+
+  private static normalizeDirName(path: string) {
+    return path.replace(/(\/packages\/)[^/]+(?=\/dist)/, "$1core");
+  }
+}

package/src/core/watcher.ts

@@ -0,0 +1,6 @@
+import type { WatcherTypeEnum } from "../types";
+
+export default abstract class Watcher {
+  abstract name: WatcherTypeEnum;
+  abstract log(data: any): Promise<void>;
+}

package/src/index.ts

@@ -0,0 +1,11 @@
+export { default as Lens } from "./core/lens";
+
+export * from "./stores";
+export * from "./watchers";
+export * from "./types/index";
+export { default as LensAdapter } from "./abstracts/adapter";
+export { default as LensStore } from "./abstracts/store";
+export { default as LensWatcher } from "./core/watcher";
+export { getStore as getLensStore } from "./context/context";
+export * as lensUtils from "./utils/index";
+export { lensEmitter, lensResource, createEmittery} from "./utils/event_emitter";

package/src/stores/better_sqlite.ts

@@ -0,0 +1,176 @@
+import Store from "../abstracts/store";
+import { randomUUID } from "crypto";
+import {
+  WatcherTypeEnum,
+  type PaginationParams,
+  type LensEntry,
+} from "../types/index";
+import Database from "libsql";
+import { sqlDateTime } from "../utils";
+
+const TABLE_NAME = "lens_entries";
+
+export default class BetterSqliteStore extends Store {
+  protected connection!: Database.Database;
+
+  public async initialize() {
+    this.connection = new Database("lens.db");
+
+    this.setupSchema();
+    console.log("Connected to Lens (SQLite) database.");
+  }
+
+  public async truncate() {
+    this.connection.prepare(`DELETE FROM ${TABLE_NAME};`).run();
+  }
+
+  public async save(entry: {
+    id?: string;
+    data: Record<string, any>;
+    minimal_data?: Record<string, any>;
+    type: WatcherTypeEnum;
+    timestamp?: string;
+    requestId?: string;
+  }) {
+    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 ?? {}),
+      });
+  }
+
+  override async getAllQueries<T extends LensEntry[]>(
+    pagination: PaginationParams
+  ) {
+    return await this.paginate<T>(WatcherTypeEnum.QUERY, pagination);
+  }
+
+  override async getAllRequests<T extends Omit<LensEntry, "data">[]>(
+    pagination: PaginationParams
+  ) {
+    return await this.paginate<T>(WatcherTypeEnum.REQUEST, pagination, false);
+  }
+
+  public async allByRequestId(requestId: string, type: WatcherTypeEnum) {
+    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);
+  }
+
+  public async paginate<T>(
+    type: WatcherTypeEnum,
+    { page, perPage }: PaginationParams,
+    includeFullData: boolean = true
+  ): Promise<{
+    meta: {
+      total: number;
+      lastPage: number;
+      currentPage: number;
+    };
+    data: T;
+  }> {
+    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 as T,
+    };
+  }
+
+  override async count(type: WatcherTypeEnum): Promise<number> {
+    const result = this.connection
+      .prepare(`SELECT count(*) as count FROM ${TABLE_NAME} WHERE type = ?`)
+      .get(type) as { count: number };
+
+    return Number(result.count);
+  }
+
+  public async find(type: WatcherTypeEnum, id: string) {
+    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);
+  }
+
+  private 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);
+  }
+
+  protected mapRow(row: any, includeFullData = true): LensEntry {
+    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: data,
+    };
+  }
+
+  protected mapRows(rows: any[], includeFullData = true) {
+    let mappedRows: LensEntry[] = [];
+
+    for (const row of rows) {
+      mappedRows.push(this.mapRow(row, includeFullData));
+    }
+
+    return mappedRows;
+  }
+
+  protected getSelectedColumns(includeFullData: boolean = true) {
+    return `SELECT id, minimal_data, type, created_at, lens_entry_id ${
+      includeFullData ? ",data" : ""
+    }`;
+  }
+}

package/src/stores/index.ts

@@ -0,0 +1 @@
+export { default as BetterSqliteStore } from "./better_sqlite";