@platecms/delta-client 1.6.0 → 1.7.0

package/README.md

@@ -44,7 +44,7 @@ const articleSchema = schema.buildingBlock({
   // Array of items
   tags: schema.array(schema.tag()),
   // For related content items
-  author: schema.contentItem({
+  author: schema.relatedContentItem({
     name: schema.string(),
     email: schema.string(),
   }),
@@ -85,14 +85,20 @@ const article = articleSchema.parse(buildingBlockFieldFulfillments);
 
 #### Available Types
 
+Root schemas
+
+- **`schema.contentItem()`** - Content items structures
+- **`schema.buildingBlock()`** - Building block structures
+
+Chainable or seperate schemas from the root schemas
+
 - **`schema.string()`** - String values
 - **`schema.number()`** - Numeric values  
 - **`schema.boolean()`** - Boolean values
 - **`schema.date()`** - Date values
 - **`schema.asset()`** - Asset references
 - **`schema.smartText()`** - Rich text content
-- **`schema.contentItem()`** - Related content items
-- **`schema.buildingBlock()`** - Building block structures
+- **`schema.relatedContentItem()`** - Related content items
 - **`schema.array()`** - Arrays of any schema
 - **`schema.gridPlacement()`** - Grid layout placements
 - **`schema.contentType()`** - Content type references
@@ -118,11 +124,11 @@ const tagsSchema = schema.array(
 
 // Nested structures
 const pageSchema = schema.buildingBlock({
-  hero: schema.contentItem({
+  hero: schema.relatedContentItem({
     title: schema.string(),
     image: schema.asset(),
   }),
-  sections: schema.array(schema.contentItem({
+  sections: schema.array(schema.relatedContentItem({
     type: schema.string(),
     content: schema.smartText(),
   })),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platecms/delta-client",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "Utilities and functions to interact with the Delta CMS.",
   "license": "UNLICENSED",
   "publishConfig": {
@@ -18,7 +18,7 @@
     "src/**/*"
   ],
   "peerDependencies": {
-    "@platecms/delta-cast": "1.6.0",
+    "@platecms/delta-cast": "1.7.0",
     "@graphql-typed-document-node/core": "3.2.0",
     "graphql": "16.11.0",
     "tslib": "2.8.1",

package/src/schema/index.spec.ts

@@ -145,10 +145,10 @@ describe("Schema", () => {
       title: [schema.number(), schema.string()],
       description: schema.smartText(),
       vegatables: schema.array(
-        schema.contentItem({
+        schema.relatedContentItem({
           name: [schema.string(), schema.number()],
           calories: schema.number(),
-          author: schema.contentItem({
+          author: schema.relatedContentItem({
             name: schema.string(),
             email: schema.string(),
           }),
@@ -217,4 +217,52 @@ describe("Schema", () => {
       },
     });
   });
+
+  it("should parse a content item and its related content item with its values", () => {
+    const book: ContentItem = {
+      contentValues: [
+        {
+          contentField: {
+            name: "name",
+            slug: "name",
+          },
+          primitiveValue: "The Great Gatsby",
+        },
+        {
+          contentField: {
+            name: "year",
+            slug: "year",
+          },
+          primitiveValue: 1925,
+        },
+        {
+          contentField: {
+            name: "author",
+            slug: "author",
+          },
+          relatedContentItem: johnDoe,
+        },
+      ],
+    } as unknown as ContentItem;
+
+    const contentItem = schema.contentItem({
+      name: schema.string(),
+      year: schema.number(),
+      author: schema.relatedContentItem({
+        name: schema.string(),
+        email: schema.string(),
+      }),
+    });
+
+    const result = contentItem.parse(book);
+
+    expect(result).toEqual({
+      name: "The Great Gatsby",
+      year: 1925,
+      author: {
+        name: "John Doe",
+        email: "john.doe@example.com",
+      },
+    });
+  });
 });

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

@@ -96,7 +96,7 @@ describe("Array schema", () => {
 
     it("should parse an array of content values", () => {
       const testSchema = schemaBuilder.array(
-        schemaBuilder.contentItem({
+        schemaBuilder.relatedContentItem({
           name: schemaBuilder.string(),
         }),
       );

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

@@ -19,16 +19,14 @@ describe("ContentItem schema", () => {
     });
 
     const result = contentItemSchema.parse({
-      relatedContentItem: {
-        contentValues: [
-          {
-            contentField: {
-              slug: "title",
-            },
-            primitiveValue: "hello",
+      contentValues: [
+        {
+          contentField: {
+            slug: "title",
           },
-        ],
-      },
+          primitiveValue: "hello",
+        },
+      ],
     });
 
     expect(result).toEqual({
@@ -42,16 +40,14 @@ describe("ContentItem schema", () => {
     });
 
     const result = contentItemSchema.parse({
-      relatedContentItem: {
-        contentValues: [
-          {
-            contentField: {
-              slug: "title",
-            },
-            primitiveValue: "hello",
+      contentValues: [
+        {
+          contentField: {
+            slug: "title",
           },
-        ],
-      },
+          primitiveValue: "hello",
+        },
+      ],
     });
 
     expect(result).toEqual({

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

@@ -1,5 +1,5 @@
 import { ObjectSchema, Schema, SchemaConfig } from ".";
-import { isContentValue } from "../utils/isContentValue";
+import { isContentItem } from "../utils/isContentValue";
 import { isArray } from "../utils";
 export class ContentItemSchema<T extends Record<string, Schema | Schema[]>>
   implements Schema<ObjectSchema<T>, unknown>
@@ -22,10 +22,10 @@ export class ContentItemSchema<T extends Record<string, Schema | Schema[]>>
 
     return Object.entries(this.structure).reduce(
       (acc, [key, value]) => {
-        const relatedContentItem = isContentValue(data) ? data.relatedContentItem : null;
+        const contentItem = isContentItem(data) ? data : null;
 
         const contentValuesForKey =
-          relatedContentItem?.contentValues.filter((contentValue) => contentValue.contentField?.slug === key) ?? [];
+          contentItem?.contentValues.filter((contentValue) => contentValue.contentField?.slug === key) ?? [];
         const shapes = Array.isArray(value) ? value : [value];
         const parsedValues = shapes.map((shape) => shape.parse(contentValuesForKey, config));
 

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

@@ -13,6 +13,7 @@ import { TagSchema } from "./tag";
 import { ContentTypeSchema } from "./contentType";
 import { Asset, ContentType, GridPlacement, PathPart, Tag } from "../../../__generated__/graphql";
 import { Root } from "@platecms/delta-cast";
+import { RelatedContentItemSchema } from "./relatedContentItem";
 
 export type ResultType =
   | Asset
@@ -47,6 +48,8 @@ export interface SchemaConfig {
 export const schema = {
   buildingBlock: <T extends Record<string, Schema | Schema[]>>(structure: T): BuildingBlockSchema<T> =>
     new BuildingBlockSchema(structure),
+  relatedContentItem: <T extends Record<string, Schema | Schema[]>>(structure: T): RelatedContentItemSchema<T> =>
+    new RelatedContentItemSchema(structure),
   contentItem: <T extends Record<string, Schema | Schema[]>>(structure: T): ContentItemSchema<T> =>
     new ContentItemSchema(structure),
   array: <T extends Schema | Schema[]>(structure: T): ArraySchema<T> => new ArraySchema(structure),

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

@@ -0,0 +1,61 @@
+import { describe, it } from "vitest";
+import { schema } from ".";
+import { RelatedContentItemSchema } from "./relatedContentItem";
+
+describe("RelatedContentItem schema", () => {
+  it("should parse an empty content item", () => {
+    const relatedContentItemSchema = new RelatedContentItemSchema({});
+
+    const result = relatedContentItemSchema.parse({
+      contentValues: [],
+    });
+
+    expect(result).toEqual({});
+  });
+
+  it("should parse a content item with its values", () => {
+    const relatedContentItemSchema = new RelatedContentItemSchema({
+      title: schema.string(),
+    });
+
+    const result = relatedContentItemSchema.parse({
+      relatedContentItem: {
+        contentValues: [
+          {
+            contentField: {
+              slug: "title",
+            },
+            primitiveValue: "hello",
+          },
+        ],
+      },
+    });
+
+    expect(result).toEqual({
+      title: "hello",
+    });
+  });
+
+  it("should parse a content item with multiple values", () => {
+    const relatedContentItemSchema = new RelatedContentItemSchema({
+      title: [schema.number(), schema.string()],
+    });
+
+    const result = relatedContentItemSchema.parse({
+      relatedContentItem: {
+        contentValues: [
+          {
+            contentField: {
+              slug: "title",
+            },
+            primitiveValue: "hello",
+          },
+        ],
+      },
+    });
+
+    expect(result).toEqual({
+      title: "hello",
+    });
+  });
+});

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

@@ -0,0 +1,39 @@
+import { ObjectSchema, Schema, SchemaConfig } from ".";
+import { isContentValue } from "../utils/isContentValue";
+import { isArray } from "../utils";
+export class RelatedContentItemSchema<T extends Record<string, Schema | Schema[]>>
+  implements Schema<ObjectSchema<T>, unknown>
+{
+  public constructor(private readonly structure: T) {}
+
+  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;
+  } {
+    if (isArray(data)) {
+      data = data[0];
+    }
+
+    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));
+
+        acc[key as keyof T] = (parsedValues.find((parsedValue) => parsedValue !== null) ??
+          null) as ObjectSchema<T>[keyof T];
+        return acc;
+      },
+      {} as unknown as ObjectSchema<T>,
+    );
+  }
+}

package/src/schema/lib/utils/isContentValue.ts

@@ -1,4 +1,4 @@
-import { ContentValue } from "../../../__generated__/graphql";
+import { ContentItem, ContentValue } from "../../../__generated__/graphql";
 
 export function isContentValue(data: unknown): data is ContentValue {
   return (
@@ -15,3 +15,7 @@ export function isContentValue(data: unknown): data is ContentValue {
       "interpolatedSmartText" in data)
   );
 }
+
+export function isContentItem(data: unknown): data is ContentItem {
+  return data !== null && typeof data === "object" && "contentValues" in data;
+}