@platecms/delta-client 1.7.0 → 1.9.0

package/src/graphql/fragments/grid-placement.fragments.gql

@@ -1,7 +1,6 @@
 fragment gridPlacementFragment on GridPlacement {
     _id: prn
     prn,
-    row
     updatedAt
     createdAt
 }

package/src/graphql/fragments/related-asset.fragment.gql

@@ -0,0 +1,9 @@
+fragment relatedAssetFragment on ContentValue {
+  relatedAssetFileName
+  relatedAssetSize
+  relatedAssetFileType
+  relatedAsset {
+    ...assetFragment
+  }
+}
+

package/src/graphql/path-parts/path-parts.query.gql

@@ -36,7 +36,10 @@ query pathParts(
                 contentItem {
                   prn
                 }
-                ...relatedAssetFragment
+                relatedAsset {
+                  ...assetFragment
+                  processedUrls(optionsList: $optionsList)
+                }
               }
             }
           }

package/src/schema/index.spec.ts

@@ -192,10 +192,7 @@ describe("Schema", () => {
         {
           name: "Carrot",
           calories: 100,
-          author: {
-            name: null,
-            email: null,
-          },
+          author: null,
         },
       ],
       tags: [

package/src/schema/lib/schemas/array.ts

@@ -30,6 +30,7 @@ export class ArraySchema<T extends Schema | Schema[]>
 
     const results = dataAsArray.map((item) => {
       const structures: Schema[] = Array.isArray(this.structure) ? this.structure : [this.structure];
+
       const resultForStructures = structures.map((schema) => schema.parse(item, config));
 
       return resultForStructures.find((result) => result !== null) ?? first(resultForStructures);

package/src/schema/lib/schemas/relatedContentItem.spec.ts

@@ -10,7 +10,7 @@ describe("RelatedContentItem schema", () => {
       contentValues: [],
     });
 
-    expect(result).toEqual({});
+    expect(result).toEqual(null);
   });
 
   it("should parse a content item with its values", () => {
@@ -58,4 +58,109 @@ describe("RelatedContentItem schema", () => {
       title: "hello",
     });
   });
+
+  it("should parse a related content item with a specific content type", () => {
+    const relatedContentItemSchema = new RelatedContentItemSchema({
+      title: schema.string(),
+    }).ofContentType("tag");
+
+    const result = relatedContentItemSchema.parse({
+      relatedContentItem: {
+        contentType: {
+          slug: "tag",
+        },
+        contentValues: [
+          {
+            contentField: {
+              slug: "title",
+            },
+            primitiveValue: "hello",
+          },
+        ],
+      },
+    });
+
+    expect(result).toEqual({
+      title: "hello",
+    });
+  });
+
+  it("should return null when parsing a related content item with a different content type", () => {
+    const relatedContentItemSchema = new RelatedContentItemSchema({
+      title: schema.string(),
+    }).ofContentType("tag");
+
+    const result = relatedContentItemSchema.parse({
+      relatedContentItem: {
+        contentType: {
+          slug: "author",
+        },
+        contentValues: [
+          {
+            contentField: {
+              slug: "title",
+            },
+            primitiveValue: "hello",
+          },
+        ],
+      },
+    });
+
+    expect(result).toEqual(null);
+  });
+
+  describe("when using an array of schemas", () => {
+    it("should parse an array of related content items", () => {
+      const relatedContentItemArraySchema = schema.array([
+        new RelatedContentItemSchema({
+          email: schema.string(),
+        }).ofContentType("person"),
+        new RelatedContentItemSchema({
+          name: schema.string(),
+        }).ofContentType("author"),
+      ]);
+
+      const result = relatedContentItemArraySchema.parse([
+        {
+          relatedContentItem: {
+            contentType: {
+              slug: "author",
+            },
+            contentValues: [
+              {
+                contentField: {
+                  slug: "name",
+                },
+                primitiveValue: "John Doe",
+              },
+            ],
+          },
+        },
+        {
+          relatedContentItem: {
+            contentType: {
+              slug: "person",
+            },
+            contentValues: [
+              {
+                contentField: {
+                  slug: "email",
+                },
+                primitiveValue: "john.doe@example.com",
+              },
+            ],
+          },
+        },
+      ]);
+
+      expect(result).toEqual([
+        {
+          name: "John Doe",
+        },
+        {
+          email: "john.doe@example.com",
+        },
+      ]);
+    });
+  });
 });

package/src/schema/lib/schemas/relatedContentItem.ts

@@ -4,28 +4,42 @@ import { isArray } from "../utils";
 export class RelatedContentItemSchema<T extends Record<string, Schema | Schema[]>>
   implements Schema<ObjectSchema<T>, unknown>
 {
+  private type?: string = undefined;
+
   public constructor(private readonly structure: T) {}
 
+  public ofContentType(slug: string): this {
+    this.type = slug;
+    return this;
+  }
+
   public parse(
     data: unknown,
     config?: SchemaConfig,
-  ): {
-    [key in keyof T]: T[key] extends Schema[]
-      ? ReturnType<T[key][number]["parse"]>
-      : T[key] extends Schema
-        ? ReturnType<T[key]["parse"]>
-        : never;
-  } {
+  ):
+    | {
+        [key in keyof T]: T[key] extends Schema[]
+          ? ReturnType<T[key][number]["parse"]>
+          : T[key] extends Schema
+            ? ReturnType<T[key]["parse"]>
+            : never;
+      }
+    | null {
     if (isArray(data)) {
       data = data[0];
     }
 
+    const relatedContentItem = isContentValue(data) ? data.relatedContentItem : null;
+
+    if (!relatedContentItem || (this.type !== null && relatedContentItem.contentType?.slug !== this.type)) {
+      return null;
+    }
+
     return Object.entries(this.structure).reduce(
       (acc, [key, value]) => {
-        const relatedContentItem = isContentValue(data) ? data.relatedContentItem : null;
-
         const contentValuesForKey =
           relatedContentItem?.contentValues.filter((contentValue) => contentValue.contentField?.slug === key) ?? [];
+
         const shapes = Array.isArray(value) ? value : [value];
         const parsedValues = shapes.map((shape) => shape.parse(contentValuesForKey, config));