@anteros/core 0.0.38 → 0.0.39

package/database/db.cache.ts

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import path from "node:path";
 import type { FindOptions, FindCallOptions } from "../types/mongo";
-import { Cache, useFilesystemCache, useMemoryCache, useRedisCache } from "../utils/cache";
+import { type Cache, useFilesystemCache, useMemoryCache, useRedisCache } from "../utils/cache";
 import { cfg } from "../server/config";
 
 /**

package/database/mongodbadapter.ts

@@ -1144,8 +1144,8 @@ class MongoRest {
             missing: (key) => ns().missing({ key }),
             delete: (key) => ns().delete({ key }),
             deleteMany: (keys) => ns().deleteMany({ keys }),
-            pull: (key) => ns().pull(key),
-            expire: (key, ttl) => ns().expire({ key, ttl }),
+            pull: (key) => ns().pull(key) as Promise<any>, // bentocache types are stricter than the TenantCache contract
+            expire: (key) => ns().expire({ key }), // bentocache soft-expire takes { key } only (grace is a getOrSet option)
             clear: () => ns().clear(),
             namespace: (name) => cache.namespace(`app:${tenantId}:${name}`),
         };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@anteros/core",
   "module": "index.ts",
-  "version": "0.0.38",
+  "version": "0.0.39",
   "type": "module",
   "description": "Anteros Core",
   "private": false,

package/probe-cache.ts

@@ -1,9 +1,9 @@
-import { Cache } from "./utils/cache";
+import { useMemoryCache } from "./utils/cache";
 
 async function probe() {
-    const c = new Cache("memory");
+    const c = useMemoryCache();
     const v = await c.get({ key: "k" });
-    const p = await c.pull({ key: "p" });
+    const p = await c.pull("p");
     const g = await c.getOrSet({ key: "g", factory: () => 42 });
     const s = await c.set({ key: "a", value: 1 });
     const h = await c.has({ key: "a" });

package/tests/cache.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach } from "bun:test";
-import { Cache, useMemoryCache, useFilesystemCache } from "../utils/cache";
+import { type Cache, useMemoryCache, useFilesystemCache } from "../utils/cache";
 
 const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
 
@@ -12,16 +12,19 @@ describe("Cache (memory)", () => {
 
     it("set + get round-trip", async () => {
         await c.set({ key: "k", value: { id: 1 }, ttl: "5m" });
-        expect(await c.get({ key: "k" })).toEqual({ id: 1 });
+        const v = await c.get({ key: "k" });
+        expect(v).toEqual({ id: 1 });
     });
 
     it("setForever never expires", async () => {
         await c.setForever({ key: "cfg", value: { theme: "dark" } });
-        expect(await c.get({ key: "cfg" })).toEqual({ theme: "dark" });
+        const v = await c.get({ key: "cfg" });
+        expect(v).toEqual({ theme: "dark" });
     });
 
-    it("get returns null on miss", async () => {
-        expect(await c.get({ key: "nope" })).toBeUndefined();
+    it("get returns undefined on miss", async () => {
+        const v = await c.get({ key: "nope" });
+        expect(v).toBeUndefined();
     });
 
     it("has / missing", async () => {
@@ -33,9 +36,11 @@ describe("Cache (memory)", () => {
 
     it("ttl expiry (ms)", async () => {
         await c.set({ key: "x", value: 1, ttl: 50 });
-        expect(await c.get({ key: "x" })).toBe(1);
+        const v1 = await c.get({ key: "x" });
+        expect(v1).toBe(1);
         await sleep(80);
-        expect(await c.get({ key: "x" })).toBeUndefined();
+        const v2 = await c.get({ key: "x" });
+        expect(v2).toBeUndefined();
     });
 
     it("getOrSet uses factory and caches", async () => {
@@ -44,21 +49,25 @@ describe("Cache (memory)", () => {
             calls++;
             return { n: calls };
         };
-        expect(await c.getOrSet({ key: "g", factory })).toEqual({ n: 1 });
-        expect(await c.getOrSet({ key: "g", factory })).toEqual({ n: 1 });
+        const a = await c.getOrSet({ key: "g", factory });
+        expect(a).toEqual({ n: 1 });
+        const b = await c.getOrSet({ key: "g", factory });
+        expect(b).toEqual({ n: 1 });
         expect(calls).toBe(1);
     });
 
     it("getOrSetForever", async () => {
         const value = await c.getOrSetForever({ key: "f", factory: () => 42 });
         expect(value).toBe(42);
-        expect(await c.get({ key: "f" })).toBe(42);
+        const v = await c.get({ key: "f" });
+        expect(v).toBe(42);
     });
 
     it("delete removes entry", async () => {
         await c.set({ key: "d", value: 1 });
         await c.delete({ key: "d" });
-        expect(await c.get({ key: "d" })).toBeUndefined();
+        const v = await c.get({ key: "d" });
+        expect(v).toBeUndefined();
     });
 
     it("deleteMany removes several keys", async () => {
@@ -71,16 +80,20 @@ describe("Cache (memory)", () => {
 
     it("pull returns and removes", async () => {
         await c.set({ key: "p", value: 7 });
-        expect(await c.pull("p")).toBe(7);
-        expect(await c.get({ key: "p" })).toBeUndefined();
+        const p = await c.pull("p");
+        expect(p).toBe(7);
+        const v = await c.get({ key: "p" });
+        expect(v).toBeUndefined();
     });
 
     it("clear empties everything", async () => {
         await c.set({ key: "a", value: 1 });
         await c.set({ key: "b", value: 2 });
         await c.clear();
-        expect(await c.get({ key: "a" })).toBeUndefined();
-        expect(await c.get({ key: "b" })).toBeUndefined();
+        const va = await c.get({ key: "a" });
+        const vb = await c.get({ key: "b" });
+        expect(va).toBeUndefined();
+        expect(vb).toBeUndefined();
     });
 
     it("getOrSet recovers after ttl expiry (grace accepted)", async () => {
@@ -89,19 +102,22 @@ describe("Cache (memory)", () => {
         expect(v1).toBe("fresh");
 
         await sleep(60); // past ttl
-        expect(await c.get({ key: "e" })).toBeUndefined(); // expired
+        const v2 = await c.get({ key: "e" });
+        expect(v2).toBeUndefined(); // expired
 
         // getOrSet re-runs the factory after expiry
-        const v2 = await c.getOrSet({ key: "e", factory: () => "fresh2" });
-        expect(v2).toBe("fresh2");
+        const v3 = await c.getOrSet({ key: "e", factory: () => "fresh2" });
+        expect(v3).toBe("fresh2");
     });
 
     it("namespace groups keys", async () => {
         const users = c.namespace("users");
         await users.set({ key: "1", value: { name: "John" }, ttl: "5m" });
         await users.set({ key: "2", value: { name: "Jane" } });
-        expect(await users.get({ key: "1" })).toEqual({ name: "John" });
-        expect(await c.get({ key: "1" })).toBeUndefined(); // not in root
+        const u1 = await users.get({ key: "1" });
+        expect(u1).toEqual({ name: "John" });
+        const root = await c.get({ key: "1" });
+        expect(root).toBeUndefined(); // not in root
         await users.clear();
         expect(await users.missing({ key: "1" })).toBe(true);
         expect(await users.missing({ key: "2" })).toBe(true);
@@ -116,9 +132,11 @@ describe("Cache (filesystem)", () => {
         await a.disconnect();
 
         const b = useFilesystemCache({ directory: dir });
-        expect(await b.get({ key: "persist" })).toEqual({ ok: true });
+        const v = await b.get({ key: "persist" });
+        expect(v).toEqual({ ok: true });
         await b.delete({ key: "persist" });
-        expect(await b.get({ key: "persist" })).toBeUndefined();
+        const gone = await b.get({ key: "persist" });
+        expect(gone).toBeUndefined();
         await b.disconnect();
     });
 });

package/utils/cache.ts

@@ -3,11 +3,9 @@ import { memoryDriver } from "bentocache/drivers/memory";
 import { redisDriver } from "bentocache/drivers/redis";
 import { fileDriver } from "bentocache/drivers/file";
 import path from "path";
-const drivers = {
-    memoryDriver,
-    redisDriver,
-    fileDriver,
-}
+
+/** The underlying BentoCache instance — full provider API, with autocompletion */
+export type Cache = InstanceType<typeof BentoCache>;
 
 type Driver = 'memory' | 'redis' | 'filesystem';
 
@@ -25,50 +23,27 @@ type CacheOptions = {
     pruneInterval?: string;
 }
 
-class Cache {
-    #cache: InstanceType<typeof BentoCache>;
-    constructor(driver: Driver, options?: CacheOptions) {
-        let store = bentostore().useL1Layer(memoryDriver({
-        }))
-
-        if (driver == 'filesystem') {
-            store = store.useL2Layer(fileDriver({
-                directory: options?.filesystem?.directory ?? path.join(process.cwd(), '.cache'),
-                pruneInterval: options?.pruneInterval ?? '1h'
-            }))
-        }
+function createCache(driver: Driver, options?: CacheOptions): Cache {
+    let store = bentostore().useL1Layer(memoryDriver({}))
 
-        if (driver == 'redis' && options?.redis?.connection) {
-            store = store.useL2Layer(redisDriver({
-                connection: options.redis.connection
-            }))
-        }
-        this.#cache = new BentoCache({
-            default: driver,
-            stores: {
-                [driver]: store,
-            }
-        })
+    if (driver == 'filesystem') {
+        store = store.useL2Layer(fileDriver({
+            directory: options?.filesystem?.directory ?? path.join(process.cwd(), '.cache'),
+            pruneInterval: options?.pruneInterval ?? '1h'
+        }))
     }
 
-    // ─── BentoCache provider API (delegated to the underlying instance) ───
-
-    set(options: any): Promise<boolean> { return this.#cache.set(options); }
-    setForever(options: any): Promise<boolean> { return this.#cache.setForever(options); }
-    get(options: any): Promise<unknown> { return this.#cache.get(options); }
-    getOrSet(options: any): Promise<unknown> { return this.#cache.getOrSet(options); }
-    getOrSetForever(options: any): Promise<unknown> { return this.#cache.getOrSetForever(options); }
-    has(options: any): Promise<boolean> { return this.#cache.has(options); }
-    missing(options: any): Promise<boolean> { return this.#cache.missing(options); }
-    pull(key: string): Promise<unknown> { return this.#cache.pull(key); }
-    delete(options: any): Promise<boolean> { return this.#cache.delete(options); }
-    deleteMany(options: any): Promise<boolean> { return this.#cache.deleteMany(options); }
-    deleteByTag(options: any): Promise<boolean> { return this.#cache.deleteByTag(options); }
-    expire(options: any): Promise<boolean> { return this.#cache.expire(options); }
-    clear(options?: any): Promise<void> { return this.#cache.clear(options); }
-    prune(): Promise<void> { return this.#cache.prune(); }
-    namespace(namespace: string): any { return this.#cache.namespace(namespace); }
-    disconnect(): Promise<void> { return this.#cache.disconnect(); }
+    if (driver == 'redis' && options?.redis?.connection) {
+        store = store.useL2Layer(redisDriver({
+            connection: options.redis.connection
+        }))
+    }
+    return new BentoCache({
+        default: driver,
+        stores: {
+            [driver]: store,
+        }
+    })
 }
 
 
@@ -79,8 +54,8 @@ function useRedisCache(options: {
         password: string;
     };
     pruneInterval?: string;
-}) {
-    return new Cache('redis', {
+}): Cache {
+    return createCache('redis', {
         redis: {
             connection: options.connection,
         },
@@ -88,15 +63,15 @@ function useRedisCache(options: {
     });
 }
 
-function useMemoryCache() {
-    return new Cache('memory');
+function useMemoryCache(): Cache {
+    return createCache('memory');
 }
 
 function useFilesystemCache(options: {
     directory: string;
     pruneInterval?: string;
-}) {
-    return new Cache('filesystem', {
+}): Cache {
+    return createCache('filesystem', {
         filesystem: {
             directory: options.directory,
         },
@@ -106,9 +81,8 @@ function useFilesystemCache(options: {
 
 
 
-export default Cache;
 export {
-    Cache,
+
     useFilesystemCache,
     useMemoryCache,
     useRedisCache

package/bench-cache.ts

@@ -1,70 +0,0 @@
-// Scratch benchmark — `bun run bench-cache.ts` (depuis packages/core)
-// Vérifie que useCache fonctionne vraiment et mesure les ms (miss vs hit vs sans cache).
-import { useRest } from "./database/rest";
-import { formatConfig, cfg } from "./server/config";
-import { syncTenants } from "./database/tenant";
-import { syncCollections } from "./database/collection";
-
-const TENANT = "bench";
-const DB = "mongodb://localhost:27017/_DB_BENCH";
-const N = 10000; // docs seedés
-
-async function main() {
-    formatConfig({
-        server: { port: 4000, cache: { enabled: true, driver: "memory" } },
-        tenants: [{ id: TENANT, dir: "bench-tenant", database: { uri: DB } }],
-    });
-    await syncTenants();
-    await syncCollections();
-
-    (cfg as any).collections = [
-        { _tenant_: TENANT, slug: "items", fields: [{ name: "title", type: "string" }, { name: "count", type: "number" }], api: { access: { "*": true } } },
-    ];
-    const rest = new useRest({ internal: false, tenant_id: TENANT });
-    const col = rest.db.collection("items");
-
-    // Seed
-    console.log(`Seeding ${N} docs…`);
-    const batch = [];
-    for (let i = 0; i < N; i++) batch.push({ title: `item-${i % 100}`, count: i });
-    for (let i = 0; i < batch.length; i += 1000) await col.insertMany(batch.slice(i, i + 1000));
-    console.log("Seeded ✓");
-
-    const params = { $match: { count: { $gte: 1000, $lte: 9000 } }, $sort: { count: -1 }, $limit: 50 };
-
-    // 1. Sans cache — moyenne sur 100 requêtes
-    const t0 = performance.now();
-    const ITERS = 100;
-    for (let i = 0; i < ITERS; i++) await rest.find("items", params);
-    const noCacheAvg = (performance.now() - t0) / ITERS;
-
-    // 2. Avec cache — 1er appel (MISS → requête DB) puis hits
-    const tMiss = performance.now();
-    const r1 = await rest.find("items", params, { useCache: true });
-    const missMs = performance.now() - tMiss;
-    console.log(`MISS: ${r1.length} docs retournés (requête DB réelle)`);
-
-    const tHits = performance.now();
-    for (let i = 0; i < ITERS; i++) await rest.find("items", params, { useCache: true });
-    const hitAvg = (performance.now() - tHits) / ITERS;
-
-    // 3. Preuve que le hit sert BIEN depuis le cache (pas la DB) :
-    //    on mute DIRECTEMENT en DB (bypass framework) un doc présent dans le résultat.
-    await col.updateMany({ count: 9000 }, { $set: { title: "MUTATED-DIRECT-DB" } });
-    const cached = await rest.find("items", params, { useCache: true });
-    const dbFresh = await rest.find("items", params);
-    const stale = cached.some((d: any) => d.title === "MUTATED-DIRECT-DB");
-    const fresh = dbFresh.some((d: any) => d.title === "MUTATED-DIRECT-DB");
-
-    console.log("\n─── RÉSULTATS (driver memory, Mongo local) ───");
-    console.log(`Sans cache  : ${noCacheAvg.toFixed(3)} ms/requête  (${ITERS} requêtes)`);
-    console.log(`MISS (cache): ${missMs.toFixed(3)} ms  (1er appel → requête DB, résultat mis en cache)`);
-    console.log(`HIT (cache) : ${hitAvg.toFixed(3)} ms/requête  (${ITERS} requêtes)`);
-    console.log(`Gain        : ${(noCacheAvg / hitAvg).toFixed(0)}× plus rapide`);
-    console.log(`Preuve cache: cache sert ${stale ? "la VALEUR MUTÉE (bug! cache pas servi)" : "l'ANCIENNE valeur (cache servi ✓)"}, requête fraîche = ${fresh ? "nouvelle valeur (DB bien mutée ✓)" : "?"}`);
-
-    await col.drop();
-    process.exit(0);
-}
-
-main().catch((e) => { console.error(e); process.exit(1); });