@platecms/delta-client 0.13.0 → 1.2.0

package/src/api/fetchContentExperiences.spec.ts

@@ -0,0 +1,82 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import { afterEach, describe, expect, it, vi } from "vitest";
+import axios, { AxiosResponse } from "axios";
+
+import { fetchContentExperiences } from "./fetchContentExperiences";
+import { PaginatedResponse } from "../app/utils/paginated-response.type";
+import { ContentExperiencesQuery } from "../__generated__/graphql";
+import { API_VERSION, apiBaseUrl } from "../utils";
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("fetchContentExperiences", () => {
+  it("calls the list endpoint with params and returns the response", async () => {
+    const mockResponse = {
+      data: {
+        links: { first: null, previous: null, self: "", next: null, last: null },
+        meta: { page: { total: 1, maxSize: 10 } },
+        data: [],
+      },
+      status: 200,
+      headers: {},
+      config: {},
+      statusText: "OK",
+    } as unknown as AxiosResponse<PaginatedResponse<ContentExperiencesQuery>>;
+
+    const get = vi.fn().mockResolvedValue(mockResponse);
+    const createSpy = vi.spyOn(axios, "create").mockReturnValue({ get } as unknown as ReturnType<typeof axios.create>);
+
+    const result = await fetchContentExperiences({
+      mode: "dev",
+      token: "token-123",
+      first: 10,
+      title: "home",
+      tags: "tag:foo",
+    });
+
+    const expectedBaseUrl = new URL(`/content-delivery-api/${API_VERSION}/content-experiences`, apiBaseUrl("dev"));
+    expect(createSpy).toHaveBeenCalledWith({
+      baseURL: expectedBaseUrl.toString(),
+      headers: { Authorization: "Bearer token-123" },
+    });
+
+    expect(get).toHaveBeenCalledWith("", {
+      params: expect.objectContaining({ first: 10, title: "home", tags: "tag:foo" }),
+    });
+
+    expect(result).toBe(mockResponse);
+  });
+
+  it("calls the path endpoint when options.path is provided", async () => {
+    const mockResponse = {
+      data: {},
+    } as unknown as AxiosResponse<PaginatedResponse<ContentExperiencesQuery>>;
+    const get = vi.fn().mockResolvedValue(mockResponse);
+    const createSpy = vi.spyOn(axios, "create").mockReturnValue({ get } as unknown as ReturnType<typeof axios.create>);
+
+    await fetchContentExperiences({
+      mode: "acc",
+      version: "v0",
+      token: "t-acc",
+      path: "/home",
+    });
+
+    expect(createSpy).toHaveBeenCalledWith({
+      baseURL: "https://api.delta-acc.getplate.rocks/content-delivery-api/v0/content-experiences/path/home",
+      headers: { Authorization: "Bearer t-acc" },
+    });
+  });
+
+  it("returns an Error when the request fails", async () => {
+    const error = new Error("boom");
+    const get = vi.fn().mockRejectedValue(error);
+    vi.spyOn(axios, "create").mockReturnValue({ get } as unknown as ReturnType<typeof axios.create>);
+
+    const result = await fetchContentExperiences({ mode: "dev", token: "t" });
+    expect(result).toBeInstanceOf(Error);
+    expect((result as Error).message).toBe("boom");
+  });
+});
+/* eslint-enable @typescript-eslint/naming-convention */

package/src/api/fetchContentExperiences.ts

@@ -0,0 +1,42 @@
+import axios, { AxiosInstance, AxiosResponse } from "axios";
+import { ContentExperiencesQuery } from "../__generated__/graphql";
+import { PaginatedResponse } from "../app/utils/paginated-response.type";
+import { API_VERSION, apiBaseUrl } from "../utils";
+import { ContentExperiencesApiOptions } from "./types";
+
+function getClient(token: string, endpoint: string): AxiosInstance {
+  return axios.create({
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    baseURL: endpoint,
+    headers: {
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      Authorization: `Bearer ${token}`,
+    },
+  });
+}
+
+export async function fetchContentExperiences(
+  options: ContentExperiencesApiOptions,
+): Promise<AxiosResponse<PaginatedResponse<ContentExperiencesQuery>> | Error> {
+  const endpointUrl = new URL(
+    `/content-delivery-api/${options.version ?? API_VERSION}/content-experiences${options.path != null ? `/path${options.path}` : ""}`,
+    apiBaseUrl(options.mode),
+  );
+  const client = getClient(options.token, endpointUrl.toString());
+  return client
+    .get("", {
+      params: {
+        first: options.first,
+        last: options.last,
+        before: options.before,
+        after: options.after,
+        title: options.title,
+        tags: options.tags,
+      },
+    })
+    .then((res) => res as AxiosResponse<PaginatedResponse<ContentExperiencesQuery>>)
+    .catch((err: unknown) => {
+      const error = err as Error;
+      return error;
+    });
+}

package/src/api/fetchContentItems.spec.ts

@@ -0,0 +1,62 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import { afterEach, describe, expect, it, vi } from "vitest";
+import axios, { AxiosResponse } from "axios";
+
+import { fetchContentItems } from "./fetchContentItems";
+import { PaginatedResponse } from "../app/utils/paginated-response.type";
+import { ContentItemsQuery } from "../__generated__/graphql";
+import { API_VERSION, apiBaseUrl } from "../utils";
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("fetchContentItems", () => {
+  it("calls the list endpoint with params and returns the response", async () => {
+    const mockResponse = {
+      data: {
+        links: { first: null, previous: null, self: "", next: null, last: null },
+        meta: { page: { total: 1, maxSize: 10 } },
+        data: [],
+      },
+      status: 200,
+      headers: {},
+      config: {},
+      statusText: "OK",
+    } as unknown as AxiosResponse<PaginatedResponse<ContentItemsQuery>>;
+
+    const get = vi.fn().mockResolvedValue(mockResponse);
+    const createSpy = vi.spyOn(axios, "create").mockReturnValue({ get } as unknown as ReturnType<typeof axios.create>);
+
+    const result = await fetchContentItems({
+      mode: "dev",
+      token: "token-123",
+      first: 10,
+      tags: "tag:foo",
+      contentTypePrn: "contentTypePrn-123",
+    });
+
+    const expectedBaseUrl = new URL(`/content-delivery-api/${API_VERSION}/content-items`, apiBaseUrl("dev"));
+    expect(createSpy).toHaveBeenCalledWith({
+      baseURL: expectedBaseUrl.toString(),
+      headers: { Authorization: "Bearer token-123" },
+    });
+
+    expect(get).toHaveBeenCalledWith("", {
+      params: expect.objectContaining({ first: 10, tags: "tag:foo", contentTypePrn: "contentTypePrn-123" }),
+    });
+
+    expect(result).toBe(mockResponse);
+  });
+
+  it("returns an Error when the request fails", async () => {
+    const error = new Error("boom");
+    const get = vi.fn().mockRejectedValue(error);
+    vi.spyOn(axios, "create").mockReturnValue({ get } as unknown as ReturnType<typeof axios.create>);
+
+    const result = await fetchContentItems({ mode: "dev", token: "t" });
+    expect(result).toBeInstanceOf(Error);
+    expect((result as Error).message).toBe("boom");
+  });
+});
+/* eslint-enable @typescript-eslint/naming-convention */

package/src/api/fetchContentItems.ts

@@ -0,0 +1,42 @@
+import axios, { AxiosInstance, AxiosResponse } from "axios";
+import { ContentItemsQuery } from "../__generated__/graphql";
+import { PaginatedResponse } from "../app/utils/paginated-response.type";
+import { API_VERSION, apiBaseUrl } from "../utils";
+import { ContentItemsApiOptions } from "./types";
+
+function getClient(token: string, endpoint: string): AxiosInstance {
+  return axios.create({
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    baseURL: endpoint,
+    headers: {
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      Authorization: `Bearer ${token}`,
+    },
+  });
+}
+
+export async function fetchContentItems(
+  options: ContentItemsApiOptions,
+): Promise<AxiosResponse<PaginatedResponse<ContentItemsQuery>> | Error> {
+  const endpointUrl = new URL(
+    `/content-delivery-api/${options.version ?? API_VERSION}/content-items`,
+    apiBaseUrl(options.mode),
+  );
+  const client = getClient(options.token, endpointUrl.toString());
+  return client
+    .get("", {
+      params: {
+        first: options.first,
+        last: options.last,
+        before: options.before,
+        after: options.after,
+        tags: options.tags,
+        contentTypePrn: options.contentTypePrn,
+      },
+    })
+    .then((res) => res as AxiosResponse<PaginatedResponse<ContentItemsQuery>>)
+    .catch((err: unknown) => {
+      const error = err as Error;
+      return error;
+    });
+}

package/src/api/fetchPathParts.spec.ts

@@ -0,0 +1,62 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import { afterEach, describe, expect, it, vi } from "vitest";
+import axios, { AxiosResponse } from "axios";
+
+import { fetchPathParts } from "./fetchPathParts";
+import { PaginatedResponse } from "../app/utils/paginated-response.type";
+import { PathPartsQuery } from "../__generated__/graphql";
+import { API_VERSION, apiBaseUrl } from "../utils";
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("fetchPathParts", () => {
+  it("calls the list endpoint with params and returns the response", async () => {
+    const mockResponse = {
+      data: {
+        links: { first: null, previous: null, self: "", next: null, last: null },
+        meta: { page: { total: 1, maxSize: 10 } },
+        data: [],
+      },
+      status: 200,
+      headers: {},
+      config: {},
+      statusText: "OK",
+    } as unknown as AxiosResponse<PaginatedResponse<PathPartsQuery>>;
+
+    const get = vi.fn().mockResolvedValue(mockResponse);
+    const createSpy = vi.spyOn(axios, "create").mockReturnValue({ get } as unknown as ReturnType<typeof axios.create>);
+
+    const result = await fetchPathParts({
+      mode: "dev",
+      token: "token-123",
+      first: 10,
+      parent: "parent-123",
+      hasContentExperience: true,
+    });
+
+    const expectedBaseUrl = new URL(`/content-delivery-api/${API_VERSION}/path-parts`, apiBaseUrl("dev"));
+    expect(createSpy).toHaveBeenCalledWith({
+      baseURL: expectedBaseUrl.toString(),
+      headers: { Authorization: "Bearer token-123" },
+    });
+
+    expect(get).toHaveBeenCalledWith("", {
+      params: expect.objectContaining({ first: 10, parent: "parent-123", hasContentExperience: true }),
+    });
+
+    expect(result).toBe(mockResponse);
+  });
+
+  it("returns an Error when the request fails", async () => {
+    const error = new Error("boom");
+    const get = vi.fn().mockRejectedValue(error);
+    vi.spyOn(axios, "create").mockReturnValue({ get } as unknown as ReturnType<typeof axios.create>);
+
+    const result = await fetchPathParts({ mode: "dev", token: "t" });
+    expect(result).toBeInstanceOf(Error);
+    expect((result as Error).message).toBe("boom");
+  });
+});
+/* eslint-enable @typescript-eslint/naming-convention */

package/src/api/fetchPathParts.ts

@@ -0,0 +1,42 @@
+import axios, { AxiosInstance, AxiosResponse } from "axios";
+import { PaginatedResponse } from "../app/utils/paginated-response.type";
+import { PathPartsQuery } from "../schema";
+import { API_VERSION, apiBaseUrl } from "../utils";
+import { PathPartsApiOptions } from "./types";
+
+function getClient(token: string, endpoint: string): AxiosInstance {
+  return axios.create({
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    baseURL: endpoint,
+    headers: {
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      Authorization: `Bearer ${token}`,
+    },
+  });
+}
+
+export async function fetchPathParts(
+  options: PathPartsApiOptions,
+): Promise<AxiosResponse<PaginatedResponse<PathPartsQuery>> | Error> {
+  const endpointUrl = new URL(
+    `/content-delivery-api/${options.version ?? API_VERSION}/path-parts`,
+    apiBaseUrl(options.mode),
+  );
+  const client = getClient(options.token, endpointUrl.toString());
+  return client
+    .get("", {
+      params: {
+        first: options.first,
+        after: options.after,
+        last: options.last,
+        before: options.before,
+        hasContentExperience: options.hasContentExperience,
+        parent: options.parent,
+      },
+    })
+    .then((res) => res as AxiosResponse<PaginatedResponse<PathPartsQuery>>)
+    .catch((err: unknown) => {
+      const error = err as Error;
+      return error;
+    });
+}

package/src/api/fetchTags.spec.ts

@@ -0,0 +1,61 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import { afterEach, describe, expect, it, vi } from "vitest";
+import axios, { AxiosResponse } from "axios";
+
+import { fetchTags } from "./fetchTags";
+import { PaginatedResponse } from "../app/utils/paginated-response.type";
+import { TagsQuery } from "../__generated__/graphql";
+import { API_VERSION, apiBaseUrl } from "../utils";
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("fetchTags", () => {
+  it("calls the list endpoint with params and returns the response", async () => {
+    const mockResponse = {
+      data: {
+        links: { first: null, previous: null, self: "", next: null, last: null },
+        meta: { page: { total: 1, maxSize: 10 } },
+        data: [],
+      },
+      status: 200,
+      headers: {},
+      config: {},
+      statusText: "OK",
+    } as unknown as AxiosResponse<PaginatedResponse<TagsQuery>>;
+
+    const get = vi.fn().mockResolvedValue(mockResponse);
+    const createSpy = vi.spyOn(axios, "create").mockReturnValue({ get } as unknown as ReturnType<typeof axios.create>);
+
+    const result = await fetchTags({
+      mode: "dev",
+      token: "token-123",
+      first: 10,
+      name: "name-123",
+    });
+
+    const expectedBaseUrl = new URL(`/content-delivery-api/${API_VERSION}/tags`, apiBaseUrl("dev"));
+    expect(createSpy).toHaveBeenCalledWith({
+      baseURL: expectedBaseUrl.toString(),
+      headers: { Authorization: "Bearer token-123" },
+    });
+
+    expect(get).toHaveBeenCalledWith("", {
+      params: expect.objectContaining({ first: 10, name: "name-123" }),
+    });
+
+    expect(result).toBe(mockResponse);
+  });
+
+  it("returns an Error when the request fails", async () => {
+    const error = new Error("boom");
+    const get = vi.fn().mockRejectedValue(error);
+    vi.spyOn(axios, "create").mockReturnValue({ get } as unknown as ReturnType<typeof axios.create>);
+
+    const result = await fetchTags({ mode: "dev", token: "t" });
+    expect(result).toBeInstanceOf(Error);
+    expect((result as Error).message).toBe("boom");
+  });
+});
+/* eslint-enable @typescript-eslint/naming-convention */

package/src/api/fetchTags.ts

@@ -0,0 +1,38 @@
+import axios, { AxiosInstance, AxiosResponse } from "axios";
+import { PaginatedResponse } from "../app/utils/paginated-response.type";
+import { TagsQuery } from "../__generated__/graphql";
+import { API_VERSION, apiBaseUrl } from "../utils";
+import { TagsApiOptions } from "./types";
+
+function getClient(token: string, endpoint: string): AxiosInstance {
+  return axios.create({
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    baseURL: endpoint,
+    headers: {
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      Authorization: `Bearer ${token}`,
+    },
+  });
+}
+
+export async function fetchTags(options: TagsApiOptions): Promise<AxiosResponse<PaginatedResponse<TagsQuery>> | Error> {
+  const endpointUrl = new URL(`/content-delivery-api/${options.version ?? API_VERSION}/tags`, apiBaseUrl(options.mode));
+  const client = getClient(options.token, endpointUrl.toString());
+
+  return client
+    .get("", {
+      params: {
+        first: options.first,
+        after: options.after,
+        last: options.last,
+        before: options.before,
+        name: options.name,
+        parent: options.parent,
+      },
+    })
+    .then((res) => res)
+    .catch((err: unknown) => {
+      const error = err;
+      return error as Error;
+    });
+}

package/src/api/index.ts

@@ -1 +1,4 @@
-export default {};
+export * from "./fetchContentExperiences";
+export * from "./fetchContentItems";
+export * from "./fetchPathParts";
+export * from "./fetchTags";

package/src/api/types.ts

@@ -0,0 +1,35 @@
+export type Mode = "acc" | "dev" | "prod";
+
+export interface DefaultApiOptions {
+  mode: Mode;
+  version?: string;
+  token: string;
+}
+
+export type PaginatedApiOptions = DefaultApiOptions & {
+  first?: number;
+  last?: number;
+  before?: string;
+  after?: string;
+};
+
+export type ContentItemsApiOptions = PaginatedApiOptions & {
+  tags?: string | null;
+  contentTypePrn?: string;
+};
+
+export type ContentExperiencesApiOptions = PaginatedApiOptions & {
+  title?: string;
+  tags?: string | null;
+  path?: string;
+};
+
+export type TagsApiOptions = PaginatedApiOptions & {
+  name?: string;
+  parent?: string;
+};
+
+export type PathPartsApiOptions = PaginatedApiOptions & {
+  parent?: string;
+  hasContentExperience?: boolean;
+};

package/src/apollo/index.ts

@@ -14,7 +14,7 @@ import { defu } from "defu";
 const placeholderOrganizationPrn = new PRN(
   "delta",
   "placeholder",
-  ServiceAbbreviation.ORGANIZATIONS_CENTER,
+  ServiceAbbreviation.PLATFORM_SERVICE,
   "organization",
   "0",
 );

package/src/app/utils/paginated-response.type.ts

@@ -0,0 +1,19 @@
+export interface PaginatedResponse<T> {
+  links: {
+    first?: string | null;
+    previous?: string | null;
+    self: string;
+    next?: string | null;
+    last?: string | null;
+  };
+  meta: {
+    page: {
+      total: number;
+      maxSize: number;
+    };
+  };
+  data: {
+    node: T;
+    cursor: string;
+  }[];
+}

package/src/factories/BaseFactory.ts

@@ -0,0 +1,19 @@
+import { v4 as uuidv4 } from "uuid";
+import { faker } from "@faker-js/faker";
+import { PRN, ServiceAbbreviation } from "@platecms/delta-plate-resource-notation";
+
+export abstract class BaseFactory<T> {
+  protected readonly prn: string;
+  protected readonly uuid: string;
+  protected readonly createdAt: string;
+  protected readonly updatedAt: string;
+
+  public constructor() {
+    this.uuid = uuidv4();
+    this.prn = new PRN("test", uuidv4(), ServiceAbbreviation.CONTENT_MANAGEMENT_SERVICE, "asset", this.uuid).toString();
+    this.createdAt = faker.date.past().toISOString();
+    this.updatedAt = faker.date.recent().toISOString();
+  }
+
+  public abstract create(input?: Partial<T>): T;
+}

package/src/factories/ChannelFactory.ts

@@ -0,0 +1,19 @@
+import { BaseFactory } from "./BaseFactory";
+import { Channel } from "../__generated__/graphql";
+import { faker } from "@faker-js/faker";
+
+export class ChannelFactory extends BaseFactory<Channel> {
+  public create(input: Partial<Channel> | undefined): Channel {
+    return {
+      prn: this.prn,
+      _id: this.prn,
+      name: faker.lorem.word(),
+      domain: faker.internet.domainName(),
+      slug: faker.internet.domainWord(),
+      createdAt: this.createdAt,
+      updatedAt: this.updatedAt,
+      __typename: "Channel",
+      ...input,
+    } as unknown as Channel;
+  }
+}

package/src/factories/ContentExperienceFactory.ts

@@ -0,0 +1,54 @@
+import { BaseFactory } from "./BaseFactory";
+import { ContentExperience, Theme } from "../__generated__/graphql";
+import { faker } from "@faker-js/faker";
+import { PathPartFactory } from "./PathPartFactory";
+import { ChannelFactory } from "./ChannelFactory";
+
+export class ContentExperienceFactory extends BaseFactory<ContentExperience> {
+  public create(input: Partial<ContentExperience> | undefined): ContentExperience {
+    return {
+      prn: this.prn,
+      _id: this.prn,
+      title: faker.word.words(2),
+      preview: null,
+      experienceComponent: {
+        _id: this.prn,
+        prn: this.prn,
+        grid: null,
+        name: faker.word.words(2),
+        isDraft: false,
+        buildingBlock: {
+          buildingBlockFields: [],
+        },
+        stage: "development",
+        preview: null,
+        isGlobal: false,
+        buildingBlockFieldFulfillments: [],
+        __typename: "ExperienceComponent",
+        createdAt: this.createdAt,
+        updatedAt: this.updatedAt,
+        blueprintedBy: null,
+      },
+      slug: faker.lorem.slug(),
+      createdAt: this.createdAt,
+      updatedAt: this.updatedAt,
+      __typename: "ContentExperience",
+      pathPart: new PathPartFactory().create({
+        channel: new ChannelFactory().create({
+          theme: {
+            _id: this.prn,
+            prn: this.prn,
+            repositoryUrl: "https://github.com/plate-dev/plate",
+            name: faker.word.words(2),
+            createdAt: this.createdAt,
+            updatedAt: this.updatedAt,
+            __typename: "Theme",
+            buildingBlocks: [],
+            channels: [],
+          } as unknown as Theme,
+        }),
+      }),
+      ...input,
+    } as unknown as ContentExperience;
+  }
+}

package/src/factories/PathPartFactory.ts

@@ -0,0 +1,26 @@
+import { BaseFactory } from "./BaseFactory";
+import { faker } from "@faker-js/faker";
+import { PathPart } from "../__generated__/graphql";
+
+export class PathPartFactory extends BaseFactory<PathPart> {
+  public create(input: Partial<PathPart> | undefined = {}): PathPart {
+    return {
+      prn: this.prn,
+      _id: this.prn,
+      path: faker.lorem.word(),
+      slug: faker.lorem.word(),
+      parent: null,
+      contentExperience: null,
+      hasContentExperience: false,
+      amountOfChildren: 0,
+      amountOfChildrenWithContentExperiences: 0,
+      amountOfDescendants: 0,
+      amountOfDescendantsWithContentExperiences: 0,
+      children: [],
+      createdAt: this.createdAt,
+      updatedAt: this.updatedAt,
+      __typename: "PathPart",
+      ...input,
+    } as unknown as PathPart;
+  }
+}

package/src/factories/TagFactory.ts

@@ -0,0 +1,30 @@
+import { BaseFactory } from "./BaseFactory";
+import { Stage, Tag, TagVisibility } from "../../src/__generated__/graphql";
+import { faker } from "@faker-js/faker";
+
+export class TagFactory extends BaseFactory<Tag> {
+  public create(input?: Partial<Tag>): Tag & { amountOfChildren: number; amountOfUses: number } {
+    return {
+      prn: this.prn,
+      _id: this.prn,
+      name: faker.lorem.word(),
+      path: faker.lorem.word(),
+      nestingLevel: faker.number.int({ min: 0, max: 5 }),
+      forceVisibilityOnDescendants: faker.datatype.boolean(),
+      hasForcedVisibility: faker.datatype.boolean(),
+      visibility: faker.datatype.boolean() ? TagVisibility.Public : TagVisibility.Private,
+      stage: faker.datatype.boolean() ? Stage.Production : Stage.Development,
+      color: faker.color.rgb(),
+      parent: null,
+      amountOfContentExperiences: faker.number.int({ min: 0, max: 10 }),
+      amountOfContentItems: faker.number.int({ min: 0, max: 10 }),
+      amountOfChildren: faker.number.int({ min: 0, max: 10 }),
+      amountOfUses: faker.number.int({ min: 0, max: 100 }),
+      createdAt: this.createdAt,
+      updatedAt: this.updatedAt,
+      children: [],
+      __typename: "Tag",
+      ...input,
+    } as unknown as Tag & { amountOfChildren: number; amountOfUses: number };
+  }
+}