@towa-digital/storyblok-nuxt-cv 0.5.0 → 0.5.2

package/README.md

@@ -87,9 +87,32 @@ export default defineNuxtConfig({
 |---|---|---|
 | Single Node process (DO app platform, plain node-server) | default (memory) | webhook (default setup) |
 | PM2 **cluster** on one host (`instances: 'max'`) | **`fsStore: true`** (or a manual `fs` mount) | webhook |
-| Multi-node / containers | mount Redis | webhook |
+| Multi-node / containers | mount Redis (see below) | webhook |
 | Cloudflare / Vercel Edge / Netlify (isolates) | default | **`ttl` (seconds, e.g. `60`)** — a webhook can't reach every isolate |
 
+### Redis mounts: make the driver fail fast
+
+A store read happens on every page render. Since 0.5.1 a read failure can't
+break the render — the module falls back to the `cv` the process fetched itself
+— but ioredis still retries **20 times per request** by default, so an
+unreachable Redis adds seconds of latency per render before that fallback runs.
+Configure it to give up immediately, and set `ttl` so each instance stays fresh
+on its own if the store is gone:
+
+```ts
+nitro: {
+  storage: {
+    'storyblok-cv': {
+      driver: 'redis',
+      host: process.env.REDIS_HOST,
+      maxRetriesPerRequest: 1,   // default 20 — fail fast, don't stall renders
+      enableOfflineQueue: false, // reject while disconnected instead of queueing
+    },
+  },
+},
+storyblokCv: { ttl: 60 },
+```
+
 On a **PM2 cluster** memory is per-worker, so a webhook only updates one worker.
 The simplest correct fix is **`fsStore`** — the module mounts an `fs` store at a
 path resolved **at runtime**, inside the app's own directory (owned by the

package/dist/module.json

@@ -4,7 +4,7 @@
   "compatibility": {
     "nuxt": ">=3.10.0"
   },
-  "version": "0.5.0",
+  "version": "0.5.2",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/runtime/server/api/cv.get.js

@@ -1,6 +1,6 @@
 import { defineEventHandler } from "#imports";
 import { readStoryblokCv } from "../utils/cv.js";
-export default defineEventHandler(async () => {
-  const record = await readStoryblokCv();
+export default defineEventHandler(async (event) => {
+  const record = await readStoryblokCv(event);
   return { cv: record?.cv ?? 0, fetchedAt: record?.fetchedAt ?? 0 };
 });

package/dist/runtime/server/api/webhook.post.js

@@ -11,7 +11,7 @@ import {
 import { refreshStoryblokCv } from "../utils/cv.js";
 const CONTENT_ACTIONS = ["published", "unpublished", "deleted", "moved"];
 export default defineEventHandler(async (event) => {
-  const { webhookSecret } = useRuntimeConfig().storyblokCv;
+  const { webhookSecret } = useRuntimeConfig(event).storyblokCv;
   if (!webhookSecret) {
     console.error("[storyblok-cv] webhook called but NUXT_STORYBLOK_CV_WEBHOOK_SECRET is not set");
     throw createError({ status: 500, message: "Webhook secret not configured" });
@@ -44,7 +44,7 @@ export default defineEventHandler(async (event) => {
     setResponseStatus(event, 204);
     return null;
   }
-  const cv = await refreshStoryblokCv();
+  const cv = await refreshStoryblokCv(event);
   return { ok: true, cv };
 });
 function safeEqual(a, b) {

package/dist/runtime/server/middleware/cv.js

@@ -7,18 +7,18 @@ export default defineEventHandler(async (event) => {
   if (path.startsWith("/api/") || path.startsWith("/_") || path.startsWith("/__")) {
     if (Date.now() - lastMapSyncCheck > MAP_SYNC_INTERVAL) {
       lastMapSyncCheck = Date.now();
-      readStoryblokCv().catch(() => {
+      readStoryblokCv(event).catch(() => {
       });
     }
     return;
   }
-  const { ttl } = useRuntimeConfig().storyblokCv;
-  const record = await readStoryblokCv();
+  const { ttl } = useRuntimeConfig(event).storyblokCv;
+  const record = await readStoryblokCv(event);
   if (record?.cv) {
     event.context.storyblokCv = record.cv;
   }
   if (ttl > 0 && (!record || Date.now() - record.fetchedAt > ttl)) {
-    const refresh = refreshStoryblokCv().catch((error) => {
+    const refresh = refreshStoryblokCv(event).catch((error) => {
       console.error("[storyblok-cv] ttl refresh failed:", error);
       return 0;
     });

package/dist/runtime/server/utils/cv.d.ts

@@ -1,3 +1,4 @@
+import type { H3Event } from 'h3';
 export interface StoryblokCvRecord {
     cv: number;
     fetchedAt: number;
@@ -7,15 +8,24 @@ export interface StoryblokCvRecord {
  * storyblok-js-client never caches or cv-pins — and this raw fetch doesn't
  * touch any client copy at all, so it works with client v5 through v7 alike.
  */
-export declare function getLiveStoryblokCv(): Promise<number>;
-/** Stored `cv` record from the storage mount, or `null` before the first refresh. */
-export declare function readStoryblokCv(): Promise<StoryblokCvRecord | null>;
-export declare function syncServerClientCv(cv: number): void;
+export declare function getLiveStoryblokCv(event?: H3Event): Promise<number>;
+/**
+ * Stored `cv` record from the storage mount, or `null` before the first
+ * refresh.
+ *
+ * Never throws: this runs on the render path (Nitro middleware), so a store
+ * that is down, misconfigured or not writable must not take page renders with
+ * it — it degrades to the in-process `cv` instead. Read failures are logged at
+ * most once a minute; per-render logging would flood the output.
+ */
+export declare function readStoryblokCv(event?: H3Event): Promise<StoryblokCvRecord | null>;
+export declare function syncServerClientCv(cv: number, event?: H3Event): void;
 /**
  * Fetch the live `cv` and persist it to storage. Auto-imported in server code —
  * call this from your own publish-webhook handler when the built-in webhook
- * route is disabled. Concurrent calls are deduped.
+ * route is disabled. Concurrent calls are deduped. Pass the request `event`
+ * when you have one, so runtime env vars apply on edge runtimes.
  *
  * @returns the live `cv` (`0` if the API reported none)
  */
-export declare function refreshStoryblokCv(): Promise<number>;
+export declare function refreshStoryblokCv(event?: H3Event): Promise<number>;

package/dist/runtime/server/utils/cv.js

@@ -1,10 +1,10 @@
 import { $fetch } from "ofetch";
 import { useRuntimeConfig, useStorage } from "#imports";
 const KEY = "current";
-const cfg = () => useRuntimeConfig().storyblokCv;
+const cfg = (event) => useRuntimeConfig(event).storyblokCv;
 const store = () => useStorage(cfg().storage);
-export async function getLiveStoryblokCv() {
-  const { token, endpoint } = cfg();
+export async function getLiveStoryblokCv(event) {
+  const { token, endpoint } = cfg(event);
   if (!token) {
     throw new Error("[storyblok-cv] no access token configured");
   }
@@ -14,14 +14,29 @@ export async function getLiveStoryblokCv() {
   });
   return response?.space?.version ?? 0;
 }
-export async function readStoryblokCv() {
-  const record = await store().getItem(KEY);
-  if (record?.cv) syncServerClientCv(record.cv);
+let inProcess = null;
+let lastReadErrorAt = 0;
+const READ_ERROR_LOG_INTERVAL = 6e4;
+export async function readStoryblokCv(event) {
+  let record = null;
+  try {
+    record = await store().getItem(KEY);
+  } catch (error) {
+    if (Date.now() - lastReadErrorAt > READ_ERROR_LOG_INTERVAL) {
+      lastReadErrorAt = Date.now();
+      console.error(
+        "[storyblok-cv] storage read FAILED \u2014 falling back to the cv this process fetched itself; check the storage mount:",
+        error
+      );
+    }
+  }
+  if (inProcess && inProcess.cv > (record?.cv ?? 0)) record = inProcess;
+  if (record?.cv) syncServerClientCv(record.cv, event);
   return record;
 }
 let serverClient = null;
 let lastSyncedCv = 0;
-export function syncServerClientCv(cv) {
+export function syncServerClientCv(cv, event) {
   if (!cv || cv === lastSyncedCv || serverClient === false) return;
   if (serverClient) {
     lastSyncedCv = cv;
@@ -30,7 +45,7 @@ export function syncServerClientCv(cv) {
   }
   import("storyblok-js-client").then((mod) => {
     const StoryblokClient = mod?.default;
-    const { token } = cfg();
+    const { token } = cfg(event);
     if (!StoryblokClient || !token) {
       serverClient = false;
       return;
@@ -43,12 +58,14 @@ export function syncServerClientCv(cv) {
   });
 }
 let pending = null;
-export function refreshStoryblokCv() {
-  pending ??= getLiveStoryblokCv().then(async (cv) => {
+export function refreshStoryblokCv(event) {
+  pending ??= getLiveStoryblokCv(event).then(async (cv) => {
     if (cv) {
-      syncServerClientCv(cv);
+      syncServerClientCv(cv, event);
+      const record = { cv, fetchedAt: Date.now() };
+      inProcess = record;
       try {
-        await store().setItem(KEY, { cv, fetchedAt: Date.now() });
+        await store().setItem(KEY, record);
       } catch (error) {
         console.error(
           "[storyblok-cv] fetched cv but FAILED to persist it \u2014 check the storage mount is writable by the runtime user:",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@towa-digital/storyblok-nuxt-cv",
-  "version": "0.5.0",
-  "description": "Keeps Storyblok published content fresh on long-running Nuxt servers by bridging the live cache version (cv) to the render client \u2014 no redeploy after publish.",
+  "version": "0.5.2",
+  "description": "Keeps Storyblok published content fresh on long-running Nuxt servers by bridging the live cache version (cv) to the render client — no redeploy after publish.",
   "repository": "github:towa-digital/storyblok-nuxt-cv",
   "author": {
     "name": "Matthias Frank",