@trieb.work/nextjs-turbo-redis-cache 1.0.0

package/dist/SyncedMap.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncedMap = void 0;
+// SyncedMap.ts
+const RedisStringsHandler_1 = require("./RedisStringsHandler");
+const SYNC_CHANNEL_SUFFIX = ':sync-channel:';
+class SyncedMap {
+    constructor(options) {
+        this.client = options.client;
+        this.keyPrefix = options.keyPrefix;
+        this.redisKey = options.redisKey;
+        this.syncChannel = `${options.keyPrefix}${SYNC_CHANNEL_SUFFIX}${options.redisKey}`;
+        this.database = options.database;
+        this.timeoutMs = options.timeoutMs;
+        this.querySize = options.querySize;
+        this.filterKeys = options.filterKeys;
+        this.resyncIntervalMs = options.resyncIntervalMs;
+        this.customizedSync = options.customizedSync;
+        this.map = new Map();
+        this.subscriberClient = this.client.duplicate();
+        this.setupLock = new Promise((resolve) => {
+            this.setupLockResolve = resolve;
+        });
+        this.setup().catch((error) => {
+            console.error('Failed to setup SyncedMap:', error);
+            throw error;
+        });
+    }
+    async setup() {
+        let setupPromises = [];
+        if (!this.customizedSync?.withoutRedisHashmap) {
+            setupPromises.push(this.initialSync());
+            this.setupPeriodicResync();
+        }
+        setupPromises.push(this.setupPubSub());
+        await Promise.all(setupPromises);
+        this.setupLockResolve();
+    }
+    async initialSync() {
+        let cursor = 0;
+        const hScanOptions = { COUNT: this.querySize };
+        try {
+            do {
+                const remoteItems = await this.client.hScan((0, RedisStringsHandler_1.getTimeoutRedisCommandOptions)(this.timeoutMs), this.keyPrefix + this.redisKey, cursor, hScanOptions);
+                for (const { field, value } of remoteItems.tuples) {
+                    if (this.filterKeys(field)) {
+                        const parsedValue = JSON.parse(value);
+                        this.map.set(field, parsedValue);
+                    }
+                }
+                cursor = remoteItems.cursor;
+            } while (cursor !== 0);
+            // Clean up keys not in Redis
+            await this.cleanupKeysNotInRedis();
+        }
+        catch (error) {
+            console.error('Error during initial sync:', error);
+            throw error;
+        }
+    }
+    async cleanupKeysNotInRedis() {
+        let cursor = 0;
+        const scanOptions = { COUNT: this.querySize, MATCH: `${this.keyPrefix}*` };
+        let remoteKeys = [];
+        try {
+            do {
+                const remoteKeysPortion = await this.client.scan((0, RedisStringsHandler_1.getTimeoutRedisCommandOptions)(this.timeoutMs), cursor, scanOptions);
+                remoteKeys = remoteKeys.concat(remoteKeysPortion.keys);
+                cursor = remoteKeysPortion.cursor;
+            } while (cursor !== 0);
+            const remoteKeysSet = new Set(remoteKeys.map((key) => key.substring(this.keyPrefix.length)));
+            const keysToDelete = [];
+            for (const key of this.map.keys()) {
+                const keyStr = key;
+                if (!remoteKeysSet.has(keyStr) && this.filterKeys(keyStr)) {
+                    keysToDelete.push(keyStr);
+                }
+            }
+            if (keysToDelete.length > 0) {
+                await this.delete(keysToDelete);
+            }
+        }
+        catch (error) {
+            console.error('Error during cleanup of keys not in Redis:', error);
+            throw error;
+        }
+    }
+    setupPeriodicResync() {
+        if (this.resyncIntervalMs && this.resyncIntervalMs > 0) {
+            setInterval(() => {
+                this.initialSync().catch((error) => {
+                    console.error('Error during periodic resync:', error);
+                });
+            }, this.resyncIntervalMs);
+        }
+    }
+    async setupPubSub() {
+        const syncHandler = async (message) => {
+            const syncMessage = JSON.parse(message);
+            if (syncMessage.type === 'insert') {
+                if (syncMessage.key !== undefined && syncMessage.value !== undefined) {
+                    this.map.set(syncMessage.key, syncMessage.value);
+                }
+            }
+            else if (syncMessage.type === 'delete') {
+                if (syncMessage.keys) {
+                    for (const key of syncMessage.keys) {
+                        this.map.delete(key);
+                    }
+                }
+            }
+        };
+        const keyEventHandler = async (_channel, message) => {
+            const key = message;
+            if (key.startsWith(this.keyPrefix)) {
+                const keyInMap = key.substring(this.keyPrefix.length);
+                if (this.filterKeys(keyInMap)) {
+                    await this.delete(keyInMap, true);
+                }
+            }
+        };
+        try {
+            await this.subscriberClient.connect();
+            await Promise.all([
+                // We use a custom channel for insert/delete For the following reason:
+                // With custom channel we can delete multiple entries in one message. If we would listen to unlink / del we
+                // could get thousands of messages for one revalidateTag (For example revalidateTag("algolia") would send an enormous amount of network packages)
+                // Also we can send the value in the message for insert
+                this.subscriberClient.subscribe(this.syncChannel, syncHandler),
+                // Subscribe to Redis keyspace notifications for evicted and expired keys
+                this.subscriberClient.subscribe(`__keyevent@${this.database}__:evicted`, keyEventHandler),
+                this.subscriberClient.subscribe(`__keyevent@${this.database}__:expired`, keyEventHandler),
+            ]);
+            // Error handling for reconnection
+            this.subscriberClient.on('error', async (err) => {
+                console.error('Subscriber client error:', err);
+                try {
+                    await this.subscriberClient.quit();
+                    this.subscriberClient = this.client.duplicate();
+                    await this.setupPubSub();
+                }
+                catch (reconnectError) {
+                    console.error('Failed to reconnect subscriber client:', reconnectError);
+                }
+            });
+        }
+        catch (error) {
+            console.error('Error setting up pub/sub client:', error);
+            throw error;
+        }
+    }
+    async waitUntilReady() {
+        await this.setupLock;
+    }
+    get(key) {
+        return this.map.get(key);
+    }
+    async set(key, value) {
+        this.map.set(key, value);
+        const operations = [];
+        // This is needed if we only want to sync delete commands. This is especially useful for non serializable data like a promise map
+        if (this.customizedSync?.withoutSetSync) {
+            return;
+        }
+        if (!this.customizedSync?.withoutRedisHashmap) {
+            const options = (0, RedisStringsHandler_1.getTimeoutRedisCommandOptions)(this.timeoutMs);
+            operations.push(this.client.hSet(options, this.keyPrefix + this.redisKey, key, JSON.stringify(value)));
+        }
+        const insertMessage = {
+            type: 'insert',
+            key: key,
+            value,
+        };
+        operations.push(this.client.publish(this.syncChannel, JSON.stringify(insertMessage)));
+        await Promise.all(operations);
+    }
+    async delete(keys, withoutSyncMessage = false) {
+        const keysArray = Array.isArray(keys) ? keys : [keys];
+        const operations = [];
+        for (const key of keysArray) {
+            this.map.delete(key);
+        }
+        if (!this.customizedSync?.withoutRedisHashmap) {
+            const options = (0, RedisStringsHandler_1.getTimeoutRedisCommandOptions)(this.timeoutMs);
+            operations.push(this.client.hDel(options, this.keyPrefix + this.redisKey, keysArray));
+        }
+        if (!withoutSyncMessage) {
+            const deletionMessage = {
+                type: 'delete',
+                keys: keysArray,
+            };
+            operations.push(this.client.publish(this.syncChannel, JSON.stringify(deletionMessage)));
+        }
+        await Promise.all(operations);
+    }
+    has(key) {
+        return this.map.has(key);
+    }
+    entries() {
+        return this.map.entries();
+    }
+}
+exports.SyncedMap = SyncedMap;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import CachedHandler from "./CachedHandler";
+export default CachedHandler;

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const CachedHandler_1 = __importDefault(require("./CachedHandler"));
+exports.default = CachedHandler_1.default;

package/dist/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.test.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+(0, vitest_1.describe)('Example Test', () => {
+    (0, vitest_1.it)('should work correctly', () => {
+        console.log("TODO tests");
+    });
+});

package/eslint.config.mjs

@@ -0,0 +1,26 @@
+import tsPlugin from '@typescript-eslint/eslint-plugin';  // Changed to default import
+import tsParser from '@typescript-eslint/parser';
+
+const config = [
+  {
+    ignores: ['dist', 'node_modules'],
+  },
+  {
+    files: ['src/**/*.ts', 'src/**/*.tsx'],
+    languageOptions: {
+      parser: tsParser,
+      ecmaVersion: 2021,
+      sourceType: 'module',
+    },
+    plugins: {
+      '@typescript-eslint': {
+        rules: tsPlugin.rules,
+      },
+    },
+    rules: {
+      ...tsPlugin.configs.recommended.rules,
+    },
+  },
+];
+
+export default config;

package/hooks/commit-msg

@@ -0,0 +1,10 @@
+#!/bin/sh
+# Commit message hook to enforce conventional commits
+npx --no-install commitlint --edit "$1"
+
+# Check if commitlint failed
+if [ $? -ne 0 ]; then
+  echo "❌ Commit message does not follow Conventional Commit format."
+  echo "👉 Example: 'feat: add user authentication'"
+  exit 1
+fi

package/hooks/pre-commit

@@ -0,0 +1,11 @@
+#!/bin/sh
+# Commit message hook to run linting on staged files
+BRANCH_NAME=$(git symbolic-ref --short HEAD)
+if [ "$BRANCH_NAME" = "main" ]; then
+  echo "❌ Direct commits to the main branch are not allowed."
+  echo "👉 Please switch to a feature branch and create a pull request."
+  exit 1
+fi
+
+npx --no-install lint-staged
+node ./scripts/vitest-run-staged.cjs

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@trieb.work/nextjs-turbo-redis-cache",
+  "version": "1.0.0",
+  "scripts": {
+    "dev": "pnpm test",
+    "build": "tsc",
+    "lint": "eslint -c eslint.config.mjs --fix",
+    "fmt": "prettier --write 'src/**/*.ts' 'src/*.ts'",
+    "test": "vitest --coverage --config vite.config.ts",
+    "test:ui": "vitest --ui  --config vite.config.ts",
+    "prepare": "./scripts/prepare.sh"
+  },
+  "main": "dist/index.js",
+  "type": "module",
+  "types": "dist/index.d.ts",
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "publishConfig": {
+    "access": "public"
+  },
+  "lint-staged": {
+    "*.{ts,tsx}": [
+      "eslint --fix",
+      "prettier --write"
+    ],
+    "*.{js,json,md}": [
+      "prettier --write"
+    ]
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^19.6.0",
+    "@commitlint/config-conventional": "^19.6.0",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^11.0.1",
+    "@semantic-release/npm": "^12.0.1",
+    "@typescript-eslint/eslint-plugin": "^8.15.0",
+    "@typescript-eslint/parser": "^8.15.0",
+    "@vitest/coverage-v8": "^2.1.5",
+    "@vitest/ui": "^2.1.5",
+    "eslint": "^9.15.0",
+    "lint-staged": "^15.2.10",
+    "prettier": "^3.3.3",
+    "semantic-release": "^24.2.0",
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.5"
+  },
+  "dependencies": {
+    "next": "^15.0.3",
+    "redis": "^4.7.0"
+  }
+}

package/release.config.cjs

@@ -0,0 +1,31 @@
+module.exports = {
+  branches: [
+    { name: 'main' }, // Stable releases
+    { name: 'beta', prerelease: true }, // Beta releases
+  ],
+  plugins: [
+    '@semantic-release/commit-analyzer', // Analyze commits to determine the release type
+    '@semantic-release/release-notes-generator', // Generate release notes
+    '@semantic-release/changelog', // Update changelog
+    [
+      '@semantic-release/npm',
+      {
+        npmPublish: true, // Publish to NPM
+        tag: 'beta', // Publish beta releases under the "beta" tag
+      },
+    ],
+    [
+      '@semantic-release/github',
+      {
+        assets: ['dist/*.tgz'], // Attach tarballs to GitHub releases
+      },
+    ],
+    [
+      '@semantic-release/git',
+      {
+        assets: ['package.json', 'package-lock.json', 'CHANGELOG.md'],
+        message: 'chore(release): ${nextRelease.version} [skip ci]',
+      },
+    ],
+  ],
+};

package/scripts/prepare.sh

@@ -0,0 +1,7 @@
+#!/bin/sh
+if [ "$CI" = "true" ]; then
+  echo "Skipping setup script execution in CI environment."
+  exit 0
+fi
+
+./scripts/setup-git.sh

package/scripts/setup-git.sh

@@ -0,0 +1,8 @@
+#!/bin/sh
+
+#hooks
+cp hooks/* .git/hooks/
+chmod +x .git/hooks/*
+
+#git rebase on pull
+git config pull.rebase true

package/scripts/setup-repo-name.sh

@@ -0,0 +1,17 @@
+#!/bin/sh
+# Get the remote repository URL
+REPO_URL=$(git config --get remote.origin.url)
+
+# Extract the repository name from the URL
+REPO_NAME=$(basename -s .git "$REPO_URL")
+echo "Renaming package to: $REPO_NAME"
+
+# Rename README_FINAL.md to README.md
+mv README_FINAL.md README.md
+
+# Replace placeholders in regular files only
+for file in *; do
+  if [ -f "$file" ]; then
+    sed -i '' "s/public-typescript-npm-package-starter/$REPO_NAME/g" "$file"
+  fi
+done

package/scripts/vitest-run-staged.cjs

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+// Helper to find the co-aligned test file
+const findTestFile = (filePath) => {
+  const ext = path.extname(filePath);
+  const testFile = filePath.replace(ext, `.test${ext}`);
+  return fs.existsSync(testFile) ? testFile : null;
+};
+
+// Run Vitest for staged test files
+(async () => {
+  const stagedFilesOutput = execSync('git diff --cached --name-only', {
+    encoding: 'utf-8',
+  });
+  const stagedFiles = stagedFilesOutput.trim().split('\n');
+
+  const stagedTsFiles = stagedFiles
+    .filter((file) => file.endsWith('.ts') && !file.endsWith('.test.ts'))
+
+  const testFiles = stagedTsFiles
+    .map((file) => findTestFile(file))
+    .filter(Boolean); // Remove nulls
+
+  const nonTestFiles = stagedTsFiles
+    .filter((file) => !findTestFile(file))
+
+  if (testFiles.length > 0) {
+    console.log('Running tests for staged files:\n  ', testFiles.join('\n  '));
+
+    const includeFiles = testFiles.map((testFile) => testFile.replace(/\.test\.ts$/, ".ts"));
+    process.env.VITEST_COVERAGE_INCLUDE = includeFiles.join(",");
+
+    execSync(`npm test -- run ${testFiles.join(' ')}`, { stdio: 'inherit' });
+  } else if (nonTestFiles.length === 0) {
+    console.log('No co-aligned test files found for staged files.');
+  }
+
+  if (nonTestFiles.length > 0) {
+    console.error('Found some staged files without a co-aligned test files:\n\t', nonTestFiles.join('\n\t'));
+  }
+})();

package/src/CachedHandler.ts

@@ -0,0 +1,25 @@
+import { CacheHandler } from "next/dist/server/lib/incremental-cache";
+import RedisStringsHandler, { CreateRedisStringsHandlerOptions } from "./RedisStringsHandler";
+
+let cachedHandler: RedisStringsHandler;
+
+export default class CachedHandler implements CacheHandler {
+  constructor(options: CreateRedisStringsHandlerOptions) {
+    if (!cachedHandler) {
+      console.log("created cached handler");
+      cachedHandler = new RedisStringsHandler(options);
+    }
+  }
+  get(...args: Parameters<RedisStringsHandler["get"]>): ReturnType<RedisStringsHandler["get"]> {
+    return cachedHandler.get(...args);
+  }
+  set(...args: Parameters<RedisStringsHandler["set"]>): ReturnType<RedisStringsHandler["set"]> {
+    return cachedHandler.set(...args);
+  }
+  revalidateTag(...args: Parameters<RedisStringsHandler["revalidateTag"]>): ReturnType<RedisStringsHandler["revalidateTag"]> {
+    return cachedHandler.revalidateTag(...args);
+  }
+  resetRequestCache(...args: Parameters<RedisStringsHandler["resetRequestCache"]>): ReturnType<RedisStringsHandler["resetRequestCache"]> {
+    return cachedHandler.resetRequestCache(...args);
+  }
+}

package/src/DeduplicatedRequestHandler.ts

@@ -0,0 +1,61 @@
+import { SyncedMap } from './SyncedMap';
+export class DeduplicatedRequestHandler<
+  T extends (...args: [never, never]) => Promise<K>,
+  K,
+> {
+  private inMemoryDeduplicationCache: SyncedMap<Promise<K>>;
+  private cachingTimeMs: number;
+  private fn: T;
+
+  constructor(
+    fn: T,
+    cachingTimeMs: number,
+    inMemoryDeduplicationCache: SyncedMap<Promise<K>>,
+  ) {
+    this.fn = fn;
+    this.cachingTimeMs = cachingTimeMs;
+    this.inMemoryDeduplicationCache = inMemoryDeduplicationCache;
+  }
+
+  // Method to manually seed a result into the cache
+  seedRequestReturn(key: string, value: K): void {
+    const resultPromise = new Promise<K>((res) => res(value));
+    this.inMemoryDeduplicationCache.set(key, resultPromise);
+    setTimeout(() => {
+      this.inMemoryDeduplicationCache.delete(key);
+    }, this.cachingTimeMs);
+  }
+
+  // Method to handle deduplicated requests
+  deduplicatedFunction = (key: string): T => {
+    //eslint-disable-next-line @typescript-eslint/no-this-alias
+    const self = this;
+    const dedupedFn = async (...args: [never, never]): Promise<K> => {
+      // If there's already a pending request with the same key, return it
+      if (
+        self.inMemoryDeduplicationCache &&
+        self.inMemoryDeduplicationCache.has(key)
+      ) {
+        const res = await self.inMemoryDeduplicationCache
+          .get(key)!
+          .then((v) => structuredClone(v));
+        return res;
+      }
+
+      // If no pending request, call the original function and store the promise
+      const promise = self.fn(...args);
+      self.inMemoryDeduplicationCache.set(key, promise);
+
+      try {
+        const result = await promise;
+        return structuredClone(result);
+      } finally {
+        // Once the promise is resolved/rejected, remove it from the map
+        setTimeout(() => {
+          self.inMemoryDeduplicationCache.delete(key);
+        }, self.cachingTimeMs);
+      }
+    };
+    return dedupedFn as T;
+  };
+}