@dudousxd/nestjs-telescope-mikro-orm 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,110 @@
+# @dudousxd/nestjs-telescope-mikro-orm
+
+## 1.0.0
+
+### Minor Changes
+
+- [`1dd4db0`](https://github.com/DavideCarvalho/nestjs-telescope/commit/1dd4db0f3cd46d04b35ac112343cfb424c2d3190) - Estimate latency percentiles (p50/p95/p99 in `/stats`) from a pre-aggregated
+  latency histogram instead of scanning every raw entry in the window. Rollups now
+  carry a fixed-size `histogram` (counts per `LATENCY_BOUNDARIES_MS` cell, plus an
+  overflow cell) aggregated at flush time from `durationMs`. When the store is a
+  `RollupStore`, `StatsService` queries the histogram rollups for the type+window,
+  merges them element-wise, and calls `estimatePercentileFromHistogram`
+  (bucket-resolution nearest-rank, O(buckets)); count/max/slow and the
+  family/cache/status/exception breakdowns still derive from the raw scan, and
+  stores without rollup support keep the exact raw-scan percentile path as a
+  fallback.
+
+  The histogram is persisted and merged additively by every `RollupStore`
+  implementation (in-memory, core SQLite, MikroORM, Redis). Legacy rollup
+  rows/hashes without a histogram are self-healed (new column/field) and read back
+  as an all-zeros array of the canonical length — never NaN, never a crash.
+
+- [`00e0539`](https://github.com/DavideCarvalho/nestjs-telescope/commit/00e05393b00047258622be093d0006af1999d300) - `MikroOrmStorageProvider` now implements the `RollupStore` SPI, so production
+  MySQL deployments get rollup-backed timeseries automatically (the Recorder's
+  ingest hook and the timeseries service both detect the provider via
+  `isRollupStore`). Adds a `TelescopeRollup` entity mapping the `telescope_rollups`
+  table (composite PK `(metric, bucket_start)` with additive `count`/`sum` and a
+  running `max`), registered in the provider's owned ORM so `schema.update({ safe:
+true })` self-heals it additively at boot — no migration. `recordRollups`
+  accumulates per `(metric, bucketStart)` inside a transaction (read-modify-write,
+  portable across MySQL/SQLite); `queryRollups` filters by metric set and an
+  inclusive bucket range; `clear()` now also empties the rollups table.
+
+- [`e14ac60`](https://github.com/DavideCarvalho/nestjs-telescope/commit/e14ac603551372fc3767c63a349c509582b5e6ab) - Add `MikroOrmStorageProvider`: persist Telescope entries to MySQL/SQLite through
+  MikroORM with zero migration and zero manual table setup.
+
+  The provider owns a **dedicated MikroORM scoped to a single `TelescopeEntry`** and
+  **self-heals its schema at boot** (`schema.ensureDatabase()` +
+  `schema.update({ safe: true })` — additive only: creates the table and adds
+  missing columns, never drops). The scoped connection means the schema diff is
+  structurally incapable of touching the host's other tables, and it avoids a
+  self-capture loop with the query watcher's `loggerFactory`. Pass your existing
+  `MikroORM` (its connection config is borrowed) or explicit connection options to
+  run Telescope on a separate database. `ensureSchema: false` opts out.
+
+  Core gains an optional `StorageProvider.init()` boot hook (awaited by
+  `TelescopeModule` at startup) and now always calls `close()` after the final
+  flush at shutdown — providers that borrow a host-owned resource must no-op
+  `close()`. Features newest-first keyset pagination via an `$or` `(createdAt, id)`
+  position and cross-driver tag filtering against a space-padded `tagsText` column.
+
+- [`d507547`](https://github.com/DavideCarvalho/nestjs-telescope/commit/d507547df3c13e76e90b8a97c4e3e1d8aef25bd1) - Add OpenTelemetry trace linking. The new `@dudousxd/nestjs-telescope-otel`
+  package implements core's `TraceContextProvider` SPI by reading the active
+  OpenTelemetry span via `@opentelemetry/api` (`OtelTraceContextProvider`,
+  optional peer, read-only — never creates or exports spans, degrades to `null`
+  when no span/API is present). Core gains the `TraceContextProvider` SPI,
+  `traceId`/`spanId` on each `Entry`, and a `meta.traceLink` template so the UI
+  can deep-link entries to a trace backend; the MikroORM storage provider adds the
+  corresponding trace columns so the ids survive persistence. The Redis storage
+  provider now reconstructs `traceId`/`spanId` when reading entries back, and the
+  dashboard shows a Trace row in the entry detail with a clickable deep-link when
+  `traceLink` is configured.
+
+### Patch Changes
+
+- [`090cd1f`](https://github.com/DavideCarvalho/nestjs-telescope/commit/090cd1ff871dbe46c1c877a26f90496550b5304c) - Dashboard insights, charts, and trace grouping. Core gains a `StatsService` +
+  `GET /stats` endpoint with per-type analytics (latency p50/p95/p99, query-family
+  breakdown, cache hit/miss ratio, request status breakdown) and an `EntryQuery.traceId`
+  filter across all storages. The schedule watcher now tags scheduled runs with a stable
+  `schedule` tag. The dashboard adds a per-type insights header with Recharts cards, cache
+  hit/miss badges, a working Schedule view (job entries tagged `schedule`), and a
+  `#/traces/:traceId` page that groups every entry sharing an OpenTelemetry trace.
+
+- [`6a4d8d5`](https://github.com/DavideCarvalho/nestjs-telescope/commit/6a4d8d56321d3840fe64e646130ccfdafcfb1bdd) - Batch pulse two-pass hydration into ONE query. `EntryQuery` gains an optional
+  `ids?: string[]` filter: when set, only entries whose `id` is in the set are
+  returned (ANDed with every other filter; an empty array returns no rows). Each
+  storage applies it natively — SQLite via `id IN (...)`, MikroORM via
+  `id: { $in }`, in-memory via a membership `Set`, and Redis via a single `MGET`
+  of the entry keys (the big win — it skips the index scan entirely). The pulse
+  service now hydrates the displayed rows (top-N slowest + exception reps + N+1
+  reps) with one batched `get({ ids })` instead of N per-id `find()` round-trips,
+  cutting pulse latency against a remote store. Pulse output shape is unchanged.
+
+- [`c4222b1`](https://github.com/DavideCarvalho/nestjs-telescope/commit/c4222b16ef4c0fc9c61694eb67033f03369ff24e) - Speed up the `/pulse` and `/timeseries` analytics endpoints by aggregating over
+  a content-less projection instead of reading every entry's heavy `content` JSON
+  blob.
+
+  `EntryQuery` gains an `omitContent?: boolean` flag. When set, `get()` returns
+  entries with `content: null` and the provider skips reading/parsing the content
+  column where its driver allows:
+
+  - **mikro-orm**: projects every persisted column EXCEPT `content` via MikroORM's
+    `fields` option, so the blob never leaves the database (the main win on MySQL).
+  - **sqlite**: SELECTs the content-less column list and skips JSON parsing.
+  - **in-memory**: returns shallow copies with `content` nulled.
+  - **redis**: stores the whole entry as one blob, so it must read it anyway —
+    `omitContent` nulls `content` after parse (correct, but no projection benefit).
+
+  `timeseries` now scans content-less (bucketing only needs `createdAt`/`type`).
+  `pulse` runs two passes: pass 1 aggregates the whole window content-less
+  (counts, slowest candidates, exception families, N+1 hotspots); pass 2 hydrates
+  `content` for ONLY the few displayed rows (top-N slowest, one representative per
+  reported exception family, one per reported N+1 family) via targeted `find`s.
+  The pulse output shape is unchanged.
+
+  At ~10k entries with large content blobs this drops pulse and timeseries from
+  several seconds to a fraction of a second.
+
+- Updated dependencies [[`73b50ad`](https://github.com/DavideCarvalho/nestjs-telescope/commit/73b50ad00193127271fdec36ad080d2858045922), [`9126bb0`](https://github.com/DavideCarvalho/nestjs-telescope/commit/9126bb04777cdaec6af3b0a1c5fe6f91d055ce82), [`1f00e62`](https://github.com/DavideCarvalho/nestjs-telescope/commit/1f00e62c8e60482b64251813680a5f866ef1619a), [`090cd1f`](https://github.com/DavideCarvalho/nestjs-telescope/commit/090cd1ff871dbe46c1c877a26f90496550b5304c), [`b7326b3`](https://github.com/DavideCarvalho/nestjs-telescope/commit/b7326b33d8d55b5f1ac5de4256f5e1980278699e), [`bfc0e26`](https://github.com/DavideCarvalho/nestjs-telescope/commit/bfc0e268388b5563d05c24e4de6ff99c74d1201a), [`7797a2a`](https://github.com/DavideCarvalho/nestjs-telescope/commit/7797a2a1554aff49bb59f5ca1b204974a7e04a41), [`6817fe6`](https://github.com/DavideCarvalho/nestjs-telescope/commit/6817fe62775b1ff847fdb1038d3298e7709569e0), [`20ceb87`](https://github.com/DavideCarvalho/nestjs-telescope/commit/20ceb878cd4495dfbc7a3c71d882ae216a633757), [`1dd4db0`](https://github.com/DavideCarvalho/nestjs-telescope/commit/1dd4db0f3cd46d04b35ac112343cfb424c2d3190), [`a9f517c`](https://github.com/DavideCarvalho/nestjs-telescope/commit/a9f517c076461aef55cfb90d072ec38427ace91b), [`9d8eb65`](https://github.com/DavideCarvalho/nestjs-telescope/commit/9d8eb6562a7584801d5aa8b74491091f0fade5f9), [`418f1f0`](https://github.com/DavideCarvalho/nestjs-telescope/commit/418f1f0421948b40b25f845441a716fa4c6655c2), [`e76980d`](https://github.com/DavideCarvalho/nestjs-telescope/commit/e76980ddd7ee740f1b337a422a98ca98d97a007e), [`80c8f97`](https://github.com/DavideCarvalho/nestjs-telescope/commit/80c8f9769c8ab9ee724635086740910bc4d44ea3), [`e14ac60`](https://github.com/DavideCarvalho/nestjs-telescope/commit/e14ac603551372fc3767c63a349c509582b5e6ab), [`6fa0946`](https://github.com/DavideCarvalho/nestjs-telescope/commit/6fa0946f5543868704864af2e32793eb448ac827), [`d507547`](https://github.com/DavideCarvalho/nestjs-telescope/commit/d507547df3c13e76e90b8a97c4e3e1d8aef25bd1), [`affd07e`](https://github.com/DavideCarvalho/nestjs-telescope/commit/affd07e4cb9ee85cfabaabed424833e8c638d04a), [`6a4d8d5`](https://github.com/DavideCarvalho/nestjs-telescope/commit/6a4d8d56321d3840fe64e646130ccfdafcfb1bdd), [`c1f1ec9`](https://github.com/DavideCarvalho/nestjs-telescope/commit/c1f1ec903d470d6b884924e2713de305b61b7481), [`cad6dae`](https://github.com/DavideCarvalho/nestjs-telescope/commit/cad6dae0dba4f22e476d78c23ce2f74f7f6848e4), [`c8596c8`](https://github.com/DavideCarvalho/nestjs-telescope/commit/c8596c85712880cb235e8cce059a1d93d339e9bd), [`c4222b1`](https://github.com/DavideCarvalho/nestjs-telescope/commit/c4222b16ef4c0fc9c61694eb67033f03369ff24e), [`de29d2f`](https://github.com/DavideCarvalho/nestjs-telescope/commit/de29d2f519b1f25bc702c9dcc737d99b4751c8c9), [`10a3bc2`](https://github.com/DavideCarvalho/nestjs-telescope/commit/10a3bc224f6e0b1a237e1e7631acad70493b4c12), [`abde392`](https://github.com/DavideCarvalho/nestjs-telescope/commit/abde39264effb31b0524cc4fa89a335276c8dccb), [`8ff32a2`](https://github.com/DavideCarvalho/nestjs-telescope/commit/8ff32a2cc95775224eea3377460d91674dfda47f), [`5f2eddd`](https://github.com/DavideCarvalho/nestjs-telescope/commit/5f2eddd0ed5d72bf1de323b45870d7ddcaf64349), [`b14a201`](https://github.com/DavideCarvalho/nestjs-telescope/commit/b14a20175eae3d3017e8cbc068d367a03f634175), [`a90ef56`](https://github.com/DavideCarvalho/nestjs-telescope/commit/a90ef569ba12484bece07d8de2045e13ff2ff528), [`593bcc8`](https://github.com/DavideCarvalho/nestjs-telescope/commit/593bcc85ad6558040c62ba66bd1e5e0cbe5a6ac7), [`7b6636b`](https://github.com/DavideCarvalho/nestjs-telescope/commit/7b6636b54438427cd53ea0cbedd186b77d807169), [`e64f35a`](https://github.com/DavideCarvalho/nestjs-telescope/commit/e64f35a1bb7cae15b2ef24404888463d04f81eef), [`4892ef6`](https://github.com/DavideCarvalho/nestjs-telescope/commit/4892ef61e45e5486d34c7ec82764e6767fe8233d)]:
+  - @dudousxd/nestjs-telescope@1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Davi Carvalho
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,164 @@
+# @dudousxd/nestjs-telescope-mikro-orm
+
+> MikroORM query watcher for
+> [@dudousxd/nestjs-telescope](https://github.com/DavideCarvalho/nestjs-telescope).
+> Captures every executed SQL query, correlates it to the request that triggered
+> it, tags slow queries, and exposes a pure N+1 detector. Also ships a
+> `MikroOrmStorageProvider` so you can persist Telescope entries in your own
+> MySQL/SQLite instead of Redis.
+
+**Status:** early development (`0.0.0`). Requires MikroORM v7+.
+
+## Install
+
+```sh
+npm install @dudousxd/nestjs-telescope @dudousxd/nestjs-telescope-mikro-orm
+```
+
+## How query capture works
+
+MikroORM v7 stores its logger in a private field set once at `Configuration`
+construction time. Runtime logger replacement is not possible after the ORM is
+built. Because of this, **the host must wire `loggerFactory` before constructing
+the ORM** — that is the real, working integration path.
+
+`MikroOrmQueryWatcher` is still registered in `watchers` (it marks the query
+entry type and logs a clear warning if `loggerFactory` is missing), but it does
+not capture queries on its own. The `loggerFactory` is the capture mechanism.
+
+## Setup
+
+Use `MikroOrmModule.forRootAsync` so `TelescopeService` can be injected before
+MikroORM is constructed:
+
+```ts
+import { TelescopeModule, TelescopeService } from '@dudousxd/nestjs-telescope';
+import {
+  MikroOrmQueryWatcher,
+  telescopeMikroOrmLogger,
+} from '@dudousxd/nestjs-telescope-mikro-orm';
+import { MikroOrmModule } from '@mikro-orm/nestjs';
+
+@Module({
+  imports: [
+    TelescopeModule.forRoot({
+      authorizer: () => true,          // restrict in production
+      watchers: [new MikroOrmQueryWatcher()],
+    }),
+
+    // forRootAsync lets us inject TelescopeService, which isn't available
+    // at module-definition time.
+    MikroOrmModule.forRootAsync({
+      inject: [TelescopeService],
+      useFactory: (telescope: TelescopeService) => ({
+        // ... your driver, dbName, entities, etc.
+        debug: ['query'],
+        loggerFactory: telescopeMikroOrmLogger(
+          (input) => telescope.record(input),
+          { slowMs: 100 },   // queries >= 100 ms get a 'slow' tag
+        ),
+      }),
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+Queries recorded via `telescopeMikroOrmLogger` automatically inherit the active
+ALS batch opened by the request middleware, so each query entry is correlated to
+the request that triggered it.
+
+## N+1 detection
+
+```ts
+import { detectNPlusOne } from '@dudousxd/nestjs-telescope-mikro-orm';
+
+// Pass the query entries for a single request batch and a repeat threshold.
+const insights = detectNPlusOne(batchEntries, 5);
+// insights: Array<{ familyHash: string; count: number; sql: string }>
+```
+
+`detectNPlusOne` is a pure function — no I/O, no side effects. Feed it the
+entries for one batch (filter by `batchId`) and it returns every query template
+that ran at least `threshold` times.
+
+## MySQL / SQLite storage
+
+`MikroOrmStorageProvider` persists Telescope entries to your application's own
+database through MikroORM, so you can use your existing MySQL (or SQLite) for
+Telescope instead of standing up Redis. **No migration and no manual table
+setup** — the provider owns a dedicated MikroORM scoped to a single
+`TelescopeEntry` and self-heals its schema at boot. Just hand it your existing
+`MikroORM`:
+
+```ts
+import { TelescopeModule } from '@dudousxd/nestjs-telescope';
+import { MikroOrmStorageProvider } from '@dudousxd/nestjs-telescope-mikro-orm';
+import { MikroORM } from '@mikro-orm/core';
+
+@Module({
+  imports: [
+    // your normal MikroOrmModule.forRoot({ ... }) — nothing to add here
+    TelescopeModule.forRootAsync({
+      inject: [MikroORM],
+      useFactory: (orm: MikroORM) => ({
+        // borrows the host's connection config; opens its own scoped connection
+        storage: new MikroOrmStorageProvider(orm),
+      }),
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+Want Telescope on a **separate database** (recommended for high write volume)?
+Pass explicit MikroORM connection options instead of the host `MikroORM`:
+
+```ts
+import { MySqlDriver } from '@mikro-orm/mysql';
+
+new MikroOrmStorageProvider({
+  driver: MySqlDriver,
+  clientUrl: process.env.TELESCOPE_DATABASE_URL,
+  // ensureSchema: false,  // opt out of boot-time schema sync (e.g. you manage it via migration)
+});
+```
+
+How it works:
+
+- **Dedicated, scoped connection.** The provider opens its OWN MikroORM that
+  knows *only* `TelescopeEntry`. Two reasons this matters: (1) the schema diff
+  can only ever touch `telescope_entries` — it is structurally incapable of
+  altering your other tables; (2) it avoids a self-capture loop — if storage
+  writes ran on the host connection (which has the query watcher's
+  `loggerFactory` wired), every `INSERT INTO telescope_entries` would be captured
+  as a query entry, recorded, flushed, and re-captured.
+- **Self-healing schema at boot.** On `init()` the provider runs
+  `schema.ensureDatabase()` + `schema.update({ safe: true })` — additive only:
+  it creates `telescope_entries` if missing and adds any missing columns, and
+  **never drops** a table or column. Set `ensureSchema: false` to disable (e.g.
+  when you provision the table via your own migration).
+- **Lifecycle.** `init()` is awaited by `TelescopeModule` at startup; `close()`
+  closes the owned connection at shutdown. You don't call either yourself.
+- **Keyset pagination** is newest-first (`createdAt DESC, id DESC`); the cursor
+  encodes a `(createdAt, id)` position via `$or`, so paging resumes correctly
+  even after older entries are pruned.
+- **Tag filtering** runs against a space-padded `tagsText` column with
+  `LIKE '% <tag> %'` (JSON-array predicates are not portable across MySQL and
+  SQLite). The `tags` JSON column remains the source of truth for retrieval.
+
+## Exports
+
+| Export | Description |
+|--------|-------------|
+| `MikroOrmQueryWatcher` | Watcher marker — add to `TelescopeModule.forRoot({ watchers })` |
+| `telescopeMikroOrmLogger(record, opts?)` | `loggerFactory`-compatible factory; `opts.slowMs` defaults to `100` |
+| `TelescopeMikroOrmLogger` | `DefaultLogger` subclass (advanced: extend or instantiate directly) |
+| `MikroOrmStorageProvider` | `StorageProvider` persisting entries to MySQL/SQLite; owns a dedicated scoped connection and self-heals its schema at boot |
+| `TelescopeEntry` | `EntitySchema` for table `telescope_entries` (owned internally by the provider; exported for advanced use — you don't register it) |
+| `detectNPlusOne(entries, threshold)` | Pure N+1 detector |
+| `queryFamilyHash(sql)` | SQL template normalizer + FNV-1a hash (used internally) |
+
+## License
+
+MIT © Davi Carvalho

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { queryFamilyHash } from '@dudousxd/nestjs-telescope';
+export { detectNPlusOne, type NPlusOneInsight } from '@dudousxd/nestjs-telescope';
+export * from './telescope-mikro-orm.logger.js';
+export * from './mikro-orm-query.watcher.js';
+export * from './telescope-entry.entity.js';
+export * from './mikro-orm-storage.provider.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,EAAE,cAAc,EAAE,KAAK,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAClF,cAAc,iCAAiC,CAAC;AAChD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,iCAAiC,CAAC"}

package/dist/index.js

@@ -0,0 +1,7 @@
+export { queryFamilyHash } from '@dudousxd/nestjs-telescope';
+export { detectNPlusOne } from '@dudousxd/nestjs-telescope';
+export * from './telescope-mikro-orm.logger.js';
+export * from './mikro-orm-query.watcher.js';
+export * from './telescope-entry.entity.js';
+export * from './mikro-orm-storage.provider.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,EAAE,cAAc,EAAwB,MAAM,4BAA4B,CAAC;AAClF,cAAc,iCAAiC,CAAC;AAChD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,iCAAiC,CAAC"}

package/dist/mikro-orm-query.watcher.d.ts

@@ -0,0 +1,43 @@
+import type { Watcher, WatcherContext } from '@dudousxd/nestjs-telescope';
+export interface MikroOrmQueryWatcherOptions {
+    slowMs?: number;
+}
+/**
+ * Captures MikroORM queries and correlates them to the active request batch.
+ *
+ * ## Integration path: host-wired loggerFactory (v7.x)
+ *
+ * MikroORM v7 caches the logger instance at `Configuration` constructor time
+ * (stored in a private `#logger` field). Runtime `config.set('loggerFactory')`
+ * does NOT update the cached logger, so zero-config runtime-wrap is not
+ * possible on v7.
+ *
+ * Instead, `register()` logs a clear warning and exposes `record` via
+ * `ctx.record`. The host must wire the logger manually:
+ *
+ * ```ts
+ * import { telescopeMikroOrmLogger } from '@dudousxd/nestjs-telescope-mikro-orm';
+ *
+ * // In your MikroORM config, before the ORM is constructed:
+ * MikroOrmModule.forRootAsync({
+ *   inject: [TelescopeService],
+ *   useFactory: (telescope: TelescopeService) => ({
+ *     debug: ['query'],
+ *     loggerFactory: telescopeMikroOrmLogger((input) => telescope.record(input)),
+ *     // ...rest of config
+ *   }),
+ * });
+ * ```
+ *
+ * Queries recorded via `telescopeMikroOrmLogger` automatically inherit the
+ * active ALS batch (set by the request middleware's `enterWith`), so they
+ * correlate to their request.
+ */
+export declare class MikroOrmQueryWatcher implements Watcher {
+    private readonly options;
+    readonly type: "query";
+    private readonly logger;
+    constructor(options?: MikroOrmQueryWatcherOptions);
+    register(_ctx: WatcherContext): void;
+}
+//# sourceMappingURL=mikro-orm-query.watcher.d.ts.map

package/dist/mikro-orm-query.watcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mikro-orm-query.watcher.d.ts","sourceRoot":"","sources":["../src/mikro-orm-query.watcher.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAK1E,MAAM,WAAW,2BAA2B;IAC1C,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,qBAAa,oBAAqB,YAAW,OAAO;IAItC,OAAO,CAAC,QAAQ,CAAC,OAAO;IAHpC,QAAQ,CAAC,IAAI,UAAmB;IAChC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAyC;gBAEnC,OAAO,GAAE,2BAAgC;IAEtE,QAAQ,CAAC,IAAI,EAAE,cAAc,GAAG,IAAI;CAqBrC"}

package/dist/mikro-orm-query.watcher.js

@@ -0,0 +1,62 @@
+import { EntryType } from '@dudousxd/nestjs-telescope';
+// packages/mikro-orm/src/mikro-orm-query.watcher.ts
+import { Logger } from '@nestjs/common';
+/**
+ * Captures MikroORM queries and correlates them to the active request batch.
+ *
+ * ## Integration path: host-wired loggerFactory (v7.x)
+ *
+ * MikroORM v7 caches the logger instance at `Configuration` constructor time
+ * (stored in a private `#logger` field). Runtime `config.set('loggerFactory')`
+ * does NOT update the cached logger, so zero-config runtime-wrap is not
+ * possible on v7.
+ *
+ * Instead, `register()` logs a clear warning and exposes `record` via
+ * `ctx.record`. The host must wire the logger manually:
+ *
+ * ```ts
+ * import { telescopeMikroOrmLogger } from '@dudousxd/nestjs-telescope-mikro-orm';
+ *
+ * // In your MikroORM config, before the ORM is constructed:
+ * MikroOrmModule.forRootAsync({
+ *   inject: [TelescopeService],
+ *   useFactory: (telescope: TelescopeService) => ({
+ *     debug: ['query'],
+ *     loggerFactory: telescopeMikroOrmLogger((input) => telescope.record(input)),
+ *     // ...rest of config
+ *   }),
+ * });
+ * ```
+ *
+ * Queries recorded via `telescopeMikroOrmLogger` automatically inherit the
+ * active ALS batch (set by the request middleware's `enterWith`), so they
+ * correlate to their request.
+ */
+export class MikroOrmQueryWatcher {
+    options;
+    type = EntryType.Query;
+    logger = new Logger(MikroOrmQueryWatcher.name);
+    constructor(options = {}) {
+        this.options = options;
+    }
+    register(_ctx) {
+        this.logger.warn([
+            'MikroOrmQueryWatcher: MikroORM v7 caches its logger at construction time,',
+            'so runtime logger replacement is not possible.',
+            'To capture queries, add loggerFactory + debug to your MikroORM config:',
+            '',
+            "  import { telescopeMikroOrmLogger } from '@dudousxd/nestjs-telescope-mikro-orm';",
+            '',
+            '  MikroOrmModule.forRootAsync({',
+            '    inject: [TelescopeService],',
+            '    useFactory: (telescope: TelescopeService) => ({',
+            "      debug: ['query'],",
+            '      loggerFactory: telescopeMikroOrmLogger((input) => telescope.record(input)),',
+            '    }),',
+            '  });',
+        ].join('\n'));
+        // slowMs option is available for consumers who use telescopeMikroOrmLogger directly.
+        void this.options.slowMs;
+    }
+}
+//# sourceMappingURL=mikro-orm-query.watcher.js.map

package/dist/mikro-orm-query.watcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mikro-orm-query.watcher.js","sourceRoot":"","sources":["../src/mikro-orm-query.watcher.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AACvD,oDAAoD;AACpD,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAMxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,OAAO,oBAAoB;IAIF;IAHpB,IAAI,GAAG,SAAS,CAAC,KAAK,CAAC;IACf,MAAM,GAAG,IAAI,MAAM,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC;IAEhE,YAA6B,UAAuC,EAAE;QAAzC,YAAO,GAAP,OAAO,CAAkC;IAAG,CAAC;IAE1E,QAAQ,CAAC,IAAoB;QAC3B,IAAI,CAAC,MAAM,CAAC,IAAI,CACd;YACE,2EAA2E;YAC3E,gDAAgD;YAChD,wEAAwE;YACxE,EAAE;YACF,mFAAmF;YACnF,EAAE;YACF,iCAAiC;YACjC,iCAAiC;YACjC,qDAAqD;YACrD,yBAAyB;YACzB,mFAAmF;YACnF,SAAS;YACT,OAAO;SACR,CAAC,IAAI,CAAC,IAAI,CAAC,CACb,CAAC;QACF,qFAAqF;QACrF,KAAK,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC;IAC3B,CAAC;CACF"}

package/dist/mikro-orm-storage.provider.d.ts

@@ -0,0 +1,51 @@
+import type { Entry, EntryQuery, EntryWithBatch, Page, RollupBucket, RollupDelta, RollupStore, StorageProvider, TagCount } from '@dudousxd/nestjs-telescope';
+import type { Options } from '@mikro-orm/core';
+import { MikroORM } from '@mikro-orm/core';
+/**
+ * Options for the dedicated, single-entity ORM the provider owns. These are
+ * standard MikroORM `Options` (connection config) plus an optional
+ * `ensureSchema` flag. Any `entities` provided here is overridden — the provider
+ * always forces `entities: [TelescopeEntry, TelescopeRollup]`.
+ */
+export type MikroOrmStorageProviderOptions = Options & {
+    ensureSchema?: boolean;
+};
+export declare class MikroOrmStorageProvider implements StorageProvider, RollupStore {
+    private readonly source;
+    private readonly ensureSchema;
+    private orm;
+    constructor(source: MikroORM | MikroOrmStorageProviderOptions, opts?: {
+        ensureSchema?: boolean;
+    });
+    private buildOrmOptions;
+    init(): Promise<void>;
+    close(): Promise<void>;
+    private forkEm;
+    store(entries: Entry[]): Promise<void>;
+    update(id: string, patch: Partial<Entry>): Promise<void>;
+    find(id: string): Promise<EntryWithBatch | null>;
+    get(query: EntryQuery): Promise<Page<Entry>>;
+    batch(batchId: string): Promise<Entry[]>;
+    tags(prefix?: string): Promise<TagCount[]>;
+    prune(olderThan: Date, keepLast?: number): Promise<number>;
+    clear(): Promise<void>;
+    /**
+     * Additively merge deltas into `telescope_rollups`, matching the sqlite
+     * provider's `on conflict do update set count = count + excluded.count, ...`
+     * semantics: accumulate count/sum and keep a running max per
+     * (metric, bucketStart).
+     *
+     * Implemented as a read-modify-write inside ONE transaction rather than a
+     * native upsert. MikroORM's `em.upsert` / `qb.onConflict().merge()` REPLACE
+     * conflicting columns; neither expresses a portable `count = count +
+     * excluded.count` self-referential increment across MySQL and SQLite without
+     * driver-specific raw SQL. The transactional read-modify-write is portable,
+     * cast-free, and — because the whole batch commits atomically with row locks
+     * on the touched PKs — safe to call repeatedly and concurrently: concurrent
+     * writers serialize on the same (metric, bucketStart) rows, so no increment is
+     * lost. New buckets are inserted; existing ones accumulate.
+     */
+    recordRollups(deltas: RollupDelta[]): Promise<void>;
+    queryRollups(metrics: string[], fromBucket: number, toBucket: number): Promise<RollupBucket[]>;
+}
+//# sourceMappingURL=mikro-orm-storage.provider.d.ts.map

package/dist/mikro-orm-storage.provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mikro-orm-storage.provider.d.ts","sourceRoot":"","sources":["../src/mikro-orm-storage.provider.ts"],"names":[],"mappings":"AAmDA,OAAO,KAAK,EACV,KAAK,EACL,UAAU,EACV,cAAc,EACd,IAAI,EACJ,YAAY,EACZ,WAAW,EACX,WAAW,EACX,eAAe,EACf,QAAQ,EACT,MAAM,4BAA4B,CAAC;AAQpC,OAAO,KAAK,EAA8B,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC3E,OAAO,EAAE,QAAQ,EAAO,MAAM,iBAAiB,CAAC;AAuChD;;;;;GAKG;AACH,MAAM,MAAM,8BAA8B,GAAG,OAAO,GAAG;IAAE,YAAY,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AA8DlF,qBAAa,uBAAwB,YAAW,eAAe,EAAE,WAAW;IAC1E,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA4C;IACnE,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAU;IACvC,OAAO,CAAC,GAAG,CAAyB;gBAGlC,MAAM,EAAE,QAAQ,GAAG,8BAA8B,EACjD,IAAI,CAAC,EAAE;QAAE,YAAY,CAAC,EAAE,OAAO,CAAA;KAAE;IAYnC,OAAO,CAAC,eAAe;IAoBjB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAYrB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAO5B,OAAO,CAAC,MAAM;IAOR,KAAK,CAAC,OAAO,EAAE,KAAK,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAStC,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAcxD,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC;IAQhD,GAAG,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IA+D5C,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC;IAMxC,IAAI,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;IAkB1C,KAAK,CAAC,SAAS,EAAE,IAAI,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAgB1D,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ5B;;;;;;;;;;;;;;;OAeG;IACG,aAAa,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAgCnD,YAAY,CAChB,OAAO,EAAE,MAAM,EAAE,EACjB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,YAAY,EAAE,CAAC;CAgB3B"}