@platecms/delta-client 0.6.0 → 0.8.0

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",
+    });
+  });
+});

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

@@ -0,0 +1,33 @@
+import { BuildingBlockFieldFulfillment } from "../../../__generated__/graphql";
+import { ObjectSchema, Schema, SchemaConfig } from ".";
+
+export class BuildingBlockSchema<T extends Record<string, Schema | Schema[]>>
+  implements Schema<ObjectSchema<T>, BuildingBlockFieldFulfillment>
+{
+  public constructor(private readonly structure: T) {}
+
+  public parse(
+    data: BuildingBlockFieldFulfillment | BuildingBlockFieldFulfillment[],
+    config?: SchemaConfig,
+  ): ObjectSchema<T> {
+    if (!Array.isArray(data)) {
+      data = [data];
+    }
+
+    const result = {} as unknown as ObjectSchema<T>;
+
+    for (const [key, schemaOrSchemas] of Object.entries(this.structure)) {
+      const valuesForField = data
+        .filter((item) => item.buildingBlockField.slug === key)
+        .map((item) => item.contentValue);
+
+      const schemas = Array.isArray(schemaOrSchemas) ? schemaOrSchemas : [schemaOrSchemas];
+      const parsedValues = schemas.map((schema) => schema.parse(valuesForField, config));
+
+      result[key as keyof T] = (parsedValues.find((parsedValue) => parsedValue !== null) ??
+        null) as ObjectSchema<T>[keyof T];
+    }
+
+    return result;
+  }
+}

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

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

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

@@ -0,0 +1,31 @@
+import { ObjectSchema, Schema, SchemaConfig } from ".";
+import { isArray } from "lodash";
+import { isContentValue } from "../utils/isContentValue";
+
+export class ContentItemSchema<T extends Record<string, Schema | Schema[]>>
+  implements Schema<ObjectSchema<T>, unknown>
+{
+  public constructor(private readonly structure: T) {}
+
+  public parse(data: unknown, config?: SchemaConfig): ObjectSchema<T> | null {
+    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?.name === 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/schemas/contentType.spec.ts

@@ -0,0 +1,113 @@
+import { describe, it } from "vitest";
+import { ContentTypeSchema } from "./contentType";
+
+describe("ContentType schema", () => {
+  it("should parse to a content type when parsing a content type content value", () => {
+    const schema = new ContentTypeSchema();
+
+    const result = schema.parse([
+      {
+        linkedContentType: {
+          prn: "123",
+          name: "title",
+          contentFields: [
+            {
+              name: "title",
+            },
+          ],
+        },
+      },
+    ]);
+
+    expect(result).toEqual({
+      prn: "123",
+      name: "title",
+      contentFields: [
+        {
+          name: "title",
+        },
+      ],
+    });
+  });
+
+  it("should return null when parsing an a non content type content value", () => {
+    const schema = new ContentTypeSchema();
+
+    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 ContentTypeSchema().placeholder({
+        prn: "123",
+        name: "title",
+        contentFields: [
+          {
+            name: "title",
+          },
+        ],
+      });
+
+      const result = schema.parse([], {
+        placeholders: true,
+      });
+
+      expect(result).toEqual({
+        prn: "123",
+        name: "title",
+        contentFields: [
+          {
+            name: "title",
+          },
+        ],
+      });
+    });
+
+    it("should return the placeholder when parsing an non content type content value", () => {
+      const schema = new ContentTypeSchema().placeholder({
+        prn: "123",
+        name: "title",
+        contentFields: [
+          {
+            name: "title",
+          },
+        ],
+      });
+
+      const result = schema.parse(
+        [
+          {
+            primitiveValue: true,
+          },
+        ],
+        {
+          placeholders: true,
+        },
+      );
+
+      expect(result).toEqual({
+        prn: "123",
+        name: "title",
+        contentFields: [
+          {
+            name: "title",
+          },
+        ],
+      });
+    });
+  });
+
+  describe("when nullable is disabled", () => {
+    it("should throw an error when parsing an non content type content value", () => {
+      const schema = new ContentTypeSchema().nullable(false);
+
+      expect(() => schema.parse([{ primitiveValue: 42 }])).toThrow("Data could not be found and is not nullable");
+    });
+  });
+});

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

@@ -0,0 +1,12 @@
+import { ContentType } from "../../../__generated__/graphql";
+import { BaseSchema } from "./baseSchema";
+
+export class ContentTypeSchema extends BaseSchema<ContentType | null, unknown> {
+  protected override findValue(data: unknown): ContentType | null {
+    if (typeof data === "object" && data !== null && "linkedContentType" in data) {
+      return (data as { linkedContentType: ContentType }).linkedContentType;
+    }
+
+    return null;
+  }
+}

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

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

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

@@ -0,0 +1,17 @@
+import { BaseSchema } from "./baseSchema";
+import { isPrimitiveValue } from "../utils/isPrimitiveValue";
+
+export class DateSchema extends BaseSchema<Date | null, unknown> {
+  public placeholderFromString(date: string): this {
+    this._placeholder = new Date(date);
+    return this;
+  }
+
+  protected override findValue(data: unknown): Date | null {
+    if (isPrimitiveValue(data) && typeof data.primitiveValue === "string") {
+      return new Date(data.primitiveValue);
+    }
+
+    return null;
+  }
+}

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

@@ -0,0 +1,77 @@
+import { describe, it } from "vitest";
+import { GridPlacementSchema } from "./gridPlacement";
+
+describe("GridPlacement schema", () => {
+  it("should parse to a grid placement when parsing a grid placement content value", () => {
+    const schema = new GridPlacementSchema();
+
+    const result = schema.parse([
+      {
+        gridPlacement: {
+          row: 0,
+        },
+      },
+    ]);
+
+    expect(result).toEqual({
+      row: 0,
+    });
+  });
+
+  it("should return null when parsing an a non grid placement content value", () => {
+    const schema = new GridPlacementSchema();
+
+    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 GridPlacementSchema().placeholder({
+        row: 0,
+      });
+
+      const result = schema.parse([], {
+        placeholders: true,
+      });
+
+      expect(result).toEqual({
+        row: 0,
+      });
+    });
+
+    it("should return the placeholder when parsing an non grid placement content value", () => {
+      const schema = new GridPlacementSchema().placeholder({
+        row: 0,
+      });
+
+      const result = schema.parse(
+        [
+          {
+            primitiveValue: true,
+          },
+        ],
+        {
+          placeholders: true,
+        },
+      );
+
+      expect(result).toEqual({
+        row: 0,
+      });
+    });
+  });
+
+  describe("when nullable is disabled", () => {
+    it("should throw an error when parsing an non grid placement content value", () => {
+      const schema = new GridPlacementSchema().nullable(false);
+
+      expect(() => schema.parse([{ primitiveValue: 42 }])).toThrow("Data could not be found and is not nullable");
+    });
+  });
+});

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

@@ -0,0 +1,12 @@
+import { GridPlacement } from "../../../__generated__/graphql";
+import { BaseSchema } from "./baseSchema";
+
+export class GridPlacementSchema extends BaseSchema<GridPlacement | null, unknown> {
+  protected override findValue(data: unknown): GridPlacement | null {
+    if (typeof data === "object" && data !== null && "gridPlacement" in data) {
+      return (data as { gridPlacement: GridPlacement }).gridPlacement;
+    }
+
+    return null;
+  }
+}

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

@@ -0,0 +1,66 @@
+import { StringSchema } from "./string";
+import { ContentItemSchema } from "./contentItem";
+import { ArraySchema } from "./array";
+import { BuildingBlockSchema } from "./buildingBlock";
+import { NumberSchema } from "./number";
+import { BooleanSchema } from "./boolean";
+import { DateSchema } from "./date";
+import { AssetSchema } from "./asset";
+import { SmartTextSchema } from "./smartText";
+import { GridPlacementSchema } from "./gridPlacement";
+import { PathPartSchema } from "./pathPart";
+import { TagSchema } from "./tag";
+import { ContentTypeSchema } from "./contentType";
+import { Asset, ContentType, GridPlacement, PathPart, Tag } from "../../../__generated__/graphql";
+import { Root } from "@platecms/delta-cast";
+
+export type ResultType =
+  | Asset
+  | ContentType
+  | Date
+  | GridPlacement
+  | PathPart
+  | Root
+  | Tag
+  | boolean
+  | number
+  | string
+  | null;
+
+export interface Schema<TResult = unknown, TData = unknown> {
+  parse: (data: TData | TData[], config?: SchemaConfig) => TResult | null;
+}
+
+export type ObjectSchema<T extends Record<string, Schema | Schema[]>> = {
+  [key in keyof T]: T[key] extends Schema[]
+    ? ReturnType<T[key][number]["parse"]> | null
+    : T[key] extends Schema
+      ? ReturnType<T[key]["parse"]> | null
+      : never;
+};
+
+export interface SchemaConfig {
+  placeholders?: boolean;
+}
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export const schema = {
+  buildingBlock: <T extends Record<string, Schema | Schema[]>>(structure: T): BuildingBlockSchema<T> =>
+    new BuildingBlockSchema(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),
+  string: (): StringSchema => new StringSchema(),
+  number: (): NumberSchema => new NumberSchema(),
+  boolean: (): BooleanSchema => new BooleanSchema(),
+  date: (): DateSchema => new DateSchema(),
+  asset: (): AssetSchema => new AssetSchema(),
+  smartText: (): SmartTextSchema => new SmartTextSchema(),
+  gridPlacement: (): GridPlacementSchema => new GridPlacementSchema(),
+  contentType: (): ContentTypeSchema => new ContentTypeSchema(),
+  pathPart: (): PathPartSchema => new PathPartSchema(),
+  tag: (): TagSchema => new TagSchema(),
+};
+
+// eslint-disable-next-line @typescript-eslint/naming-convention, id-length
+export const s = schema;