@cntrl-site/sdk 0.2.14 → 0.3.0

package/lib/Client/Client.js

@@ -20,35 +20,36 @@ class Client {
         }
     }
     async getProject() {
-        const projectUrl = new url_1.URL(`/projects/${this.projectId}`, this.APIUrl);
-        const response = await this.fetchImpl(projectUrl.href);
-        if (!response.ok) {
-            throw new Error(`Failed to fetch project with id #${this.projectId}: ${response.statusText}`);
+        try {
+            const response = await this.fetchProject();
+            const data = await response.json();
+            const project = core_1.ProjectSchema.parse(data);
+            return project;
+        }
+        catch (e) {
+            throw e;
         }
-        const data = await response.json();
-        const project = core_1.ProjectSchema.parse(data);
-        return project;
     }
     async getPageArticle(pageSlug) {
-        const projectUrl = new url_1.URL(`/projects/${this.projectId}`, this.APIUrl);
-        const projectResponse = await this.fetchImpl(projectUrl.href);
-        if (!projectResponse.ok) {
-            throw new Error(`Failed to fetch project with id #${this.projectId}: ${projectResponse.statusText}`);
-        }
-        const data = await projectResponse.json();
-        const project = core_1.ProjectSchema.parse(data);
-        const page = project.pages.find((page) => page.slug === pageSlug);
-        if (!page) {
-            throw new Error(`Page with a slug ${pageSlug} was not found in project with id #${this.projectId}`);
+        try {
+            const projectResponse = await this.fetchProject();
+            const data = await projectResponse.json();
+            const project = core_1.ProjectSchema.parse(data);
+            const articleId = this.findArticleIdByPageSlug(pageSlug, project.pages);
+            const articleResponse = await this.fetchArticle(articleId);
+            const articleData = await articleResponse.json();
+            const article = core_1.ArticleSchema.parse(articleData);
+            return article;
         }
-        const url = new url_1.URL(`/articles/${page.articleId}`, this.APIUrl);
-        const articleResponse = await this.fetchImpl(url.href);
-        if (!articleResponse.ok) {
-            throw new Error(`Failed to fetch article with id #${page.articleId}: ${articleResponse.statusText}`);
+        catch (e) {
+            throw e;
         }
-        const articleData = await articleResponse.json();
-        const article = core_1.ArticleSchema.parse(articleData);
-        return article;
+    }
+    async getTypePresets() {
+        const response = await this.fetchTypePresets();
+        const data = await response.json();
+        const typePresets = core_1.TypePresetsSchema.parse(data);
+        return typePresets;
     }
     static getPageMeta(projectMeta, pageMeta) {
         return pageMeta.enabled ? {
@@ -59,5 +60,36 @@ class Client {
             favicon: projectMeta.favicon
         } : projectMeta;
     }
+    async fetchProject() {
+        const url = new url_1.URL(`/projects/${this.projectId}`, this.APIUrl);
+        const response = await this.fetchImpl(url.href);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch project with id #${this.projectId}: ${response.statusText}`);
+        }
+        return response;
+    }
+    async fetchArticle(articleId) {
+        const url = new url_1.URL(`/articles/${articleId}`, this.APIUrl);
+        const response = await this.fetchImpl(url.href);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch article with id #${articleId}: ${response.statusText}`);
+        }
+        return response;
+    }
+    async fetchTypePresets() {
+        const url = new url_1.URL(`/projects/${this.projectId}/type-presets`, this.APIUrl);
+        const response = await this.fetchImpl(url.href);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch type presets for the project with id #${this.projectId}: ${response.statusText}`);
+        }
+        return response;
+    }
+    findArticleIdByPageSlug(slug, pages) {
+        const page = pages.find((page) => page.slug === slug);
+        if (!page) {
+            throw new Error(`Page with a slug ${slug} was not found in project with id #${this.projectId}`);
+        }
+        return page.articleId;
+    }
 }
 exports.Client = Client;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cntrl-site/sdk",
-  "version": "0.2.14",
+  "version": "0.3.0",
   "description": "Generic SDK for use in public websites.",
   "main": "lib/index.js",
   "types": "src/index.ts",

package/src/Client/Client.test.ts

@@ -0,0 +1,184 @@
+import { Client } from './Client';
+import { projectMock } from './__mock__/projectMock';
+import { articleMock } from './__mock__/articleMock';
+import { typePresetsMock } from './__mock__/typePresetsMock';
+import { TMeta, TPageMeta } from '@cntrl-site/core';
+
+describe('Client', () => {
+  it('returns project', async () => {
+    let fetchCalledTimes = 0;
+    const projectId = 'projectId';
+    const apiUrl = 'https://api.cntrl.site/';
+    const fetch = async (url: string) => {
+      fetchCalledTimes += 1;
+      expect(url).toBe(`${apiUrl}projects/${projectId}`);
+      return Promise.resolve({
+        ok: true,
+        json: () => Promise.resolve(projectMock),
+        statusText: ''
+      });
+    };
+    const client = new Client(projectId, apiUrl, fetch);
+    const project = await client.getProject();
+    expect(fetchCalledTimes).toBe(1);
+    expect(project).toEqual(projectMock);
+  });
+
+  it('throws an error upon project fetch failure', async () => {
+    const projectId = 'projectId';
+    const apiUrl = 'https://api.cntrl.site/';
+    const fetch = async () => Promise.resolve({
+      ok: false,
+      statusText: 'reason',
+      json: () => Promise.resolve()
+    });
+    const client = new Client(projectId, apiUrl, fetch);
+    await expect(client.getProject()).rejects.toEqual(new Error('Failed to fetch project with id #projectId: reason'));
+  });
+
+  it('returns article by page slug', async () => {
+    let fetchCalledTimes = 0;
+    const projectId = 'projectId';
+    const apiUrl = 'https://api.cntrl.site/';
+    const projectApiUrl = `${apiUrl}projects/projectId`;
+    const articleApiUrl = `${apiUrl}articles/articleId`;
+    const fetch = async (url: string) => {
+      fetchCalledTimes += 1;
+      if (fetchCalledTimes === 1) {
+        expect(url).toBe(projectApiUrl);
+      }
+      if (fetchCalledTimes === 2) {
+        expect(url).toBe(articleApiUrl);
+      }
+      return Promise.resolve({
+        ok: true,
+        json: () => Promise.resolve(url === projectApiUrl ? projectMock : articleMock),
+        statusText: ''
+      });
+    };
+    const client = new Client(projectId, apiUrl, fetch);
+    const article = await client.getPageArticle('/');
+    expect(fetchCalledTimes).toBe(2);
+    expect(article).toEqual(articleMock);
+  });
+
+  it('throws an error upon project fetch failure when trying to get article by slug', async () => {
+    const projectId = 'projectId';
+    const apiUrl = 'https://api.cntrl.site/';
+    const fetch = async () => Promise.resolve({
+      ok: false,
+      statusText: 'reason',
+      json: () => Promise.resolve()
+    });
+    const client = new Client(projectId, apiUrl, fetch);
+    await expect(client.getPageArticle('/'))
+      .rejects.toEqual(new Error('Failed to fetch project with id #projectId: reason'));
+  });
+
+  it('throws an error upon article fetch failure when trying to get article by slug', async () => {
+    const projectId = 'projectId';
+    const apiUrl = 'https://api.cntrl.site/';
+    const projectApiUrl = `${apiUrl}projects/projectId`;
+    const fetch = (url: string) => {
+      return Promise.resolve({
+        ok: url === projectApiUrl,
+        json: () => Promise.resolve(projectMock),
+        statusText: 'reason'
+      });
+    };
+    const client = new Client(projectId, apiUrl, fetch);
+    await expect(client.getPageArticle('/'))
+      .rejects.toEqual(new Error('Failed to fetch article with id #articleId: reason'));
+  });
+
+  it('throws an error when trying to fetch article by nonexistent slug', async () => {
+    const projectId = 'projectId';
+    const apiUrl = 'https://api.cntrl.site/';
+    const projectApiUrl = `${apiUrl}projects/projectId`;
+    const slug = '/nonexistent-slug';
+    const fetch = (url: string) => {
+      return Promise.resolve({
+        ok: url === projectApiUrl,
+        json: () => Promise.resolve(projectMock),
+        statusText: 'reason'
+      });
+    };
+    const client = new Client(projectId, apiUrl, fetch);
+    await expect(client.getPageArticle(slug))
+      .rejects.toEqual(new Error(`Page with a slug ${slug} was not found in project with id #${projectId}`));
+  });
+
+  it('returns type presets by project id', async () => {
+    let fetchCalledTimes = 0;
+    const projectId = 'projectId';
+    const apiUrl = 'https://api.cntrl.site/';
+    const fetch = (url: string) => {
+      fetchCalledTimes += 1;
+      expect(url).toBe(`${apiUrl}projects/${projectId}/type-presets`);
+      return Promise.resolve({
+        ok: true,
+        json: () => Promise.resolve(typePresetsMock),
+        statusText: ''
+      });
+    };
+    const client = new Client(projectId, apiUrl, fetch);
+    const presets = await client.getTypePresets();
+    expect(presets).toEqual(typePresetsMock);
+    expect(fetchCalledTimes).toEqual(1);
+  });
+
+  it('throws an error upon type presets fetch failure', async () => {
+    const projectId = 'projectId';
+    const apiUrl = 'https://api.cntrl.site/';
+    const fetch = () => {
+      return Promise.resolve({
+        ok: false,
+        json: () => Promise.resolve(),
+        statusText: 'reason'
+      });
+    };
+    const client = new Client(projectId, apiUrl, fetch);
+    await expect(client.getTypePresets()).rejects.toEqual(
+      new Error(`Failed to fetch type presets for the project with id #${projectId}: reason`)
+    );
+  });
+
+  it('merges two meta objects into one with priority of page-based over project-based', () => {
+    const pageMeta: TPageMeta = {
+      enabled: true,
+      description: 'page-desc',
+      title: 'page-title'
+    };
+
+    const projectMeta: TMeta = {
+      opengraphThumbnail: 'proj-og',
+      description: 'proj-desc',
+      title: 'proj-title',
+      keywords: 'project, keywords'
+    };
+    const meta = Client.getPageMeta(projectMeta, pageMeta);
+    expect(meta.keywords).toBe(projectMeta.keywords);
+    expect(meta.opengraphThumbnail).toBe(projectMeta.opengraphThumbnail);
+    expect(meta.description).toBe(pageMeta.description);
+    expect(meta.title).toBe(pageMeta.title);
+  });
+
+  it('ignores page meta when `enabled` is set to `false` and uses only generic project meta', () => {
+    const pageMeta: TPageMeta = {
+      enabled: false,
+      description: 'page-desc',
+      title: 'page-title'
+    };
+
+    const projectMeta: TMeta = {
+      opengraphThumbnail: 'proj-og',
+      keywords: 'project, keywords'
+    };
+
+    const meta = Client.getPageMeta(projectMeta, pageMeta);
+    expect(meta.keywords).toBe(projectMeta.keywords);
+    expect(meta.opengraphThumbnail).toBe(projectMeta.opengraphThumbnail);
+    expect(meta.description).toBeUndefined();
+    expect(meta.title).toBeUndefined();
+  });
+});

package/src/Client/Client.ts

@@ -1,4 +1,14 @@
-import { TProject, ProjectSchema, TArticle, ArticleSchema, TMeta, TPageMeta } from '@cntrl-site/core';
+import {
+  TProject,
+  ProjectSchema,
+  TArticle,
+  ArticleSchema,
+  TMeta,
+  TPageMeta,
+  TTypePresets,
+  TypePresetsSchema,
+  TPage
+} from '@cntrl-site/core';
 import fetch from 'isomorphic-fetch';
 import { URL } from 'url';
 
@@ -6,7 +16,7 @@ export class Client {
   constructor(
     private projectId: string,
     private APIUrl: string,
-    private fetchImpl = fetch
+    private fetchImpl: FetchImpl = fetch
   ) {
     if (projectId.length === 0) {
       throw new Error('CNTRL SDK: Project ID is empty. Did you forget to pass it?');
@@ -17,37 +27,36 @@ export class Client {
   }
 
   async getProject(): Promise<TProject> {
-    const projectUrl = new URL(`/projects/${this.projectId}`, this.APIUrl);
-    const response = await this.fetchImpl(projectUrl.href);
-    if (!response.ok) {
-      throw new Error(`Failed to fetch project with id #${this.projectId}: ${response.statusText}`);
+    try {
+      const response = await this.fetchProject();
+      const data = await response.json();
+      const project = ProjectSchema.parse(data);
+      return project;
+    } catch (e) {
+      throw e;
     }
-    const data = await response.json();
-    const project = ProjectSchema.parse(data);
-    return project;
   }
 
   async getPageArticle(pageSlug: string): Promise<TArticle> {
-    const projectUrl = new URL(`/projects/${this.projectId}`, this.APIUrl);
-    const projectResponse = await this.fetchImpl(projectUrl.href);
-    if (!projectResponse.ok) {
-      throw new Error(`Failed to fetch project with id #${this.projectId}: ${projectResponse.statusText}`);
-    }
-    const data = await projectResponse.json();
-    const project = ProjectSchema.parse(data);
-    const page = project.pages.find((page) => page.slug === pageSlug);
-    if (!page) {
-      throw new Error(`Page with a slug ${pageSlug} was not found in project with id #${this.projectId}`);
+    try {
+      const projectResponse = await this.fetchProject();
+      const data = await projectResponse.json();
+      const project = ProjectSchema.parse(data);
+      const articleId = this.findArticleIdByPageSlug(pageSlug, project.pages);
+      const articleResponse = await this.fetchArticle(articleId);
+      const articleData = await articleResponse.json();
+      const article = ArticleSchema.parse(articleData);
+      return article;
+    } catch (e) {
+      throw e;
     }
-    const url = new URL(`/articles/${page.articleId}`, this.APIUrl);
-    const articleResponse = await this.fetchImpl(url.href);
-    if (!articleResponse.ok) {
-      throw new Error(`Failed to fetch article with id #${page.articleId}: ${articleResponse.statusText}`);
-    }
-    const articleData = await articleResponse.json();
-    const article = ArticleSchema.parse(articleData);
+  }
 
-    return article;
+  async getTypePresets(): Promise<TTypePresets> {
+    const response = await this.fetchTypePresets();
+    const data = await response.json();
+    const typePresets = TypePresetsSchema.parse(data);
+    return typePresets;
   }
 
   public static getPageMeta(projectMeta: TMeta, pageMeta: TPageMeta): TMeta {
@@ -59,4 +68,49 @@ export class Client {
       favicon: projectMeta.favicon
     } : projectMeta;
   }
+
+  private async fetchProject(): Promise<FetchImplResponse> {
+    const url = new URL(`/projects/${this.projectId}`, this.APIUrl);
+    const response = await this.fetchImpl(url.href);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch project with id #${this.projectId}: ${response.statusText}`);
+    }
+    return response;
+  }
+
+  private async fetchArticle(articleId: string): Promise<FetchImplResponse> {
+    const url = new URL(`/articles/${articleId}`, this.APIUrl);
+    const response = await this.fetchImpl(url.href);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch article with id #${articleId}: ${response.statusText}`);
+    }
+    return response;
+  }
+
+  private async fetchTypePresets(): Promise<FetchImplResponse> {
+    const url = new URL(`/projects/${this.projectId}/type-presets`, this.APIUrl);
+    const response = await this.fetchImpl(url.href);
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch type presets for the project with id #${this.projectId}: ${response.statusText}`
+      );
+    }
+    return response;
+  }
+
+  private findArticleIdByPageSlug(slug: string, pages: TPage[]): string {
+    const page = pages.find((page) => page.slug === slug);
+    if (!page) {
+      throw new Error(`Page with a slug ${slug} was not found in project with id #${this.projectId}`);
+    }
+    return page.articleId;
+  }
 }
+
+interface FetchImplResponse {
+  ok: boolean;
+  json(): Promise<any>;
+  statusText: string;
+}
+
+type FetchImpl = (url: string) => Promise<FetchImplResponse>;

package/src/Client/__mock__/articleMock.ts

@@ -0,0 +1,15 @@
+import { TArticle } from '@cntrl-site/core';
+
+export const articleMock: TArticle = {
+  id: 'articleId',
+  sections: [
+    {
+      id: 'sectionId',
+      items: [],
+      position: {},
+      height: {},
+      hidden: {},
+      color: {}
+    }
+  ]
+};

package/src/Client/__mock__/projectMock.ts

@@ -0,0 +1,40 @@
+import { TProject } from '@cntrl-site/core';
+
+export const projectMock: TProject = {
+  id: 'projectId',
+  layouts: [],
+  fonts: {
+    google: '',
+    adobe: '',
+    custom: []
+  },
+  html: {
+    beforeBodyClose: '',
+    afterBodyOpen: '',
+    head: ''
+  },
+  meta: {
+    favicon: undefined,
+    title: undefined,
+    opengraphThumbnail: undefined,
+    keywords: undefined,
+    description: undefined
+  },
+  grid: {
+    color: 'rgba(0, 0, 0, 1)'
+  },
+  pages: [{
+    id: 'pageId',
+    title: 'Page',
+    articleId: 'articleId',
+    slug: '/',
+    isPublished: true,
+    meta: {
+      opengraphThumbnail: 'page-thumbnail',
+      title: 'page-title',
+      description: 'page-description',
+      enabled: true,
+      keywords: 'page-keywords'
+    }
+  }]
+};

package/src/Client/__mock__/typePresetsMock.ts

@@ -0,0 +1,6 @@
+import { TTypePresets } from '@cntrl-site/core';
+
+export const typePresetsMock: TTypePresets = {
+  id: 'typePresetsId',
+  presets: []
+};