@geekmidas/telescope 0.0.1

package/dist/storage/kysely.d.cts

@@ -0,0 +1,161 @@
+import { ExceptionEntry, LogEntry, QueryOptions, RequestEntry, TelescopeStats, TelescopeStorage } from "../types-BGDhFv4R.cjs";
+import { Kysely } from "kysely";
+
+//#region src/storage/kysely.d.ts
+
+/**
+ * Database table interface for telescope requests.
+ * Use this to define your telescope_requests table in your Kysely database schema.
+ */
+interface TelescopeRequestTable {
+  id: string;
+  method: string;
+  path: string;
+  url: string;
+  headers: unknown;
+  body: unknown | null;
+  query: unknown | null;
+  status: number;
+  response_headers: unknown;
+  response_body: unknown | null;
+  duration: number;
+  timestamp: Date;
+  ip: string | null;
+  user_id: string | null;
+  tags: unknown | null;
+}
+/**
+ * Database table interface for telescope exceptions.
+ */
+interface TelescopeExceptionTable {
+  id: string;
+  name: string;
+  message: string;
+  stack: unknown;
+  source: unknown | null;
+  request_id: string | null;
+  timestamp: Date;
+  handled: boolean;
+  tags: unknown | null;
+}
+/**
+ * Database table interface for telescope logs.
+ */
+interface TelescopeLogTable {
+  id: string;
+  level: string;
+  message: string;
+  context: unknown | null;
+  request_id: string | null;
+  timestamp: Date;
+}
+/**
+ * Combined database interface for all telescope tables.
+ * Use this to extend your database schema.
+ *
+ * @example
+ * ```typescript
+ * import type { TelescopeTables } from '@geekmidas/telescope/storage/kysely';
+ *
+ * interface Database extends TelescopeTables {
+ *   users: UserTable;
+ *   // ... other tables
+ * }
+ * ```
+ */
+interface TelescopeTables {
+  telescope_requests: TelescopeRequestTable;
+  telescope_exceptions: TelescopeExceptionTable;
+  telescope_logs: TelescopeLogTable;
+}
+/**
+ * Configuration for KyselyStorage.
+ */
+interface KyselyStorageConfig<DB> {
+  /** Kysely database instance */
+  db: Kysely<DB>;
+  /**
+   * Table name prefix (default: 'telescope').
+   * Tables will be named: {prefix}_requests, {prefix}_exceptions, {prefix}_logs
+   */
+  tablePrefix?: string;
+}
+/**
+ * Kysely-based storage implementation for Telescope.
+ * Stores telescope data in PostgreSQL, MySQL, or SQLite using Kysely.
+ *
+ * @template DB - Your Kysely database schema (must include TelescopeTables)
+ *
+ * @example
+ * ```typescript
+ * import { Kysely, PostgresDialect } from 'kysely';
+ * import { KyselyStorage, type TelescopeTables } from '@geekmidas/telescope/storage/kysely';
+ *
+ * interface Database extends TelescopeTables {
+ *   users: UserTable;
+ * }
+ *
+ * const db = new Kysely<Database>({ dialect: new PostgresDialect({ pool }) });
+ * const storage = new KyselyStorage({ db });
+ *
+ * const telescope = new Telescope({ storage });
+ * ```
+ */
+declare class KyselyStorage<DB> implements TelescopeStorage {
+  private readonly db;
+  private readonly requestsTable;
+  private readonly exceptionsTable;
+  private readonly logsTable;
+  constructor(config: KyselyStorageConfig<DB>);
+  saveRequest(entry: RequestEntry): Promise<void>;
+  saveRequests(entries: RequestEntry[]): Promise<void>;
+  getRequests(options?: QueryOptions): Promise<RequestEntry[]>;
+  getRequest(id: string): Promise<RequestEntry | null>;
+  saveException(entry: ExceptionEntry): Promise<void>;
+  saveExceptions(entries: ExceptionEntry[]): Promise<void>;
+  getExceptions(options?: QueryOptions): Promise<ExceptionEntry[]>;
+  getException(id: string): Promise<ExceptionEntry | null>;
+  saveLog(entry: LogEntry): Promise<void>;
+  saveLogs(entries: LogEntry[]): Promise<void>;
+  getLogs(options?: QueryOptions): Promise<LogEntry[]>;
+  prune(olderThan: Date): Promise<number>;
+  getStats(): Promise<TelescopeStats>;
+  private applyQueryOptions;
+  private requestToRow;
+  private rowToRequest;
+  private exceptionToRow;
+  private rowToException;
+  private logToRow;
+  private rowToLog;
+  /**
+   * Parse a JSON value that may already be parsed (e.g., from jsonb columns).
+   */
+  private parseJson;
+}
+/**
+ * SQL migration to create telescope tables.
+ * Use this to set up the required tables in your database.
+ *
+ * @example
+ * ```typescript
+ * import { getTelescopeMigration } from '@geekmidas/telescope/storage/kysely';
+ *
+ * // In your migration file
+ * export async function up(db: Kysely<any>): Promise<void> {
+ *   const migration = getTelescopeMigration();
+ *   await db.schema.executeRaw(migration.up).execute();
+ * }
+ *
+ * export async function down(db: Kysely<any>): Promise<void> {
+ *   const migration = getTelescopeMigration();
+ *   await db.schema.executeRaw(migration.down).execute();
+ * }
+ * ```
+ */
+declare function getTelescopeMigration(tablePrefix?: string): {
+  up: string;
+  down: string;
+};
+//#endregion
+export { KyselyStorage, KyselyStorageConfig, TelescopeExceptionTable, TelescopeLogTable, TelescopeRequestTable, TelescopeTables, getTelescopeMigration };
+//# sourceMappingURL=kysely.d.cts.map

package/dist/storage/kysely.d.mts

@@ -0,0 +1,161 @@
+import { ExceptionEntry, LogEntry, QueryOptions, RequestEntry, TelescopeStats, TelescopeStorage } from "../types-CZbzz8kx.mjs";
+import { Kysely } from "kysely";
+
+//#region src/storage/kysely.d.ts
+
+/**
+ * Database table interface for telescope requests.
+ * Use this to define your telescope_requests table in your Kysely database schema.
+ */
+interface TelescopeRequestTable {
+  id: string;
+  method: string;
+  path: string;
+  url: string;
+  headers: unknown;
+  body: unknown | null;
+  query: unknown | null;
+  status: number;
+  response_headers: unknown;
+  response_body: unknown | null;
+  duration: number;
+  timestamp: Date;
+  ip: string | null;
+  user_id: string | null;
+  tags: unknown | null;
+}
+/**
+ * Database table interface for telescope exceptions.
+ */
+interface TelescopeExceptionTable {
+  id: string;
+  name: string;
+  message: string;
+  stack: unknown;
+  source: unknown | null;
+  request_id: string | null;
+  timestamp: Date;
+  handled: boolean;
+  tags: unknown | null;
+}
+/**
+ * Database table interface for telescope logs.
+ */
+interface TelescopeLogTable {
+  id: string;
+  level: string;
+  message: string;
+  context: unknown | null;
+  request_id: string | null;
+  timestamp: Date;
+}
+/**
+ * Combined database interface for all telescope tables.
+ * Use this to extend your database schema.
+ *
+ * @example
+ * ```typescript
+ * import type { TelescopeTables } from '@geekmidas/telescope/storage/kysely';
+ *
+ * interface Database extends TelescopeTables {
+ *   users: UserTable;
+ *   // ... other tables
+ * }
+ * ```
+ */
+interface TelescopeTables {
+  telescope_requests: TelescopeRequestTable;
+  telescope_exceptions: TelescopeExceptionTable;
+  telescope_logs: TelescopeLogTable;
+}
+/**
+ * Configuration for KyselyStorage.
+ */
+interface KyselyStorageConfig<DB> {
+  /** Kysely database instance */
+  db: Kysely<DB>;
+  /**
+   * Table name prefix (default: 'telescope').
+   * Tables will be named: {prefix}_requests, {prefix}_exceptions, {prefix}_logs
+   */
+  tablePrefix?: string;
+}
+/**
+ * Kysely-based storage implementation for Telescope.
+ * Stores telescope data in PostgreSQL, MySQL, or SQLite using Kysely.
+ *
+ * @template DB - Your Kysely database schema (must include TelescopeTables)
+ *
+ * @example
+ * ```typescript
+ * import { Kysely, PostgresDialect } from 'kysely';
+ * import { KyselyStorage, type TelescopeTables } from '@geekmidas/telescope/storage/kysely';
+ *
+ * interface Database extends TelescopeTables {
+ *   users: UserTable;
+ * }
+ *
+ * const db = new Kysely<Database>({ dialect: new PostgresDialect({ pool }) });
+ * const storage = new KyselyStorage({ db });
+ *
+ * const telescope = new Telescope({ storage });
+ * ```
+ */
+declare class KyselyStorage<DB> implements TelescopeStorage {
+  private readonly db;
+  private readonly requestsTable;
+  private readonly exceptionsTable;
+  private readonly logsTable;
+  constructor(config: KyselyStorageConfig<DB>);
+  saveRequest(entry: RequestEntry): Promise<void>;
+  saveRequests(entries: RequestEntry[]): Promise<void>;
+  getRequests(options?: QueryOptions): Promise<RequestEntry[]>;
+  getRequest(id: string): Promise<RequestEntry | null>;
+  saveException(entry: ExceptionEntry): Promise<void>;
+  saveExceptions(entries: ExceptionEntry[]): Promise<void>;
+  getExceptions(options?: QueryOptions): Promise<ExceptionEntry[]>;
+  getException(id: string): Promise<ExceptionEntry | null>;
+  saveLog(entry: LogEntry): Promise<void>;
+  saveLogs(entries: LogEntry[]): Promise<void>;
+  getLogs(options?: QueryOptions): Promise<LogEntry[]>;
+  prune(olderThan: Date): Promise<number>;
+  getStats(): Promise<TelescopeStats>;
+  private applyQueryOptions;
+  private requestToRow;
+  private rowToRequest;
+  private exceptionToRow;
+  private rowToException;
+  private logToRow;
+  private rowToLog;
+  /**
+   * Parse a JSON value that may already be parsed (e.g., from jsonb columns).
+   */
+  private parseJson;
+}
+/**
+ * SQL migration to create telescope tables.
+ * Use this to set up the required tables in your database.
+ *
+ * @example
+ * ```typescript
+ * import { getTelescopeMigration } from '@geekmidas/telescope/storage/kysely';
+ *
+ * // In your migration file
+ * export async function up(db: Kysely<any>): Promise<void> {
+ *   const migration = getTelescopeMigration();
+ *   await db.schema.executeRaw(migration.up).execute();
+ * }
+ *
+ * export async function down(db: Kysely<any>): Promise<void> {
+ *   const migration = getTelescopeMigration();
+ *   await db.schema.executeRaw(migration.down).execute();
+ * }
+ * ```
+ */
+declare function getTelescopeMigration(tablePrefix?: string): {
+  up: string;
+  down: string;
+};
+//#endregion
+export { KyselyStorage, KyselyStorageConfig, TelescopeExceptionTable, TelescopeLogTable, TelescopeRequestTable, TelescopeTables, getTelescopeMigration };
+//# sourceMappingURL=kysely.d.mts.map

package/dist/storage/kysely.mjs

@@ -0,0 +1,334 @@
+//#region src/storage/kysely.ts
+/**
+* Kysely-based storage implementation for Telescope.
+* Stores telescope data in PostgreSQL, MySQL, or SQLite using Kysely.
+*
+* @template DB - Your Kysely database schema (must include TelescopeTables)
+*
+* @example
+* ```typescript
+* import { Kysely, PostgresDialect } from 'kysely';
+* import { KyselyStorage, type TelescopeTables } from '@geekmidas/telescope/storage/kysely';
+*
+* interface Database extends TelescopeTables {
+*   users: UserTable;
+* }
+*
+* const db = new Kysely<Database>({ dialect: new PostgresDialect({ pool }) });
+* const storage = new KyselyStorage({ db });
+*
+* const telescope = new Telescope({ storage });
+* ```
+*/
+var KyselyStorage = class {
+	db;
+	requestsTable;
+	exceptionsTable;
+	logsTable;
+	constructor(config) {
+		this.db = config.db;
+		const prefix = config.tablePrefix ?? "telescope";
+		this.requestsTable = `${prefix}_requests`;
+		this.exceptionsTable = `${prefix}_exceptions`;
+		this.logsTable = `${prefix}_logs`;
+	}
+	async saveRequest(entry) {
+		const row = this.requestToRow(entry);
+		await this.db.insertInto(this.requestsTable).values(row).execute();
+	}
+	async saveRequests(entries) {
+		if (entries.length === 0) return;
+		const rows = entries.map((e) => this.requestToRow(e));
+		await this.db.insertInto(this.requestsTable).values(rows).execute();
+	}
+	async getRequests(options) {
+		let query = this.db.selectFrom(this.requestsTable).selectAll().orderBy("timestamp", "desc");
+		query = this.applyQueryOptions(query, options);
+		const rows = await query.execute();
+		return rows.map((row) => this.rowToRequest(row));
+	}
+	async getRequest(id) {
+		const row = await this.db.selectFrom(this.requestsTable).selectAll().where("id", "=", id).executeTakeFirst();
+		return row ? this.rowToRequest(row) : null;
+	}
+	async saveException(entry) {
+		const row = this.exceptionToRow(entry);
+		await this.db.insertInto(this.exceptionsTable).values(row).execute();
+	}
+	async saveExceptions(entries) {
+		if (entries.length === 0) return;
+		const rows = entries.map((e) => this.exceptionToRow(e));
+		await this.db.insertInto(this.exceptionsTable).values(rows).execute();
+	}
+	async getExceptions(options) {
+		let query = this.db.selectFrom(this.exceptionsTable).selectAll().orderBy("timestamp", "desc");
+		query = this.applyQueryOptions(query, options);
+		const rows = await query.execute();
+		return rows.map((row) => this.rowToException(row));
+	}
+	async getException(id) {
+		const row = await this.db.selectFrom(this.exceptionsTable).selectAll().where("id", "=", id).executeTakeFirst();
+		return row ? this.rowToException(row) : null;
+	}
+	async saveLog(entry) {
+		const row = this.logToRow(entry);
+		await this.db.insertInto(this.logsTable).values(row).execute();
+	}
+	async saveLogs(entries) {
+		if (entries.length === 0) return;
+		const rows = entries.map((e) => this.logToRow(e));
+		await this.db.insertInto(this.logsTable).values(rows).execute();
+	}
+	async getLogs(options) {
+		let query = this.db.selectFrom(this.logsTable).selectAll().orderBy("timestamp", "desc");
+		query = this.applyQueryOptions(query, options);
+		const rows = await query.execute();
+		return rows.map((row) => this.rowToLog(row));
+	}
+	async prune(olderThan) {
+		const results = await Promise.all([
+			this.db.deleteFrom(this.requestsTable).where("timestamp", "<", olderThan).executeTakeFirst(),
+			this.db.deleteFrom(this.exceptionsTable).where("timestamp", "<", olderThan).executeTakeFirst(),
+			this.db.deleteFrom(this.logsTable).where("timestamp", "<", olderThan).executeTakeFirst()
+		]);
+		return results.reduce((sum, result) => sum + Number(result.numDeletedRows ?? 0), 0);
+	}
+	async getStats() {
+		const [requestsResult, exceptionsResult, logsResult] = await Promise.all([
+			this.db.selectFrom(this.requestsTable).select((eb) => [
+				eb.fn.count("id").as("count"),
+				eb.fn.min("timestamp").as("oldest"),
+				eb.fn.max("timestamp").as("newest")
+			]).executeTakeFirst(),
+			this.db.selectFrom(this.exceptionsTable).select((eb) => [
+				eb.fn.count("id").as("count"),
+				eb.fn.min("timestamp").as("oldest"),
+				eb.fn.max("timestamp").as("newest")
+			]).executeTakeFirst(),
+			this.db.selectFrom(this.logsTable).select((eb) => [
+				eb.fn.count("id").as("count"),
+				eb.fn.min("timestamp").as("oldest"),
+				eb.fn.max("timestamp").as("newest")
+			]).executeTakeFirst()
+		]);
+		const allDates = [
+			requestsResult?.oldest,
+			requestsResult?.newest,
+			exceptionsResult?.oldest,
+			exceptionsResult?.newest,
+			logsResult?.oldest,
+			logsResult?.newest
+		].filter((d) => d != null).sort((a, b) => new Date(a).getTime() - new Date(b).getTime());
+		return {
+			requests: Number(requestsResult?.count ?? 0),
+			exceptions: Number(exceptionsResult?.count ?? 0),
+			logs: Number(logsResult?.count ?? 0),
+			oldestEntry: allDates[0] ? new Date(allDates[0]) : void 0,
+			newestEntry: allDates.length > 0 ? new Date(allDates[allDates.length - 1]) : void 0
+		};
+	}
+	applyQueryOptions(query, options) {
+		if (!options) return query.limit(50);
+		if (options.after) query = query.where("timestamp", ">=", options.after);
+		if (options.before) query = query.where("timestamp", "<=", options.before);
+		if (options.search) query = query.where((eb) => eb.or([
+			eb("message", "ilike", `%${options.search}%`),
+			eb("path", "ilike", `%${options.search}%`),
+			eb("url", "ilike", `%${options.search}%`)
+		]));
+		const limit = options.limit ?? 50;
+		const offset = options.offset ?? 0;
+		return query.limit(limit).offset(offset);
+	}
+	requestToRow(entry) {
+		return {
+			id: entry.id,
+			method: entry.method,
+			path: entry.path,
+			url: entry.url,
+			headers: entry.headers,
+			body: entry.body ?? null,
+			query: entry.query ?? null,
+			status: entry.status,
+			response_headers: entry.responseHeaders,
+			response_body: entry.responseBody ?? null,
+			duration: entry.duration,
+			timestamp: entry.timestamp,
+			ip: entry.ip ?? null,
+			user_id: entry.userId ?? null,
+			tags: entry.tags ?? null
+		};
+	}
+	rowToRequest(row) {
+		return {
+			id: row.id,
+			method: row.method,
+			path: row.path,
+			url: row.url,
+			headers: this.parseJson(row.headers),
+			body: row.body ? this.parseJson(row.body) : void 0,
+			query: row.query ? this.parseJson(row.query) : void 0,
+			status: row.status,
+			responseHeaders: this.parseJson(row.response_headers),
+			responseBody: row.response_body ? this.parseJson(row.response_body) : void 0,
+			duration: row.duration,
+			timestamp: new Date(row.timestamp),
+			ip: row.ip ?? void 0,
+			userId: row.user_id ?? void 0,
+			tags: row.tags ? this.parseJson(row.tags) : void 0
+		};
+	}
+	exceptionToRow(entry) {
+		return {
+			id: entry.id,
+			name: entry.name,
+			message: entry.message,
+			stack: entry.stack,
+			source: entry.source ?? null,
+			request_id: entry.requestId ?? null,
+			timestamp: entry.timestamp,
+			handled: entry.handled,
+			tags: entry.tags ?? null
+		};
+	}
+	rowToException(row) {
+		return {
+			id: row.id,
+			name: row.name,
+			message: row.message,
+			stack: this.parseJson(row.stack),
+			source: row.source ? this.parseJson(row.source) : void 0,
+			requestId: row.request_id ?? void 0,
+			timestamp: new Date(row.timestamp),
+			handled: row.handled,
+			tags: row.tags ? this.parseJson(row.tags) : void 0
+		};
+	}
+	logToRow(entry) {
+		return {
+			id: entry.id,
+			level: entry.level,
+			message: entry.message,
+			context: entry.context ?? null,
+			request_id: entry.requestId ?? null,
+			timestamp: entry.timestamp
+		};
+	}
+	rowToLog(row) {
+		return {
+			id: row.id,
+			level: row.level,
+			message: row.message,
+			context: row.context ? this.parseJson(row.context) : void 0,
+			requestId: row.request_id ?? void 0,
+			timestamp: new Date(row.timestamp)
+		};
+	}
+	/**
+	* Parse a JSON value that may already be parsed (e.g., from jsonb columns).
+	*/
+	parseJson(value) {
+		if (typeof value === "object" && value !== null) return value;
+		if (typeof value === "string") try {
+			return JSON.parse(value);
+		} catch {
+			return value;
+		}
+		return value;
+	}
+};
+/**
+* SQL migration to create telescope tables.
+* Use this to set up the required tables in your database.
+*
+* @example
+* ```typescript
+* import { getTelescopeMigration } from '@geekmidas/telescope/storage/kysely';
+*
+* // In your migration file
+* export async function up(db: Kysely<any>): Promise<void> {
+*   const migration = getTelescopeMigration();
+*   await db.schema.executeRaw(migration.up).execute();
+* }
+*
+* export async function down(db: Kysely<any>): Promise<void> {
+*   const migration = getTelescopeMigration();
+*   await db.schema.executeRaw(migration.down).execute();
+* }
+* ```
+*/
+function getTelescopeMigration(tablePrefix = "telescope") {
+	return {
+		up: `
+-- Telescope requests table
+CREATE TABLE IF NOT EXISTS ${tablePrefix}_requests (
+  id VARCHAR(21) PRIMARY KEY,
+  method VARCHAR(10) NOT NULL,
+  path TEXT NOT NULL,
+  url TEXT NOT NULL,
+  headers JSONB NOT NULL,
+  body JSONB,
+  query JSONB,
+  status INTEGER NOT NULL,
+  response_headers JSONB NOT NULL,
+  response_body JSONB,
+  duration DOUBLE PRECISION NOT NULL,
+  timestamp TIMESTAMPTZ NOT NULL,
+  ip VARCHAR(45),
+  user_id VARCHAR(255),
+  tags JSONB
+);
+
+CREATE INDEX IF NOT EXISTS idx_${tablePrefix}_requests_timestamp
+  ON ${tablePrefix}_requests (timestamp DESC);
+CREATE INDEX IF NOT EXISTS idx_${tablePrefix}_requests_path
+  ON ${tablePrefix}_requests (path);
+CREATE INDEX IF NOT EXISTS idx_${tablePrefix}_requests_status
+  ON ${tablePrefix}_requests (status);
+
+-- Telescope exceptions table
+CREATE TABLE IF NOT EXISTS ${tablePrefix}_exceptions (
+  id VARCHAR(21) PRIMARY KEY,
+  name VARCHAR(255) NOT NULL,
+  message TEXT NOT NULL,
+  stack JSONB NOT NULL,
+  source JSONB,
+  request_id VARCHAR(21),
+  timestamp TIMESTAMPTZ NOT NULL,
+  handled BOOLEAN NOT NULL DEFAULT FALSE,
+  tags JSONB
+);
+
+CREATE INDEX IF NOT EXISTS idx_${tablePrefix}_exceptions_timestamp
+  ON ${tablePrefix}_exceptions (timestamp DESC);
+CREATE INDEX IF NOT EXISTS idx_${tablePrefix}_exceptions_request_id
+  ON ${tablePrefix}_exceptions (request_id);
+
+-- Telescope logs table
+CREATE TABLE IF NOT EXISTS ${tablePrefix}_logs (
+  id VARCHAR(21) PRIMARY KEY,
+  level VARCHAR(10) NOT NULL,
+  message TEXT NOT NULL,
+  context JSONB,
+  request_id VARCHAR(21),
+  timestamp TIMESTAMPTZ NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_${tablePrefix}_logs_timestamp
+  ON ${tablePrefix}_logs (timestamp DESC);
+CREATE INDEX IF NOT EXISTS idx_${tablePrefix}_logs_level
+  ON ${tablePrefix}_logs (level);
+CREATE INDEX IF NOT EXISTS idx_${tablePrefix}_logs_request_id
+  ON ${tablePrefix}_logs (request_id);
+`,
+		down: `
+DROP TABLE IF EXISTS ${tablePrefix}_logs;
+DROP TABLE IF EXISTS ${tablePrefix}_exceptions;
+DROP TABLE IF EXISTS ${tablePrefix}_requests;
+`
+	};
+}
+
+//#endregion
+export { KyselyStorage, getTelescopeMigration };
+//# sourceMappingURL=kysely.mjs.map