@platecms/delta-client 0.6.0 → 0.8.0

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,105 @@
+import { describe, it } from "vitest";
+import { SmartTextSchema } from "./smartText";
+import { c } from "@platecms/delta-castscript";
+
+describe("SmartText schema", () => {
+  it("should parse to a smart text when parsing a smart text content value", () => {
+    const schema = new SmartTextSchema();
+
+    const result = schema.parse([
+      {
+        interpolatedSmartText: c("root", [c("paragraph", "hello")]),
+      },
+    ]);
+
+    expect(result).toEqual({
+      type: "root",
+      children: [
+        {
+          type: "paragraph",
+          children: [
+            {
+              type: "text",
+              value: "hello",
+            },
+          ],
+        },
+      ],
+    });
+  });
+
+  it("should return null when parsing an a non smart text content value", () => {
+    const schema = new SmartTextSchema();
+
+    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 SmartTextSchema().placeholder(c("root", [c("paragraph", "placeholder")]));
+
+      const result = schema.parse([], {
+        placeholders: true,
+      });
+
+      expect(result).toEqual({
+        type: "root",
+        children: [
+          {
+            type: "paragraph",
+            children: [
+              {
+                type: "text",
+                value: "placeholder",
+              },
+            ],
+          },
+        ],
+      });
+    });
+
+    it("should return the placeholder when parsing an non smart text content value", () => {
+      const schema = new SmartTextSchema().placeholder(c("root", [c("paragraph", "placeholder")]));
+
+      const result = schema.parse(
+        [
+          {
+            primitiveValue: true,
+          },
+        ],
+        {
+          placeholders: true,
+        },
+      );
+
+      expect(result).toEqual({
+        type: "root",
+        children: [
+          {
+            type: "paragraph",
+            children: [
+              {
+                type: "text",
+                value: "placeholder",
+              },
+            ],
+          },
+        ],
+      });
+    });
+  });
+
+  describe("when nullable is disabled", () => {
+    it("should throw an error when parsing an non smart text content value", () => {
+      const schema = new SmartTextSchema().nullable(false);
+
+      expect(() => schema.parse([{ primitiveValue: 42 }])).toThrow("Data could not be found and is not nullable");
+    });
+  });
+});

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

@@ -0,0 +1,12 @@
+import { Root as SmartText } from "@platecms/delta-cast";
+import { BaseSchema } from "./baseSchema";
+
+export class SmartTextSchema extends BaseSchema<SmartText | null, unknown> {
+  protected override findValue(data: unknown): SmartText | null {
+    if (typeof data === "object" && data !== null && "interpolatedSmartText" in data) {
+      return (data as { interpolatedSmartText: SmartText }).interpolatedSmartText;
+    }
+
+    return null;
+  }
+}

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,111 @@
+import { isContentValue } from "./isContentValue";
+
+describe("isContentValue", () => {
+  it("should return false if the data is not a content value and has values", () => {
+    const data = {
+      __typename: "ContentValue",
+    };
+
+    const result = isContentValue(data);
+
+    expect(result).toBe(false);
+  });
+
+  it("should return true if the data is a content value and has a primitive value", () => {
+    const data = {
+      __typename: "ContentValue",
+      primitiveValue: "Hello",
+    };
+
+    const result = isContentValue(data);
+
+    expect(result).toBe(true);
+  });
+
+  it("should return true if the data is a content value and has a related asset", () => {
+    const data = {
+      __typename: "ContentValue",
+      relatedAsset: {
+        __typename: "Asset",
+      },
+    };
+
+    const result = isContentValue(data);
+
+    expect(result).toBe(true);
+  });
+
+  it("should return true if the data is a content value and has a linked content type", () => {
+    const data = {
+      __typename: "ContentValue",
+      linkedContentType: {
+        __typename: "ContentType",
+      },
+    };
+  });
+
+  it("should return true if the data is a content value and has a linked grid placement", () => {
+    const data = {
+      __typename: "ContentValue",
+      linkedGridPlacement: {
+        __typename: "GridPlacement",
+      },
+    };
+
+    const result = isContentValue(data);
+
+    expect(result).toBe(true);
+  });
+
+  it("should return true if the data is a content value and has a linked path part", () => {
+    const data = {
+      __typename: "ContentValue",
+      linkedPathPart: {
+        __typename: "PathPart",
+      },
+    };
+
+    const result = isContentValue(data);
+
+    expect(result).toBe(true);
+  });
+
+  it("should return true if the data is a content value and has a linked tag", () => {
+    const data = {
+      __typename: "ContentValue",
+      linkedTag: {
+        __typename: "Tag",
+      },
+    };
+
+    const result = isContentValue(data);
+
+    expect(result).toBe(true);
+  });
+
+  it("should return true if the data is a content value and has a related content item", () => {
+    const data = {
+      __typename: "ContentValue",
+      relatedContentItem: {
+        __typename: "ContentItem",
+      },
+    };
+
+    const result = isContentValue(data);
+
+    expect(result).toBe(true);
+  });
+
+  it("should return true if the data is a content value and has a smart text", () => {
+    const data = {
+      __typename: "ContentValue",
+      smartText: {
+        __typename: "SmartText",
+      },
+    };
+
+    const result = isContentValue(data);
+
+    expect(result).toBe(true);
+  });
+});

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

@@ -0,0 +1,17 @@
+import { ContentValue } from "../../../__generated__/graphql";
+
+export function isContentValue(data: unknown): data is ContentValue {
+  return (
+    data !== null &&
+    typeof data === "object" &&
+    ("primitiveValue" in data ||
+      "relatedAsset" in data ||
+      "linkedContentType" in data ||
+      "linkedGridPlacement" in data ||
+      "linkedPathPart" in data ||
+      "linkedTag" in data ||
+      "relatedContentItem" in data ||
+      "smartText" in data ||
+      "interpolatedSmartText" in data)
+  );
+}

package/src/schema/lib/utils/isPrimitiveValue.spec.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it } from "vitest";
+import { isPrimitiveValue } from "./isPrimitiveValue";
+
+describe("isPrimitiveValue", () => {
+  it("should return false if the data is not a content value", () => {
+    const data = {
+      __typename: "ContentValue",
+    };
+
+    const result = isPrimitiveValue(data);
+
+    expect(result).toBe(false);
+  });
+
+  it("should return false if the data is a content value and has no primitive value", () => {
+    const data = {
+      __typename: "ContentValue",
+      relatedAsset: {
+        __typename: "Asset",
+      },
+    };
+
+    const result = isPrimitiveValue(data);
+
+    expect(result).toBe(false);
+  });
+
+  it("should return true if the data is a content value and has a primitive value", () => {
+    const data = {
+      __typename: "ContentValue",
+      primitiveValue: "Hello",
+    };
+
+    const result = isPrimitiveValue(data);
+
+    expect(result).toBe(true);
+  });
+});

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

@@ -0,0 +1,7 @@
+import { Primitive } from "@platecms/delta-types";
+import { ContentValue } from "../../../__generated__/graphql";
+import { isContentValue } from "./isContentValue";
+
+export function isPrimitiveValue(data: unknown): data is ContentValue & { primitiveValue: Primitive } {
+  return isContentValue(data) && data.primitiveValue !== null && data.primitiveValue !== undefined;
+}