@webda/cache 4.0.0-beta.3

package/LICENSE

@@ -0,0 +1,166 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.
+

package/README.md

@@ -0,0 +1,115 @@
+# @webda/cache module
+
+This module is part of Webda Application Framework that allows you to quickly develop applications with all modern prerequisites: Security, Extensibility, GraphQL, REST, CloudNative [https://webda.io](https://webda.io)
+
+<img src="https://webda.io/images/webda.svg" width="128" />
+
+![CI](https://github.com/loopingz/webda.io/workflows/CI/badge.svg)
+
+[![Join the chat at https://gitter.im/loopingz/webda](https://badges.gitter.im/loopingz/webda.svg)](https://gitter.im/loopingz/webda?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![codecov](https://codecov.io/gh/loopingz/webda.io/branch/main/graph/badge.svg?token=8N9DNM3K3O)](https://codecov.io/gh/loopingz/webda.io)
+[![SonarCloud.io](https://sonarcloud.io/api/project_badges/measure?project=loopingz_webda.io&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=loopingz_webda.io)
+![CodeQL](https://github.com/loopingz/webda.io/workflows/CodeQL/badge.svg)
+
+<!-- README_HEADER -->
+
+# @webda/cache
+
+> Method-level caching decorator library for Webda — annotate any method with `@ProcessCache` or `@ObjectCache` to add TTL, LRU, and statistics-aware memoization with no boilerplate.
+
+## When to use it
+
+- You want to cache expensive async lookups (database queries, HTTP calls) at the method level without manually managing cache state.
+- You need per-instance caching (`@ObjectCache`) or process-wide shared caching (`@ProcessCache`).
+- You need a custom cache scope (per async context, per request) via `createCacheAnnotation`.
+
+## Install
+
+```bash
+pnpm add @webda/cache
+```
+
+## Configuration
+
+`@webda/cache` is a pure TypeScript library — it has no Webda service entry and requires no `webda.config.json` entry. Import and apply the decorators directly.
+
+| Option | Type | Default | Description |
+|---|---|---|---|
+| `ttl` | number | — | Time-to-live in milliseconds. Entries older than this are evicted on next access. |
+| `maxSize` | number | — | Maximum entries per instance (LRU eviction when exceeded). |
+| `gcInterval` | number | — | Interval in ms for automatic TTL garbage collection. |
+| `enableStats` | boolean | `false` | Track hit/miss/eviction counters. |
+| `hashStrategy` | `"sha256"` \| `"simple"` | `"sha256"` | Key hashing algorithm for argument fingerprinting. |
+| `shouldCache` | `(result) => boolean` | — | Predicate to skip caching specific results (e.g. nulls). |
+| `methodKeyGenerator` | function | — | Custom function to compute the per-call cache key. |
+| `classKeyGenerator` | function | — | Custom function to compute the per-instance cache key. |
+
+## Usage
+
+```typescript
+import { ObjectCache, ProcessCache, createCacheAnnotation } from "@webda/cache";
+
+// Per-instance cache — each class instance has its own cache
+class UserService {
+  @ObjectCache({ ttl: 30000 })
+  async fetchUser(id: string): Promise<User> {
+    // Called at most once per unique `id` per instance within the 30s TTL
+    return db.users.findById(id);
+  }
+}
+
+// Process-wide cache — shared across all instances in the Node.js process
+class ConfigService {
+  @ProcessCache({ ttl: 60000 })
+  getConfig(env: string): Config {
+    return loadConfigFromDisk(env);
+  }
+}
+
+// Custom cache scope (e.g. per async context / per HTTP request)
+import { AsyncLocalStorage } from "async_hooks";
+const storage = new AsyncLocalStorage<object>();
+const RequestCache = createCacheAnnotation(() => storage.getStore() ?? null, { ttl: 5000 });
+
+class SearchService {
+  @RequestCache()
+  async search(query: string): Promise<Result[]> {
+    return performSearch(query);
+  }
+}
+
+// Manual cache control
+const service = new UserService();
+ObjectCache.clear(service, "fetchUser", "123");    // clear one entry
+ObjectCache.clearAll(service, "fetchUser");         // clear all entries for a method
+ObjectCache.clearAll(service);                      // clear entire instance cache
+
+// Statistics
+const stats = ObjectCache.getStats();
+// { hits: 42, misses: 8, evictions: 3, sets: 11 }
+```
+
+## Reference
+
+- API reference: see the auto-generated typedoc at `docs/pages/Modules/cache/`.
+- Source: [`packages/cache`](https://github.com/loopingz/webda.io/tree/main/packages/cache)
+- Related: [`@webda/core`](../core) for service-level caching patterns; [`@webda/decorators`](../decorators) for the underlying `createMethodDecorator` primitive used internally.
+
+<!-- README_FOOTER -->
+## Sponsors
+
+<!--
+Support this project by becoming a sponsor. Your logo will show up here with a link to your website. [Become a sponsor](mailto:sponsor@webda.io)
+-->
+
+Arize AI is a machine learning observability and model monitoring platform. It helps you visualize, monitor, and explain your machine learning models. [Learn more](https://arize.com)
+
+[<img src="https://arize.com/hubfs/arize/brand/arize-logomark-1.png" width="200">](https://arize.com)
+
+Loopingz is a software development company that provides consulting and development services. [Learn more](https://loopingz.com)
+
+[<img src="https://loopingz.com/images/logo.png" width="200">](https://loopingz.com)
+
+Tellae is an innovative consulting firm specialized in cities transportation issues. We provide our clients, both public and private, with solutions to support your strategic and operational decisions. [Learn more](https://tellae.fr)
+
+[<img src="https://tellae.fr/" width="200">](https://tellae.fr)

package/lib/cache.d.ts

@@ -0,0 +1,299 @@
+/**
+ * Cache statistics for tracking performance metrics.
+ */
+export interface CacheStats {
+    hits: number;
+    misses: number;
+    evictions: number;
+    sets: number;
+}
+/**
+ * Options controlling cache key generation and storage behavior.
+ */
+export interface CacheOptions {
+    /**
+     * Define how to cache the method call.
+     * If undefined is returned then no caching is done.
+     *
+     * @param property
+     * @param args
+     * @returns
+     */
+    methodKeyGenerator?: (property: string, args: any[]) => string | undefined;
+    /**
+     * Generator for the instance-level cache key (e.g., per `this`).
+     */
+    classKeyGenerator?: (instance: object) => any;
+    /**
+     * Define how long the cache should be kept (in milliseconds).
+     */
+    ttl?: number;
+    /**
+     * Maximum number of entries per instance cache.
+     * When exceeded, least recently used entries are evicted.
+     */
+    maxSize?: number;
+    /**
+     * Automatic garbage collection interval (in milliseconds).
+     * When set, expired entries are automatically cleaned up.
+     */
+    gcInterval?: number;
+    /**
+     * Enable cache statistics tracking (hits, misses, evictions).
+     */
+    enableStats?: boolean;
+    /**
+     * Predicate to decide whether a result should be cached.
+     * Return `false` to skip caching for a specific result value.
+     *
+     * Called with the resolved value for async methods.
+     *
+     * @example
+     * // Only cache non-null results
+     * shouldCache: (result) => result !== null
+     *
+     * @example
+     * // Only cache successful HTTP responses
+     * shouldCache: (result) => result?.status === 200
+     */
+    shouldCache?: (result: any) => boolean;
+    /**
+     * Algorithm to use for default argument key generation.
+     *
+     * - `'sha256'` (default): Hashes the serialized arguments with SHA-256.
+     *   Collision-resistant and produces fixed-length keys, but involves
+     *   a crypto operation on every cache miss.
+     * - `'simple'`: Uses a typed, length-prefixed string encoding without
+     *   hashing. Faster for hot paths but produces longer keys proportional
+     *   to argument size.
+     *
+     * Has no effect when a custom `methodKeyGenerator` is provided.
+     */
+    hashStrategy?: "sha256" | "simple";
+    /**
+     * Custom `CacheMap` implementation constructor.
+     */
+    cacheMap?: new (options: CacheOptions) => CacheMap;
+    /**
+     * Custom `CacheStorage` implementation constructor.
+     */
+    cacheStorage?: new (options?: CacheOptions) => CacheStorage;
+}
+/**
+ * Storage for cached method results for a single instance.
+ *
+ * Maintains an internal timestamp per entry to support TTL-based
+ * invalidation during reads and garbage collection.
+ *
+ * Keys are method-level cache keys produced by `methodKeyGenerator`.
+ * Supports LRU eviction when maxSize is configured.
+ */
+export declare class CacheStorage extends Map<string, {
+    value: any;
+    timestamp: number;
+}> {
+    private options?;
+    stats: CacheStats;
+    /** Create a new CacheStorage.
+     * @param options - cache configuration options
+     */
+    constructor(options?: CacheOptions | undefined);
+    /**
+     * Check whether a cached value exists and is still valid.
+     * Applies TTL: if an entry is expired, it is evicted and treated as missing.
+     *
+     * @param key - the method cache key
+     * @returns true if a valid cached entry exists
+     */
+    hasCachedMethod(key: string): boolean;
+    /**
+     * Store a cached value for the given method key.
+     * Implements LRU eviction when maxSize is reached.
+     *
+     * Note: `args` is accepted for potential future strategies but not used here.
+     *
+     * @param key - the method cache key
+     * @param _args - original method arguments (reserved)
+     * @param value - the value to cache
+     */
+    setCachedMethod(key: string, _args: any[], value: any): void;
+    /**
+     * Retrieve the cached value for the given method key (without TTL re-check).
+     *
+     * @param key - the method cache key
+     * @returns the cached value or undefined
+     */
+    getCachedMethod(key: string): any;
+    /**
+     * Delete cache entries.
+     * If the key ends with `$`, all entries starting with the prefix are removed.
+     *
+     * @param key - the method cache key or prefix
+     */
+    deleteCachedMethod(key: string): void;
+    /**
+     * Remove all expired entries based on TTL.
+     */
+    garbageCollect(): void;
+    /**
+     * Get current cache statistics.
+     *
+     * @returns a copy of the current stats
+     */
+    getStats(): CacheStats;
+    /**
+     * Reset cache statistics to zero.
+     */
+    resetStats(): void;
+}
+/**
+ * Cache map storing `CacheStorage` per instance key.
+ *
+ * The instance key is produced by `classKeyGenerator`.
+ */
+export declare class CacheMap<T extends object = object> extends Map<T, CacheStorage> {
+    private options?;
+    private gcTimer?;
+    /** Create a new CacheMap.
+     * @param options - cache configuration options
+     */
+    constructor(options?: CacheOptions | undefined);
+    /**
+     * Get a cached value for a given instance and method key.
+     *
+     * @param target - the instance key
+     * @param key - the method cache key
+     * @returns the cached value or undefined
+     */
+    getCachedMethod(target: T, key: string): any;
+    /**
+     * Check if a cached value exists for the given instance and method key.
+     * Tracks cache hits when enableStats is true (misses tracked in setCachedMethod).
+     *
+     * @param target - the instance key
+     * @param key - the method cache key
+     * @returns true if a valid cached entry exists
+     */
+    hasCachedMethod(target: T, key: string): boolean;
+    /**
+     * Store a cached value for the given instance + method key.
+     * Tracks misses when enableStats is true (only if key didn't exist).
+     *
+     * @param target - the instance key
+     * @param key - the method cache key
+     * @param _args - original method arguments (reserved)
+     * @param value - the value to cache
+     */
+    setCachedMethod(target: T, key: string, _args: any[], value: any): void;
+    /**
+     * Trigger garbage collection on all instance stores.
+     */
+    garbageCollect(): void;
+    /**
+     * Start automatic garbage collection timer.
+     */
+    private startAutoGC;
+    /**
+     * Stop automatic garbage collection timer.
+     */
+    stopAutoGC(): void;
+    /**
+     * Get aggregated statistics across all instance caches.
+     *
+     * @returns the aggregated stats
+     */
+    getStats(): CacheStats;
+    /**
+     * Reset statistics for all instance caches.
+     */
+    resetStats(): void;
+}
+/**
+ * Compute a deterministic hash for a list of arguments.
+ *
+ * Returns a base64-encoded SHA-256 digest, or `undefined` if any
+ * argument cannot be serialized deterministically.
+ *
+ * @param args - the arguments to hash
+ * @returns base64 SHA-256 digest or undefined
+ */
+export declare function argumentsHash(args: any[]): string | undefined;
+/**
+ * Compute a simple typed key for a list of arguments without hashing.
+ *
+ * Uses length-prefixed, type-tagged encoding to produce a unique string
+ * representation for each distinct argument list, or `undefined` if any
+ * argument cannot be serialized deterministically.
+ *
+ * Format per argument: `<TYPE><LENGTH>:<VALUE>` where TYPE is a single
+ * uppercase letter identifying the argument type. No separator is needed
+ * between arguments because the length prefix makes the encoding unambiguous.
+ *
+ * This is faster than {@link argumentsHash} because it skips the SHA-256
+ * step. Keys may be longer in proportion to argument size. Prefer this
+ * strategy for hot sync paths with small, simple arguments.
+ *
+ * @param args - the arguments to encode
+ * @returns typed key string or undefined
+ */
+export declare function argumentsSimpleKey(args: any[]): string | undefined;
+/**
+ * Register a logger used by the cache system to report non-cacheable calls.
+ *
+ * @param logger - the logging function to register
+ */
+export declare function registerCacheLogger(logger: (...args: any[]) => void): void;
+/**
+ * Create a cache annotation (method decorator) bound to a given source provider.
+ *
+ * The returned decorator caches method results based on keys generated by
+ * `methodKeyGenerator` and `classKeyGenerator`. It also exposes utility methods:
+ * - `clear(target, propertyKey, ...args)`: Clear specific cache entry
+ * - `clearAll(target, propertyKey?)`: Clear all or method-prefixed entries
+ * - `garbageCollect()`: Run TTL-based cleanup
+ *
+ * @param source - function returning the cache host for a given target
+ * @param options - cache configuration options
+ * @returns the cache method decorator with utility methods
+ */
+export declare function createCacheAnnotation(source: (target: object | null) => object | null, options?: CacheOptions): {
+    (value: import("@webda/decorators").AnyMethod, context: ClassMethodDecoratorContext<any, any>): void | import("@webda/decorators").AnyMethod;
+    (...args: any[]): (value: import("@webda/decorators").AnyMethod, context: ClassMethodDecoratorContext<any, any>) => void | import("@webda/decorators").AnyMethod;
+} & {
+    clear: (target: object, propertyKey: string, ...args: any[]) => void;
+    clearAll: (target: object, propertyKey?: string) => void;
+    garbageCollect: () => void;
+    getStats: () => CacheStats;
+    resetStats: () => void;
+};
+/**
+ * Cache decorator using a process-level storage.
+ *
+ * Suitable for cross-instance caching within the same Node.js process.
+ */
+declare const ProcessCache: {
+    (value: import("@webda/decorators").AnyMethod, context: ClassMethodDecoratorContext<any, any>): void | import("@webda/decorators").AnyMethod;
+    (...args: any[]): (value: import("@webda/decorators").AnyMethod, context: ClassMethodDecoratorContext<any, any>) => void | import("@webda/decorators").AnyMethod;
+} & {
+    clear: (target: object, propertyKey: string, ...args: any[]) => void;
+    clearAll: (target: object, propertyKey?: string) => void;
+    garbageCollect: () => void;
+    getStats: () => CacheStats;
+    resetStats: () => void;
+};
+/**
+ * Cache decorator using an object-level storage (per instance).
+ *
+ * Suitable for encapsulated caches tied to specific objects.
+ */
+declare const ObjectCache: {
+    (value: import("@webda/decorators").AnyMethod, context: ClassMethodDecoratorContext<any, any>): void | import("@webda/decorators").AnyMethod;
+    (...args: any[]): (value: import("@webda/decorators").AnyMethod, context: ClassMethodDecoratorContext<any, any>) => void | import("@webda/decorators").AnyMethod;
+} & {
+    clear: (target: object, propertyKey: string, ...args: any[]) => void;
+    clearAll: (target: object, propertyKey?: string) => void;
+    garbageCollect: () => void;
+    getStats: () => CacheStats;
+    resetStats: () => void;
+};
+export { ProcessCache, ObjectCache };

package/lib/cache.js

@@ -0,0 +1,604 @@
+/* c8 ignore next */
+import { createMethodDecorator, getMetadata } from "@webda/decorators";
+import { createHash } from "node:crypto";
+/**
+ * Storage for cached method results for a single instance.
+ *
+ * Maintains an internal timestamp per entry to support TTL-based
+ * invalidation during reads and garbage collection.
+ *
+ * Keys are method-level cache keys produced by `methodKeyGenerator`.
+ * Supports LRU eviction when maxSize is configured.
+ */
+export class CacheStorage extends Map {
+    /** Create a new CacheStorage.
+     * @param options - cache configuration options
+     */
+    constructor(options) {
+        super();
+        this.options = options;
+        this.stats = { hits: 0, misses: 0, evictions: 0, sets: 0 };
+    }
+    /**
+     * Check whether a cached value exists and is still valid.
+     * Applies TTL: if an entry is expired, it is evicted and treated as missing.
+     *
+     * @param key - the method cache key
+     * @returns true if a valid cached entry exists
+     */
+    hasCachedMethod(key) {
+        const exists = this.has(key);
+        // Implement TTL check if needed
+        if (this.options?.ttl && exists) {
+            const cached = this.get(key);
+            if (cached && Date.now() - cached.timestamp > this.options.ttl) {
+                this.delete(key);
+                if (this.options.enableStats) {
+                    this.stats.evictions++;
+                }
+                return false;
+            }
+        }
+        return exists;
+    }
+    /**
+     * Store a cached value for the given method key.
+     * Implements LRU eviction when maxSize is reached.
+     *
+     * Note: `args` is accepted for potential future strategies but not used here.
+     *
+     * @param key - the method cache key
+     * @param _args - original method arguments (reserved)
+     * @param value - the value to cache
+     */
+    setCachedMethod(key, _args, value) {
+        // LRU: if key exists, delete it so we can re-add it at the end (most recent)
+        if (this.has(key)) {
+            this.delete(key);
+        }
+        // Check if we need to evict the oldest entry (LRU)
+        if (this.options?.maxSize && this.size >= this.options.maxSize) {
+            // Map iteration order is insertion order, so first key is oldest
+            const oldestKey = this.keys().next().value;
+            if (oldestKey !== undefined) {
+                this.delete(oldestKey);
+                if (this.options.enableStats) {
+                    this.stats.evictions++;
+                }
+            }
+        }
+        this.set(key, { value, timestamp: Date.now() });
+        if (this.options?.enableStats) {
+            this.stats.sets++;
+        }
+    }
+    /**
+     * Retrieve the cached value for the given method key (without TTL re-check).
+     *
+     * @param key - the method cache key
+     * @returns the cached value or undefined
+     */
+    getCachedMethod(key) {
+        const cached = this.get(key);
+        return cached?.value;
+    }
+    /**
+     * Delete cache entries.
+     * If the key ends with `$`, all entries starting with the prefix are removed.
+     *
+     * @param key - the method cache key or prefix
+     */
+    deleteCachedMethod(key) {
+        if (key.endsWith("$")) {
+            const prefix = key.slice(0, -1); // Remove trailing $ to get the actual prefix
+            for (const k of this.keys()) {
+                if (k.startsWith(prefix)) {
+                    this.delete(k);
+                }
+            }
+        }
+        else {
+            this.delete(key);
+        }
+    }
+    /**
+     * Remove all expired entries based on TTL.
+     */
+    garbageCollect() {
+        if (this.options?.ttl) {
+            const now = Date.now();
+            let evicted = 0;
+            for (const [key, { timestamp }] of this.entries()) {
+                if (now - timestamp > this.options.ttl) {
+                    this.delete(key);
+                    evicted++;
+                }
+            }
+            if (this.options.enableStats && evicted > 0) {
+                this.stats.evictions += evicted;
+            }
+        }
+    }
+    /**
+     * Get current cache statistics.
+     *
+     * @returns a copy of the current stats
+     */
+    getStats() {
+        return { ...this.stats };
+    }
+    /**
+     * Reset cache statistics to zero.
+     */
+    resetStats() {
+        this.stats = { hits: 0, misses: 0, evictions: 0, sets: 0 };
+    }
+}
+/**
+ * Cache map storing `CacheStorage` per instance key.
+ *
+ * The instance key is produced by `classKeyGenerator`.
+ */
+export class CacheMap extends Map {
+    /** Create a new CacheMap.
+     * @param options - cache configuration options
+     */
+    constructor(options) {
+        super();
+        this.options = options;
+        // Start automatic garbage collection if interval is configured
+        if (this.options?.gcInterval && this.options.gcInterval > 0) {
+            this.startAutoGC();
+        }
+    }
+    /**
+     * Get a cached value for a given instance and method key.
+     *
+     * @param target - the instance key
+     * @param key - the method cache key
+     * @returns the cached value or undefined
+     */
+    getCachedMethod(target, key) {
+        if (!this.has(target)) {
+            return undefined;
+        }
+        return this.get(target).getCachedMethod(key);
+    }
+    /**
+     * Check if a cached value exists for the given instance and method key.
+     * Tracks cache hits when enableStats is true (misses tracked in setCachedMethod).
+     *
+     * @param target - the instance key
+     * @param key - the method cache key
+     * @returns true if a valid cached entry exists
+     */
+    hasCachedMethod(target, key) {
+        if (this.has(target)) {
+            const cache = this.get(target);
+            const exists = cache.hasCachedMethod(key);
+            if (this.options?.enableStats && exists) {
+                cache.stats.hits++;
+            }
+            return exists;
+        }
+        return false;
+    }
+    /**
+     * Store a cached value for the given instance + method key.
+     * Tracks misses when enableStats is true (only if key didn't exist).
+     *
+     * @param target - the instance key
+     * @param key - the method cache key
+     * @param _args - original method arguments (reserved)
+     * @param value - the value to cache
+     */
+    setCachedMethod(target, key, _args, value) {
+        if (!this.has(target)) {
+            this.set(target, new (this.options?.cacheStorage ?? CacheStorage)(this.options));
+        }
+        const cache = this.get(target);
+        const isNewEntry = !cache.has(key);
+        cache.setCachedMethod(key, _args, value);
+        // Track miss only for new entries (not updates)
+        if (this.options?.enableStats && isNewEntry) {
+            cache.stats.misses++;
+        }
+    }
+    /**
+     * Trigger garbage collection on all instance stores.
+     */
+    garbageCollect() {
+        for (const [, cache] of this.entries()) {
+            cache.garbageCollect();
+        }
+    }
+    /**
+     * Start automatic garbage collection timer.
+     */
+    startAutoGC() {
+        if (this.gcTimer) {
+            return; // Already running
+        }
+        this.gcTimer = setInterval(() => {
+            this.garbageCollect();
+        }, this.options.gcInterval);
+        // Allow Node.js to exit even if timer is active
+        if (this.gcTimer.unref) {
+            this.gcTimer.unref();
+        }
+    }
+    /**
+     * Stop automatic garbage collection timer.
+     */
+    stopAutoGC() {
+        if (this.gcTimer) {
+            clearInterval(this.gcTimer);
+            this.gcTimer = undefined;
+        }
+    }
+    /**
+     * Get aggregated statistics across all instance caches.
+     *
+     * @returns the aggregated stats
+     */
+    getStats() {
+        const aggregated = { hits: 0, misses: 0, evictions: 0, sets: 0 };
+        for (const cache of this.values()) {
+            const stats = cache.getStats();
+            aggregated.hits += stats.hits;
+            aggregated.misses += stats.misses;
+            aggregated.evictions += stats.evictions;
+            aggregated.sets += stats.sets;
+        }
+        return aggregated;
+    }
+    /**
+     * Reset statistics for all instance caches.
+     */
+    resetStats() {
+        for (const cache of this.values()) {
+            cache.resetStats();
+        }
+    }
+}
+/**
+ * Resolve and return the `CacheMap` from a cache provider.
+ *
+ * The provider is expected to return a host object on which `caches`
+ * will be lazily initialized to a `CacheMap`. If the provider returns
+ * `null`, caching is disabled and `null` is returned.
+ *
+ * @param provider - function returning the cache host
+ * @param options - cache configuration options
+ * @param target - the target instance or null
+ * @returns the CacheMap or null if caching is disabled
+ */
+function getSource(provider, options, target) {
+    const cache = provider(target);
+    if (cache === null) {
+        return null;
+    }
+    cache.caches ?? (cache.caches = new (options.cacheMap ?? CacheMap)(options));
+    return cache.caches;
+}
+/**
+ * Compute a deterministic hash for a list of arguments.
+ *
+ * Returns a base64-encoded SHA-256 digest, or `undefined` if any
+ * argument cannot be serialized deterministically.
+ *
+ * @param args - the arguments to hash
+ * @returns base64 SHA-256 digest or undefined
+ */
+export function argumentsHash(args) {
+    const hash = createHash("sha256");
+    for (const arg of args) {
+        if (arg === null) {
+            hash.update("null");
+        }
+        else if (arg === undefined) {
+            hash.update("undefined");
+        }
+        else if (typeof arg === "string" || typeof arg === "number" || typeof arg === "boolean") {
+            // Primitives can be directly stringified
+            hash.update(String(arg));
+        }
+        else if (typeof arg.toJSON === "function") {
+            // Try toJSON first for objects with custom serialization
+            try {
+                hash.update(JSON.stringify(arg.toJSON()));
+            }
+            catch {
+                return undefined;
+            }
+        }
+        else if (Array.isArray(arg) || (typeof arg === "object" && arg.constructor === Object)) {
+            // Plain objects and arrays - use JSON.stringify
+            try {
+                hash.update(JSON.stringify(arg));
+            }
+            catch {
+                return undefined;
+            }
+        }
+        else if (typeof arg.toString === "function" && arg.toString !== Object.prototype.toString) {
+            // Custom toString implementation (not the default [object Object])
+            hash.update(arg.toString());
+        }
+        else {
+            // We cannot find a deterministic representation for the object
+            return undefined;
+        }
+    }
+    return hash.digest("base64");
+}
+/**
+ * Compute a simple typed key for a list of arguments without hashing.
+ *
+ * Uses length-prefixed, type-tagged encoding to produce a unique string
+ * representation for each distinct argument list, or `undefined` if any
+ * argument cannot be serialized deterministically.
+ *
+ * Format per argument: `<TYPE><LENGTH>:<VALUE>` where TYPE is a single
+ * uppercase letter identifying the argument type. No separator is needed
+ * between arguments because the length prefix makes the encoding unambiguous.
+ *
+ * This is faster than {@link argumentsHash} because it skips the SHA-256
+ * step. Keys may be longer in proportion to argument size. Prefer this
+ * strategy for hot sync paths with small, simple arguments.
+ *
+ * @param args - the arguments to encode
+ * @returns typed key string or undefined
+ */
+export function argumentsSimpleKey(args) {
+    const parts = [];
+    for (const arg of args) {
+        if (arg === null) {
+            // N — no content needed, null is unambiguous
+            parts.push("N");
+        }
+        else if (arg === undefined) {
+            // X — no content needed, undefined is unambiguous
+            parts.push("X");
+        }
+        else if (typeof arg === "string") {
+            parts.push("S" + arg.length + ":" + arg);
+        }
+        else if (typeof arg === "number") {
+            const s = String(arg);
+            parts.push("D" + s.length + ":" + s);
+        }
+        else if (typeof arg === "boolean") {
+            const s = String(arg);
+            parts.push("B" + s.length + ":" + s);
+        }
+        else if (typeof arg.toJSON === "function") {
+            try {
+                const j = JSON.stringify(arg.toJSON());
+                parts.push("J" + j.length + ":" + j);
+            }
+            catch {
+                return undefined;
+            }
+        }
+        else if (Array.isArray(arg) || (typeof arg === "object" && arg.constructor === Object)) {
+            try {
+                const j = JSON.stringify(arg);
+                parts.push("O" + j.length + ":" + j);
+            }
+            catch {
+                return undefined;
+            }
+        }
+        else if (typeof arg.toString === "function" && arg.toString !== Object.prototype.toString) {
+            const s = arg.toString();
+            parts.push("T" + s.length + ":" + s);
+        }
+        else {
+            return undefined;
+        }
+    }
+    return parts.join("");
+}
+let cacheLogger = (...args) => { };
+/**
+ * Register a logger used by the cache system to report non-cacheable calls.
+ *
+ * @param logger - the logging function to register
+ */
+export function registerCacheLogger(logger) {
+    cacheLogger = logger;
+}
+/**
+ * Create a cache annotation (method decorator) bound to a given source provider.
+ *
+ * The returned decorator caches method results based on keys generated by
+ * `methodKeyGenerator` and `classKeyGenerator`. It also exposes utility methods:
+ * - `clear(target, propertyKey, ...args)`: Clear specific cache entry
+ * - `clearAll(target, propertyKey?)`: Clear all or method-prefixed entries
+ * - `garbageCollect()`: Run TTL-based cleanup
+ *
+ * @param source - function returning the cache host for a given target
+ * @param options - cache configuration options
+ * @returns the cache method decorator with utility methods
+ */
+export function createCacheAnnotation(source, options = {}) {
+    options.methodKeyGenerator ?? (options.methodKeyGenerator = (property, args) => {
+        if (options.hashStrategy === "simple") {
+            const key = argumentsSimpleKey(args);
+            return key !== undefined ? property + "$" + key : undefined;
+        }
+        const hash = argumentsHash(args);
+        return hash ? property + "$" + hash : undefined;
+    });
+    options.classKeyGenerator ?? (options.classKeyGenerator = (instance) => instance);
+    const globalOptions = options;
+    const annotation = createMethodDecorator((value, context, decoratorOptions) => {
+        var _a, _b;
+        const options = { ...globalOptions, ...decoratorOptions };
+        if (options.methodKeyGenerator && context.metadata) {
+            (_a = context.metadata)["webda.cache.methodKeyGenerator"] ?? (_a["webda.cache.methodKeyGenerator"] = {});
+            context.metadata["webda.cache.methodKeyGenerator"][value.name] = options.methodKeyGenerator;
+        }
+        if (options.classKeyGenerator && context.metadata) {
+            (_b = context.metadata)["webda.cache.classKeyGenerator"] ?? (_b["webda.cache.classKeyGenerator"] = {});
+            context.metadata["webda.cache.classKeyGenerator"][value.name] = options.classKeyGenerator;
+        }
+        options.methodKeyGenerator ?? (options.methodKeyGenerator = globalOptions.methodKeyGenerator);
+        options.classKeyGenerator ?? (options.classKeyGenerator = globalOptions.classKeyGenerator);
+        // eslint-disable-next-line func-names -- required to keep 'this' context
+        return function (...args) {
+            const cache = getSource(source, options, this);
+            const key = options.methodKeyGenerator(value.name, args);
+            const instanceKey = options.classKeyGenerator(this);
+            if (key && instanceKey && cache && cache.hasCachedMethod(instanceKey, key)) {
+                return cache.getCachedMethod(instanceKey, key);
+            }
+            const res = value.apply(this, args);
+            // Handle both sync and async methods
+            if (res instanceof Promise) {
+                // For async methods, cache the Promise itself to handle concurrent calls
+                // but replace it with the resolved value once it resolves
+                if (key && instanceKey && cache) {
+                    cache.setCachedMethod(instanceKey, key, args, res);
+                }
+                return res
+                    .then((resolvedValue) => {
+                    if (key && instanceKey && cache) {
+                        if (!options.shouldCache || options.shouldCache(resolvedValue)) {
+                            // Replace Promise with resolved value
+                            cache.setCachedMethod(instanceKey, key, args, resolvedValue);
+                        }
+                        else {
+                            // shouldCache returned false: remove the pending Promise entry
+                            if (cache.has(instanceKey)) {
+                                cache.get(instanceKey).deleteCachedMethod(key);
+                            }
+                        }
+                    }
+                    return resolvedValue;
+                })
+                    .catch((error) => {
+                    // Remove from cache on error so it can be retried
+                    if (key && instanceKey && cache && cache.has(instanceKey)) {
+                        cache.get(instanceKey).deleteCachedMethod(key);
+                    }
+                    throw error;
+                });
+            }
+            // Sync method
+            if (key && instanceKey && cache) {
+                if (!options.shouldCache || options.shouldCache(res)) {
+                    cache.setCachedMethod(instanceKey, key, args, res);
+                }
+                // shouldCache returning false is intentional — no warning needed
+            }
+            else {
+                cacheLogger("WARN", "Cache cannot be stored, no key generated", this, value.name, args);
+            }
+            return res;
+        };
+    });
+    /**
+     * Clear a specific cached entry for a target method and arguments.
+     *
+     * @param target - the instance to clear cache for
+     * @param propertyKey - the method name
+     * @param args - the method arguments identifying the entry
+     */
+    annotation.clear = function clearCache(target, propertyKey, ...args) {
+        const cache = getSource(source, options, target);
+        if (!cache)
+            return;
+        const metadata = getMetadata((target.constructor ?? target));
+        const keyGenerator = metadata?.["webda.cache.methodKeyGenerator"]?.[propertyKey] || options.methodKeyGenerator;
+        const classKeyGen = metadata?.["webda.cache.classKeyGenerator"]?.[propertyKey] || options.classKeyGenerator;
+        const instanceKey = classKeyGen(target);
+        const key = keyGenerator(propertyKey, args);
+        if (cache.has(instanceKey)) {
+            cache.get(instanceKey).deleteCachedMethod(key);
+        }
+    };
+    /**
+     * Clear all cached entries for a target, or only those for a specific method.
+     *
+     * If `propertyKey` is provided, all entries with that method prefix are removed.
+     *
+     * @param target - the instance to clear cache for
+     * @param propertyKey - optional method name to scope clearing
+     */
+    annotation.clearAll = function clearAllCache(target, propertyKey) {
+        const cache = getSource(source, options, target);
+        if (!cache)
+            return;
+        const metadata = getMetadata((target.constructor ?? target));
+        const classKeyGen = propertyKey
+            ? metadata?.["webda.cache.classKeyGenerator"]?.[propertyKey] || options.classKeyGenerator
+            : options.classKeyGenerator;
+        const instanceKey = classKeyGen(target);
+        if (cache.has(instanceKey)) {
+            if (propertyKey === undefined) {
+                cache.delete(instanceKey);
+            }
+            else {
+                cache.get(instanceKey).deleteCachedMethod(propertyKey + "$");
+            }
+        }
+    };
+    /**
+     * Run garbage collection on the underlying `CacheMap`.
+     */
+    annotation.garbageCollect = function garbageCollect() {
+        const cache = getSource(source, options, null);
+        if (cache) {
+            cache.garbageCollect();
+        }
+    };
+    /**
+     * Get aggregated cache statistics.
+     *
+     * @returns the aggregated stats
+     */
+    annotation.getStats = function getStats() {
+        const cache = getSource(source, options, null);
+        if (cache) {
+            return cache.getStats();
+        }
+        return { hits: 0, misses: 0, evictions: 0, sets: 0 };
+    };
+    /**
+     * Reset cache statistics.
+     */
+    annotation.resetStats = function resetStats() {
+        const cache = getSource(source, options, null);
+        if (cache) {
+            cache.resetStats();
+        }
+    };
+    return annotation;
+}
+const symbol = Symbol.for("webda.caches");
+/**
+ * Cache decorator using a process-level storage.
+ *
+ * Suitable for cross-instance caching within the same Node.js process.
+ */
+const ProcessCache = createCacheAnnotation(() => {
+    const p = process;
+    p[symbol] ?? (p[symbol] = {});
+    return p[symbol];
+});
+/**
+ * Cache decorator using an object-level storage (per instance).
+ *
+ * Suitable for encapsulated caches tied to specific objects.
+ */
+const ObjectCache = createCacheAnnotation((target) => {
+    if (target === null)
+        return null;
+    const t = target;
+    t[symbol] ?? (t[symbol] = {});
+    return t[symbol];
+});
+export { ProcessCache, ObjectCache };
+//# sourceMappingURL=cache.js.map

package/lib/cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.js","sourceRoot":"","sources":["../src/cache.ts"],"names":[],"mappings":"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"}

package/lib/index.d.ts

@@ -0,0 +1 @@
+export * from "./cache.js";

package/lib/index.js

@@ -0,0 +1,2 @@
+export * from "./cache.js";
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC"}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@webda/cache",
+  "version": "4.0.0-beta.3",
+  "description": "A flexible method-level caching library with decorator support, TTL expiration, and multiple storage strategies",
+  "keywords": [
+    "webda"
+  ],
+  "author": "Remi Cattiau <remi@cattiau.com>",
+  "repository": "git://github.com/loopingz/webda.io.git",
+  "main": "lib/cache.js",
+  "typings": "lib/cache.d.ts",
+  "devDependencies": {
+    "@types/node": "25.5.0",
+    "@vitest/coverage-v8": "^4.1.2",
+    "jscodeshift": "^17.3.0",
+    "skott": "^0.35.8",
+    "typescript": "7.1.0-dev.20260929.1",
+    "vite": "^6.0.0",
+    "vitest": "^4.1.2",
+    "@webda/compiler": "^4.0.0-beta.3",
+    "@webda/decorators": "^4.0.0-beta.3",
+    "@webda/test": "4.0.0-beta.3"
+  },
+  "files": [
+    "lib"
+  ],
+  "c8": {
+    "report-dir": "./reports",
+    "reporter": [
+      "html",
+      "lcov",
+      "json",
+      "text"
+    ],
+    "exclude": [
+      "src/test.ts",
+      "**/*.spec.ts",
+      "test/**/*",
+      "*/stores/webdaql/WebdaQL*"
+    ],
+    "excludeNodeModules": true
+  },
+  "homepage": "https://webda.io",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "build:watch": "tsc --watch",
+    "pretest": "npm run build",
+    "format": "prettier --check src/**/*",
+    "format:fix": "prettier --write src/**/*",
+    "lint": "eslint",
+    "lint:fix": "eslint --fix",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:debug": "vitest debug",
+    "test:coverage": "vitest run --coverage",
+    "deps:graph": "skott --showCircularDependencies --no-trackTypeOnlyDependencies --displayMode=raw -e .ts"
+  }
+}