@platecms/delta-client 1.0.0 → 1.3.0

package/src/schema/index.spec.ts

@@ -0,0 +1,211 @@
+import { describe, it } from "vitest";
+import { BuildingBlockField, ContentItem, ExperienceComponent } from "../__generated__/graphql";
+import { schema } from "./lib/schemas";
+import { c } from "@platecms/delta-castscript";
+
+const johnDoe: ContentItem = {
+  contentValues: [
+    {
+      contentField: {
+        name: "name",
+      },
+      primitiveValue: "John Doe",
+    },
+    {
+      contentField: {
+        name: "email",
+      },
+      primitiveValue: "john.doe@example.com",
+    },
+  ],
+} as unknown as ContentItem;
+
+const broccoli: ContentItem = {
+  contentValues: [
+    {
+      contentField: {
+        name: "name",
+      },
+      primitiveValue: "Broccoli",
+    },
+    {
+      contentField: {
+        name: "calories",
+      },
+      primitiveValue: 200,
+    },
+    {
+      contentField: {
+        name: "author",
+      },
+      relatedContentItem: johnDoe,
+    },
+  ],
+} as unknown as ContentItem;
+
+const carrot: ContentItem = {
+  contentValues: [
+    {
+      contentField: {
+        name: "name",
+      },
+      primitiveValue: "Carrot",
+    },
+    {
+      contentField: {
+        name: "calories",
+      },
+      primitiveValue: 100,
+    },
+  ],
+} as unknown as ContentItem;
+
+const experienceComponent: ExperienceComponent = {
+  buildingBlockFieldFulfillments: [
+    {
+      buildingBlockField: {
+        prn: "123",
+        slug: "title",
+      } as unknown as BuildingBlockField,
+      contentValue: {
+        primitiveValue: "Hello back!",
+      },
+    },
+    {
+      buildingBlockField: {
+        prn: "123",
+        slug: "description",
+      } as unknown as BuildingBlockField,
+      contentValue: {
+        interpolatedSmartText: c("root", [c("paragraph", "Hello back again!")]),
+      },
+    },
+    {
+      buildingBlockField: {
+        prn: "123",
+        slug: "vegatables",
+      } as unknown as BuildingBlockField,
+      contentValue: {
+        relatedContentItem: broccoli,
+      },
+    },
+    {
+      buildingBlockField: {
+        prn: "123",
+        slug: "vegatables",
+      } as unknown as BuildingBlockField,
+      contentValue: {
+        relatedContentItem: carrot,
+      },
+    },
+    {
+      buildingBlockField: {
+        prn: "123",
+        slug: "tags",
+      } as unknown as BuildingBlockField,
+      contentValue: {
+        linkedTag: {
+          prn: "123",
+          name: "title",
+          path: "title",
+        },
+      },
+    },
+    {
+      buildingBlockField: {
+        prn: "123",
+        slug: "type",
+      } as unknown as BuildingBlockField,
+      contentValue: {
+        linkedContentType: {
+          prn: "123",
+          name: "title",
+          contentFields: [
+            {
+              name: "title",
+            },
+          ],
+        },
+      },
+    },
+  ],
+} as unknown as ExperienceComponent;
+
+describe("Schema", () => {
+  it("should parse an building block with its values", () => {
+    const buildingBlock = schema.buildingBlock({
+      title: [schema.number(), schema.string()],
+      description: schema.smartText(),
+      vegatables: schema.array(
+        schema.contentItem({
+          name: [schema.string(), schema.number()],
+          calories: schema.number(),
+          author: schema.contentItem({
+            name: schema.string(),
+            email: schema.string(),
+          }),
+        }),
+      ),
+      tags: schema.array(schema.tag()),
+      type: schema.contentType(),
+      isVisible: schema.boolean().placeholder(true),
+    });
+
+    const result = buildingBlock.parse(experienceComponent.buildingBlockFieldFulfillments, {
+      placeholders: true,
+    });
+
+    expect(result).toEqual({
+      title: "Hello back!",
+      isVisible: true,
+      description: {
+        type: "root",
+        children: [
+          {
+            type: "paragraph",
+            children: [
+              {
+                type: "text",
+                value: "Hello back again!",
+              },
+            ],
+          },
+        ],
+      },
+      vegatables: [
+        {
+          name: "Broccoli",
+          calories: 200,
+          author: {
+            name: "John Doe",
+            email: "john.doe@example.com",
+          },
+        },
+        {
+          name: "Carrot",
+          calories: 100,
+          author: {
+            name: null,
+            email: null,
+          },
+        },
+      ],
+      tags: [
+        {
+          prn: "123",
+          name: "title",
+          path: "title",
+        },
+      ],
+      type: {
+        prn: "123",
+        name: "title",
+        contentFields: [
+          {
+            name: "title",
+          },
+        ],
+      },
+    });
+  });
+});

package/src/schema/{index.d.ts → index.ts}

@@ -1,7 +1,9 @@
 export * from "./lib/schemas";
+
 export * from "./lib/schemas/contentItem";
 export * from "./lib/schemas/buildingBlock";
 export * from "./lib/schemas/array";
+
 export * from "./lib/schemas/string";
 export * from "./lib/schemas/number";
 export * from "./lib/schemas/boolean";
@@ -12,3 +14,5 @@ export * from "./lib/schemas/gridPlacement";
 export * from "./lib/schemas/contentType";
 export * from "./lib/schemas/pathPart";
 export * from "./lib/schemas/tag";
+
+export * from "./../__generated__/graphql";

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

@@ -0,0 +1,126 @@
+import { describe, it } from "vitest";
+import { schema as schemaBuilder } from ".";
+
+describe("Array schema", () => {
+  it("should parse an array of content values", () => {
+    const testSchema = schemaBuilder.array(schemaBuilder.string());
+
+    const result = testSchema.parse([
+      {
+        primitiveValue: "hello",
+      },
+      {
+        primitiveValue: "world",
+      },
+    ]);
+
+    expect(result).toEqual(["hello", "world"]);
+  });
+
+  it("should return an empty array when parsing a non array", () => {
+    const testSchema = schemaBuilder.array(schemaBuilder.string());
+
+    const result = testSchema.parse([]);
+
+    expect(result).toEqual([]);
+  });
+
+  it("should return an empty array when parsing an empty array", () => {
+    const testSchema = schemaBuilder.array(schemaBuilder.string());
+
+    const result = testSchema.parse([]);
+
+    expect(result).toEqual([]);
+  });
+
+  it("should display string placholders when parsing an array", () => {
+    const testSchema = schemaBuilder
+      .array(schemaBuilder.string().placeholder("placeholder"))
+      .placeholder({ minLength: 2 });
+
+    const result = testSchema.parse([], {
+      placeholders: true,
+    });
+
+    expect(result).toEqual(["placeholder", "placeholder"]);
+  });
+
+  it("should display placholders for content items when parsing an arraray", () => {
+    const testSchema = schemaBuilder
+      .array(
+        schemaBuilder.contentItem({
+          title: schemaBuilder.string().placeholder("title"),
+        }),
+      )
+      .placeholder({ minLength: 2 });
+
+    const result = testSchema.parse([], {
+      placeholders: true,
+    });
+
+    expect(result).toEqual([
+      {
+        title: "title",
+      },
+      {
+        title: "title",
+      },
+    ]);
+  });
+
+  it("should display placholders when parsing an array", () => {
+    const testSchema = schemaBuilder
+      .array(schemaBuilder.string().placeholder("placeholder"))
+      .placeholder({ minLength: 1 });
+
+    const result = testSchema.parse([]);
+
+    expect(result).toEqual([]);
+  });
+
+  describe("when using multiple schemas", () => {
+    it("should parse an array of strings and numbers", () => {
+      const testSchema = schemaBuilder.array([schemaBuilder.string(), schemaBuilder.number()]);
+
+      const result = testSchema.parse([
+        {
+          primitiveValue: "hello",
+        },
+        {
+          primitiveValue: 42,
+        },
+      ]);
+
+      expect(result).toEqual(["hello", 42]);
+    });
+
+    it("should parse an array of content values", () => {
+      const testSchema = schemaBuilder.array(
+        schemaBuilder.contentItem({
+          name: schemaBuilder.string(),
+        }),
+      );
+
+      const result = testSchema.parse([
+        {
+          relatedContentItem: {
+            contentValues: [
+              {
+                contentField: {
+                  name: "name",
+                },
+                primitiveValue: "hello",
+              },
+            ],
+          },
+        },
+      ]);
+
+      expect(result).toEqual([
+        {
+          name: "hello",
+        },
+      ]);
+    });
+  });
+});

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

@@ -0,0 +1,46 @@
+import { Schema, SchemaConfig } from ".";
+import { compact, first } from "../utils";
+
+export class ArraySchema<T extends Schema | Schema[]>
+  implements
+    Schema<
+      T extends Schema[] ? ReturnType<T[number]["parse"]>[] : T extends Schema ? ReturnType<T["parse"]>[] : never,
+      unknown
+    >
+{
+  private _minLength: number = 0;
+
+  public constructor(private readonly structure: T) {}
+
+  public placeholder({ minLength }: { minLength: number }): this {
+    this._minLength = minLength;
+    return this;
+  }
+
+  public parse(
+    data: unknown,
+    config?: SchemaConfig,
+  ): T extends Schema[] ? ReturnType<T[number]["parse"]>[] : T extends Schema ? ReturnType<T["parse"]>[] : never {
+    const dataAsArray = Array.isArray(data) ? data : [];
+
+    if (dataAsArray.length < this._minLength) {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+      dataAsArray.push(...Array(this._minLength - dataAsArray.length).fill(null));
+    }
+
+    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);
+    }) as T extends Schema[] ? ReturnType<T[number]["parse"]>[] : T extends Schema ? ReturnType<T["parse"]>[] : never;
+
+    return config?.placeholders === true
+      ? results
+      : (compact(results) as T extends Schema[]
+          ? ReturnType<T[number]["parse"]>[]
+          : T extends Schema
+            ? ReturnType<T["parse"]>[]
+            : never);
+  }
+}

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

@@ -0,0 +1,101 @@
+import { describe, it } from "vitest";
+import { AssetSchema } from "./asset";
+
+describe("Asset schema", () => {
+  it("should parse to an asset when parsing an asset content value", () => {
+    const schema = new AssetSchema();
+
+    const result = schema.parse([
+      {
+        relatedAsset: {
+          prn: "123",
+          name: "title",
+          url: "url",
+          mimeType: "image/png",
+          fileSize: 100,
+          width: 100,
+          height: 100,
+        },
+      },
+    ]);
+
+    expect(result).toEqual({
+      prn: "123",
+      name: "title",
+      url: "url",
+      mimeType: "image/png",
+      fileSize: 100,
+      width: 100,
+      height: 100,
+    });
+  });
+
+  it("should return null when parsing an a non asset content value", () => {
+    const schema = new AssetSchema();
+
+    const result = schema.parse([
+      {
+        primitiveValue: "hello",
+      },
+    ]);
+
+    expect(result).toEqual(null);
+  });
+
+  describe("when placeholders are enabled", () => {
+    it("should return the placeholder when parsing an empty array", () => {
+      const schema = new AssetSchema().placeholder({
+        prn: "123",
+        url: "url",
+        mimeType: "image/png",
+        fileSize: 100,
+      });
+
+      const result = schema.parse([], {
+        placeholders: true,
+      });
+
+      expect(result).toEqual({
+        prn: "123",
+        url: "url",
+        mimeType: "image/png",
+        fileSize: 100,
+      });
+    });
+
+    it("should return the placeholder when parsing an non asset content value", () => {
+      const schema = new AssetSchema().placeholder({
+        prn: "123",
+        url: "url",
+        mimeType: "image/png",
+        fileSize: 100,
+      });
+
+      const result = schema.parse(
+        [
+          {
+            primitiveValue: true,
+          },
+        ],
+        {
+          placeholders: true,
+        },
+      );
+
+      expect(result).toEqual({
+        prn: "123",
+        url: "url",
+        mimeType: "image/png",
+        fileSize: 100,
+      });
+    });
+  });
+
+  describe("when nullable is disabled", () => {
+    it("should throw an error when parsing an non asset content value", () => {
+      const schema = new AssetSchema().nullable(false);
+
+      expect(() => schema.parse([{ primitiveValue: 42 }])).toThrow("Data could not be found and is not nullable");
+    });
+  });
+});

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

@@ -0,0 +1,13 @@
+import { Asset } from "../../../__generated__/graphql";
+import { isContentValue } from "../utils/isContentValue";
+import { BaseSchema } from "./baseSchema";
+
+export class AssetSchema extends BaseSchema<Asset | null, unknown> {
+  protected override findValue(data: unknown): Asset | null {
+    if (isContentValue(data) && "relatedAsset" in data) {
+      return (data as { relatedAsset: Asset }).relatedAsset;
+    }
+
+    return null;
+  }
+}

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

@@ -0,0 +1,42 @@
+import { ResultType, Schema, SchemaConfig } from ".";
+import { isArray } from "../utils";
+
+export abstract class BaseSchema<TResult extends ResultType, TData> implements Schema<TResult, TData> {
+  protected _isNullable = true;
+  protected _placeholder: TResult | null = null;
+
+  public nullable(value: boolean = false): this {
+    this._isNullable = value;
+
+    return this;
+  }
+
+  public placeholder(placeholder: Partial<TResult>): this {
+    this._placeholder = placeholder as TResult;
+
+    return this;
+  }
+
+  public parse(data: TData | TData[], config?: SchemaConfig): TResult | null {
+    if (isArray(data)) {
+      data = data[this.findIndex(data)];
+    }
+
+    if (this.findValue(data) !== null) {
+      return this.findValue(data);
+    }
+
+    if (!this._isNullable) {
+      throw new Error("Data could not be found and is not nullable");
+    }
+
+    return config?.placeholders === true ? this._placeholder : null;
+  }
+
+  private findIndex(data: TData[]): number {
+    const index = data.findIndex((item) => this.findValue(item) !== null);
+    return index !== -1 ? index : 0;
+  }
+
+  protected abstract findValue(data: TData): TResult | null;
+}

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

@@ -0,0 +1,65 @@
+import { describe, it } from "vitest";
+import { BooleanSchema } from "./boolean";
+
+describe("Boolean schema", () => {
+  it("should parse to a boolean when parsing a boolean content value", () => {
+    const schema = new BooleanSchema();
+
+    const result = schema.parse([
+      {
+        primitiveValue: true,
+      },
+    ]);
+
+    expect(result).toEqual(true);
+  });
+
+  it("should return null when parsing an a non boolean content value", () => {
+    const schema = new BooleanSchema();
+
+    const result = schema.parse([
+      {
+        primitiveValue: "hello",
+      },
+    ]);
+
+    expect(result).toEqual(null);
+  });
+
+  describe("when placeholders are enabled", () => {
+    it("should return the placeholder when parsing an empty array", () => {
+      const schema = new BooleanSchema().placeholder(true);
+
+      const result = schema.parse([], {
+        placeholders: true,
+      });
+
+      expect(result).toEqual(true);
+    });
+
+    it("should return the placeholder when parsing an non boolean content value", () => {
+      const schema = new BooleanSchema().placeholder(true);
+
+      const result = schema.parse(
+        [
+          {
+            primitiveValue: "hello",
+          },
+        ],
+        {
+          placeholders: true,
+        },
+      );
+
+      expect(result).toEqual(true);
+    });
+  });
+
+  describe("when nullable is disabled", () => {
+    it("should throw an error when parsing an non boolean content value", () => {
+      const schema = new BooleanSchema().nullable(false);
+
+      expect(() => schema.parse([{ primitiveValue: "hello" }])).toThrow("Data could not be found and is not nullable");
+    });
+  });
+});

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

@@ -0,0 +1,12 @@
+import { BaseSchema } from "./baseSchema";
+import { isPrimitiveValue } from "../utils/isPrimitiveValue";
+
+export class BooleanSchema extends BaseSchema<boolean, unknown> {
+  protected override findValue(data: unknown): boolean | null {
+    if (isPrimitiveValue(data) && typeof data.primitiveValue === "boolean") {
+      return data.primitiveValue;
+    }
+
+    return null;
+  }
+}

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

@@ -0,0 +1,56 @@
+import { describe, it } from "vitest";
+import { BuildingBlockSchema } from "./buildingBlock";
+import { schema } from ".";
+import { BuildingBlockFieldFulfillment } from "../../../__generated__/graphql";
+
+describe("BuildingBlock schema", () => {
+  it("should parse an empty building block", () => {
+    const buildingBlockSchema = new BuildingBlockSchema({});
+
+    const result = buildingBlockSchema.parse([]);
+
+    expect(result).toEqual({});
+  });
+
+  it("should parse a building block with its values", () => {
+    const buildingBlockSchema = new BuildingBlockSchema({
+      title: schema.string(),
+    });
+
+    const result = buildingBlockSchema.parse([
+      {
+        buildingBlockField: {
+          slug: "title",
+        },
+        contentValue: {
+          primitiveValue: "hello",
+        },
+      },
+    ] as BuildingBlockFieldFulfillment[]);
+
+    expect(result).toEqual({
+      title: "hello",
+    });
+  });
+
+  it("should parse a building block with multiple values", () => {
+    const buildingBlockSchema = schema.buildingBlock({
+      title: schema.string(),
+    });
+
+    const result = buildingBlockSchema.parse([
+      {
+        buildingBlockField: {
+          slug: "title",
+        },
+        contentValue: {
+          primitiveValue: "hello",
+        },
+      },
+    ] as unknown as BuildingBlockFieldFulfillment[]);
+
+    expect(result).toEqual({
+      title: "hello",
+    });
+  });
+});