@quintype/framework 7.4.2-ttl.0 → 7.5.0-internal-api.1

package/README.md

@@ -286,7 +286,7 @@ Preloading app.js and /route-data.json can be triggered by passing preloadJS tru
 
 ### multiple publishers
 
-FIXME: Write notes on `host_to_api_host`, `host_to_automatic_api_host` and `skip_warm_config`
+FIXME: Write notes on `host_to_api_host`, `host_to_automatic_api_host`, `wildcard_automatic_api_host` and `skip_warm_config`
 
 ### forwardFavicon
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quintype/framework",
-  "version": "7.4.2-ttl.0",
+  "version": "7.5.0-internal-api.1",
   "description": "Libraries to help build Quintype Node.js apps",
   "main": "index.js",
   "engines": {

package/server/impl/api-client-impl.js

@@ -20,9 +20,7 @@ const {
 const _ = require("lodash");
 
 function getClientImpl(config, cachedSecondaryClients, hostname) {
-  return (
-    cachedSecondaryClients[hostname] || createTemporaryClient(config, hostname)
-  );
+  return cachedSecondaryClients[hostname] || createTemporaryClient(config, hostname);
 }
 
 function createTemporaryClient(config, hostname) {
@@ -31,11 +29,13 @@ function createTemporaryClient(config, hostname) {
     return new Client(configuredHosts[hostname], true);
   }
 
-  const matchedString = (config.host_to_automatic_api_host || []).find((str) =>
-    hostname.includes(str)
-  );
-  if (matchedString)
-    return new Client(`https://${hostname.replace(matchedString, "")}`, true);
+  const matchedMadridUrl = (config.wildcard_automatic_api_host || []).find((str) => hostname.includes(str));
+
+  if (matchedMadridUrl) return new Client(`http://${hostname.replace(matchedMadridUrl, ".internal")}`, true);
+
+  const matchedString = (config.host_to_automatic_api_host || []).find((str) => hostname.includes(str));
+
+  if (matchedString) return new Client(`https://${hostname.replace(matchedString, "")}`, true);
 }
 
 function itemToCacheKey(publisherId, item, depth) {
@@ -58,10 +58,7 @@ function getItemCacheKeys(publisherId, items, depth) {
         storyCacheKeys.push(storyToCacheKey(publisherId, item.story));
         break;
       case "collection":
-        const collectionKeys = Collection.build(item).getCollectionCacheKeys(
-          publisherId,
-          depth - 1
-        );
+        const collectionKeys = Collection.build(item).getCollectionCacheKeys(publisherId, depth - 1);
         storyCacheKeys.push(...collectionKeys.storyCacheKeys);
         collectionCacheKeys.push(...collectionKeys.collectionCacheKeys);
         break;
@@ -78,40 +75,36 @@ Collection.prototype.getCollectionCacheKeys = function (publisherId, depth) {
       collectionCacheKeys: [collectionToCacheKey(publisherId, this)],
     };
   }
-  const { storyCacheKeys, collectionCacheKeys } = getItemCacheKeys(
-    publisherId,
-    this.items,
-    depth
-  );
+  const { storyCacheKeys, collectionCacheKeys } = getItemCacheKeys(publisherId, this.items, depth);
   collectionCacheKeys.unshift(collectionToCacheKey(publisherId, this));
   return { storyCacheKeys, collectionCacheKeys };
 };
 
-Collection.prototype.isAutomated = function() {
+Collection.prototype.isAutomated = function () {
   return !!this.automated;
 };
 
-Collection.prototype.getChildCollections = function() {
+Collection.prototype.getChildCollections = function () {
   return this.items && this.items.filter((i) => i.type === "collection");
 };
 
-Collection.prototype.getCacheableChildItems = function() {
+Collection.prototype.getCacheableChildItems = function () {
   return this.isAutomated() ? this.getChildCollections() : this.items;
 };
 
-Collection.prototype.isLeafCollection = function() {
+Collection.prototype.isLeafCollection = function () {
   return !this.getCacheableChildItems() && !this["collection-cache-keys"];
 };
 
 Collection.prototype.cacheKeys = function (publisherId, depth) {
   if (depth < 0 || this.isLeafCollection()) {
-    return [collectionToCacheKey(publisherId,this)];
+    return [collectionToCacheKey(publisherId, this)];
   }
-  const remainingDepth = _.isNumber(depth) ? (depth - 1) : depth;
-  return ([
+  const remainingDepth = _.isNumber(depth) ? depth - 1 : depth;
+  return [
     ...(this["collection-cache-keys"] ? this["collection-cache-keys"] : []),
     ..._.flatMap(this.getCacheableChildItems(), (item) => itemToCacheKey(publisherId, item, remainingDepth)),
-  ]);
+  ];
 };
 
 Story.prototype.cacheKeys = function (publisherId) {

package/server/routes.js

@@ -87,13 +87,7 @@ exports.upstreamQuintypeRoutes = function upstreamQuintypeRoutes(
   });
 
   // Mention the routes which don't want to override the s-maxage value
-  const excludeRoutes = [
-    "/qlitics.js",
-    "/api/v1/breaking-news",
-    "/stories.rss",
-    "/collection.rss",
-    "/api/v1/advanced-search",
-  ];
+  const excludeRoutes = ["/qlitics.js", "/api/v1/breaking-news"];
 
   app.all("/api/*", sketchesProxy);
   app.all("/login", sketchesProxy);

package/test/unit/api-client-test.js

@@ -1,41 +1,22 @@
 const assert = require("assert");
 
-const {
-  getClientImpl,
-  Client,
-  Story,
-  Author,
-  Collection,
-  CustomPath,
-} = require("../../server/impl/api-client-impl");
+const { getClientImpl, Client, Story, Author, Collection, CustomPath } = require("../../server/impl/api-client-impl");
 
 describe("ApiClient", function () {
   describe("getClient", function () {
     it("returns a cachedSecondaryClient if present", function () {
       const expectedClient = new Client("foo.staging.quintype.io", true);
-      const client = getClientImpl(
-        {},
-        { "foo.com": expectedClient },
-        "foo.com"
-      );
+      const client = getClientImpl({}, { "foo.com": expectedClient }, "foo.com");
       assert.equal(expectedClient, client);
     });
 
     it("creates a temporary client if it matches a string", function () {
-      const client = getClientImpl(
-        { host_to_automatic_api_host: ["-web"] },
-        {},
-        "foo-web.staging.quintype.io"
-      );
+      const client = getClientImpl({ host_to_automatic_api_host: ["-web"] }, {}, "foo-web.staging.quintype.io");
       assert.equal("https://foo.staging.quintype.io", client.baseUrl);
     });
 
     it("creates a temporary client if it matches a string with a .", function () {
-      const client = getClientImpl(
-        { host_to_automatic_api_host: [".madrid"] },
-        {},
-        "foo.madrid.quintype.io"
-      );
+      const client = getClientImpl({ host_to_automatic_api_host: [".madrid"] }, {}, "foo.madrid.quintype.io");
       assert.equal("https://foo.quintype.io", client.baseUrl);
     });
 
@@ -52,6 +33,15 @@ describe("ApiClient", function () {
       assert.equal("https://foo.quintype.io", client.baseUrl);
     });
 
+    it("creates a wildcard temporary client if it matches a string", function () {
+      const client = getClientImpl(
+        { wildcard_automatic_api_host: [".madrid", "-madrid"] },
+        {},
+        "foo.madrid.quintype.io"
+      );
+      assert.equal("http://foo.internal.quintype.io", client.baseUrl);
+    });
+
     it("returns null if no client is found", function () {
       const client = getClientImpl({}, {}, "www.unknown.com");
       assert.equal(null, client);
@@ -147,13 +137,13 @@ describe("ApiClient", function () {
     it("should return as leaf collection when it has no items and has no collection cache keys", () => {
       const collection = Collection.build({
         id: 851,
-        'associated-metadata': {},
-        type: 'collection',
-        name: 'review-fashion',
-        slug: 'review-fashion',
-        template: 'default',
-        metadata: { 'cover-image': null },
-        'collection-date': null
+        "associated-metadata": {},
+        type: "collection",
+        name: "review-fashion",
+        slug: "review-fashion",
+        template: "default",
+        metadata: { "cover-image": null },
+        "collection-date": null,
       });
 
       assert.strictEqual(collection.isLeafCollection(), true);
@@ -162,16 +152,16 @@ describe("ApiClient", function () {
     it("should not be a leaf collection when collection has items or collection cache keys", () => {
       const collectionWithCacheKeys = Collection.build({
         id: 851,
-        'associated-metadata': {},
-        type: 'collection',
-        slug: 'review-fashion',
+        "associated-metadata": {},
+        type: "collection",
+        slug: "review-fashion",
         "collection-cache-keys": ["c/1/851", "sc/1/1233"],
       });
       const collectionWithItems = Collection.build({
         id: 851,
-        'associated-metadata': {},
-        type: 'collection',
-        slug: 'review-fashion',
+        "associated-metadata": {},
+        type: "collection",
+        slug: "review-fashion",
         items: [{ type: "story", story: { id: "xyz1235" } }],
       });
 
@@ -208,10 +198,10 @@ describe("ApiClient", function () {
         ],
       });
 
-      assert.strictEqual(collection.getCacheableChildItems(1).filter((c) => c.type === 'collection').length, 1);
+      assert.strictEqual(collection.getCacheableChildItems(1).filter((c) => c.type === "collection").length, 1);
       assert.strictEqual(collection.getCacheableChildItems(1)[0].id, "851");
 
-      assert.strictEqual(collection.getCacheableChildItems().filter((c) => c.type === 'collection').length, 1);
+      assert.strictEqual(collection.getCacheableChildItems().filter((c) => c.type === "collection").length, 1);
       assert.strictEqual(collection.getCacheableChildItems()[0].id, "851");
     });
 
@@ -271,10 +261,7 @@ describe("ApiClient", function () {
           },
         ],
       });
-      assert.deepEqual(
-        ["c/1/42", "s/1/264f46f9", "s/1/1e5acfe4"],
-        collection.cacheKeys(1)
-      );
+      assert.deepEqual(["c/1/42", "s/1/264f46f9", "s/1/1e5acfe4"], collection.cacheKeys(1));
     });
 
     it("should include all nested stories and collection ids as cache tags for a manual collection", function () {
@@ -305,7 +292,7 @@ describe("ApiClient", function () {
                 story: { id: "fd4fa2c4-5441-434a-bf76-7660bbf1a09d" },
               },
             ],
-          }
+          },
         ],
       });
       assert.deepEqual(
@@ -330,10 +317,7 @@ describe("ApiClient", function () {
           },
         ],
       });
-      assert.deepEqual(
-        ["c/1/42", "sc/1/38586"],
-        collection.cacheKeys(1)
-      );
+      assert.deepEqual(["c/1/42", "sc/1/38586"], collection.cacheKeys(1));
     });
 
     it("should include all nested collection cache keys excluding story keys as cache keys for automated collection", function () {
@@ -365,13 +349,10 @@ describe("ApiClient", function () {
                 story: { id: "fd4fa2c4-5441-434a-bf76-7660bbf1a09d" },
               },
             ],
-          }
+          },
         ],
       });
-      assert.deepEqual(
-        ["c/1/42", "sc/1/38586", "c/1/43", "e/1/123"],
-        collection.cacheKeys(1)
-      );
+      assert.deepEqual(["c/1/42", "sc/1/38586", "c/1/43", "e/1/123"], collection.cacheKeys(1));
     });
 
     it("should return cache keys when an automated collection has a manual collection", function () {
@@ -403,13 +384,10 @@ describe("ApiClient", function () {
                 story: { id: "fd4fa2c4-5441-434a-bf76-7660bbf1a09d" },
               },
             ],
-          }
+          },
         ],
       });
-      assert.deepEqual(
-        ["c/1/42", "sc/1/38586", "c/1/43", "s/1/0c2809d8", "s/1/fd4fa2c4"],
-        collection.cacheKeys(1)
-      );
+      assert.deepEqual(["c/1/42", "sc/1/38586", "c/1/43", "s/1/0c2809d8", "s/1/fd4fa2c4"], collection.cacheKeys(1));
     });
 
     it("should return cache keys when a manual collection has an automated collection under it", function () {
@@ -440,13 +418,10 @@ describe("ApiClient", function () {
                 story: { id: "fd4fa2c4-5441-434a-bf76-7660bbf1a09d" },
               },
             ],
-          }
+          },
         ],
       });
-      assert.deepEqual(
-        ["c/1/42", "s/1/264f46f9", "s/1/1e5acfe4", "c/1/43", "sc/1/38586"],
-        collection.cacheKeys(1)
-      );
+      assert.deepEqual(["c/1/42", "s/1/264f46f9", "s/1/1e5acfe4", "c/1/43", "sc/1/38586"], collection.cacheKeys(1));
     });
 
     it("should include nested collection and stories cache tags only upto depth when depth is passed", function () {
@@ -473,7 +448,7 @@ describe("ApiClient", function () {
                     automated: false,
                     id: "700",
                     items: [
-                      { type: "story", story: { id: "abcdef12" }},
+                      { type: "story", story: { id: "abcdef12" } },
                       {
                         type: "collection",
                         "collection-cache-keys": ["c/1/850", "sc/1/112"],
@@ -499,13 +474,13 @@ describe("ApiClient", function () {
                       { type: "story", story: { id: "xyz12" } },
                       {
                         id: 851,
-                        'associated-metadata': {},
-                        type: 'collection',
-                        name: 'review-fashion',
-                        slug: 'review-fashion',
-                        template: 'default',
-                        metadata: { 'cover-image': null },
-                        'collection-date': null
+                        "associated-metadata": {},
+                        type: "collection",
+                        name: "review-fashion",
+                        slug: "review-fashion",
+                        template: "default",
+                        metadata: { "cover-image": null },
+                        "collection-date": null,
                       },
                     ],
                   },
@@ -516,21 +491,21 @@ describe("ApiClient", function () {
         ],
       });
       assert.deepEqual(
-          [
-            "c/1/42",
-            "sc/1/38586",
-            "c/1/500",
-            "sc/1/38587",
-            "c/1/600",
-            "sc/1/38588",
-            "c/1/700",
-            "s/1/abcdef12",
-            "c/1/850",
-            "c/1/800",
-            "c/1/900",
-            "s/1/xyz12",
-            "c/1/851"
-          ],
+        [
+          "c/1/42",
+          "sc/1/38586",
+          "c/1/500",
+          "sc/1/38587",
+          "c/1/600",
+          "sc/1/38588",
+          "c/1/700",
+          "s/1/abcdef12",
+          "c/1/850",
+          "c/1/800",
+          "c/1/900",
+          "s/1/xyz12",
+          "c/1/851",
+        ],
         collection.cacheKeys(1, 3)
       );
     });
@@ -559,7 +534,7 @@ describe("ApiClient", function () {
                     automated: false,
                     id: "700",
                     items: [
-                      { type: "story", story: { id: "abcdef12" }},
+                      { type: "story", story: { id: "abcdef12" } },
                       {
                         type: "collection",
                         "collection-cache-keys": ["c/1/850", "sc/1/112"],
@@ -629,7 +604,7 @@ describe("ApiClient", function () {
               },
             ],
           },
-          { type: "story", story: { id: "abcdef12" }},
+          { type: "story", story: { id: "abcdef12" } },
         ],
       });
 
@@ -650,10 +625,7 @@ describe("ApiClient", function () {
           },
         ],
       });
-      assert.deepEqual(
-        ["c/1/42", "sc/1/38586", "c/1/500", "s/1/abcdef12"],
-        collection.cacheKeys(1)
-      );
+      assert.deepEqual(["c/1/42", "sc/1/38586", "c/1/500", "s/1/abcdef12"], collection.cacheKeys(1));
     });
 
     it("should add all nested collection cache tags even when leaf collection does not have much data", function () {
@@ -670,22 +642,19 @@ describe("ApiClient", function () {
               { type: "story", story: { id: "abcdef12" } },
               {
                 id: 147182,
-                'associated-metadata': {},
-                type: 'collection',
-                name: 'review-fashion',
-                slug: 'review-fashion',
-                template: 'default',
-                metadata: { 'cover-image': null },
-                'collection-date': null
-              }
+                "associated-metadata": {},
+                type: "collection",
+                name: "review-fashion",
+                slug: "review-fashion",
+                template: "default",
+                metadata: { "cover-image": null },
+                "collection-date": null,
+              },
             ],
           },
         ],
       });
-      assert.deepEqual(
-        ["c/1/42", "sc/1/38586", "c/1/500", "s/1/abcdef12", "c/1/147182"],
-        collection.cacheKeys(1)
-      );
+      assert.deepEqual(["c/1/42", "sc/1/38586", "c/1/500", "s/1/abcdef12", "c/1/147182"], collection.cacheKeys(1));
     });
 
     it("can also find the cache key for a sorter", function () {