@sabschyks/arca 0.0.1

package/LICENSE

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

package/README.md

@@ -0,0 +1,195 @@
+<div align="center">
+
+![Arca Banner](https://placehold.co/1200x300/1a1a1a/ffffff?text=ARCA&font=montserrat)
+
+**High-Concurrency Cache Coalescing & State Management for Node.js**
+
+Prevent cache stampedes, eliminate duplicated fetches, and keep your APIs fast under extreme load.
+
+[![CI](https://github.com/sabschyks/Arca/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/sabschyks/Arca/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+</div>
+
+---
+
+## 🚨 The Problem: Cache Stampede
+
+In high-scale systems, when a popular cache key expires, **hundreds or thousands of concurrent requests** may hit your database at the same time before the cache is repopulated.
+
+This phenomenon is known as the **Cache Stampede** or **Thundering Herd** problem.
+
+Most traditional caching libraries (e.g. simple Redis wrappers):
+
+- Only store values
+- Do not coordinate concurrent requests
+- Do not protect your database under high contention
+
+---
+
+## 🛡️ The Solution: Arca
+
+**Arca** is more than a cache client — it’s a **concurrency shield** for Node.js applications.
+
+### Core Features
+
+1. **Request Coalescing (Singleflight)**  
+   If 1,000 requests ask for the same key simultaneously, Arca executes the fetcher **only once**.  
+   All requests await the same Promise.
+
+2. **Stale-While-Revalidate (SWR)**  
+   Serve stale data instantly (near-zero latency) while refreshing the cache in the background.
+
+3. **Adapter-Agnostic Storage**  
+   Works out of the box with:
+   - In-Memory storage (default)
+   - Redis (for distributed systems)
+
+---
+
+## 📦 Installation
+
+```bash
+# Using pnpm (recommended)
+pnpm add arca
+
+# Using npm
+npm install arca
+
+# Using yarn
+yarn add arca
+````
+
+---
+
+## ⚡ Quick Start
+
+```ts
+import { Arca } from 'arca';
+
+// 1. Initialize Arca (defaults to in-memory storage)
+const arca = new Arca({ defaultTtl: 60_000 }); // 1 minute
+
+async function getUserProfile(userId: string) {
+  // 2. Wrap your expensive operation
+  return arca.get(`user:${userId}`, async () => {
+    console.log('Fetching from database...');
+    return db.query('SELECT * FROM users WHERE id = ?', [userId]);
+  });
+}
+
+// 3. Simulate concurrent traffic
+Promise.all([
+  getUserProfile('123'),
+  getUserProfile('123'),
+  getUserProfile('123'),
+]);
+
+// ✅ Result:
+// The database is hit only once.
+// All requests resolve with the same data.
+```
+
+---
+
+## 🔄 Stale-While-Revalidate (SWR) Explained
+
+Arca implements **SWR** to keep your application fast even when cached data expires.
+
+**Example timeline:**
+
+1. **Time 0s**
+   Data is cached with a TTL of 60s.
+
+2. **Time 61s**
+   A request arrives. The cache entry is expired.
+
+3. **Arca behavior**
+
+   * Immediately returns the stale value (latency ≈ 0ms)
+   * Triggers a background refresh (singleflight-protected)
+
+4. **Next request**
+
+   * Receives the fresh data
+
+This guarantees:
+
+* Low latency
+* No traffic spikes
+* No duplicated fetches
+
+---
+
+## 🌐 Redis Adapter (Production Ready)
+
+For distributed environments such as **Kubernetes**, **Serverless**, or **multi-instance APIs**, Arca supports Redis.
+
+### Install Redis client
+
+```bash
+pnpm add ioredis
+```
+
+### Configure Arca with Redis
+
+```ts
+import { Arca, RedisAdapter } from 'arca';
+
+const arca = new Arca({
+  storage: new RedisAdapter('redis://localhost:6379'),
+  defaultTtl: 1000 * 60 * 5, // 5 minutes
+});
+```
+
+---
+
+## 📚 API Reference
+
+### `new Arca(options)`
+
+| Option       | Type             | Description                                  |
+| ------------ | ---------------- | -------------------------------------------- |
+| `storage`    | `StorageAdapter` | Cache backend (default: `MemoryAdapter`).     |
+| `defaultTtl` | `number`         | Default TTL in milliseconds (default: 60000). |
+
+---
+
+### `arca.get<T>(key, fetcher, options?)`
+
+Retrieve a value from cache or compute it safely under concurrency.
+
+**Parameters:**
+
+* `key: string`
+  Unique cache identifier.
+
+* `fetcher: () => Promise<T>`
+  Function executed when the value is missing or stale.
+
+* `options?:`
+
+  * `ttl?: number` – Override TTL for this key.
+  * `forceRefresh?: boolean` – Bypass cache and fetch fresh data.
+
+---
+
+### `arca.delete(key)`
+
+Manually invalidate a cache entry.
+
+```ts
+arca.delete('user:123');
+```
+
+---
+
+## 🧠 When Should You Use Arca?
+
+Arca shines when:
+
+* You have **high-traffic endpoints**.
+* Requests often target the **same resources**.
+* Cache expiration causes **database spikes**.
+* You want **zero-config protection** against stampedes.
+

package/dist/index.d.mts

@@ -0,0 +1,68 @@
+import { Redis } from 'ioredis';
+
+interface CacheEntry<T> {
+    value: T;
+    createdAt: number;
+    ttl: number;
+}
+interface StorageAdapter {
+    get<T>(key: string): Promise<CacheEntry<T> | null>;
+    set<T>(key: string, value: T, ttl: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+}
+interface ArcaOptions {
+    storage?: StorageAdapter;
+    defaultTtl?: number;
+}
+interface FetchOptions {
+    forceRefresh?: boolean;
+    ttl?: number;
+}
+
+declare class MemoryAdapter implements StorageAdapter {
+    private map;
+    get<T>(key: string): Promise<CacheEntry<T> | null>;
+    set<T>(key: string, value: T, ttl: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+}
+
+declare class RedisAdapter implements StorageAdapter {
+    private client;
+    constructor(connectionStringOrClient: string | Redis);
+    get<T>(key: string): Promise<CacheEntry<T> | null>;
+    set<T>(key: string, value: T, ttl: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+    /**
+     * Método útil para fechar conexão em testes ou shutdown gracioso
+     */
+    disconnect(): Promise<void>;
+}
+
+declare class Arca {
+    private storage;
+    private coalescer;
+    private defaultTtl;
+    constructor(options?: ArcaOptions);
+    /**
+     * Busca um dado.
+     * Estratégia: State-While-Revalidate
+     */
+    get<T>(key: string, fetcher: () => Promise<T>, options?: FetchOptions): Promise<T>;
+    /**
+     * Executa a busca através do Coalesces e salva no Storage.
+     */
+    private resolveFetch;
+    /**
+     * Wrapper para atualização em background que não trava a resposta principal.
+     */
+    private backgroundUpdate;
+    /**
+     * Limpa uma nova chave manualmente
+     */
+    delete(key: string): Promise<void>;
+}
+
+export { Arca, type ArcaOptions, type CacheEntry, type FetchOptions, MemoryAdapter, RedisAdapter, type StorageAdapter };

package/dist/index.d.ts

@@ -0,0 +1,68 @@
+import { Redis } from 'ioredis';
+
+interface CacheEntry<T> {
+    value: T;
+    createdAt: number;
+    ttl: number;
+}
+interface StorageAdapter {
+    get<T>(key: string): Promise<CacheEntry<T> | null>;
+    set<T>(key: string, value: T, ttl: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+}
+interface ArcaOptions {
+    storage?: StorageAdapter;
+    defaultTtl?: number;
+}
+interface FetchOptions {
+    forceRefresh?: boolean;
+    ttl?: number;
+}
+
+declare class MemoryAdapter implements StorageAdapter {
+    private map;
+    get<T>(key: string): Promise<CacheEntry<T> | null>;
+    set<T>(key: string, value: T, ttl: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+}
+
+declare class RedisAdapter implements StorageAdapter {
+    private client;
+    constructor(connectionStringOrClient: string | Redis);
+    get<T>(key: string): Promise<CacheEntry<T> | null>;
+    set<T>(key: string, value: T, ttl: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+    /**
+     * Método útil para fechar conexão em testes ou shutdown gracioso
+     */
+    disconnect(): Promise<void>;
+}
+
+declare class Arca {
+    private storage;
+    private coalescer;
+    private defaultTtl;
+    constructor(options?: ArcaOptions);
+    /**
+     * Busca um dado.
+     * Estratégia: State-While-Revalidate
+     */
+    get<T>(key: string, fetcher: () => Promise<T>, options?: FetchOptions): Promise<T>;
+    /**
+     * Executa a busca através do Coalesces e salva no Storage.
+     */
+    private resolveFetch;
+    /**
+     * Wrapper para atualização em background que não trava a resposta principal.
+     */
+    private backgroundUpdate;
+    /**
+     * Limpa uma nova chave manualmente
+     */
+    delete(key: string): Promise<void>;
+}
+
+export { Arca, type ArcaOptions, type CacheEntry, type FetchOptions, MemoryAdapter, RedisAdapter, type StorageAdapter };

package/dist/index.js

@@ -0,0 +1,198 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Arca: () => Arca,
+  MemoryAdapter: () => MemoryAdapter,
+  RedisAdapter: () => RedisAdapter
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/adapters/memory.ts
+var MemoryAdapter = class {
+  map = /* @__PURE__ */ new Map();
+  async get(key) {
+    const entry = this.map.get(key);
+    return entry || null;
+  }
+  async set(key, value, ttl) {
+    this.map.set(key, {
+      value,
+      createdAt: Date.now(),
+      ttl
+    });
+  }
+  async delete(key) {
+    this.map.delete(key);
+  }
+  async clear() {
+    this.map.clear();
+  }
+};
+
+// src/core/coalescer.ts
+var Coalescer = class {
+  // Armazena as promessas EM VOO (in-flight).
+  // Chave -> Promise<Pending>
+  inflight = /* @__PURE__ */ new Map();
+  /**
+   * Executa uma função assíncrona garantindo que, para uma mesma chave,
+   * apenas uma execução real ocorra simultaneamente.
+   * * @param key Identificador único da operação (ex: 'GET:/api/users/1')
+   * @param fn A função que busca o dado real (ex: consulta ao DB)
+   */
+  async execute(key, fn) {
+    const existing = this.inflight.get(key);
+    if (existing) {
+      return existing;
+    }
+    const promise = fn().then((result) => {
+      return result;
+    }).catch((error) => {
+      throw error;
+    }).finally(() => {
+      this.inflight.delete(key);
+    });
+    this.inflight.set(key, promise);
+    return promise;
+  }
+  /**
+   * Retorna quantas requisições estão pendentes no momento.
+   * Útil para métricas e observabilidade.
+   */
+  getInflightCount() {
+    return this.inflight.size;
+  }
+};
+
+// src/adapters/redis.ts
+var import_ioredis = __toESM(require("ioredis"));
+var RedisAdapter = class {
+  client;
+  constructor(connectionStringOrClient) {
+    if (typeof connectionStringOrClient === "string") {
+      this.client = new import_ioredis.default(connectionStringOrClient);
+    } else {
+      this.client = connectionStringOrClient;
+    }
+  }
+  async get(key) {
+    const data = await this.client.get(key);
+    if (!data) return null;
+    try {
+      return JSON.parse(data);
+    } catch {
+      return null;
+    }
+  }
+  async set(key, value, ttl) {
+    const entry = {
+      value,
+      createdAt: Date.now(),
+      ttl
+    };
+    await this.client.set(key, JSON.stringify(entry), "PX", ttl);
+  }
+  async delete(key) {
+    await this.client.del(key);
+  }
+  async clear() {
+    await this.client.flushdb();
+  }
+  /**
+   * Método útil para fechar conexão em testes ou shutdown gracioso
+   */
+  async disconnect() {
+    await this.client.quit();
+  }
+};
+
+// src/index.ts
+var Arca = class {
+  storage;
+  coalescer;
+  defaultTtl;
+  constructor(options = {}) {
+    this.storage = options.storage || new MemoryAdapter();
+    this.defaultTtl = options.defaultTtl || 6e4;
+    this.coalescer = new Coalescer();
+  }
+  /**
+   * Busca um dado.
+   * Estratégia: State-While-Revalidate
+   */
+  async get(key, fetcher, options = {}) {
+    const ttl = options.ttl || this.defaultTtl;
+    if (!options.forceRefresh) {
+      const cached = await this.storage.get(key);
+      if (cached) {
+        const isExpired = Date.now() - cached.createdAt > cached.ttl;
+        if (!isExpired) {
+          return cached.value;
+        }
+        this.backgroundUpdate(key, fetcher, ttl).catch((err) => {
+          console.error(`[Arca] Background update failed for key: ${key}`, err);
+        });
+        return cached.value;
+      }
+    }
+    return this.resolveFetch(key, fetcher, ttl);
+  }
+  /**
+   * Executa a busca através do Coalesces e salva no Storage.
+   */
+  async resolveFetch(key, fetcher, ttl) {
+    return this.coalescer.execute(key, async () => {
+      const value = await fetcher();
+      await this.storage.set(key, value, ttl);
+      return value;
+    });
+  }
+  /**
+   * Wrapper para atualização em background que não trava a resposta principal.
+   */
+  async backgroundUpdate(key, fetcher, ttl) {
+    await this.resolveFetch(key, fetcher, ttl);
+  }
+  /**
+   * Limpa uma nova chave manualmente
+   */
+  async delete(key) {
+    await this.storage.delete(key);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Arca,
+  MemoryAdapter,
+  RedisAdapter
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/adapters/memory.ts","../src/core/coalescer.ts","../src/adapters/redis.ts"],"sourcesContent":["/**\n * Arca - High Concurrency Cache\n */\nimport { MemoryAdapter } from \"./adapters/memory\";\nimport { Coalescer } from \"./core/coalescer\";\nimport type { ArcaOptions, FetchOptions, StorageAdapter } from \"./types\";\n\nexport * from \"./adapters/memory\";\nexport * from \"./adapters/redis\";\nexport * from \"./types\";\n\nexport class Arca {\n  private storage: StorageAdapter;\n  private coalescer: Coalescer;\n  private defaultTtl: number;\n\n  constructor(options: ArcaOptions = {}) {\n    this.storage = options.storage || new MemoryAdapter();\n    this.defaultTtl = options.defaultTtl || 60000; // 1 minuto padrão\n    this.coalescer = new Coalescer();\n  }\n\n  /**\n   * Busca um dado.\n   * Estratégia: State-While-Revalidate\n   */\n  public async get<T>(\n    key: string,\n    fetcher: () => Promise<T>,\n    options: FetchOptions = {},\n  ): Promise<T> {\n    const ttl = options.ttl || this.defaultTtl;\n\n    // 1. Tentar pegar do cache (se não forçado a ignorar)\n    if (!options.forceRefresh) {\n      const cached = await this.storage.get<T>(key);\n\n      if (cached) {\n        const isExpired = Date.now() - cached.createdAt > cached.ttl;\n\n        if (!isExpired) {\n          // HIT: Retorna dado fresco\n          return cached.value;\n        }\n\n        // STALE: O dado existe mas venceu.\n        // Retornamos o dado velho IMEDIATAMENTE e atualizamos em background.\n        // Usamos o coalescer para garantir que apenas UM background update ocorra.\n        this.backgroundUpdate(key, fetcher, ttl).catch((err) => {\n          console.error(`[Arca] Background update failed for key: ${key}`, err);\n        });\n\n        return cached.value;\n      }\n    }\n\n    // MISS: Não tem no cache ou forceRefresh=true\n    // Precisamos buscar (e esperar) o dado novo.\n    return this.resolveFetch(key, fetcher, ttl);\n  }\n\n  /**\n   * Executa a busca através do Coalesces e salva no Storage.\n   */\n  private async resolveFetch<T>(key: string, fetcher: () => Promise<T>, ttl: number): Promise<T> {\n    return this.coalescer.execute(key, async () => {\n      const value = await fetcher();\n      await this.storage.set(key, value, ttl);\n      return value;\n    });\n  }\n\n  /**\n   * Wrapper para atualização em background que não trava a resposta principal.\n   */\n  private async backgroundUpdate<T>(\n    key: string,\n    fetcher: () => Promise<T>,\n    ttl: number,\n  ): Promise<void> {\n    // Apenas chamamos o resolverFetch. O Coalescer cuida de não duplicar.\n    await this.resolveFetch(key, fetcher, ttl);\n  }\n\n  /**\n   * Limpa uma nova chave manualmente\n   */\n  public async delete(key: string): Promise<void> {\n    await this.storage.delete(key);\n  }\n}\n","import type { CacheEntry, StorageAdapter } from \"../types\";\n\nexport class MemoryAdapter implements StorageAdapter {\n  private map = new Map<string, CacheEntry<unknown>>();\n\n  async get<T>(key: string): Promise<CacheEntry<T> | null> {\n    const entry = this.map.get(key);\n    return (entry as CacheEntry<T>) || null;\n  }\n\n  async set<T>(key: string, value: T, ttl: number): Promise<void> {\n    this.map.set(key, {\n      value,\n      createdAt: Date.now(),\n      ttl,\n    });\n  }\n\n  async delete(key: string): Promise<void> {\n    this.map.delete(key);\n  }\n\n  async clear(): Promise<void> {\n    this.map.clear();\n  }\n}\n","/**\n * Implementação de Coalescência de Requisições.\n * Também conhecido como padrão \"SingleFlight\".\n * * Objetivo: Eliminar requisições pendentes idênticas duplicadas para evitar\n * problemas de \"Thundering Herd\" / \"Cache Stampede\".\n */\nexport class Coalescer {\n  // Armazena as promessas EM VOO (in-flight).\n  // Chave -> Promise<Pending>\n  private inflight = new Map<string, Promise<unknown>>();\n\n  /**\n   * Executa uma função assíncrona garantindo que, para uma mesma chave,\n   * apenas uma execução real ocorra simultaneamente.\n   * * @param key Identificador único da operação (ex: 'GET:/api/users/1')\n   * @param fn A função que busca o dado real (ex: consulta ao DB)\n   */\n  public async execute<T>(key: string, fn: () => Promise<T>): Promise<T> {\n    // 1. Se já existe uma promessa pendente para essa chave, retorne-a.\n    // Isso é o \"Coalescing\" acontecendo.\n    const existing = this.inflight.get(key);\n    if (existing) {\n      return existing as Promise<T>;\n    }\n\n    // 2. Se não existe, criamos a promessa.\n    const promise = fn()\n      .then((result) => {\n        // Sucesso: Retorna o valor.\n        return result;\n      })\n      .catch((error) => {\n        // Erro: Propaga o erro.\n        throw error;\n      })\n      .finally(() => {\n        // 3. Limpeza.\n        // Independente de sucesso ou falha, removemos a promessa do mapa.\n        // Se não fizermos isso, futuras chamadas receberiam uma promessa já resolvida (stale)\n        // ou nunca mais executariam a função novamente (memory leak/deadlock lógico).\n        this.inflight.delete(key);\n      });\n\n    this.inflight.set(key, promise);\n\n    return promise as Promise<T>;\n  }\n\n  /**\n   * Retorna quantas requisições estão pendentes no momento.\n   * Útil para métricas e observabilidade.\n   */\n  public getInflightCount(): number {\n    return this.inflight.size;\n  }\n}\n","import Redis, { type Redis as RedisClient } from \"ioredis\";\nimport type { CacheEntry, StorageAdapter } from \"../types\";\n\nexport class RedisAdapter implements StorageAdapter {\n  private client: RedisClient;\n\n  constructor(connectionStringOrClient: string | RedisClient) {\n    if (typeof connectionStringOrClient === \"string\") {\n      this.client = new Redis(connectionStringOrClient);\n    } else {\n      this.client = connectionStringOrClient;\n    }\n  }\n\n  async get<T>(key: string): Promise<CacheEntry<T> | null> {\n    const data = await this.client.get(key);\n\n    if (!data) return null;\n\n    try {\n      // O Redis retorna string, precisamos recompor o objeto CacheEntry\n      return JSON.parse(data) as CacheEntry<T>;\n    } catch {\n      // Se o JSON estiver corrompido, tratamos como miss\n      return null;\n    }\n  }\n\n  async set<T>(key: string, value: T, ttl: number): Promise<void> {\n    const entry: CacheEntry<T> = {\n      value,\n      createdAt: Date.now(),\n      ttl,\n    };\n\n    // 'PX' define o TTL em milissegundos nativamente no Redis\n    await this.client.set(key, JSON.stringify(entry), \"PX\", ttl);\n  }\n\n  async delete(key: string): Promise<void> {\n    await this.client.del(key);\n  }\n\n  async clear(): Promise<void> {\n    await this.client.flushdb();\n  }\n\n  /**\n   * Método útil para fechar conexão em testes ou shutdown gracioso\n   */\n  async disconnect(): Promise<void> {\n    await this.client.quit();\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACEO,IAAM,gBAAN,MAA8C;AAAA,EAC3C,MAAM,oBAAI,IAAiC;AAAA,EAEnD,MAAM,IAAO,KAA4C;AACvD,UAAM,QAAQ,KAAK,IAAI,IAAI,GAAG;AAC9B,WAAQ,SAA2B;AAAA,EACrC;AAAA,EAEA,MAAM,IAAO,KAAa,OAAU,KAA4B;AAC9D,SAAK,IAAI,IAAI,KAAK;AAAA,MAChB;AAAA,MACA,WAAW,KAAK,IAAI;AAAA,MACpB;AAAA,IACF,CAAC;AAAA,EACH;AAAA,EAEA,MAAM,OAAO,KAA4B;AACvC,SAAK,IAAI,OAAO,GAAG;AAAA,EACrB;AAAA,EAEA,MAAM,QAAuB;AAC3B,SAAK,IAAI,MAAM;AAAA,EACjB;AACF;;;ACnBO,IAAM,YAAN,MAAgB;AAAA;AAAA;AAAA,EAGb,WAAW,oBAAI,IAA8B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQrD,MAAa,QAAW,KAAa,IAAkC;AAGrE,UAAM,WAAW,KAAK,SAAS,IAAI,GAAG;AACtC,QAAI,UAAU;AACZ,aAAO;AAAA,IACT;AAGA,UAAM,UAAU,GAAG,EAChB,KAAK,CAAC,WAAW;AAEhB,aAAO;AAAA,IACT,CAAC,EACA,MAAM,CAAC,UAAU;AAEhB,YAAM;AAAA,IACR,CAAC,EACA,QAAQ,MAAM;AAKb,WAAK,SAAS,OAAO,GAAG;AAAA,IAC1B,CAAC;AAEH,SAAK,SAAS,IAAI,KAAK,OAAO;AAE9B,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,mBAA2B;AAChC,WAAO,KAAK,SAAS;AAAA,EACvB;AACF;;;ACvDA,qBAAiD;AAG1C,IAAM,eAAN,MAA6C;AAAA,EAC1C;AAAA,EAER,YAAY,0BAAgD;AAC1D,QAAI,OAAO,6BAA6B,UAAU;AAChD,WAAK,SAAS,IAAI,eAAAA,QAAM,wBAAwB;AAAA,IAClD,OAAO;AACL,WAAK,SAAS;AAAA,IAChB;AAAA,EACF;AAAA,EAEA,MAAM,IAAO,KAA4C;AACvD,UAAM,OAAO,MAAM,KAAK,OAAO,IAAI,GAAG;AAEtC,QAAI,CAAC,KAAM,QAAO;AAElB,QAAI;AAEF,aAAO,KAAK,MAAM,IAAI;AAAA,IACxB,QAAQ;AAEN,aAAO;AAAA,IACT;AAAA,EACF;AAAA,EAEA,MAAM,IAAO,KAAa,OAAU,KAA4B;AAC9D,UAAM,QAAuB;AAAA,MAC3B;AAAA,MACA,WAAW,KAAK,IAAI;AAAA,MACpB;AAAA,IACF;AAGA,UAAM,KAAK,OAAO,IAAI,KAAK,KAAK,UAAU,KAAK,GAAG,MAAM,GAAG;AAAA,EAC7D;AAAA,EAEA,MAAM,OAAO,KAA4B;AACvC,UAAM,KAAK,OAAO,IAAI,GAAG;AAAA,EAC3B;AAAA,EAEA,MAAM,QAAuB;AAC3B,UAAM,KAAK,OAAO,QAAQ;AAAA,EAC5B;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,aAA4B;AAChC,UAAM,KAAK,OAAO,KAAK;AAAA,EACzB;AACF;;;AH1CO,IAAM,OAAN,MAAW;AAAA,EACR;AAAA,EACA;AAAA,EACA;AAAA,EAER,YAAY,UAAuB,CAAC,GAAG;AACrC,SAAK,UAAU,QAAQ,WAAW,IAAI,cAAc;AACpD,SAAK,aAAa,QAAQ,cAAc;AACxC,SAAK,YAAY,IAAI,UAAU;AAAA,EACjC;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAa,IACX,KACA,SACA,UAAwB,CAAC,GACb;AACZ,UAAM,MAAM,QAAQ,OAAO,KAAK;AAGhC,QAAI,CAAC,QAAQ,cAAc;AACzB,YAAM,SAAS,MAAM,KAAK,QAAQ,IAAO,GAAG;AAE5C,UAAI,QAAQ;AACV,cAAM,YAAY,KAAK,IAAI,IAAI,OAAO,YAAY,OAAO;AAEzD,YAAI,CAAC,WAAW;AAEd,iBAAO,OAAO;AAAA,QAChB;AAKA,aAAK,iBAAiB,KAAK,SAAS,GAAG,EAAE,MAAM,CAAC,QAAQ;AACtD,kBAAQ,MAAM,4CAA4C,GAAG,IAAI,GAAG;AAAA,QACtE,CAAC;AAED,eAAO,OAAO;AAAA,MAChB;AAAA,IACF;AAIA,WAAO,KAAK,aAAa,KAAK,SAAS,GAAG;AAAA,EAC5C;AAAA;AAAA;AAAA;AAAA,EAKA,MAAc,aAAgB,KAAa,SAA2B,KAAyB;AAC7F,WAAO,KAAK,UAAU,QAAQ,KAAK,YAAY;AAC7C,YAAM,QAAQ,MAAM,QAAQ;AAC5B,YAAM,KAAK,QAAQ,IAAI,KAAK,OAAO,GAAG;AACtC,aAAO;AAAA,IACT,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA,EAKA,MAAc,iBACZ,KACA,SACA,KACe;AAEf,UAAM,KAAK,aAAa,KAAK,SAAS,GAAG;AAAA,EAC3C;AAAA;AAAA;AAAA;AAAA,EAKA,MAAa,OAAO,KAA4B;AAC9C,UAAM,KAAK,QAAQ,OAAO,GAAG;AAAA,EAC/B;AACF;","names":["Redis"]}

package/dist/index.mjs

@@ -0,0 +1,159 @@
+// src/adapters/memory.ts
+var MemoryAdapter = class {
+  map = /* @__PURE__ */ new Map();
+  async get(key) {
+    const entry = this.map.get(key);
+    return entry || null;
+  }
+  async set(key, value, ttl) {
+    this.map.set(key, {
+      value,
+      createdAt: Date.now(),
+      ttl
+    });
+  }
+  async delete(key) {
+    this.map.delete(key);
+  }
+  async clear() {
+    this.map.clear();
+  }
+};
+
+// src/core/coalescer.ts
+var Coalescer = class {
+  // Armazena as promessas EM VOO (in-flight).
+  // Chave -> Promise<Pending>
+  inflight = /* @__PURE__ */ new Map();
+  /**
+   * Executa uma função assíncrona garantindo que, para uma mesma chave,
+   * apenas uma execução real ocorra simultaneamente.
+   * * @param key Identificador único da operação (ex: 'GET:/api/users/1')
+   * @param fn A função que busca o dado real (ex: consulta ao DB)
+   */
+  async execute(key, fn) {
+    const existing = this.inflight.get(key);
+    if (existing) {
+      return existing;
+    }
+    const promise = fn().then((result) => {
+      return result;
+    }).catch((error) => {
+      throw error;
+    }).finally(() => {
+      this.inflight.delete(key);
+    });
+    this.inflight.set(key, promise);
+    return promise;
+  }
+  /**
+   * Retorna quantas requisições estão pendentes no momento.
+   * Útil para métricas e observabilidade.
+   */
+  getInflightCount() {
+    return this.inflight.size;
+  }
+};
+
+// src/adapters/redis.ts
+import Redis from "ioredis";
+var RedisAdapter = class {
+  client;
+  constructor(connectionStringOrClient) {
+    if (typeof connectionStringOrClient === "string") {
+      this.client = new Redis(connectionStringOrClient);
+    } else {
+      this.client = connectionStringOrClient;
+    }
+  }
+  async get(key) {
+    const data = await this.client.get(key);
+    if (!data) return null;
+    try {
+      return JSON.parse(data);
+    } catch {
+      return null;
+    }
+  }
+  async set(key, value, ttl) {
+    const entry = {
+      value,
+      createdAt: Date.now(),
+      ttl
+    };
+    await this.client.set(key, JSON.stringify(entry), "PX", ttl);
+  }
+  async delete(key) {
+    await this.client.del(key);
+  }
+  async clear() {
+    await this.client.flushdb();
+  }
+  /**
+   * Método útil para fechar conexão em testes ou shutdown gracioso
+   */
+  async disconnect() {
+    await this.client.quit();
+  }
+};
+
+// src/index.ts
+var Arca = class {
+  storage;
+  coalescer;
+  defaultTtl;
+  constructor(options = {}) {
+    this.storage = options.storage || new MemoryAdapter();
+    this.defaultTtl = options.defaultTtl || 6e4;
+    this.coalescer = new Coalescer();
+  }
+  /**
+   * Busca um dado.
+   * Estratégia: State-While-Revalidate
+   */
+  async get(key, fetcher, options = {}) {
+    const ttl = options.ttl || this.defaultTtl;
+    if (!options.forceRefresh) {
+      const cached = await this.storage.get(key);
+      if (cached) {
+        const isExpired = Date.now() - cached.createdAt > cached.ttl;
+        if (!isExpired) {
+          return cached.value;
+        }
+        this.backgroundUpdate(key, fetcher, ttl).catch((err) => {
+          console.error(`[Arca] Background update failed for key: ${key}`, err);
+        });
+        return cached.value;
+      }
+    }
+    return this.resolveFetch(key, fetcher, ttl);
+  }
+  /**
+   * Executa a busca através do Coalesces e salva no Storage.
+   */
+  async resolveFetch(key, fetcher, ttl) {
+    return this.coalescer.execute(key, async () => {
+      const value = await fetcher();
+      await this.storage.set(key, value, ttl);
+      return value;
+    });
+  }
+  /**
+   * Wrapper para atualização em background que não trava a resposta principal.
+   */
+  async backgroundUpdate(key, fetcher, ttl) {
+    await this.resolveFetch(key, fetcher, ttl);
+  }
+  /**
+   * Limpa uma nova chave manualmente
+   */
+  async delete(key) {
+    await this.storage.delete(key);
+  }
+};
+export {
+  Arca,
+  MemoryAdapter,
+  RedisAdapter
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/adapters/memory.ts","../src/core/coalescer.ts","../src/adapters/redis.ts","../src/index.ts"],"sourcesContent":["import type { CacheEntry, StorageAdapter } from \"../types\";\n\nexport class MemoryAdapter implements StorageAdapter {\n  private map = new Map<string, CacheEntry<unknown>>();\n\n  async get<T>(key: string): Promise<CacheEntry<T> | null> {\n    const entry = this.map.get(key);\n    return (entry as CacheEntry<T>) || null;\n  }\n\n  async set<T>(key: string, value: T, ttl: number): Promise<void> {\n    this.map.set(key, {\n      value,\n      createdAt: Date.now(),\n      ttl,\n    });\n  }\n\n  async delete(key: string): Promise<void> {\n    this.map.delete(key);\n  }\n\n  async clear(): Promise<void> {\n    this.map.clear();\n  }\n}\n","/**\n * Implementação de Coalescência de Requisições.\n * Também conhecido como padrão \"SingleFlight\".\n * * Objetivo: Eliminar requisições pendentes idênticas duplicadas para evitar\n * problemas de \"Thundering Herd\" / \"Cache Stampede\".\n */\nexport class Coalescer {\n  // Armazena as promessas EM VOO (in-flight).\n  // Chave -> Promise<Pending>\n  private inflight = new Map<string, Promise<unknown>>();\n\n  /**\n   * Executa uma função assíncrona garantindo que, para uma mesma chave,\n   * apenas uma execução real ocorra simultaneamente.\n   * * @param key Identificador único da operação (ex: 'GET:/api/users/1')\n   * @param fn A função que busca o dado real (ex: consulta ao DB)\n   */\n  public async execute<T>(key: string, fn: () => Promise<T>): Promise<T> {\n    // 1. Se já existe uma promessa pendente para essa chave, retorne-a.\n    // Isso é o \"Coalescing\" acontecendo.\n    const existing = this.inflight.get(key);\n    if (existing) {\n      return existing as Promise<T>;\n    }\n\n    // 2. Se não existe, criamos a promessa.\n    const promise = fn()\n      .then((result) => {\n        // Sucesso: Retorna o valor.\n        return result;\n      })\n      .catch((error) => {\n        // Erro: Propaga o erro.\n        throw error;\n      })\n      .finally(() => {\n        // 3. Limpeza.\n        // Independente de sucesso ou falha, removemos a promessa do mapa.\n        // Se não fizermos isso, futuras chamadas receberiam uma promessa já resolvida (stale)\n        // ou nunca mais executariam a função novamente (memory leak/deadlock lógico).\n        this.inflight.delete(key);\n      });\n\n    this.inflight.set(key, promise);\n\n    return promise as Promise<T>;\n  }\n\n  /**\n   * Retorna quantas requisições estão pendentes no momento.\n   * Útil para métricas e observabilidade.\n   */\n  public getInflightCount(): number {\n    return this.inflight.size;\n  }\n}\n","import Redis, { type Redis as RedisClient } from \"ioredis\";\nimport type { CacheEntry, StorageAdapter } from \"../types\";\n\nexport class RedisAdapter implements StorageAdapter {\n  private client: RedisClient;\n\n  constructor(connectionStringOrClient: string | RedisClient) {\n    if (typeof connectionStringOrClient === \"string\") {\n      this.client = new Redis(connectionStringOrClient);\n    } else {\n      this.client = connectionStringOrClient;\n    }\n  }\n\n  async get<T>(key: string): Promise<CacheEntry<T> | null> {\n    const data = await this.client.get(key);\n\n    if (!data) return null;\n\n    try {\n      // O Redis retorna string, precisamos recompor o objeto CacheEntry\n      return JSON.parse(data) as CacheEntry<T>;\n    } catch {\n      // Se o JSON estiver corrompido, tratamos como miss\n      return null;\n    }\n  }\n\n  async set<T>(key: string, value: T, ttl: number): Promise<void> {\n    const entry: CacheEntry<T> = {\n      value,\n      createdAt: Date.now(),\n      ttl,\n    };\n\n    // 'PX' define o TTL em milissegundos nativamente no Redis\n    await this.client.set(key, JSON.stringify(entry), \"PX\", ttl);\n  }\n\n  async delete(key: string): Promise<void> {\n    await this.client.del(key);\n  }\n\n  async clear(): Promise<void> {\n    await this.client.flushdb();\n  }\n\n  /**\n   * Método útil para fechar conexão em testes ou shutdown gracioso\n   */\n  async disconnect(): Promise<void> {\n    await this.client.quit();\n  }\n}\n","/**\n * Arca - High Concurrency Cache\n */\nimport { MemoryAdapter } from \"./adapters/memory\";\nimport { Coalescer } from \"./core/coalescer\";\nimport type { ArcaOptions, FetchOptions, StorageAdapter } from \"./types\";\n\nexport * from \"./adapters/memory\";\nexport * from \"./adapters/redis\";\nexport * from \"./types\";\n\nexport class Arca {\n  private storage: StorageAdapter;\n  private coalescer: Coalescer;\n  private defaultTtl: number;\n\n  constructor(options: ArcaOptions = {}) {\n    this.storage = options.storage || new MemoryAdapter();\n    this.defaultTtl = options.defaultTtl || 60000; // 1 minuto padrão\n    this.coalescer = new Coalescer();\n  }\n\n  /**\n   * Busca um dado.\n   * Estratégia: State-While-Revalidate\n   */\n  public async get<T>(\n    key: string,\n    fetcher: () => Promise<T>,\n    options: FetchOptions = {},\n  ): Promise<T> {\n    const ttl = options.ttl || this.defaultTtl;\n\n    // 1. Tentar pegar do cache (se não forçado a ignorar)\n    if (!options.forceRefresh) {\n      const cached = await this.storage.get<T>(key);\n\n      if (cached) {\n        const isExpired = Date.now() - cached.createdAt > cached.ttl;\n\n        if (!isExpired) {\n          // HIT: Retorna dado fresco\n          return cached.value;\n        }\n\n        // STALE: O dado existe mas venceu.\n        // Retornamos o dado velho IMEDIATAMENTE e atualizamos em background.\n        // Usamos o coalescer para garantir que apenas UM background update ocorra.\n        this.backgroundUpdate(key, fetcher, ttl).catch((err) => {\n          console.error(`[Arca] Background update failed for key: ${key}`, err);\n        });\n\n        return cached.value;\n      }\n    }\n\n    // MISS: Não tem no cache ou forceRefresh=true\n    // Precisamos buscar (e esperar) o dado novo.\n    return this.resolveFetch(key, fetcher, ttl);\n  }\n\n  /**\n   * Executa a busca através do Coalesces e salva no Storage.\n   */\n  private async resolveFetch<T>(key: string, fetcher: () => Promise<T>, ttl: number): Promise<T> {\n    return this.coalescer.execute(key, async () => {\n      const value = await fetcher();\n      await this.storage.set(key, value, ttl);\n      return value;\n    });\n  }\n\n  /**\n   * Wrapper para atualização em background que não trava a resposta principal.\n   */\n  private async backgroundUpdate<T>(\n    key: string,\n    fetcher: () => Promise<T>,\n    ttl: number,\n  ): Promise<void> {\n    // Apenas chamamos o resolverFetch. O Coalescer cuida de não duplicar.\n    await this.resolveFetch(key, fetcher, ttl);\n  }\n\n  /**\n   * Limpa uma nova chave manualmente\n   */\n  public async delete(key: string): Promise<void> {\n    await this.storage.delete(key);\n  }\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@sabschyks/arca",
+  "version": "0.0.1",
+  "description": "High-concurrency cache coalescing and state management library.",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist/index.js",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "cache",
+    "concurrency",
+    "promise",
+    "deduplication",
+    "swr",
+    "typescript"
+  ],
+  "author": "Sabrinna Guimarães (sabschyks)",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.14",
+    "@changesets/cli": "^2.29.8",
+    "@types/ioredis-mock": "^8.2.6",
+    "@types/node": "^25.2.1",
+    "@vitest/coverage-v8": "^4.0.18",
+    "husky": "^9.1.7",
+    "ioredis-mock": "^8.13.1",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  },
+  "dependencies": {
+    "ioredis": "^5.9.2"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "lint": "biome check .",
+    "lint:fix": "biome check --write .",
+    "typecheck": "tsc --noEmit",
+    "release": "pnpm build && changeset publish"
+  }
+}