Done?

Author: smithamax

.github/workflows/npm-publish.yml

@@ -0,0 +1,55 @@
+on: push
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [20.x, 22.x]
+
+    services:
+      redis:
+        image: redis
+        # Set health checks to wait until redis has started
+        options: >-
+          --health-cmd "redis-cli ping"
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+        ports:
+          - 6379:6379
+
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+      - run: npm ci
+      - run: npm test
+
+  lint:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+      - run: npm ci
+      - run: npm lint
+      - run: ./scripts/example-check.sh
+
+  # publish:
+  #   needs: ["test", "lint"]
+  #   runs-on: ubuntu-latest
+
+  #   steps:
+  #     - uses: actions/checkout@v4
+  #     - uses: actions/setup-node@v4
+  #       with:
+  #         node-version: 20
+  #     - run: npm ci
+  #     - uses: JS-DevTools/npm-publish@v1
+  #       with:
+  #         token: ${{ secrets.NPM_TOKEN }}

README.md

@@ -4,67 +4,56 @@
 
 ### Basic usage
 
-For the most common cases you a simple 2 layer LRU + Redis cache is sufficient.
+For the most common cases use a simple 2 layer LRU + Redis cache is sufficient.
 
-```typescript
-import { CompositeCache, RedisCache LruCache } from '@loke/cache-kit';
+```ts
+import { Cache, LruMemoryCacheStore, RedisCacheStore } from "@loke/cache-kit";
 import Redis from "ioredis";
 import { create as createLogger } from "@loke/logger";
 
-
 const logger = createLogger();
-const redisClient = new Redis(process.env.REDIS_HOST);
-
-
-const cache = new CompositeCache(
-  "users:{userId}"
-    // Caches will be checked in order, and the first cache to return a value
-    // will be used
-  [
-    new LruCache({ max: 1000 }),
-    new RedisCache(redisClient, "tidy-api"),
-  ],
-  logger
+const redisClient = new Redis();
+
+const cache = new Cache(
+  "users:{userId}",
+  // Caches will be checked in order, and the first cache to return a value
+  // will be used
+  [new LruMemoryCacheStore({ max: 1000 }), new RedisCacheStore(redisClient)],
+  logger,
 );
 
-
 const userId = 123;
 
-const user = cache.apply(
-  { userId },
-  async () => {
-    // This function will only be called if the cache is empty
-    const value = await fetchUser(userId);
-
-    // the ttl is returned as part of the result so it can vary per request
-    return {
-      value,
-      ttl: 60 * 60 * 1000, // 1 hour in milliseconds
-    };
-  }
-);
+const user = cache.apply({ userId }, async () => {
+  // This function will only be called if the cache is empty
+  const value = await fetch(`http://example.com/user/${userId}`);
+
+  // the ttl is returned as part of the result so it can vary per request
+  return {
+    value,
+    ttl: 60 * 60 * 1000, // 1 hour in milliseconds
+  };
+});
 ```
 
 ### Single flight cache
 
 In cases where you don't want the overhead of storing the value in a cache, you
-can use a single flight cache. Concurrent requests will piggyback on the result
-of the first request.
+can use the cache for single flighting requests. Concurrent requests will
+piggyback on the result of the first request.
 
-```typescript
-import { CompositeCache } from '@loke/cache-kit';
+```ts
+import { Cache } from "@loke/cache-kit";
 import { create as createLogger } from "@loke/logger";
 
-
 const logger = createLogger();
 
-
-const cache = new CompositeCache(
-  "users:{userId}"
+const cache = new Cache(
+  "users:{userId}",
   // An empty list of caches will result in a single flight only cache, where
   // the value is only cached for the duration of the request
   [],
-  logger
+  logger,
 );
 ```
 

package-lock.json

@@ -17,13 +17,15 @@
   "scripts": {
     "test": "tsx --test",
     "lint": "eslint . && prettier --check .",
-    "build": "pkgroll --sourcemap"
+    "build": "pkgroll --sourcemap",
+    "prepare": "npm run build"
   },
   "author": "",
   "license": "ISC",
   "description": "",
   "devDependencies": {
     "@eslint/js": "^9.18.0",
+    "@loke/logger": "^3.4.0",
     "@tsconfig/node20": "^20.1.4",
     "@types/node": "^22.10.8",
     "eslint": "^9.18.0",

package.json

@@ -0,0 +1,24 @@
+#!/bin/bash
+
+# Extracts code blocks from README.md and checks them with TypeScript compiler
+
+awk '/^```/{
+    if (p) {
+        p=0;
+        close(file)
+    } else {
+        p=1;
+        count++;
+        lang=$0;
+        sub(/^```/, "", lang);
+        if (lang == "") lang="txt";
+        file=sprintf("readme_example_%d.%s", count, lang)
+        next
+    }
+}
+p{print > file}' README.md
+
+echo "Checking typescript examples"
+npx tsc --noEmit --module node16 readme_example_*.ts
+
+rm readme_example_*

scripts/example-check.sh

@@ -2,8 +2,9 @@ import test from "node:test";
 import crypto from "crypto";
 import Redis from "ioredis";
 import assert from "assert/strict";
+import { nullLogger } from "@loke/logger";
 
-import { CompositeCache, LruMemoryCache, RedisCache } from ".";
+import { Cache, LruMemoryCacheStore, RedisCacheStore } from ".";
 
 const randomId = () => crypto.randomBytes(16).toString("hex");
 
@@ -15,10 +16,10 @@ test("apply - should be able to apply caching to a function", async (t) => {
   const redisClient = new Redis(REDIS_HOST);
   t.after(() => redisClient.quit());
 
-  const cache = new CompositeCache(
+  const cache = new Cache(
     "test:{id}",
-    [new LruMemoryCache({ max: 10 }), new RedisCache(redisClient)],
-    console,
+    [new LruMemoryCacheStore({ max: 10 }), new RedisCacheStore(redisClient)],
+    nullLogger,
   );
 
   let callCount = 0;
@@ -40,10 +41,10 @@ test("apply - number keys should be valid", async (t) => {
   const redisClient = new Redis(REDIS_HOST);
   t.after(() => redisClient.quit());
 
-  const cache = new CompositeCache(
+  const cache = new Cache(
     "test-number:{id}",
-    [new LruMemoryCache({ max: 10 }), new RedisCache(redisClient)],
-    console,
+    [new LruMemoryCacheStore({ max: 10 }), new RedisCacheStore(redisClient)],
+    nullLogger,
   );
 
   let callCount = 0;
@@ -67,10 +68,10 @@ test("apply - should only need to call service once in parallel (single flight)"
   const redisClient = new Redis(REDIS_HOST);
   t.after(() => redisClient.quit());
 
-  const cache = new CompositeCache(
+  const cache = new Cache(
     "test:{id}",
-    [new LruMemoryCache({ max: 10 }), new RedisCache(redisClient)],
-    console,
+    [new LruMemoryCacheStore({ max: 10 }), new RedisCacheStore(redisClient)],
+    nullLogger,
   );
 
   let resolveAllApplied: (_: unknown) => void;
@@ -110,10 +111,10 @@ test("apply - should pass through errors", async (t) => {
   const redisClient = new Redis(REDIS_HOST);
   t.after(() => redisClient.quit());
 
-  const cache = new CompositeCache(
+  const cache = new Cache(
     "test:{id}",
-    [new LruMemoryCache({ max: 10 }), new RedisCache(redisClient)],
-    console,
+    [new LruMemoryCacheStore({ max: 10 }), new RedisCacheStore(redisClient)],
+    nullLogger,
   );
 
   const errToThrow = new Error("test error");