decap-cms-lib-util 3.2.0 → 3.3.1

package/src/__tests__/apiUtils.spec.js

@@ -1,74 +0,0 @@
-import * as apiUtils from '../APIUtils';
-describe('APIUtils', () => {
-  describe('generateContentKey', () => {
-    it('should generate content key', () => {
-      expect(apiUtils.generateContentKey('posts', 'dir1/dir2/post-title')).toBe(
-        'posts/dir1/dir2/post-title',
-      );
-    });
-  });
-
-  describe('parseContentKey', () => {
-    it('should parse content key', () => {
-      expect(apiUtils.parseContentKey('posts/dir1/dir2/post-title')).toEqual({
-        collection: 'posts',
-        slug: 'dir1/dir2/post-title',
-      });
-    });
-  });
-
-  describe('isCMSLabel', () => {
-    it('should return true for CMS label', () => {
-      expect(apiUtils.isCMSLabel('decap-cms/draft', 'decap-cms/')).toBe(true);
-    });
-
-    it('should return false for non CMS label', () => {
-      expect(apiUtils.isCMSLabel('other/label', 'decap-cms/')).toBe(false);
-    });
-
-    it('should return true if the prefix not provided for CMS label', () => {
-      expect(apiUtils.isCMSLabel('decap-cms/draft', '')).toBe(true);
-    });
-
-    it('should return false if a different prefix provided for CMS label', () => {
-      expect(apiUtils.isCMSLabel('decap-cms/draft', 'other/')).toBe(false);
-    });
-
-    it('should return true for CMS label when undefined prefix is passed', () => {
-      expect(apiUtils.isCMSLabel('decap-cms/draft', undefined)).toBe(true);
-    });
-  });
-
-  describe('labelToStatus', () => {
-    it('should get status from label when default prefix is passed', () => {
-      expect(apiUtils.labelToStatus('decap-cms/draft', 'decap-cms/')).toBe('draft');
-    });
-
-    it('should get status from label when custom prefix is passed', () => {
-      expect(apiUtils.labelToStatus('other/draft', 'other/')).toBe('draft');
-    });
-
-    it('should get status from label when empty prefix is passed', () => {
-      expect(apiUtils.labelToStatus('decap-cms/draft', '')).toBe('draft');
-    });
-
-    it('should get status from label when undefined prefix is passed', () => {
-      expect(apiUtils.labelToStatus('decap-cms/draft', undefined)).toBe('draft');
-    });
-  });
-
-  describe('statusToLabel', () => {
-    it('should generate label from status when default prefix is passed', () => {
-      expect(apiUtils.statusToLabel('draft', 'decap-cms/')).toBe('decap-cms/draft');
-    });
-    it('should generate label from status when custom prefix is passed', () => {
-      expect(apiUtils.statusToLabel('draft', 'other/')).toBe('other/draft');
-    });
-    it('should generate label from status when empty prefix is passed', () => {
-      expect(apiUtils.statusToLabel('draft', '')).toBe('decap-cms/draft');
-    });
-    it('should generate label from status when undefined prefix is passed', () => {
-      expect(apiUtils.statusToLabel('draft', undefined)).toBe('decap-cms/draft');
-    });
-  });
-});

package/src/__tests__/asyncLock.spec.js

@@ -1,85 +0,0 @@
-import { asyncLock } from '../asyncLock';
-
-jest.useFakeTimers();
-jest.spyOn(console, 'warn').mockImplementation(() => {});
-
-describe('asyncLock', () => {
-  it('should be able to acquire a new lock', async () => {
-    const lock = asyncLock();
-
-    const acquired = await lock.acquire();
-
-    expect(acquired).toBe(true);
-  });
-
-  it('should not be able to acquire an acquired lock', async () => {
-    const lock = asyncLock();
-    await lock.acquire();
-
-    const promise = lock.acquire();
-
-    // advance by default lock timeout
-    jest.advanceTimersByTime(15000);
-
-    const acquired = await promise;
-
-    expect(acquired).toBe(false);
-  });
-
-  it('should be able to acquire an acquired lock that was released', async () => {
-    const lock = asyncLock();
-    await lock.acquire();
-
-    const promise = lock.acquire();
-
-    // release the lock in the "future"
-    setTimeout(() => lock.release(), 100);
-
-    // advance to the time where the lock will be released
-    jest.advanceTimersByTime(100);
-
-    const acquired = await promise;
-
-    expect(acquired).toBe(true);
-  });
-
-  it('should accept a timeout for acquire', async () => {
-    const lock = asyncLock();
-    await lock.acquire();
-
-    const promise = lock.acquire(50);
-
-    /// advance by lock timeout
-    jest.advanceTimersByTime(50);
-
-    const acquired = await promise;
-
-    expect(acquired).toBe(false);
-  });
-
-  it('should be able to re-acquire a lock after a timeout', async () => {
-    const lock = asyncLock();
-    await lock.acquire();
-
-    const promise = lock.acquire();
-
-    // advance by default lock timeout
-    jest.advanceTimersByTime(15000);
-
-    let acquired = await promise;
-
-    expect(acquired).toBe(false);
-
-    acquired = await lock.acquire();
-    expect(acquired).toBe(true);
-  });
-
-  it('should suppress "leave called too many times" error', async () => {
-    const lock = asyncLock();
-
-    await expect(() => lock.release()).not.toThrow();
-
-    expect(console.warn).toHaveBeenCalledTimes(1);
-    expect(console.warn).toHaveBeenCalledWith('leave called too many times.');
-  });
-});

package/src/__tests__/backendUtil.spec.js

@@ -1,97 +0,0 @@
-import { oneLine } from 'common-tags';
-import nock from 'nock';
-
-import { parseLinkHeader, getAllResponses, getPathDepth, filterByExtension } from '../backendUtil';
-
-describe('parseLinkHeader', () => {
-  it('should return the right rel urls', () => {
-    const url = 'https://api.github.com/resource';
-    const link = oneLine`
-      <${url}?page=1>; rel="first",
-      <${url}?page=2>; rel="prev",
-      <${url}?page=4>; rel="next",
-      <${url}?page=5>; rel="last"
-    `;
-    const linkHeader = parseLinkHeader(link);
-
-    expect(linkHeader.next).toBe(`${url}?page=4`);
-    expect(linkHeader.last).toBe(`${url}?page=5`);
-    expect(linkHeader.first).toBe(`${url}?page=1`);
-    expect(linkHeader.prev).toBe(`${url}?page=2`);
-  });
-});
-
-describe('getAllResponses', () => {
-  function generatePulls(length) {
-    return Array.from({ length }, (_, id) => {
-      return { id: id + 1, number: `134${id}`, state: 'open' };
-    });
-  }
-
-  function createLinkHeaders({ page, pageCount }) {
-    const pageNum = parseInt(page, 10);
-    const pageCountNum = parseInt(pageCount, 10);
-    const url = 'https://api.github.com/pulls';
-
-    function link(linkPage) {
-      return `<${url}?page=${linkPage}>`;
-    }
-
-    const linkHeader = oneLine`
-      ${pageNum === 1 ? '' : `${link(1)}; rel="first",`}
-      ${pageNum === pageCountNum ? '' : `${link(pageCount)}; rel="last",`}
-      ${pageNum === 1 ? '' : `${link(pageNum - 1)}; rel="prev",`}
-      ${pageNum === pageCountNum ? '' : `${link(pageNum + 1)}; rel="next",`}
-    `.slice(0, -1);
-
-    return { Link: linkHeader };
-  }
-
-  function interceptCall({ perPage = 30, repeat = 1, data = [] } = {}) {
-    nock('https://api.github.com')
-      .get('/pulls')
-      .query(true)
-      .times(repeat)
-      .reply(uri => {
-        const searchParams = new URLSearchParams(uri.split('?')[1]);
-        const page = searchParams.get('page') || 1;
-        const pageCount = data.length <= perPage ? 1 : Math.ceil(data.length / perPage);
-        const pageLastIndex = page * perPage;
-        const pageFirstIndex = pageLastIndex - perPage;
-        const resp = data.slice(pageFirstIndex, pageLastIndex);
-        return [200, resp, createLinkHeaders({ page, pageCount })];
-      });
-  }
-
-  it('should return all paged response', async () => {
-    interceptCall({ repeat: 3, data: generatePulls(70) });
-    const res = await getAllResponses('https://api.github.com/pulls', {}, 'next', url => url);
-    const pages = await Promise.all(res.map(res => res.json()));
-
-    expect(pages[0]).toHaveLength(30);
-    expect(pages[1]).toHaveLength(30);
-    expect(pages[2]).toHaveLength(10);
-  });
-});
-
-describe('getPathDepth', () => {
-  it('should return 1 for empty string', () => {
-    expect(getPathDepth('')).toBe(1);
-  });
-
-  it('should return 2 for path of one nested folder', () => {
-    expect(getPathDepth('{{year}}/{{slug}}')).toBe(2);
-  });
-});
-
-describe('filterByExtension', () => {
-  it('should return true when extension matches', () => {
-    expect(filterByExtension({ path: 'file.html.md' }, '.html.md')).toBe(true);
-    expect(filterByExtension({ path: 'file.html.md' }, 'html.md')).toBe(true);
-  });
-
-  it("should return false when extension doesn't match", () => {
-    expect(filterByExtension({ path: 'file.json' }, '.html.md')).toBe(false);
-    expect(filterByExtension({ path: 'file.json' }, 'html.md')).toBe(false);
-  });
-});

package/src/__tests__/implementation.spec.js

@@ -1,58 +0,0 @@
-import { getMediaAsBlob, getMediaDisplayURL } from '../implementation';
-
-describe('implementation', () => {
-  describe('getMediaAsBlob', () => {
-    it('should return response blob on non svg file', async () => {
-      const blob = {};
-      const readFile = jest.fn().mockResolvedValue(blob);
-
-      await expect(getMediaAsBlob('static/media/image.png', 'sha', readFile)).resolves.toBe(blob);
-
-      expect(readFile).toHaveBeenCalledTimes(1);
-      expect(readFile).toHaveBeenCalledWith('static/media/image.png', 'sha', {
-        parseText: false,
-      });
-    });
-
-    it('should return text blob on svg file', async () => {
-      const text = 'svg';
-      const readFile = jest.fn().mockResolvedValue(text);
-
-      await expect(getMediaAsBlob('static/media/logo.svg', 'sha', readFile)).resolves.toEqual(
-        new Blob([text], { type: 'image/svg+xml' }),
-      );
-
-      expect(readFile).toHaveBeenCalledTimes(1);
-      expect(readFile).toHaveBeenCalledWith('static/media/logo.svg', 'sha', {
-        parseText: true,
-      });
-    });
-  });
-
-  describe('getMediaDisplayURL', () => {
-    it('should return createObjectURL result', async () => {
-      const blob = {};
-      const readFile = jest.fn().mockResolvedValue(blob);
-      const semaphore = { take: jest.fn(callback => callback()), leave: jest.fn() };
-
-      global.URL.createObjectURL = jest
-        .fn()
-        .mockResolvedValue('blob:http://localhost:8080/blob-id');
-
-      await expect(
-        getMediaDisplayURL({ path: 'static/media/image.png', id: 'sha' }, readFile, semaphore),
-      ).resolves.toBe('blob:http://localhost:8080/blob-id');
-
-      expect(semaphore.take).toHaveBeenCalledTimes(1);
-      expect(semaphore.leave).toHaveBeenCalledTimes(1);
-
-      expect(readFile).toHaveBeenCalledTimes(1);
-      expect(readFile).toHaveBeenCalledWith('static/media/image.png', 'sha', {
-        parseText: false,
-      });
-
-      expect(global.URL.createObjectURL).toHaveBeenCalledTimes(1);
-      expect(global.URL.createObjectURL).toHaveBeenCalledWith(blob);
-    });
-  });
-});

package/src/__tests__/path.spec.js

@@ -1,53 +0,0 @@
-import { fileExtensionWithSeparator, fileExtension } from '../path';
-
-describe('fileExtensionWithSeparator', () => {
-  it('should return the extension of a file', () => {
-    expect(fileExtensionWithSeparator('index.html')).toEqual('.html');
-  });
-
-  it('should return the extension of a file path', () => {
-    expect(fileExtensionWithSeparator('/src/main/index.html')).toEqual('.html');
-  });
-
-  it('should return the extension of a file path with trailing slash', () => {
-    expect(fileExtensionWithSeparator('/src/main/index.html/')).toEqual('.html');
-  });
-
-  it('should return the extension for an extension with two ..', () => {
-    expect(fileExtensionWithSeparator('/src/main/index..html')).toEqual('.html');
-  });
-
-  it('should return an empty string for the parent path ..', () => {
-    expect(fileExtensionWithSeparator('..')).toEqual('');
-  });
-
-  it('should return an empty string if the file has no extension', () => {
-    expect(fileExtensionWithSeparator('/src/main/index')).toEqual('');
-  });
-});
-
-describe('fileExtension', () => {
-  it('should return the extension of a file', () => {
-    expect(fileExtension('index.html')).toEqual('html');
-  });
-
-  it('should return the extension of a file path', () => {
-    expect(fileExtension('/src/main/index.html')).toEqual('html');
-  });
-
-  it('should return the extension of a file path with trailing slash', () => {
-    expect(fileExtension('/src/main/index.html/')).toEqual('html');
-  });
-
-  it('should return the extension for an extension with two ..', () => {
-    expect(fileExtension('/src/main/index..html')).toEqual('html');
-  });
-
-  it('should return an empty string for the parent path ..', () => {
-    expect(fileExtension('..')).toEqual('');
-  });
-
-  it('should return an empty string if the file has no extension', () => {
-    expect(fileExtension('/src/main/index')).toEqual('');
-  });
-});

package/src/__tests__/unsentRequest.spec.js

@@ -1,19 +0,0 @@
-import unsentRequest from '../unsentRequest';
-
-describe('unsentRequest', () => {
-  describe('withHeaders', () => {
-    it('should create new request with headers', () => {
-      expect(unsentRequest.withHeaders({ Authorization: 'token' })('path').toJS()).toEqual({
-        url: 'path',
-        headers: { Authorization: 'token' },
-      });
-    });
-
-    it('should add headers to existing request', () => {
-      expect(unsentRequest.withHeaders({ Authorization: 'token' }, 'path').toJS()).toEqual({
-        url: 'path',
-        headers: { Authorization: 'token' },
-      });
-    });
-  });
-});

package/src/asyncLock.ts

@@ -1,43 +0,0 @@
-import semaphore from 'semaphore';
-
-export type AsyncLock = { release: () => void; acquire: () => Promise<boolean> };
-
-export function asyncLock(): AsyncLock {
-  let lock = semaphore(1);
-
-  function acquire(timeout = 15000) {
-    const promise = new Promise<boolean>(resolve => {
-      // this makes sure a caller doesn't gets stuck forever awaiting on the lock
-      const timeoutId = setTimeout(() => {
-        // we reset the lock in that case to allow future consumers to use it without being blocked
-        lock = semaphore(1);
-        resolve(false);
-      }, timeout);
-
-      lock.take(() => {
-        clearTimeout(timeoutId);
-        resolve(true);
-      });
-    });
-
-    return promise;
-  }
-
-  function release() {
-    try {
-      // suppress too many calls to leave error
-      lock.leave();
-    } catch (e) {
-      // calling 'leave' too many times might not be good behavior
-      // but there is no reason to completely fail on it
-      if (e.message !== 'leave called too many times.') {
-        throw e;
-      } else {
-        console.warn('leave called too many times.');
-        lock = semaphore(1);
-      }
-    }
-  }
-
-  return { acquire, release };
-}

package/src/backendUtil.ts

@@ -1,120 +0,0 @@
-import { flow, fromPairs } from 'lodash';
-import { map } from 'lodash/fp';
-import { fromJS } from 'immutable';
-
-import unsentRequest from './unsentRequest';
-import APIError from './APIError';
-
-type Formatter = (res: Response) => Promise<string | Blob | unknown>;
-
-export function filterByExtension(file: { path: string }, extension: string) {
-  const path = file?.path || '';
-  return path.endsWith(extension.startsWith('.') ? extension : `.${extension}`);
-}
-
-function catchFormatErrors(format: string, formatter: Formatter) {
-  return (res: Response) => {
-    try {
-      return formatter(res);
-    } catch (err) {
-      throw new Error(
-        `Response cannot be parsed into the expected format (${format}): ${err.message}`,
-      );
-    }
-  };
-}
-
-const responseFormatters = fromJS({
-  json: async (res: Response) => {
-    const contentType = res.headers.get('Content-Type') || '';
-    if (!contentType.startsWith('application/json') && !contentType.startsWith('text/json')) {
-      throw new Error(`${contentType} is not a valid JSON Content-Type`);
-    }
-    return res.json();
-  },
-  text: async (res: Response) => res.text(),
-  blob: async (res: Response) => res.blob(),
-}).mapEntries(([format, formatter]: [string, Formatter]) => [
-  format,
-  catchFormatErrors(format, formatter),
-]);
-
-export async function parseResponse(
-  res: Response,
-  { expectingOk = true, format = 'text', apiName = '' },
-) {
-  let body;
-  try {
-    const formatter = responseFormatters.get(format, false);
-    if (!formatter) {
-      throw new Error(`${format} is not a supported response format.`);
-    }
-    body = await formatter(res);
-  } catch (err) {
-    throw new APIError(err.message, res.status, apiName);
-  }
-  if (expectingOk && !res.ok) {
-    const isJSON = format === 'json';
-    const message = isJSON ? body.message || body.msg || body.error?.message : body;
-    throw new APIError(isJSON && message ? message : body, res.status, apiName);
-  }
-  return body;
-}
-
-export function responseParser(options: {
-  expectingOk?: boolean;
-  format: string;
-  apiName: string;
-}) {
-  return (res: Response) => parseResponse(res, options);
-}
-
-export function parseLinkHeader(header: string | null) {
-  if (!header) {
-    return {};
-  }
-  return flow([
-    linksString => linksString.split(','),
-    map((str: string) => str.trim().split(';')),
-    map(([linkStr, keyStr]) => [
-      keyStr.match(/rel="(.*?)"/)[1],
-      linkStr
-        .trim()
-        .match(/<(.*?)>/)[1]
-        .replace(/\+/g, '%20'),
-    ]),
-    fromPairs,
-  ])(header);
-}
-
-export async function getAllResponses(
-  url: string,
-  options: { headers?: {} } = {},
-  linkHeaderRelName: string,
-  nextUrlProcessor: (url: string) => string,
-) {
-  const maxResponses = 30;
-  let responseCount = 1;
-
-  let req = unsentRequest.fromFetchArguments(url, options);
-
-  const pageResponses = [];
-
-  while (req && responseCount < maxResponses) {
-    const pageResponse = await unsentRequest.performRequest(req);
-    const linkHeader = pageResponse.headers.get('Link');
-    const nextURL = linkHeader && parseLinkHeader(linkHeader)[linkHeaderRelName];
-
-    const { headers = {} } = options;
-    req = nextURL && unsentRequest.fromFetchArguments(nextUrlProcessor(nextURL), { headers });
-    pageResponses.push(pageResponse);
-    responseCount++;
-  }
-
-  return pageResponses;
-}
-
-export function getPathDepth(path: string) {
-  const depth = path.split('/').length;
-  return depth;
-}

package/src/getBlobSHA.ts

@@ -1,12 +0,0 @@
-import { sha256 } from 'js-sha256';
-
-export default (blob: Blob): Promise<string> =>
-  new Promise((resolve, reject) => {
-    const fr = new FileReader();
-    fr.onload = ({ target }) => resolve(sha256(target?.result || ''));
-    fr.onerror = err => {
-      fr.abort();
-      reject(err);
-    };
-    fr.readAsArrayBuffer(blob);
-  });