feat(server): remove references to unpublished content

Author: dlehmhus

package.json

@@ -29,7 +29,7 @@
     "testserver:ci": "npm --prefix demo run testserver:ci",
     "e2e": "npm run build:test-client && with-server --run=testserver:ci npm run cypress -- -- ",
     "cypress": "cypress run --config=baseUrl=$SERVER_URL",
-    "e2e:dev": "with-server --run=testserver npm run cypress:dev",
+    "e2e:dev": "npm run build:test-client && with-server --run=testserver:ci npm run cypress:dev",
     "cypress:dev": "cypress open --config=baseUrl=$SERVER_URL",
     "create-test-seeds": "./scripts/createSeeds.js ./cypress/support/knexfile.js"
   },

src/content/convert.ts

@@ -7,21 +7,18 @@ import {
   PreviewOpts,
   ContentFormat
 } from "../../typings";
-import visit from "../model/visit";
+import visit, { NO_STORE_VALUE } from "../model/visit";
 import formatQuillDelta from "./formatQuillDelta";
 import getRefUrl from "./getRefUrl";
 
 /**
  * Converts a content from its internal representation to a format
  * requested by the client.
- *
- * NOTE: Currently `richtext` is the only type that gets converted.
- * This could also be a good place to convert `media` ids to full URLs.
  */
 
 type ConvertProps = {
   content: Data;
-  contentRefs?: ContentRefs;
+  contentRefs: ContentRefs;
   contentModel: Model;
   allModels: Model[];
   contentFormat: ContentFormat;
@@ -106,24 +103,35 @@ export default function convert({
           _content: ref.model
         };
 
+        // Refs can only contain an id but no model,
+        // this means the ref is not actually a ref but a string
         const isAbsoluteRef = !ref.model;
-
         if (isAbsoluteRef) {
           convertedRef._url = ref.id;
           return convertedRef;
         }
 
-        // For external data sources content references don't exist
-        if (!contentRefs || !contentRefs[ref.model]) return convertedRef;
-
-        const refModel = allModels.find(
+        const referencedModel = allModels.find(
           m => m.name.toLowerCase() === ref.model.toLowerCase()
         );
-        if (!refModel || !refModel.urlPath) return convertedRef;
+
+        // For external data sources content references don't exist
+        if (referencedModel!.external) return convertedRef;
+
+        // No content for the ref was provided,
+        // this means the referenced content does not exists anymore.
+        // This happens when content get deleted or is scheduled
+        if (!referencedModel || !contentRefs[ref.model]) return NO_STORE_VALUE;
+
+        // If the referenced content has no `urlPath`,
+        // we don't need to add the `_url`
+        if (!referencedModel.urlPath) return convertedRef;
 
         const allRefData = contentRefs[ref.model][ref.id];
-        const url = getRefUrl((allRefData || {}).data, refModel.urlPath);
-        convertedRef._url = url;
+        convertedRef._url = getRefUrl(
+          (allRefData || {}).data,
+          referencedModel.urlPath
+        );
 
         return convertedRef;
       }

src/content/rest/__tests__/apiHelper.ts

@@ -145,5 +145,30 @@ export function createApiWriteHelpers(
 
     return body;
   };
-  return { create, update };
+
+  const schedule = async (
+    type: string,
+    id: string,
+    data: {
+      visibleFrom?: Date | string | null;
+      visibleUntil?: Date | string | null;
+    }
+  ) => {
+    const { body } = await server
+      .post(`/admin/rest/content/${type}/${id}/schedule`)
+      .set(headers)
+      .send(data)
+      .expect(204);
+
+    return body;
+  };
+
+  const publish = async (type: string, id: string) =>
+    server
+      .post(`/admin/rest/content/${type}/${id}/publish`)
+      .set(headers)
+      .send({ rev: 1 })
+      .expect(204);
+
+  return { create, update, schedule, publish };
 }

src/content/rest/__tests__/joins.test.ts

@@ -43,6 +43,8 @@ describe("joins", () => {
   let headers: object;
   let find: ReturnType<typeof createApiReadHelpers>["find"];
   let create: ReturnType<typeof createApiWriteHelpers>["create"];
+  let schedule: ReturnType<typeof createApiWriteHelpers>["schedule"];
+  let publish: ReturnType<typeof createApiWriteHelpers>["publish"];
 
   let a: any;
   let b: any;
@@ -73,7 +75,7 @@ describe("joins", () => {
     ));
 
     ({ find } = createApiReadHelpers(server));
-    ({ create } = createApiWriteHelpers(server, headers));
+    ({ create, schedule, publish } = createApiWriteHelpers(server, headers));
 
     c = await create(modelC.name, {
       title: faker.lorem.slug()
@@ -180,4 +182,56 @@ describe("joins", () => {
       }
     });
   });
+
+  it("should not include expired refs", async () => {
+    await publish(modelC.name, c.id);
+    await publish(modelB.name, b.id);
+    await publish(modelA.name, a.id);
+
+    await schedule(modelC.name, c.id, {
+      visibleUntil: new Date(Date.now() - 1)
+    });
+
+    const resp1 = await find(
+      modelA.name,
+      a.id,
+      { join: { B: ["refC"] } },
+      true
+    );
+
+    await expect(resp1).toStrictEqual({
+      ...expectedResponse,
+      _refs: {
+        ...expectedResponse._refs,
+        content: {
+          [modelB.name]: {
+            [b.id]: {
+              _id: b.id,
+              _type: modelB.name
+            }
+          }
+        }
+      }
+    });
+
+    await schedule(modelB.name, b.id, {
+      visibleUntil: new Date(Date.now() - 1)
+    });
+
+    const resp2 = await find(
+      modelA.name,
+      a.id,
+      { join: { B: ["refC"] } },
+      true
+    );
+
+    await expect(resp2).toStrictEqual({
+      _id: a.id,
+      title: expectedResponse.title,
+      _refs: {
+        media: {},
+        content: {}
+      }
+    });
+  });
 });

src/model/visit.ts

@@ -4,7 +4,7 @@ import * as Cotype from "../../typings";
  */
 import _ from "lodash";
 
-export const NO_STORE_VALUE = Symbol("NoStore");
+export const NO_STORE_VALUE = Symbol();
 
 type Visitor = {
   [key: string]: (
@@ -79,7 +79,7 @@ export default function visit(
       );
       if (typeof ret !== "undefined") {
         if (parent && key) {
-          if (typeof ret === "string" && ret === NO_STORE_VALUE) {
+          if (ret === NO_STORE_VALUE) {
             return _.set(parent, key, undefined);
           }
           _.set(parent, key, ret);