@lensjs/core 2.2.1 → 2.3.0

package/dist/stores/queued_sqlite.cjs

@@ -0,0 +1,278 @@
+"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/stores/queued_sqlite.ts
+var queued_sqlite_exports = {};
+__export(queued_sqlite_exports, {
+  default: () => QueuedSqliteStore
+});
+module.exports = __toCommonJS(queued_sqlite_exports);
+
+// src/mixins/queued_store.ts
+var import_denque = __toESM(require("denque"), 1);
+function QueuedStore(Base) {
+  return class Queued extends Base {
+    queue;
+    processingInterval = null;
+    BATCH_SIZE;
+    PROCESS_INTERVAL_MS;
+    WARN_THRESHOLD;
+    PREALLOCATE;
+    constructor(...args) {
+      super(...args);
+      const config = args[0] || {};
+      this.BATCH_SIZE = config.batchSize ?? 100;
+      this.PROCESS_INTERVAL_MS = config.processIntervalMs ?? 100;
+      this.WARN_THRESHOLD = config.warnThreshold ?? 1e5;
+      this.PREALLOCATE = config.preallocate ?? true;
+      this.queue = this.PREALLOCATE ? new import_denque.default([], { capacity: this.WARN_THRESHOLD * 2 }) : new import_denque.default();
+    }
+    async initialize() {
+      if (super["initialize"]) {
+        await super["initialize"].call(this);
+      }
+      this.startProcessingQueue();
+      process.on("SIGINT", () => this.shutdown());
+      process.on("SIGTERM", () => this.shutdown());
+    }
+    async truncate() {
+      this.queue.clear();
+      if (super["truncate"]) {
+        await super["truncate"].call(this);
+      }
+    }
+    async save(entry) {
+      this.queue.push(entry);
+      if (this.queue.length > this.WARN_THRESHOLD) {
+        console.warn(`\u26A0\uFE0F LensJs Queue size very large: ${this.queue.length}`);
+      }
+    }
+    startProcessingQueue() {
+      if (this.processingInterval) clearInterval(this.processingInterval);
+      this.processingInterval = setInterval(
+        () => this.processQueue(),
+        this.PROCESS_INTERVAL_MS
+      );
+    }
+    async processQueue() {
+      if (this.queue.isEmpty()) return;
+      const batchSize = Math.min(
+        this.BATCH_SIZE,
+        Math.max(10, Math.floor(this.queue.length / 10))
+      );
+      const entriesToProcess = this.queue.remove(0, batchSize);
+      if (!entriesToProcess.length) return;
+      for (const entry of entriesToProcess) {
+        super["save"]?.call(this, entry).catch((error) => {
+          console.error("Error saving queued entry:", error);
+        });
+      }
+    }
+    async stopProcessingQueue() {
+      if (this.processingInterval) {
+        clearInterval(this.processingInterval);
+        this.processingInterval = null;
+      }
+      if (!this.queue.isEmpty()) {
+        await this.processQueue();
+      }
+    }
+    async shutdown() {
+      await this.stopProcessingQueue();
+      process.exit(0);
+    }
+  };
+}
+
+// src/utils/compose.ts
+function compose(superclass, ...mixins) {
+  return mixins.reduce((c, mixin) => mixin(c), superclass);
+}
+
+// src/abstracts/store.ts
+var Store = class {
+  constructor(...args) {
+  }
+  getAllExceptions(_paginationParams) {
+    return this.defaultMinimalPaginate();
+  }
+  stringifyData(data) {
+    if (typeof data === "string") {
+      return data;
+    }
+    try {
+      return JSON.stringify(data);
+    } catch (e) {
+      console.error(`Failed to stringify lens data: ${e}`);
+    }
+  }
+  defaultMinimalPaginate() {
+    return Promise.resolve({
+      data: [],
+      meta: {
+        currentPage: 0,
+        lastPage: 0,
+        total: 0
+      }
+    });
+  }
+};
+
+// 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: this.stringifyData(entry.data),
+      type: entry.type,
+      created_at: entry.timestamp ?? (0, import_date.nowISO)(),
+      lens_entry_id: entry.requestId || null,
+      minimalData: this.stringifyData(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 getAllCacheEntries(pagination) {
+    return await this.paginate("cache" /* CACHE */, pagination);
+  }
+  async getAllExceptions(pagination) {
+    return await this.paginate("exception" /* EXCEPTION */, pagination, false);
+  }
+  async allByRequestId(requestId, type, includeFullData = true) {
+    const rows = this.connection.prepare(
+      `${this.getSelectedColumns(includeFullData)} FROM ${TABLE_NAME} WHERE type = $type AND lens_entry_id = $requestId ORDER BY created_at DESC`
+    ).all({ type, requestId });
+    return this.mapRows(rows, includeFullData);
+  }
+  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() {
+    this.connection.exec("PRAGMA journal_mode = WAL;");
+    this.connection.exec("PRAGMA synchronous = NORMAL;");
+    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);
+    `;
+    const lensEntryIdIndex = `
+      CREATE INDEX IF NOT EXISTS lens_entry_id_index
+      ON ${TABLE_NAME} (lens_entry_id);
+    `;
+    this.connection.exec(createTable);
+    this.connection.exec(createIndex);
+    this.connection.exec(lensEntryIdIndex);
+  }
+  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/stores/queued_sqlite.ts
+var QueuedSqliteStore = class extends compose(
+  BetterSqliteStore,
+  QueuedStore
+) {
+};

package/dist/stores/queued_sqlite.d.cts

@@ -0,0 +1,43 @@
+import BetterSqliteStore from './better_sqlite.cjs';
+import * as denque from 'denque';
+import { WatcherTypeEnum } from '../types/index.cjs';
+import '../abstracts/store.cjs';
+import 'sql-formatter';
+import 'libsql';
+
+declare const QueuedSqliteStore_base: {
+    new (...args: any[]): {
+        [x: string]: any;
+        queue: denque<{
+            id?: string;
+            data: Record<string, any>;
+            minimal_data?: Record<string, any>;
+            type: WatcherTypeEnum;
+            timestamp?: string;
+            requestId?: string;
+        }>;
+        processingInterval: NodeJS.Timeout | null;
+        readonly BATCH_SIZE: number;
+        readonly PROCESS_INTERVAL_MS: number;
+        readonly WARN_THRESHOLD: number;
+        readonly PREALLOCATE: boolean;
+        initialize(): Promise<void>;
+        truncate(): Promise<void>;
+        save(entry: {
+            id?: string;
+            data: Record<string, any>;
+            minimal_data?: Record<string, any>;
+            type: WatcherTypeEnum;
+            timestamp?: string;
+            requestId?: string;
+        }): Promise<void>;
+        startProcessingQueue(): void;
+        processQueue(): Promise<void>;
+        stopProcessingQueue(): Promise<void>;
+        shutdown(): Promise<void>;
+    };
+} & typeof BetterSqliteStore;
+declare class QueuedSqliteStore extends QueuedSqliteStore_base {
+}
+
+export { QueuedSqliteStore as default };

package/dist/stores/queued_sqlite.d.ts

@@ -0,0 +1,43 @@
+import BetterSqliteStore from './better_sqlite.js';
+import * as denque from 'denque';
+import { WatcherTypeEnum } from '../types/index.js';
+import '../abstracts/store.js';
+import 'sql-formatter';
+import 'libsql';
+
+declare const QueuedSqliteStore_base: {
+    new (...args: any[]): {
+        [x: string]: any;
+        queue: denque<{
+            id?: string;
+            data: Record<string, any>;
+            minimal_data?: Record<string, any>;
+            type: WatcherTypeEnum;
+            timestamp?: string;
+            requestId?: string;
+        }>;
+        processingInterval: NodeJS.Timeout | null;
+        readonly BATCH_SIZE: number;
+        readonly PROCESS_INTERVAL_MS: number;
+        readonly WARN_THRESHOLD: number;
+        readonly PREALLOCATE: boolean;
+        initialize(): Promise<void>;
+        truncate(): Promise<void>;
+        save(entry: {
+            id?: string;
+            data: Record<string, any>;
+            minimal_data?: Record<string, any>;
+            type: WatcherTypeEnum;
+            timestamp?: string;
+            requestId?: string;
+        }): Promise<void>;
+        startProcessingQueue(): void;
+        processQueue(): Promise<void>;
+        stopProcessingQueue(): Promise<void>;
+        shutdown(): Promise<void>;
+    };
+} & typeof BetterSqliteStore;
+declare class QueuedSqliteStore extends QueuedSqliteStore_base {
+}
+
+export { QueuedSqliteStore as default };

package/dist/stores/queued_sqlite.js

@@ -0,0 +1,245 @@
+// src/mixins/queued_store.ts
+import Denque from "denque";
+function QueuedStore(Base) {
+  return class Queued extends Base {
+    queue;
+    processingInterval = null;
+    BATCH_SIZE;
+    PROCESS_INTERVAL_MS;
+    WARN_THRESHOLD;
+    PREALLOCATE;
+    constructor(...args) {
+      super(...args);
+      const config = args[0] || {};
+      this.BATCH_SIZE = config.batchSize ?? 100;
+      this.PROCESS_INTERVAL_MS = config.processIntervalMs ?? 100;
+      this.WARN_THRESHOLD = config.warnThreshold ?? 1e5;
+      this.PREALLOCATE = config.preallocate ?? true;
+      this.queue = this.PREALLOCATE ? new Denque([], { capacity: this.WARN_THRESHOLD * 2 }) : new Denque();
+    }
+    async initialize() {
+      if (super["initialize"]) {
+        await super["initialize"].call(this);
+      }
+      this.startProcessingQueue();
+      process.on("SIGINT", () => this.shutdown());
+      process.on("SIGTERM", () => this.shutdown());
+    }
+    async truncate() {
+      this.queue.clear();
+      if (super["truncate"]) {
+        await super["truncate"].call(this);
+      }
+    }
+    async save(entry) {
+      this.queue.push(entry);
+      if (this.queue.length > this.WARN_THRESHOLD) {
+        console.warn(`\u26A0\uFE0F LensJs Queue size very large: ${this.queue.length}`);
+      }
+    }
+    startProcessingQueue() {
+      if (this.processingInterval) clearInterval(this.processingInterval);
+      this.processingInterval = setInterval(
+        () => this.processQueue(),
+        this.PROCESS_INTERVAL_MS
+      );
+    }
+    async processQueue() {
+      if (this.queue.isEmpty()) return;
+      const batchSize = Math.min(
+        this.BATCH_SIZE,
+        Math.max(10, Math.floor(this.queue.length / 10))
+      );
+      const entriesToProcess = this.queue.remove(0, batchSize);
+      if (!entriesToProcess.length) return;
+      for (const entry of entriesToProcess) {
+        super["save"]?.call(this, entry).catch((error) => {
+          console.error("Error saving queued entry:", error);
+        });
+      }
+    }
+    async stopProcessingQueue() {
+      if (this.processingInterval) {
+        clearInterval(this.processingInterval);
+        this.processingInterval = null;
+      }
+      if (!this.queue.isEmpty()) {
+        await this.processQueue();
+      }
+    }
+    async shutdown() {
+      await this.stopProcessingQueue();
+      process.exit(0);
+    }
+  };
+}
+
+// src/utils/compose.ts
+function compose(superclass, ...mixins) {
+  return mixins.reduce((c, mixin) => mixin(c), superclass);
+}
+
+// src/abstracts/store.ts
+var Store = class {
+  constructor(...args) {
+  }
+  getAllExceptions(_paginationParams) {
+    return this.defaultMinimalPaginate();
+  }
+  stringifyData(data) {
+    if (typeof data === "string") {
+      return data;
+    }
+    try {
+      return JSON.stringify(data);
+    } catch (e) {
+      console.error(`Failed to stringify lens data: ${e}`);
+    }
+  }
+  defaultMinimalPaginate() {
+    return Promise.resolve({
+      data: [],
+      meta: {
+        currentPage: 0,
+        lastPage: 0,
+        total: 0
+      }
+    });
+  }
+};
+
+// src/stores/better_sqlite.ts
+import { randomUUID } from "crypto";
+import Database from "libsql";
+import { nowISO } 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: this.stringifyData(entry.data),
+      type: entry.type,
+      created_at: entry.timestamp ?? nowISO(),
+      lens_entry_id: entry.requestId || null,
+      minimalData: this.stringifyData(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 getAllCacheEntries(pagination) {
+    return await this.paginate("cache" /* CACHE */, pagination);
+  }
+  async getAllExceptions(pagination) {
+    return await this.paginate("exception" /* EXCEPTION */, pagination, false);
+  }
+  async allByRequestId(requestId, type, includeFullData = true) {
+    const rows = this.connection.prepare(
+      `${this.getSelectedColumns(includeFullData)} FROM ${TABLE_NAME} WHERE type = $type AND lens_entry_id = $requestId ORDER BY created_at DESC`
+    ).all({ type, requestId });
+    return this.mapRows(rows, includeFullData);
+  }
+  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() {
+    this.connection.exec("PRAGMA journal_mode = WAL;");
+    this.connection.exec("PRAGMA synchronous = NORMAL;");
+    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);
+    `;
+    const lensEntryIdIndex = `
+      CREATE INDEX IF NOT EXISTS lens_entry_id_index
+      ON ${TABLE_NAME} (lens_entry_id);
+    `;
+    this.connection.exec(createTable);
+    this.connection.exec(createIndex);
+    this.connection.exec(lensEntryIdIndex);
+  }
+  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/stores/queued_sqlite.ts
+var QueuedSqliteStore = class extends compose(
+  BetterSqliteStore,
+  QueuedStore
+) {
+};
+export {
+  QueuedSqliteStore as default
+};

package/dist/types/index.d.cts

@@ -93,9 +93,14 @@ declare enum WatcherTypeEnum {
     EXCEPTION = "exception"
 }
 type LensConfig = {
-    basePath: string;
+    path: string;
     appName: string;
     enabled: boolean;
+    storeQueueConfig?: QueuedStoreConfig;
+    hiddenParams?: {
+        headers?: string[];
+        bodyParams?: string[];
+    };
 };
 type LensEntry = {
     id: string;
@@ -134,5 +139,12 @@ type ApiResponse<T> = {
 };
 type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS";
 type RouteHttpMethod = "get" | "post" | "put" | "delete" | "patch";
+type Constructor = new (...args: any[]) => any;
+interface QueuedStoreConfig {
+    batchSize?: number;
+    processIntervalMs?: number;
+    warnThreshold?: number;
+    preallocate?: boolean;
+}
 
-export { type ApiResponse, type CacheAction, type CacheEntry, type Entry, type ExceptionEntry, type HttpMethod, type LensConfig, type LensEntry, type PaginationParams, type Paginator, type QueryEntry, type QueryType, type RequestEntry, type RouteDefinition, type RouteDefinitionHandler, type RouteHttpMethod, type SqlQueryType, type UserEntry, WatcherTypeEnum };
+export { type ApiResponse, type CacheAction, type CacheEntry, type Constructor, type Entry, type ExceptionEntry, type HttpMethod, type LensConfig, type LensEntry, type PaginationParams, type Paginator, type QueryEntry, type QueryType, type QueuedStoreConfig, type RequestEntry, type RouteDefinition, type RouteDefinitionHandler, type RouteHttpMethod, type SqlQueryType, type UserEntry, WatcherTypeEnum };

package/dist/types/index.d.ts

@@ -93,9 +93,14 @@ declare enum WatcherTypeEnum {
     EXCEPTION = "exception"
 }
 type LensConfig = {
-    basePath: string;
+    path: string;
     appName: string;
     enabled: boolean;
+    storeQueueConfig?: QueuedStoreConfig;
+    hiddenParams?: {
+        headers?: string[];
+        bodyParams?: string[];
+    };
 };
 type LensEntry = {
     id: string;
@@ -134,5 +139,12 @@ type ApiResponse<T> = {
 };
 type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS";
 type RouteHttpMethod = "get" | "post" | "put" | "delete" | "patch";
+type Constructor = new (...args: any[]) => any;
+interface QueuedStoreConfig {
+    batchSize?: number;
+    processIntervalMs?: number;
+    warnThreshold?: number;
+    preallocate?: boolean;
+}
 
-export { type ApiResponse, type CacheAction, type CacheEntry, type Entry, type ExceptionEntry, type HttpMethod, type LensConfig, type LensEntry, type PaginationParams, type Paginator, type QueryEntry, type QueryType, type RequestEntry, type RouteDefinition, type RouteDefinitionHandler, type RouteHttpMethod, type SqlQueryType, type UserEntry, WatcherTypeEnum };
+export { type ApiResponse, type CacheAction, type CacheEntry, type Constructor, type Entry, type ExceptionEntry, type HttpMethod, type LensConfig, type LensEntry, type PaginationParams, type Paginator, type QueryEntry, type QueryType, type QueuedStoreConfig, type RequestEntry, type RouteDefinition, type RouteDefinitionHandler, type RouteHttpMethod, type SqlQueryType, type UserEntry, WatcherTypeEnum };

package/dist/ui/assets/{CacheActionBadge-WGVr5yhe.js → CacheActionBadge-BB4uokI1.js}

@@ -1 +1 @@
-import{j as r}from"./index-CQJv-KV7.js";const d=({action:e})=>{const t={hit:"bg-green-100 text-green-800 dark:bg-green-600 dark:text-white",miss:"bg-amber-100 text-amber-800 dark:bg-amber-600 dark:text-white",write:"bg-blue-100 text-blue-800 dark:bg-blue-600 dark:text-white",delete:"bg-red-100 text-red-800 dark:bg-red-600 dark:text-white",clear:"bg-gray-100 text-gray-800 dark:bg-gray-600 dark:text-white"};return r.jsx("span",{className:`rounded px-2 py-1 text-sm font-semibold ${t[e]||t.clear}`,children:e})};export{d as C};
+import{j as r}from"./index-TW_-MgRG.js";const d=({action:e})=>{const t={hit:"bg-green-100 text-green-800 dark:bg-green-600 dark:text-white",miss:"bg-amber-100 text-amber-800 dark:bg-amber-600 dark:text-white",write:"bg-blue-100 text-blue-800 dark:bg-blue-600 dark:text-white",delete:"bg-red-100 text-red-800 dark:bg-red-600 dark:text-white",clear:"bg-gray-100 text-gray-800 dark:bg-gray-600 dark:text-white"};return r.jsx("span",{className:`rounded px-2 py-1 text-sm font-semibold ${t[e]||t.clear}`,children:e})};export{d as C};

package/dist/ui/assets/CacheEntriesTable-B8cUXhos.js

@@ -0,0 +1 @@
+import{j as a}from"./index-TW_-MgRG.js";import{L as s}from"./LoadMore-CLPR6Zd4.js";import{T as t}from"./Table-kak5sL5X.js";import{g as r}from"./columns-BvIUTkjN.js";import"./index-BRRKsoNv.js";import"./CacheActionBadge-BB4uokI1.js";const p=({hasMoreObject:o})=>a.jsxs("div",{className:"w-full",children:[a.jsx("div",{className:"overflow-x-auto",children:a.jsx(t,{columns:r(),data:o.data})}),a.jsx(s,{paginatedPage:o})]});export{p as default};

package/dist/ui/assets/CacheEntryContainer-WkdnGvnu.js

@@ -0,0 +1,2 @@
+const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["./CacheEntriesTable-B8cUXhos.js","./index-TW_-MgRG.js","./index-CsnKQ5Mh.css","./LoadMore-CLPR6Zd4.js","./Table-kak5sL5X.js","./columns-BvIUTkjN.js","./index-BRRKsoNv.js","./CacheActionBadge-BB4uokI1.js"])))=>i.map(i=>d[i]);
+import{r as t,j as a,_ as s}from"./index-TW_-MgRG.js";import{u as i}from"./useLoadMore-JCWak1Dg.js";import{u as m}from"./useCacheEntries-Pvte_aNc.js";import"./useLensApi-BFdsfrzR.js";const n=t.lazy(()=>s(()=>import("./CacheEntriesTable-B8cUXhos.js"),__vite__mapDeps([0,1,2,3,4,5,6,7]),import.meta.url)),_=()=>{const{loadMoreItems:e,getItems:r}=m(),o=i({paginatedPage:e});return t.useEffect(()=>{r()},[]),a.jsx(n,{hasMoreObject:o})};export{_ as default};

package/dist/ui/assets/CacheEntryDetails-BeZnoIpm.js

@@ -0,0 +1 @@
+import{j as a,L as s,q as r,k as i}from"./index-TW_-MgRG.js";import{D as o,T as n}from"./TabbedDataViewer-ofhEq_Wj.js";import{C as u}from"./CacheActionBadge-BB4uokI1.js";import d from"./JsonViewer-D-KPN089.js";import"./copy-DzXuP4eO.js";function b({data:e}){const t=[e.lens_entry_id?{label:"Request",value:a.jsx(s,{to:`${r(i()).REQUESTS}/${e.lens_entry_id}`,className:"text-blue-600 hover:underline font-semibold",children:"View Request"}),className:"text-gray-900 dark:text-gray-100"}:null,{label:"Operation",value:a.jsx(u,{action:e.data.action}),className:"text-gray-900 dark:text-gray-100"},e.data.data.key?{label:"Key",value:e.data.data.key??"__",className:"text-gray-900 dark:text-gray-100"}:null].filter(l=>!!l);return a.jsxs("div",{className:"flex flex-col gap-4",children:[a.jsx(o,{title:"Details",items:t}),a.jsx(n,{tabs:[{id:"value",label:"Value",shouldShow:!!e.data.data.value,content:a.jsx(d,{data:e.data.data.value})}],defaultActiveTab:"value"})]})}export{b as default};