@platecms/delta-client 0.6.0 → 0.8.0

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

@@ -1,2 +1,2 @@
 export * from "./fragment-masking";
-export * from "./gql";
+export * from "./gql";

package/src/api/index.ts

@@ -0,0 +1 @@
+export default {};

package/src/apollo/index.ts

@@ -0,0 +1,70 @@
+import { HeaderKeys, Stage } from "@platecms/delta-types";
+import {
+  ApolloClient,
+  ApolloLink,
+  FetchPolicy,
+  InMemoryCache,
+  NormalizedCacheObject,
+  createHttpLink,
+  from,
+} from "@apollo/client";
+import { PRN, ServiceAbbreviation } from "@platecms/delta-plate-resource-notation";
+import { compact } from "lodash";
+import { defu } from "defu";
+
+const placeholderOrganizationPrn = new PRN(
+  "delta",
+  "placeholder",
+  ServiceAbbreviation.ORGANIZATIONS_CENTER,
+  "organization",
+  "0",
+);
+
+function createApolloClient(
+  uri: string,
+  options?: {
+    name?: string;
+    errorLink?: ApolloLink;
+    headers?: Record<string, string>;
+  },
+): ApolloClient<NormalizedCacheObject> {
+  function getHeaders(): Record<string, string> {
+    return {
+      [HeaderKeys.X_DELTA_ORGANIZATION]:
+        localStorage.getItem(HeaderKeys.X_DELTA_ORGANIZATION) ?? placeholderOrganizationPrn.toString(),
+      [HeaderKeys.X_DELTA_STAGE]: localStorage.getItem(HeaderKeys.X_DELTA_STAGE) ?? Stage.DEVELOPMENT,
+    };
+  }
+
+  const authLink = new ApolloLink((operation, forward) => {
+    const contextHeaders: Record<string, string> | undefined = operation.getContext()?.headers;
+    const setContextHeaders = defu(contextHeaders, getHeaders());
+
+    operation.setContext({
+      headers: setContextHeaders,
+    });
+    return forward(operation);
+  });
+
+  const httpLink = createHttpLink({
+    uri,
+    credentials: "include",
+  });
+
+  return new ApolloClient({
+    name: options?.name,
+    cache: new InMemoryCache(),
+    defaultOptions: {
+      query: {
+        /*
+         * Cast to FetchPolicy as cache-and-network is valid but not exposed as a type
+         * See @apollo/client/core/watchQueryOptions.d.ts line 13 for more details
+         */
+        fetchPolicy: "cache-and-network" as FetchPolicy,
+      },
+    },
+    link: from(compact([options?.errorLink, authLink.concat(httpLink)])),
+  });
+}
+
+export { createApolloClient };

package/src/graphql/tags/tag.query.gql

@@ -0,0 +1,5 @@
+query tag($prn: [PRN!]!) {
+  tag(prn: $prn) {
+    ...tagFragment
+  }
+}

package/src/graphql/tags/tags.fragments.gql

@@ -0,0 +1,17 @@
+fragment tagFragment on Tag {
+  _id: prn
+  prn
+  name
+  path
+  color
+  visibility
+  forceVisibilityOnDescendants
+  stage
+  amountOfChildren
+  amountOfContentExperiences
+  amountOfContentItems
+  hasForcedVisibility
+  nestingLevel
+  createdAt
+  updatedAt
+}

package/src/index.ts

@@ -0,0 +1 @@
+export {};

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.ts

@@ -0,0 +1,18 @@
+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";
+export * from "./lib/schemas/date";
+export * from "./lib/schemas/asset";
+export * from "./lib/schemas/smartText";
+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,111 @@
+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 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,38 @@
+import { compact, first } from "lodash";
+import { Schema, SchemaConfig } from ".";
+
+export class ArraySchema<T extends Schema | Schema[]>
+  implements Schema<T extends Schema[] ? T[number]["parse"][] : T extends Schema ? 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[] ? T[number]["parse"][] : T extends Schema ? 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[] ? T[number]["parse"][] : T extends Schema ? T["parse"][] : never;
+
+    return config?.placeholders === true
+      ? results
+      : (compact(results) as T extends Schema[] ? T[number]["parse"][] : T extends Schema ? 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([
+      {
+        linkedAsset: {
+          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,12 @@
+import { Asset } from "../../../__generated__/graphql";
+import { BaseSchema } from "./baseSchema";
+
+export class AssetSchema extends BaseSchema<Asset | null, unknown> {
+  protected override findValue(data: unknown): Asset | null {
+    if (typeof data === "object" && data !== null && "linkedAsset" in data) {
+      return (data as { linkedAsset: Asset }).linkedAsset;
+    }
+
+    return null;
+  }
+}

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

@@ -0,0 +1,42 @@
+import { isArray } from "lodash";
+import { ResultType, Schema, SchemaConfig } from ".";
+
+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;
+}