@platecms/delta-client 1.0.0 → 1.3.0

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([
+      {
+        linkedPathPart: {
+          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,13 @@
+import { PathPart } from "../../../__generated__/graphql";
+import { isContentValue } from "../utils/isContentValue";
+import { BaseSchema } from "./baseSchema";
+
+export class PathPartSchema extends BaseSchema<PathPart | null, unknown> {
+  protected override findValue(data: unknown): PathPart | null {
+    if (isContentValue(data) && "linkedPathPart" in data) {
+      return (data as { linkedPathPart: PathPart }).linkedPathPart;
+    }
+
+    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,13 @@
+import { Root as SmartText } from "@platecms/delta-cast";
+import { BaseSchema } from "./baseSchema";
+import { isContentValue } from "../utils/isContentValue";
+
+export class SmartTextSchema extends BaseSchema<SmartText | null, unknown> {
+  protected override findValue(data: unknown): SmartText | null {
+    if (isContentValue(data) && "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,13 @@
+import { Tag } from "../../../__generated__/graphql";
+import { isContentValue } from "../utils/isContentValue";
+import { BaseSchema } from "./baseSchema";
+
+export class TagSchema extends BaseSchema<Tag | null, unknown> {
+  protected override findValue(data: unknown): Tag | null {
+    if (isContentValue(data) && "linkedTag" in data) {
+      return (data as { linkedTag: Tag }).linkedTag;
+    }
+
+    return null;
+  }
+}

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

@@ -0,0 +1,160 @@
+import { compact, first, isArray } from "./index";
+
+describe("first", () => {
+  it("should return the first element of an array with numbers", () => {
+    const array = [1, 2, 3, 4, 5];
+    const result = first(array);
+    expect(result).toBe(1);
+  });
+
+  it("should return the first element of an array with strings", () => {
+    const array = ["apple", "banana", "cherry"];
+    const result = first(array);
+    expect(result).toBe("apple");
+  });
+
+  it("should return the first element of an array with objects", () => {
+    const obj1 = { id: 1, name: "first" };
+    const obj2 = { id: 2, name: "second" };
+    const array = [obj1, obj2];
+    const result = first(array);
+    expect(result).toBe(obj1);
+  });
+
+  it("should return undefined for an empty array", () => {
+    const array: number[] = [];
+    const result = first(array);
+    expect(result).toBeUndefined();
+  });
+
+  it("should return the first element even if it's falsy", () => {
+    const array = [0, 1, 2];
+    const result = first(array);
+    expect(result).toBe(0);
+  });
+
+  it("should work with arrays containing undefined", () => {
+    const array = [undefined, "second", "third"];
+    const result = first(array);
+    expect(result).toBeUndefined();
+  });
+});
+
+describe("compact", () => {
+  it("should remove null values from array", () => {
+    const array = [1, null, 2, null, 3];
+    const result = compact(array);
+    expect(result).toEqual([1, 2, 3]);
+  });
+
+  it("should remove undefined values from array", () => {
+    const array = [1, undefined, 2, undefined, 3];
+    const result = compact(array);
+    expect(result).toEqual([1, 2, 3]);
+  });
+
+  it("should remove false values from array", () => {
+    const array = [true, false, true, false];
+    const result = compact(array);
+    expect(result).toEqual([true, true]);
+  });
+
+  it("should remove empty strings from array", () => {
+    const array = ["hello", "", "world", ""];
+    const result = compact(array);
+    expect(result).toEqual(["hello", "world"]);
+  });
+
+  it("should remove zero values from array", () => {
+    const array = [1, 0, 2, 0, 3];
+    const result = compact(array);
+    expect(result).toEqual([1, 2, 3]);
+  });
+
+  it("should remove all falsy values in mixed array", () => {
+    const array = [1, null, "hello", undefined, false, "", 0, 2, "world"];
+    const result = compact(array);
+    expect(result).toEqual([1, "hello", 2, "world"]);
+  });
+
+  it("should return empty array when all values are falsy", () => {
+    const array = [null, undefined, false, "", 0];
+    const result = compact(array);
+    expect(result).toEqual([]);
+  });
+
+  it("should return same array when no falsy values", () => {
+    const array = [1, 2, "hello", true, { id: 1 }];
+    const result = compact(array);
+    expect(result).toEqual([1, 2, "hello", true, { id: 1 }]);
+  });
+
+  it("should work with empty array", () => {
+    const array: (string | null)[] = [];
+    const result = compact(array);
+    expect(result).toEqual([]);
+  });
+});
+
+describe("isArray", () => {
+  it("should return true for empty array", () => {
+    const value: unknown = [];
+    expect(isArray(value)).toBe(true);
+  });
+
+  it("should return true for array of numbers", () => {
+    const value: unknown = [1, 2, 3];
+    expect(isArray(value)).toBe(true);
+  });
+
+  it("should return true for array of strings", () => {
+    const value: unknown = ["a", "b", "c"];
+    expect(isArray(value)).toBe(true);
+  });
+
+  it("should return true for array of objects", () => {
+    const value: unknown = [{ id: 1 }, { id: 2 }];
+    expect(isArray(value)).toBe(true);
+  });
+
+  it("should return false for null", () => {
+    const value: unknown = null;
+    expect(isArray(value)).toBe(false);
+  });
+
+  it("should return false for undefined", () => {
+    const value: unknown = undefined;
+    expect(isArray(value)).toBe(false);
+  });
+
+  it("should return false for plain object", () => {
+    const value: unknown = { key: "value" };
+    expect(isArray(value)).toBe(false);
+  });
+
+  it("should return false for string", () => {
+    const value: unknown = "hello";
+    expect(isArray(value)).toBe(false);
+  });
+
+  it("should return false for number", () => {
+    const value: unknown = 42;
+    expect(isArray(value)).toBe(false);
+  });
+
+  it("should return false for boolean", () => {
+    const value: unknown = true;
+    expect(isArray(value)).toBe(false);
+  });
+
+  it("should return false for function", () => {
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    function value(): void {}
+    expect(isArray(value)).toBe(false);
+  });
+
+  it("should return false for Date object", () => {
+    const value: unknown = new Date();
+    expect(isArray(value)).toBe(false);
+  });
+});

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

@@ -0,0 +1,11 @@
+export function first<T>(array: T[]): T | undefined {
+  return array[0];
+}
+
+export function compact<T>(array: (T | "" | 0 | false | null | undefined)[]): T[] {
+  return array.filter((value) => Boolean(value)) as T[];
+}
+
+export function isArray<T>(value: unknown): value is T[] {
+  return Array.isArray(value);
+}