apostrophe 4.31.0 → 4.31.1-beta.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 4.31.1-beta.1
+
+### Fixes
+
+The `@apostrophecms/oembed` module now caches failed lookups in addition to successful ones. Previously only successes were cached, so a bad or removed URL (such as a deleted YouTube video) could be requested over and over, triggering provider rate-limiting (e.g. YouTube 429 errors) and temporary lockouts. Cached entries written by older versions of Apostrophe are still tolerated, so no cache clearing is required when upgrading. In addition, the underlying error is now logged (via structured logging) before the higher-level "Video URL invalid" error is thrown, making the original cause easier to diagnose.
+
 ## 4.31.0 (2026-06-10)
 
 ### Adds
@@ -12,7 +18,7 @@
 ### Fixes
 
 - Fixed an issue where using the Tab key to navigate within modals could incorrectly jump focus to a wrong element instead of the next input field.
-Fixed Tab navigation escaping out of modals when the form contained hidden sections or elements that became disabled after editing.
+  Fixed Tab navigation escaping out of modals when the form contained hidden sections or elements that became disabled after editing.
 - Fixed adding or removing an area field from a schema breaking existing documents on an external front such as Astro.
 - For Astro: `AposArea` now renders only schema-backed areas. A missing area no longer throws, and an area orphaned by removing its field from the schema (while its content remains in the document) renders nothing instead of breaking sibling areas in edit mode. Logged-in editors get a diagnostic message in place of an orphaned area; anonymous visitors see nothing.
 - Editable documents sent to an external front (Asgtro) now materialize empty area objects for schema area fields added after the document was created, so they can be edited in context.

package/modules/@apostrophecms/oembed/index.js

@@ -86,7 +86,9 @@ module.exports = {
       // The `options` object is passed on to `oembetter.fetch`.
       //
       // Responses are automatically cached, by default for one hour. See the
-      // cacheLifetime option to the module.
+      // cacheLifetime option to the module. Failures are cached as well, so
+      // that a bad or removed URL does not lead to repeated requests that can
+      // trigger rate-limiting (e.g. YouTube 429 errors and lockouts).
       async query(req, url, options) {
         if (!options) {
           options = {};
@@ -112,18 +114,44 @@ module.exports = {
           throw self.apos.error('invalid', req.t('apostrophe:oembedVideoUrlInvalid'));
         }
         const key = url + ':' + JSON.stringify(options);
-        let response = await self.apos.cache.get('@apostrophecms/oembed', key);
-        if (response !== undefined) {
-          return response;
+        const cached = await self.apos.cache.get('@apostrophecms/oembed', key);
+        if (cached !== undefined) {
+          // Cache entries are wrapped so that both successes and failures can
+          // be remembered. Caching failures prevents a bad or removed URL
+          // (such as a deleted YouTube video) from being requested over and
+          // over, which can trigger 429 rate-limiting and temporary lockouts.
+          //
+          // Legacy entries written before this wrapping existed are the raw
+          // oembed response object, so tolerate them by returning them as-is.
+          if (cached && cached.aposOembedCache) {
+            if (cached.error) {
+              throw self.apos.error('invalid', req.t('apostrophe:oembedVideoUrlInvalid'));
+            }
+            return cached.response;
+          }
+          return cached;
         }
-        if (options.alwaysIframe) {
-          response = await self.iframe(req, url, options);
-        } else {
-          try {
+        let response;
+        try {
+          if (options.alwaysIframe) {
+            response = await self.iframe(req, url, options);
+          } else {
             response = await require('util').promisify(self.oembetter.fetch)(url, options);
-          } catch (err) {
-            throw self.apos.error('invalid', req.t('apostrophe:oembedVideoUrlInvalid'));
           }
+        } catch (err) {
+          // Log the underlying cause first, since the higher-level error
+          // thrown below would otherwise obscure it.
+          self.logError(req, 'query-failed', err.message, {
+            url,
+            stack: err.stack
+          });
+          // Cache the failure too, so we don't keep hammering the provider
+          // for a URL that is currently failing.
+          await self.apos.cache.set('@apostrophecms/oembed', key, {
+            aposOembedCache: true,
+            error: true
+          }, self.options.cacheLifetime);
+          throw self.apos.error('invalid', req.t('apostrophe:oembedVideoUrlInvalid'));
         }
         // Make non-secure URLs protocol relative and
         // let the browser upgrade them to https if needed
@@ -137,8 +165,13 @@ module.exports = {
         if (response.html) {
           response.html = makeProtocolRelative(response.html);
         }
-        // cache oembed responses for one hour
-        await self.apos.cache.set('@apostrophecms/oembed', key, response, self.options.cacheLifetime);
+        // Cache the successful response (by default for one hour; see the
+        // cacheLifetime option).
+        await self.apos.cache.set('@apostrophecms/oembed', key, {
+          aposOembedCache: true,
+          error: false,
+          response
+        }, self.options.cacheLifetime);
         return response;
       },
       // Not currently used. Present for backwards compatibility

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apostrophe",
-  "version": "4.31.0",
+  "version": "4.31.1-beta.1",
   "description": "The Apostrophe Content Management System.",
   "main": "index.js",
   "repository": {
@@ -120,15 +120,15 @@
     "webpack": "^5.106.1",
     "webpack-merge": "^5.7.3",
     "xregexp": "^2.0.0",
-    "broadband": "^1.1.0",
-    "launder": "^1.7.1",
     "@apostrophecms/db-connect": "^1.0.1",
-    "oembetter": "^1.2.0",
+    "broadband": "^1.1.0",
     "boring": "^1.1.1",
     "express-cache-on-demand": "^1.0.4",
+    "launder": "^1.7.1",
+    "postcss-viewport-to-container-toggle": "^2.3.0",
+    "oembetter": "^1.2.0",
     "sanitize-html": "^2.17.5",
-    "uploadfs": "^1.26.1",
-    "postcss-viewport-to-container-toggle": "^2.3.0"
+    "uploadfs": "^1.26.1"
   },
   "devDependencies": {
     "chai": "^4.3.10",
@@ -137,8 +137,8 @@
     "mocha": "^11.7.5",
     "nyc": "^17.1.0",
     "stylelint": "^16.5.0",
-    "eslint-config-apostrophe": "^6.0.2",
-    "stylelint-config-apostrophe": "^4.4.0"
+    "stylelint-config-apostrophe": "^4.4.0",
+    "eslint-config-apostrophe": "^6.0.2"
   },
   "browserslist": [
     "ie >= 10"

package/test/oembed.js

@@ -53,4 +53,102 @@ describe('Oembed', function() {
   //   const data = JSON.parse(response.body);
   //   assert(data.type === 'video');
   // });
+
+  it('should cache successful responses and not re-fetch them', async function() {
+    const req = apos.task.getReq();
+    const url = 'https://example.com/good-video';
+    let calls = 0;
+    const original = apos.oembed.oembetter.fetch;
+    apos.oembed.oembetter.fetch = (fetchUrl, options, cb) => {
+      calls++;
+      return cb(null, {
+        type: 'video',
+        title: 'Success',
+        html: '<iframe src="//example.com/embed"></iframe>'
+      });
+    };
+
+    try {
+      const first = await apos.oembed.query(req, url);
+      assert.strictEqual(first.title, 'Success');
+      assert.strictEqual(calls, 1);
+
+      // Second call must be served from the cache, not re-fetched
+      const second = await apos.oembed.query(req, url);
+      assert.strictEqual(second.title, 'Success');
+      assert.strictEqual(calls, 1);
+    } finally {
+      apos.oembed.oembetter.fetch = original;
+    }
+  });
+
+  it('should cache failures so a bad URL is not requested repeatedly, and log the original error', async function() {
+    const req = apos.task.getReq();
+    const url = 'https://example.com/bad-video';
+    let calls = 0;
+    const original = apos.oembed.oembetter.fetch;
+    apos.oembed.oembetter.fetch = (fetchUrl, options, cb) => {
+      calls++;
+      return cb(new Error('simulated provider failure'));
+    };
+
+    // Capture structured log output to confirm the original error is logged
+    const originalLogError = apos.oembed.logError;
+    const logged = [];
+    apos.oembed.logError = (...args) => logged.push(args);
+
+    try {
+      await assert.rejects(
+        () => apos.oembed.query(req, url),
+        { name: 'invalid' }
+      );
+      assert.strictEqual(calls, 1);
+
+      // The underlying cause is logged before the higher-level error is thrown
+      assert.strictEqual(logged.length, 1);
+      const [ loggedReq, eventType, message ] = logged[0];
+      assert.strictEqual(loggedReq, req);
+      assert.strictEqual(eventType, 'query-failed');
+      assert.strictEqual(message, 'simulated provider failure');
+
+      // Second call must be served from the cached failure, not re-fetched
+      await assert.rejects(
+        () => apos.oembed.query(req, url),
+        { name: 'invalid' }
+      );
+      assert.strictEqual(calls, 1);
+    } finally {
+      apos.oembed.oembetter.fetch = original;
+      apos.oembed.logError = originalLogError;
+    }
+  });
+
+  it('should tolerate legacy (unwrapped) cache entries without crashing', async function() {
+    const req = apos.task.getReq();
+    const url = 'https://example.com/legacy-video';
+    const legacyResponse = {
+      type: 'video',
+      title: 'Legacy',
+      html: '<iframe src="//example.com/legacy"></iframe>'
+    };
+
+    // Simulate a raw response cached by an older version of this module
+    const originalGet = apos.cache.get;
+    apos.cache.get = async () => legacyResponse;
+
+    // Fetching must not happen when the cache already has data
+    const originalFetch = apos.oembed.oembetter.fetch;
+    apos.oembed.oembetter.fetch = (fetchUrl, options, cb) => {
+      return cb(new Error('should not be called for a cache hit'));
+    };
+
+    try {
+      const result = await apos.oembed.query(req, url);
+      assert.strictEqual(result.title, 'Legacy');
+      assert.strictEqual(result.type, 'video');
+    } finally {
+      apos.cache.get = originalGet;
+      apos.oembed.oembetter.fetch = originalFetch;
+    }
+  });
 });