@nestjs-pipeline/cache 0.4.0 → 0.4.2

package/README.md

@@ -1,57 +1,11 @@
 # @nestjs-pipeline/cache
 
-## Architectural role
-
-This reusable package caches final application query results, including expensive
-aggregations, read models combining repositories and external-service composition.
-It complements repository snapshot/read-through caches; it is not replaced by
-them just because a particular example currently uses repository caching. Choose
-the layer that owns the result and define its dependencies, security scope and
-freshness. Using both layers is optional, and invalidation is not automatically
-shared.
-
 [![npm version](https://img.shields.io/npm/v/@nestjs-pipeline/cache.svg)](https://www.npmjs.com/package/@nestjs-pipeline/cache)
 [![License](https://img.shields.io/npm/l/@nestjs-pipeline/cache.svg)](https://www.npmjs.com/package/@nestjs-pipeline/cache)
 
 Caching behavior for `@nestjs-pipeline/core`, powered by [cache-manager](https://www.npmjs.com/package/cache-manager) v7 on top of [Keyv](https://keyv.org/). Transparently cache query results — declaratively, with zero changes to your handler code — and choose any backend: **memory** (default), **redis**, **memcache**, **sqlite**, or **postgres**.
 
----
-
-## Table of Contents
-
-- [Why](#why)
-- [Installation](#installation)
-- [Quick Start](#quick-start)
-  - [1. Register the module](#1-register-the-module)
-  - [2. Attach the behavior](#2-attach-the-behavior)
-  - [3. Configure per handler](#3-configure-per-handler)
-- [Choosing a Store](#choosing-a-store)
-  - [Memory (default)](#memory-default)
-  - [Redis](#redis)
-  - [Memcache](#memcache)
-  - [SQLite](#sqlite)
-  - [Postgres](#postgres)
-  - [Tiered (multi-layer) caches](#tiered-multi-layer-caches)
-  - [Escape hatches](#escape-hatches)
-- [How It Works](#how-it-works)
-  - [What gets cached](#what-gets-cached)
-  - [Cache keys](#cache-keys)
-  - [Tenant partitioning](#tenant-partitioning)
-  - [Options resolution](#options-resolution)
-  - [Context items](#context-items)
-- [Configuration](#configuration)
-- [Behavior Contract & Bootstrap Diagnostics](#behavior-contract--bootstrap-diagnostics)
-- [Custom Logger](#custom-logger)
-- [API Reference](#api-reference)
-- [License](#license)
-
----
-
-## Why
-
-Read-heavy queries often hit the same data repeatedly. `@nestjs-pipeline/cache` adds a transparent caching layer to your CQRS pipeline without coupling the caching logic to your business code. It is a thin, type-safe behavior over [cache-manager](https://github.com/jaredwray/cacheable) v7 + [Keyv](https://keyv.org/), so you get tiered caches and a consistent interface across every supported backend.
-
----
+**Documentation:** [guide](https://aristoteliss.github.io/nestjs-pipeline/packages/nestjs-pipeline/cache/) · [API reference](https://aristoteliss.github.io/nestjs-pipeline/api/nestjs-pipeline/cache/) · [all packages](https://aristoteliss.github.io/nestjs-pipeline/)
 
 ## Installation
 
@@ -65,11 +19,10 @@ pnpm add @nestjs-pipeline/cache cache-manager keyv
 pnpm add @nestjs-pipeline/core @nestjs/common reflect-metadata
 ```
 
-Requires Node.js 22.12 or later, `@nestjs/common` `^12.1.0`, `@nestjs-pipeline/core` `^0.4.0`,
+Requires Node.js 22.12 or later, `@nestjs/common` `^12.1.0`, `@nestjs-pipeline/core` `^0.4.2`,
 `cache-manager` `^7.0.0` and `keyv` `^5.0.0`.
 
-Published as an ES module; a CommonJS application loads it with `require()`. Coming from
-0.3.x, see [Upgrading from 0.3.x](https://github.com/aristoteliss/nestjs-pipeline#upgrading-from-03x).
+Published as an ES module; a CommonJS application loads it with `require()`. Coming from 0.3.x, see [Upgrading from 0.3.x](https://aristoteliss.github.io/nestjs-pipeline/upgrading/from-0-3/).
 
 **Optional store adapters** — install only the one(s) you use:
 
@@ -80,495 +33,6 @@ pnpm add @keyv/sqlite     # type: 'sqlite'
 pnpm add @keyv/postgres   # type: 'postgres'
 ```
 
-> The `memory` store needs no adapter — it ships with Keyv. The other backends are loaded lazily; you only need the matching `@keyv/*` package when you actually select that store type.
-
----
-
-## Quick Start
-
-### 1. Register the module
-
-```ts
-import { Module } from '@nestjs/common';
-import { PipelineModule } from '@nestjs-pipeline/core';
-import { CacheModule, CacheBehavior } from '@nestjs-pipeline/cache';
-
-@Module({
-  imports: [
-    // In-memory cache with a 30s default TTL
-    CacheModule.forRoot({ ttl: 30_000 }),
-    // Make CacheBehavior available to @UsePipeline/globalBehaviors.
-    PipelineModule.forRoot({ behaviors: [CacheBehavior] }),
-  ],
-})
-export class AppModule {}
-```
-
-The cache is built when the application instantiates its providers, once per
-application. To derive store settings from injected configuration, use
-`forRootAsync`:
-
-```ts
-CacheModule.forRootAsync({
-  inject: [ConfigService],
-  useFactory: (config: ConfigService) => ({
-    store: { type: 'redis', url: config.getOrThrow('REDIS_URL') },
-    ttl: 30_000,
-  }),
-});
-```
-
-A cache built from `store` (or the default memory store) is disconnected on
-application shutdown (`app.close()` or Nest shutdown hooks). A supplied `cache` or
-`stores` belongs to the caller, who closes it.
-
-### 2. Attach the behavior
-
-The `behaviors` option above registers `CacheBehavior` with Nest DI; it does not execute it globally. Attach it per handler with `@UsePipeline`, or put it in `globalBehaviors` if you want it to run for a global scope.
-
-### 3. Configure per handler
-
-This protected-query fragment assumes the pipeline has a tenant (`context.tenantId`,
-see [Tenant partitioning](#tenant-partitioning)) and that an upstream behavior sets
-`currentUserId` and `capabilityVersion` on `context.items` before caching runs.
-The handler still performs entity and field authorization on cache misses.
-
-```ts
-import { QueryHandler, type IQueryHandler } from '@nestjs/cqrs';
-import { UsePipeline } from '@nestjs-pipeline/core';
-import { cache, createPartitionedCacheKeyFactory } from '@nestjs-pipeline/cache';
-
-@QueryHandler(GetUserQuery)
-@UsePipeline(cache({
-  ttl: 60_000,
-  key: createPartitionedCacheKeyFactory({
-    principal: (ctx) => ctx.items.get('currentUserId') as string | undefined,
-    scope: (ctx) => {
-      const scope = ctx.items.get('capabilityVersion');
-      if (typeof scope !== 'string' || !scope.trim()) {
-        throw new Error('Missing capability version');
-      }
-      return scope;
-    },
-  }),
-}))
-export class GetUserHandler implements IQueryHandler<GetUserQuery> {
-  async execute(query: GetUserQuery) {
-    // ...expensive read; result cached for 60s
-  }
-}
-```
-
-> Use `cache({ inheritModuleKey: true })` only when the module supplies the key factory.
-> The raw tuple form `@UsePipeline([CacheBehavior, { ... }])` remains supported as an escape hatch.
-
----
-
-## Choosing a Store
-
-The backend is selected once, when registering the module. Per-handler options
-(`ttl`, `key`, `condition`, `kinds`) are independent of the store you pick.
-
-### Memory (default)
-
-```ts
-CacheModule.forRoot({ ttl: 30_000 });
-// equivalent to:
-CacheModule.forRoot({ store: { type: 'memory' }, ttl: 30_000 });
-```
-
-### Redis
-
-```ts
-CacheModule.forRoot({
-  store: { type: 'redis', url: 'redis://localhost:6379' },
-  ttl: 60_000,
-});
-```
-
-### Memcache
-
-```ts
-CacheModule.forRoot({
-  store: { type: 'memcache', url: 'localhost:11211' },
-});
-```
-
-### SQLite
-
-```ts
-CacheModule.forRoot({
-  store: { type: 'sqlite', url: 'sqlite://./cache.sqlite' },
-});
-```
-
-### Postgres
-
-```ts
-CacheModule.forRoot({
-  store: {
-    type: 'postgres',
-    url: 'postgresql://user:pass@localhost:5432/db',
-    options: { table: 'cache' },
-  },
-});
-```
-
-### Tiered (multi-layer) caches
-
-Provide an array of stores — they are checked in order (fastest first) and
-writes fan out to every layer:
-
-```ts
-CacheModule.forRoot({
-  store: [
-    { type: 'memory', ttl: 5_000 }, // L1: in-process
-    { type: 'redis', url: 'redis://localhost:6379' }, // L2: shared
-  ],
-});
-```
-
-### Escape hatches
-
-For full control, pass a pre-built `cache-manager` instance or your own `Keyv`
-stores:
-
-```ts
-import { createCache } from 'cache-manager';
-import { Keyv } from 'keyv';
-import KeyvRedis from '@keyv/redis';
-
-// Pre-built Keyv stores
-CacheModule.forRoot({
-  stores: [new Keyv({ store: new KeyvRedis('redis://localhost:6379') })],
-});
-
-// Fully pre-built cache
-CacheModule.forRoot({ cache: createCache({ stores: [new Keyv()] }) });
-```
-
-| Option | Precedence | Description |
-| ------ | ---------- | ----------- |
-| `cache` | 1 (highest) | A ready-made `cache-manager` instance. |
-| `stores` | 2 | Pre-built `Keyv[]` (tiered, highest priority first). |
-| `store` | 3 | Declarative config — a single store or an array. |
-| _(none)_ | 4 (fallback) | In-memory `Keyv`. |
-
----
-
-## How It Works
-
-### What gets cached
-
-Only **query** requests are cached by default — commands and events always pass
-through untouched. Override this with the `kinds` option. On a cache miss,
-`null` and `undefined` results are not written. A hit returns the value from
-that lookup directly. `CacheBehavior` does not use `cache-manager.wrap()` or
-background refresh because a refresh callback would re-run every behavior and
-side effect nested after the cache behavior.
-
-Cached results are JSON values. On a miss the behavior stores the JSON form of
-the handler result and returns that same form, so a miss and a later hit have
-the same shape: a `Date` is an ISO string and a class instance a plain object on
-both. Return plain JSON data (a snapshot or read model) from cached handlers. A
-result without a JSON form (a `bigint`, a cycle) is returned unchanged, not
-cached, and logged as a warning.
-
-### Store errors
-
-Declaratively created stores use `throwOnErrors: true`. Pre-built `cache` and
-`stores` remain caller-owned and are passed through without changing their error
-settings. The behavior can handle only failures those implementations surface;
-it cannot detect backend errors they swallow.
-
-`CacheBehavior` owns a consistent failure policy independently of the injected
-`cache-manager` or custom cache implementation. By default, `failOpen: true`:
-
-- a thrown cache read is logged, recorded as `cache.hit = false`, and bypasses
-  the cache write for that execution; the handler result still uses the same JSON conversion as a normal miss;
-- a thrown cache write is logged and the successful handler result is returned.
-
-Set `failOpen: false` to log and propagate either store error. This strict mode
-can turn a successful downstream handler execution into a rejected request when
-the subsequent cache write fails, so it is best suited to cases where cache
-availability is part of the operation's contract. Errors from the condition,
-key factory, or downstream handler are always propagated unchanged.
-
-### Cache keys
-
-The helper emits `cache:v3:<tenant>:<principal>:<scope>:<requestName>:<sha256>`,
-with escaped segments and the absent-segment encoding supplied by core
-`joinKeySegments`. Treat the generated key as opaque. Changing from older
-formats causes a cold cache; let old entries expire or remove their namespace.
-
-`key` is **required**. There is deliberately no default.
-
-The previous default embedded `context.correlationId`, which is unique per
-request. That made the cache write an entry for every query and never read one
-back — two extra round-trips and unbounded store growth for a zero percent hit
-rate. It was not an authorization boundary either: a client can send its own
-correlation ID, and nested executions deliberately inherit one. Correlation metadata
-does not establish principal or permission isolation, as correlation IDs may be supplied
-or reused. Cache hits skip the handler, including entity/field checks. For protected
-results, provide an explicit `key` covering tenant, principal type/ID, effective
-permission scope and response dependencies; fail closed if required context is
-missing. Configure invalidation/freshness for that result separately. A type-level
-authorization behavior outside the cache does not reproduce every entity check.
-
-Use `createPartitionedCacheKeyFactory`. It partitions every dimension that can
-change an authorized response, escapes each segment so `a:b` + `c` cannot collide
-with `a` + `b:c`, and fails closed with `MissingCachePartitionError` when a
-required dimension is absent:
-
-```typescript
-import { createPartitionedCacheKeyFactory } from '@nestjs-pipeline/cache';
-
-@UsePipeline([CacheBehavior, {
-  key: createPartitionedCacheKeyFactory({
-    principal: (ctx) => ctx.items.get('currentUserId') as string | undefined,
-    // Include a role-set hash or capability version, otherwise a principal whose
-    // permissions were revoked keeps reading the old response until it expires.
-    scope: (ctx) => ctx.items.get('capabilityVersion') as string | undefined,
-  }),
-}])
-export class GetUsersHandler {}
-```
-
-For genuinely public responses that are identical for every caller:
-
-```typescript
-createPartitionedCacheKeyFactory({
-  principal: () => 'public',
-  requirePrincipal: false,
-  requireTenant: false,
-  requireScope: false,
-});
-```
-
-The permission scope is required by default: creating a factory without a
-`scope` resolver throws unless `requireScope: false` declares that responses do
-not depend on the caller's permissions, and a resolver that returns nothing
-throws `MissingCachePartitionError` at request time.
-
-The tenant options are the same for the cache, idempotency and rate-limit key factories
-(`TenantPartitionOptions` of `@nestjs-pipeline/core`): `includeTenant` (default `true`)
-puts the tenant in the key, and `requireTenant` (default: `includeTenant`) refuses a
-missing one. The three packages' partition errors extend `MissingPartitionError`.
-
-The request payload is included as a SHA-256 digest, so secrets and search terms
-stay out of Redis key listings. The digest is built with `stableStringify` from `@cqrs-ddd/safe-stringify` (not re-exported by this package), which
-sorts object keys recursively so structurally equal payloads map to the same
-entry. It accepts `null`, booleans, finite numbers, strings, arrays, record-like
-objects, and valid dates (converted to ISO strings). Lossy native JSON cases such
-as `Map`, `Set`, `RegExp`, `Error`, binary values, non-finite numbers,
-`undefined`, bigint, functions, symbols, and cycles are rejected instead of
-risking a collision.
-
-Because a cache hit returns before the handler runs, it also skips whatever
-entity-level authorization and field filtering the handler performs. That is why
-tenant, principal and scope are all required by the helper by default. Opt out
-of each explicitly with `requireTenant: false`, `requirePrincipal: false` or
-`requireScope: false`.
-
-A caught `MissingCachePartitionError` names the missing dimension:
-
-```typescript
-import { MissingCachePartitionError } from '@nestjs-pipeline/cache';
-
-if (error instanceof MissingCachePartitionError) {
-  // error.name === 'MissingCachePartitionError'; map it to 401/403 in your filter
-}
-```
-
-### Tenant partitioning
-
-The tenant segment of the key is `context.tenantId`, not a value on
-`context.items`. The pipeline takes it from the tenant source configured on
-`PipelineModule.forRoot()`; the cache package does not import
-`@nestjs-pipeline/tenant`:
-
-```typescript
-import { Module } from '@nestjs/common';
-import { PipelineModule } from '@nestjs-pipeline/core';
-import { tenantSource } from '@nestjs-pipeline/tenant';
-import { CacheBehavior, CacheModule } from '@nestjs-pipeline/cache';
-
-@Module({
-  imports: [
-    CacheModule.forRoot({ ttl: 30_000 }),
-    PipelineModule.forRoot({
-      sources: { tenantId: tenantSource },
-      behaviors: [CacheBehavior],
-    }),
-  ],
-})
-export class AppModule {}
-```
-
-For a single-tenant deployment, leave the tenant out of the key:
-
-```typescript
-createPartitionedCacheKeyFactory({
-  includeTenant: false,
-  principal: (ctx) => ctx.items.get('currentUserId') as string | undefined,
-  scope: (ctx) => ctx.items.get('capabilityVersion') as string | undefined,
-});
-```
-
-The correlation id is never part of the key (see above).
-
-### Sharing a key factory through module defaults
-
-Set the factory once in `defaults` and opt in per handler with
-`inheritModuleKey: true`; `cache()` rejects a call with neither `key` nor
-`inheritModuleKey` at compile time:
-
-```typescript
-CacheModule.forRoot({
-  ttl: 30_000,
-  defaults: {
-    key: createPartitionedCacheKeyFactory({
-      principal: (ctx) => ctx.items.get('currentUserId') as string | undefined,
-      scope: (ctx) => ctx.items.get('capabilityVersion') as string | undefined,
-    }),
-  },
-});
-
-@QueryHandler(ListOrdersQuery)
-@UsePipeline(cache({ inheritModuleKey: true, ttl: 10_000 }))
-export class ListOrdersHandler {}
-```
-
-### Conditional caching
-
-`condition` returns `false` to bypass the cache for one request:
-
-```typescript
-@UsePipeline(cache({
-  inheritModuleKey: true,
-  condition: (ctx) => (ctx.request as { fresh?: boolean }).fresh !== true,
-}))
-export class GetReportHandler {}
-```
-
-### Options resolution
-
-Effective options for a handler are resolved as:
-
-1. Module-wide defaults bound via `CacheModule.forRoot({ ttl, defaults })`.
-2. Per-handler options from `@UsePipeline([CacheBehavior, { ... }])`,
-   shallow-merged on top (handler keys win).
-
-### Context items
-
-The behavior records diagnostics on `context.items`:
-
-| Item Token | Type | Meaning |
-| ---------- | ---- | ------- |
-| `CACHE_HIT_ITEM` | `boolean` | Whether the request was served from cache. |
-| `CACHE_KEY_ITEM` | `string` | The resolved cache key. |
-
-Exported as unique `Symbol` constants (`CACHE_HIT_ITEM` and `CACHE_KEY_ITEM`) to prevent key collisions in `context.items`. `CACHE_HIT_ITEM_TOKEN` and `CACHE_KEY_ITEM_TOKEN` are typed tokens over the same keys for `getPipelineItem` / `requirePipelineItem` from `@nestjs-pipeline/core`.
-
-`buildCacheAttributes(context)` turns the hit flag into the attribute `cache.hit`. Use it for span attributes through `AttributesBehavior` of [`@nestjs-pipeline/opentelemetry`](https://github.com/aristoteliss/nestjs-pipeline/tree/master/packages/pipeline-opentelemetry#attributes-from-other-behaviors), for audit `metadata`, or on a log line; it needs no telemetry package. It returns `{}` when the behavior did not run, never a fabricated miss, and never includes the key.
-
-
----
-
-## Configuration
-
-`CacheModuleOptions` (passed to `CacheModule.forRoot`):
-
-| Field | Type | Description |
-| ----- | ---- | ----------- |
-| `cache` | `Cache` | Pre-built `cache-manager` instance (escape hatch). |
-| `stores` | `Keyv[]` | Pre-built Keyv stores (tiered). |
-| `store` | `CacheStoreConfig \| CacheStoreConfig[]` | Declarative store(s). |
-| `ttl` | `number` | Default TTL (ms) for stores and handlers. |
-| `nonBlocking` | `boolean` | Optimize multi-store reads/writes. |
-| `defaults` | `CacheBehaviorOptions` | Default per-handler options. |
-
-`CacheBehaviorOptions` (per handler and/or module `defaults`):
-
-| Field | Type | Default | Description |
-| ----- | ---- | ------- | ----------- |
-| `kinds` | `Array<'command' \| 'query' \| 'event' \| 'unknown'>` | `['query']` | Request kinds eligible for caching. |
-| `ttl` | `number` | module `ttl` | TTL (ms) for entries written by this handler. |
-| `key` | `(context) => string` | Required | Explicit cache-key factory; use `createPartitionedCacheKeyFactory` for protected responses. |
-| `condition` | `(context) => boolean` | _always_ | Gate whether a request is cached. |
-| `failOpen` | `boolean` | `true` | Log and bypass thrown cache read/write errors; set `false` to propagate them. |
-
-`CacheStoreConfig` (declarative store):
-
-| Field | Type | Description |
-| ----- | ---- | ----------- |
-| `type` | `'memory' \| 'redis' \| 'memcache' \| 'sqlite' \| 'postgres'` | Backend to build. |
-| `url` | `string` | Connection string / URI (ignored for `memory`). |
-| `namespace` | `string` | Key prefix for this store. |
-| `ttl` | `number` | Default TTL (ms) for this store. |
-| `options` | `Record<string, unknown>` | Adapter-specific options passed through. |
-
----
-
-## Behavior Contract & Bootstrap Diagnostics
-
-`CacheBehavior` implements `@nestjs-pipeline/core` behavior contract diagnostics:
-
-### Ordering Constraints
-
-- **Execution order**: Cache lookup must execute **after** CASL authorization (`@nestjs-pipeline/casl:CaslBehavior`) for all active cache request kinds (`kinds: ['query']` by default). This guarantees unauthenticated or unauthorized callers never receive cached responses.
-- **Dynamic evaluation**: The ordering rule evaluates dynamically per handler. For inactive request kinds (e.g. a command handler where cache defaults to queries only), ordering constraints are not enforced.
-
-### Validation Invariants
-
-- **Callable key factory**: Whenever caching is active for a handler's request kind, `key` must be a callable function (`typeof === 'function'`). Strings or non-callable values are rejected fast at bootstrap.
-- **Module defaults**: Application-wide defaults supplied to `CacheModule.forRoot({ defaults: { ... } })` are resolved by `CacheBehavior.resolveEffectiveOptions` and evaluated alongside handler options during bootstrap.
-
----
-
-## Custom Logger
-
-Diagnostic logger failures do not replace handler results or cache-store errors.
-
-`CacheBehavior` emits `debug` cache hit/miss lines and `warn`/`error` store-failure lines through the logger injected with `LOGGING_BEHAVIOR_LOGGER`, falling back to a standard NestJS `Logger` when that token is not bound. `CacheModule` logs the store-initialization message through a NestJS `Logger` when the cache is built.
-
----
-
-## API Reference
-
-```ts
-import {
-  CacheModule,
-  CacheBehavior,
-  cache,
-  CACHE_DEFAULT_OPTIONS,
-  PIPELINE_CACHE,
-  CACHE_HIT_ITEM,
-  CACHE_HIT_ITEM_TOKEN,
-  CACHE_KEY_ITEM,
-  CACHE_KEY_ITEM_TOKEN,
-  CacheManagerAdapter,
-  buildCache,
-  buildCacheAttributes,
-  buildKeyv,
-  createPartitionedCacheKeyFactory,
-  MissingCachePartitionError,
-  type CachePartitionDimension,
-  type IPipelineCache,
-  type CacheModuleOptions,
-  type CacheModuleAsyncOptions,
-  type CacheBehaviorOptions,
-  type CacheIntentOptions,
-  type CacheStoreConfig,
-  type CacheStoreType,
-  type CacheKeyFactory,
-  type CacheCondition,
-  type PartitionedCacheKeyOptions,
-} from '@nestjs-pipeline/cache';
-```
-
----
-
 ## License
 
 Distributed under a dual license: **AGPLv3** (open source) or a **Commercial

package/dist/constants/tokens.d.ts

@@ -1,5 +1,5 @@
 /**
- * Injection token holding the shared `cache-manager` {@link import('cache-manager').Cache}
+ * Injection token holding the shared `cache-manager` `Cache`
  * instance built by {@link CacheModule.forRoot} or {@link CacheModule.forRootAsync}.
  */
 export declare const PIPELINE_CACHE: unique symbol;

package/dist/constants/tokens.js

@@ -1,6 +1,6 @@
 /* Copyright (C) 2026-present Aristotelis — see repository license. */
 /**
- * Injection token holding the shared `cache-manager` {@link import('cache-manager').Cache}
+ * Injection token holding the shared `cache-manager` `Cache`
  * instance built by {@link CacheModule.forRoot} or {@link CacheModule.forRootAsync}.
  */
 export const PIPELINE_CACHE = Symbol('PIPELINE_CACHE');

package/dist/helpers/build-attributes.d.ts

@@ -12,7 +12,8 @@ import { type IPipelineContext } from '@nestjs-pipeline/core';
  * @param context - The pipeline execution, read after `CacheBehavior` ran.
  * @returns The attributes; empty when the behavior did not run.
  *
- * @example Span attributes, with `AttributesBehavior` of `@nestjs-pipeline/opentelemetry`
+ * @example Span attributes
+ * With `AttributesBehavior` of `@nestjs-pipeline/opentelemetry`:
  * ```ts
  * PipelineModule.forRoot({
  *   globalBehaviors: {

package/dist/helpers/build-attributes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build-attributes.d.ts","sourceRoot":"","sources":["../../src/helpers/build-attributes.ts"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,gBAAgB,EACtB,MAAM,uBAAuB,CAAC;AAG/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,gBAAgB,GACxB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAIzB"}
+{"version":3,"file":"build-attributes.d.ts","sourceRoot":"","sources":["../../src/helpers/build-attributes.ts"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,gBAAgB,EACtB,MAAM,uBAAuB,CAAC;AAG/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,gBAAgB,GACxB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAIzB"}

package/dist/helpers/build-attributes.js

@@ -14,7 +14,8 @@ import { CACHE_HIT_ITEM_TOKEN } from '../cache.behavior.js';
  * @param context - The pipeline execution, read after `CacheBehavior` ran.
  * @returns The attributes; empty when the behavior did not run.
  *
- * @example Span attributes, with `AttributesBehavior` of `@nestjs-pipeline/opentelemetry`
+ * @example Span attributes
+ * With `AttributesBehavior` of `@nestjs-pipeline/opentelemetry`:
  * ```ts
  * PipelineModule.forRoot({
  *   globalBehaviors: {

package/dist/helpers/build-attributes.js.map

@@ -1 +1 @@
-{"version":3,"file":"build-attributes.js","sourceRoot":"","sources":["../../src/helpers/build-attributes.ts"],"names":[],"mappings":"AAAA,sEAAsE;AAEtE,OAAO,EACL,eAAe,EACf,eAAe,GAEhB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,UAAU,oBAAoB,CAClC,OAAyB;IAEzB,OAAO,eAAe,CAAC,OAAO,EAAE,oBAAoB,CAAC;QACnD,CAAC,CAAC,EAAE,WAAW,EAAE,eAAe,CAAC,OAAO,EAAE,oBAAoB,CAAC,KAAK,IAAI,EAAE;QAC1E,CAAC,CAAC,EAAE,CAAC;AACT,CAAC"}
+{"version":3,"file":"build-attributes.js","sourceRoot":"","sources":["../../src/helpers/build-attributes.ts"],"names":[],"mappings":"AAAA,sEAAsE;AAEtE,OAAO,EACL,eAAe,EACf,eAAe,GAEhB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAM,UAAU,oBAAoB,CAClC,OAAyB;IAEzB,OAAO,eAAe,CAAC,OAAO,EAAE,oBAAoB,CAAC;QACnD,CAAC,CAAC,EAAE,WAAW,EAAE,eAAe,CAAC,OAAO,EAAE,oBAAoB,CAAC,KAAK,IAAI,EAAE;QAC1E,CAAC,CAAC,EAAE,CAAC;AACT,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjs-pipeline/cache",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "Caching behavior for the NestJS pipeline — cache-manager v7 on top of Keyv with pluggable stores (memory, redis, memcache, sqlite, postgres).",
   "author": "Aristotelis <aristotelis@ik.me>",
   "license": "SEE LICENSE IN LICENSE",
@@ -24,7 +24,7 @@
     "url": "git+https://github.com/aristoteliss/nestjs-pipeline.git",
     "directory": "packages/pipeline-cache"
   },
-  "homepage": "https://github.com/aristoteliss/nestjs-pipeline#readme",
+  "homepage": "https://aristoteliss.github.io/nestjs-pipeline/packages/nestjs-pipeline/cache/",
   "bugs": {
     "url": "https://github.com/aristoteliss/nestjs-pipeline/issues"
   },
@@ -54,7 +54,7 @@
     "cache-manager": "^7.0.0",
     "keyv": "^5.0.0",
     "reflect-metadata": "^0.1.13 || ^0.2.0",
-    "@nestjs-pipeline/core": "^0.4.0"
+    "@nestjs-pipeline/core": "^0.4.2"
   },
   "peerDependenciesMeta": {
     "@keyv/memcache": {
@@ -77,10 +77,10 @@
     "keyv": "^5.6.0",
     "reflect-metadata": "^0.2.2",
     "vitest": "^5.0.2",
-    "@nestjs-pipeline/core": "0.4.0"
+    "@nestjs-pipeline/core": "0.4.2"
   },
   "dependencies": {
-    "@cqrs-ddd/safe-stringify": "^0.4.0"
+    "@cqrs-ddd/safe-stringify": "^0.4.2"
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",