@sparted/shared-library 1.0.8-alpha.6 → 1.0.8

package/src/github/merge/create-pull-request.ts

@@ -1,42 +0,0 @@
-import type { AxiosInstance } from 'axios';
-import { z } from 'zod';
-
-import { handleError } from '../commit/utils';
-
-export type CreatePullRequestArgs = {
-  title: string;
-  body: string;
-  head: string;
-  base: string;
-};
-
-export type CreatePullRequestResponse = {
-  url: string;
-  number: number;
-};
-
-const createPullRequestResponseSchema = z.object({
-  url: z.string(),
-  number: z.number(),
-});
-
-export type CreatePullRequest = (args: CreatePullRequestArgs) => Promise<CreatePullRequestResponse>;
-
-export type CreatePullRequestFactory = (instance: AxiosInstance) => CreatePullRequest;
-
-export const createPullRequestFactory: CreatePullRequestFactory = (instance) => async (args) => {
-  const { title, body, head, base } = args;
-
-  try {
-    const { data } = await instance.post<CreatePullRequestResponse>('/pulls', {
-      title,
-      body,
-      head,
-      base,
-    });
-
-    return createPullRequestResponseSchema.parse(data);
-  } catch (error) {
-    throw handleError(error);
-  }
-};

package/src/github/merge/index.ts

@@ -1,2 +0,0 @@
-export * from './create-pull-request';
-export * from './merge-pull-request';

package/src/github/merge/merge-pull-request.ts

@@ -1,39 +0,0 @@
-import { AxiosInstance } from 'axios';
-import { z } from 'zod';
-
-import { handleError } from '../commit/utils';
-
-export type MergePullRequestArgs = {
-  pullRequestNumber: number;
-  commitTitle: string;
-  commitMessage: string;
-  mergeMethod: 'merge' | 'squash' | 'rebase';
-};
-
-export type MergePullRequestResponse = {
-  sha: string;
-};
-
-const mergePullRequestResponseSchema = z.object({
-  sha: z.string(),
-});
-
-export type MergePullRequest = (args: MergePullRequestArgs) => Promise<MergePullRequestResponse>;
-
-export type MergePullRequestFactory = (instance: AxiosInstance) => MergePullRequest;
-
-export const mergePullRequestFactory: MergePullRequestFactory = (instance) => async (args) => {
-  const { pullRequestNumber, commitTitle, commitMessage, mergeMethod } = args;
-
-  try {
-    const { data } = await instance.put<MergePullRequestResponse>(`/pulls/${pullRequestNumber}/merge`, {
-      commit_title: commitTitle,
-      commit_message: commitMessage,
-      merge_method: mergeMethod,
-    });
-
-    return mergePullRequestResponseSchema.parse(data);
-  } catch (error) {
-    throw handleError(error);
-  }
-};

package/src/http/__tests__/encode-search-object.test.ts

@@ -1,34 +0,0 @@
-import { encodeSearchObject } from '../encode-search-object';
-
-describe('encodeSearchObject', () => {
-  it('should not encode sort and query if undefined', () => {
-    const url = encodeSearchObject({
-      limit: 10,
-      offset: 15,
-    });
-
-    expect(url).toStrictEqual('offset=15&limit=10');
-  });
-
-  it('should encode sort and query twice', () => {
-    const url = encodeSearchObject({
-      limit: 10,
-      offset: 0,
-      sort: {
-        name: 'asc',
-        editionDate: 'desc',
-      },
-      query: {
-        name: 'The name of something',
-        status: 'published',
-      },
-    });
-
-    expect(url).toStrictEqual([
-      'offset=0',
-      'limit=10',
-      'sort=name%3Aasc%2BeditionDate%3Adesc',
-      'query=name%3AThe%2520name%2520of%2520something%2Bstatus%3Apublished',
-    ].join('&'));
-  });
-});

package/src/http/__tests__/fetch-with-timeout.test.ts

@@ -1,50 +0,0 @@
-/* eslint-disable import/first -- https://github.com/jefflau/jest-fetch-mock#to-setup-for-an-individual-test */
-
-import fetchMock, { enableFetchMocks } from 'jest-fetch-mock';
-
-// must appear before any other imports
-enableFetchMocks();
-
-import { fetchWithTimeout } from '../fetch-with-timeout';
-
-describe('fetchWithTimeout', () => {
-  beforeEach(() => {
-    fetchMock.resetMocks();
-  });
-
-  it('should call fetch with the same parameters', async () => {
-    const url = 'http://some/url';
-    const init = {
-      headers: {
-        some: 'header',
-      },
-    };
-
-    fetchMock.mockResponseOnce('mock response');
-    const response = await fetchWithTimeout(url, init);
-
-    expect(fetch as any).toHaveBeenNthCalledWith(1, url, expect.objectContaining(init));
-    expect(await response.text()).toBe('mock response');
-  });
-
-  it('should abort the request if timeout has elapsed', async () => {
-    jest.useFakeTimers();
-    const TIMEOUT = 3000;
-    const REQUEST_TIMEOUT = TIMEOUT * 2;
-
-    // This request will take too long
-    fetchMock.mockResponseOnce(async () => {
-      jest.advanceTimersByTime(REQUEST_TIMEOUT);
-      return 'mock response';
-    });
-
-    // https://github.com/jefflau/jest-fetch-mock/issues/159
-    (global as any).DOMException = Error;
-
-    const responsePromise = fetchWithTimeout('http://some/url', { timeout: TIMEOUT });
-
-    jest.advanceTimersByTime(TIMEOUT + 100);
-
-    await expect(responsePromise).rejects.toThrow('The operation was aborted. ');
-  });
-});

package/src/http/encode-search-object.ts

@@ -1,39 +0,0 @@
-import { SearchObject } from '../types';
-
-export type EncodingConfig = {
-  keyValueDelimiter: string,
-  pairDelimiter: string,
-};
-
-const defaultEncodingConfig: EncodingConfig = {
-  keyValueDelimiter: ':',
-  pairDelimiter: '+',
-};
-
-export const encodeSearchValue = <T extends Record<string, string>>(
-  searchValue: T,
-  config: EncodingConfig = defaultEncodingConfig,
-) => {
-  const { pairDelimiter, keyValueDelimiter } = config;
-
-  return Object.entries(searchValue)
-    .map(([key, value]) => `${key}${keyValueDelimiter}${encodeURI(value)}`)
-    .join(pairDelimiter);
-};
-
-export const encodeSearchObject = (searchObject: SearchObject): string => {
-  const { sort, query, offset, limit } = searchObject;
-
-  const sortEncoded = sort ? encodeSearchValue(sort) : null;
-  const queryEncoded = query ? encodeSearchValue(query) : null;
-
-  const urlParams = new URLSearchParams({
-    offset: offset.toString(),
-    limit: limit.toString(),
-  });
-
-  if (sortEncoded) urlParams.append('sort', sortEncoded);
-  if (queryEncoded) urlParams.append('query', queryEncoded);
-
-  return urlParams.toString();
-};

package/src/http/fetch-with-timeout.ts

@@ -1,24 +0,0 @@
-export type RequestInitWithTimeout = RequestInit & {
-  timeout?: number
-};
-
-/**
- * Use fetch to perform an HTTP request
- * Add an optional timeout, that will abort the request if it has not returned before
- */
-export const fetchWithTimeout = (input: RequestInfo, init?: Omit<RequestInitWithTimeout, 'signal'> | undefined): Promise<Response> => {
-  const abortController = new AbortController();
-
-  const { timeout, ...rest } = init || {};
-
-  const params = {
-    ...rest,
-    signal: abortController.signal,
-  };
-
-  if (timeout !== undefined) {
-    setTimeout(() => abortController.abort(), timeout);
-  }
-
-  return fetch(input, params);
-};

package/src/http/index.ts

@@ -1,2 +0,0 @@
-export * from './encode-search-object';
-export * from './fetch-with-timeout';

package/src/linked-list/__tests__/apply-diff-linked-list.test.ts

@@ -1,103 +0,0 @@
-import { createLinkedList } from '../create-linked-list';
-import { applyDiffLinkedList } from '../apply-diff-linked-list';
-
-describe('applyDiffLinkedList', () => {
-  const items = {
-    1: { id: '1', nextId: '2', previousId: null, value: 1 },
-    2: { id: '2', nextId: '3', previousId: '1', value: 2 },
-    3: { id: '3', nextId: '4', previousId: '2', value: 3 },
-    4: { id: '4', nextId: null, previousId: '3', value: 4 },
-  };
-
-  const linkedList = createLinkedList('1', items);
-
-  it('should handle a delete', () => {
-    const newList = applyDiffLinkedList(items['2'], null, linkedList);
-
-    expect(newList.items).toStrictEqual({
-      1: { id: '1', nextId: '3', previousId: null, value: 1 },
-      3: { id: '3', nextId: '4', previousId: '1', value: 3 },
-      4: { id: '4', nextId: null, previousId: '3', value: 4 },
-    });
-    expect(newList.head).toStrictEqual(newList.items['1']);
-  });
-
-  it('should handle an insert', () => {
-    const insertedItem = { id: '5', nextId: null, previousId: '4', value: 5 };
-    const newList = applyDiffLinkedList(null, insertedItem, linkedList);
-
-    expect(newList.items).toStrictEqual({
-      1: { id: '1', nextId: '2', previousId: null, value: 1 },
-      2: { id: '2', nextId: '3', previousId: '1', value: 2 },
-      3: { id: '3', nextId: '4', previousId: '2', value: 3 },
-      4: { id: '4', nextId: '5', previousId: '3', value: 4 },
-      5: { id: '5', nextId: null, previousId: '4', value: 5 },
-    });
-    expect(newList.head).toStrictEqual(newList.items['1']);
-  });
-
-  it('should throw an error if the two items are null', () => {
-    expect(() => applyDiffLinkedList(null, null, linkedList)).toThrowError(
-      'Cannot have both before & after as null',
-    );
-  });
-
-  it('should throw an error if it tries to change the id', () => {
-    const before = linkedList.items['2'];
-    const after = { ...before, id: '6' };
-
-    expect(() => applyDiffLinkedList(before, after, linkedList)).toThrowError(
-      'Cannot change id of a ListNode',
-    );
-  });
-
-  it('should update a node if it has the same nextId', () => {
-    const before = linkedList.items['2'];
-    const after = { ...before, value: 22 };
-
-    const newList = applyDiffLinkedList(before, after, linkedList);
-
-    expect(newList.items).toStrictEqual({
-      1: { id: '1', nextId: '2', previousId: null, value: 1 },
-      2: { id: '2', nextId: '3', previousId: '1', value: 22 },
-      3: { id: '3', nextId: '4', previousId: '2', value: 3 },
-      4: { id: '4', nextId: null, previousId: '3', value: 4 },
-    });
-    expect(newList.head).toStrictEqual(newList.items['1']);
-  });
-
-  it('should update a node if it has the same nextId', () => {
-    const before = linkedList.items['2'];
-    const after = { ...before, value: 22 };
-
-    const newList = applyDiffLinkedList(before, after, linkedList);
-
-    expect(newList.items).toStrictEqual({
-      1: { id: '1', nextId: '2', previousId: null, value: 1 },
-      2: { id: '2', nextId: '3', previousId: '1', value: 22 },
-      3: { id: '3', nextId: '4', previousId: '2', value: 3 },
-      4: { id: '4', nextId: null, previousId: '3', value: 4 },
-    });
-    expect(newList.head).toStrictEqual(newList.items['1']);
-  });
-
-  it('should handle a reorder and an update', () => {
-    const before = linkedList.items['2'];
-    const after = {
-      ...before,
-      value: 22,
-      nextId: '4',
-      previousId: '3',
-    };
-
-    const newList = applyDiffLinkedList(before, after, linkedList);
-
-    expect(newList.items).toStrictEqual({
-      1: { id: '1', nextId: '3', previousId: null, value: 1 },
-      3: { id: '3', nextId: '2', previousId: '1', value: 3 },
-      2: { id: '2', nextId: '4', previousId: '3', value: 22 },
-      4: { id: '4', nextId: null, previousId: '2', value: 4 },
-    });
-    expect(newList.head).toStrictEqual(newList.items['1']);
-  });
-});

package/src/linked-list/__tests__/create-linked-list.test.ts

@@ -1,204 +0,0 @@
-import { createLinkedList } from '../create-linked-list';
-
-import { reduceLinkedList } from '../reduce-linked-list';
-import { findLinkedList } from '../find-linked-list';
-import { whileLinkedList } from '../while-linked-list';
-import { removeLinkedList } from '../remove-linked-list';
-import { insertLinkedList } from '../insert-linked-list';
-import { getLinkedList } from '../get-linked-list';
-import { updateLinkedList } from '../update-linked-list';
-import { applyDiffLinkedList } from '../apply-diff-linked-list';
-
-jest.mock('../reduce-linked-list');
-jest.mock('../find-linked-list');
-jest.mock('../while-linked-list');
-jest.mock('../remove-linked-list');
-jest.mock('../insert-linked-list');
-jest.mock('../get-linked-list');
-jest.mock('../update-linked-list');
-jest.mock('../apply-diff-linked-list');
-
-describe('createLinkedList', () => {
-  it('should create an empty list', () => {
-    const linkedList = createLinkedList(null, {});
-
-    expect(linkedList.head).toBeNull();
-    expect(linkedList.items).toStrictEqual({});
-    expect(linkedList.format).toBeNull();
-  });
-
-  it('should have the right head', () => {
-    const node = { title: 'Micro knowledge', id: '2', nextId: null };
-    const map = { 2: node };
-
-    const linkedList = createLinkedList('2', map);
-
-    expect(linkedList.head).toStrictEqual(node);
-  });
-
-  it('should set format to single', () => {
-    const map = {
-      1: { id: '1', nextId: '2' },
-      2: { id: '2', nextId: null },
-    };
-
-    const linkedList = createLinkedList('1', map);
-
-    expect(linkedList.format).toStrictEqual('single');
-  });
-
-  it('should set format to double', () => {
-    const map = {
-      1: { id: '1', nextId: '2', previousId: null },
-      2: { id: '2', nextId: null, previousId: '1' },
-    };
-
-    const linkedList = createLinkedList('1', map);
-
-    expect(linkedList.format).toStrictEqual('double');
-  });
-
-  it('should throw an error if some nodes are double linkedand some are single linked', () => {
-    const map = {
-      1: { id: '1', nextId: '2', previousId: null },
-      2: { id: '2', nextId: null },
-    };
-
-    expect(() => createLinkedList('1', map)).toThrowError(
-      'Invalid previous node in the linked list',
-    );
-  });
-
-  it('should throw an error if some nodes have invalid previous', () => {
-    const map = {
-      1: { id: '1', nextId: '2', previousId: null },
-      2: { id: '2', nextId: '3', previousId: '1' },
-      3: { id: '3', nextId: null, previousId: '1' },
-    };
-
-    expect(() => createLinkedList('1', map)).toThrowError(
-      'Invalid previous node in the linked list',
-    );
-  });
-
-  it('should have the right size', () => {
-    const map = {
-      1: { id: '1', nextId: '2', previousId: null },
-      2: { id: '2', nextId: '3', previousId: '1' },
-      3: { id: '3', nextId: null, previousId: '2' },
-    };
-
-    const linkedList = createLinkedList('1', map);
-
-    expect(linkedList.size).toStrictEqual(3);
-  });
-
-  describe('methods', () => {
-    const reduceLinkedListMocked = jest.mocked(reduceLinkedList);
-    const findLinkedListMocked = jest.mocked(findLinkedList);
-    const whileLinkedListMocked = jest.mocked(whileLinkedList);
-    const removeLinkedListMocked = jest.mocked(removeLinkedList);
-    const insertLinkedListMocked = jest.mocked(insertLinkedList);
-    const getLinkedListMocked = jest.mocked(getLinkedList);
-    const updateLinkedListMocked = jest.mocked(updateLinkedList);
-    const applyDiffLinkedListMocked = jest.mocked(applyDiffLinkedList);
-
-    const record = {
-      1: { id: '1', nextId: '2', previousId: null },
-      2: { id: '2', nextId: null, previousId: '1' },
-    };
-    const linkedList = createLinkedList('1', record);
-    const list = {
-      headId: '1',
-      items: record,
-    };
-    const manipulationConfig = {
-      factory: expect.toBeFunction(),
-      format: 'double',
-      list,
-    };
-
-    beforeEach(() => {
-      jest.clearAllMocks();
-    });
-
-    it('it should have reduce', () => {
-      reduceLinkedListMocked.mockReturnValue('reduce');
-
-      const accumulatorFunction = jest.fn().mockName('accumulatorFunction');
-      const result = linkedList.reduce(accumulatorFunction, 'init');
-
-      expect(result).toStrictEqual('reduce');
-      expect(reduceLinkedListMocked).toHaveBeenCalledWith(accumulatorFunction, 'init', list);
-    });
-
-    it('it should have find', () => {
-      findLinkedListMocked.mockReturnValue('find' as any);
-
-      const findPredicate = jest.fn().mockName('findPredicate');
-      const result = linkedList.find(findPredicate);
-
-      expect(result).toStrictEqual('find');
-      expect(findLinkedListMocked).toHaveBeenCalledWith(findPredicate, list);
-    });
-
-    it('it should have while', () => {
-      whileLinkedListMocked.mockReturnValue('while' as any);
-
-      const whilePredicate = jest.fn().mockName('whilePredicate');
-      const result = linkedList.while(whilePredicate, '2');
-
-      expect(result).toStrictEqual('while');
-      expect(whileLinkedListMocked).toHaveBeenCalledWith(whilePredicate, list, '2');
-    });
-
-    it('it should have remove', () => {
-      removeLinkedListMocked.mockReturnValue('remove' as any);
-
-      const result = linkedList.remove('3');
-
-      expect(result).toStrictEqual('remove');
-      expect(removeLinkedListMocked).toHaveBeenCalledWith('3', manipulationConfig);
-    });
-
-    it('it should have insert', () => {
-      insertLinkedListMocked.mockReturnValue('insert' as any);
-
-      const item = { id: '5', nextId: '6', previousId: '4' };
-      const result = linkedList.insert(item as any);
-
-      expect(result).toStrictEqual('insert');
-      expect(insertLinkedListMocked).toHaveBeenCalledWith(item, manipulationConfig);
-    });
-
-    it('it should have get', () => {
-      getLinkedListMocked.mockReturnValue('get' as any);
-
-      const result = linkedList.get('5');
-
-      expect(result).toStrictEqual('get');
-      expect(getLinkedListMocked).toHaveBeenCalledWith('5', list);
-    });
-
-    it('it should have update', () => {
-      updateLinkedListMocked.mockReturnValue('update' as any);
-
-      const updatedItem = { id: '5', nextId: '6', previousId: '4' };
-      const result = linkedList.update(updatedItem as any);
-
-      expect(result).toStrictEqual('update');
-      expect(updateLinkedListMocked).toHaveBeenCalledWith(updatedItem, manipulationConfig);
-    });
-
-    it('it should have applyDiff', () => {
-      applyDiffLinkedListMocked.mockReturnValue('applydiff' as any);
-
-      const before = { id: '5', nextId: '6', previousId: '4' };
-      const after = { id: '5', nextId: '7', previousId: '4' };
-      const result = linkedList.applyDiff(before as any, after as any);
-
-      expect(result).toStrictEqual('applydiff');
-      expect(applyDiffLinkedListMocked).toHaveBeenCalledWith(before, after, linkedList);
-    });
-  });
-});

package/src/linked-list/__tests__/find-linked-list.test.ts

@@ -1,40 +0,0 @@
-import { findLinkedList } from '../find-linked-list';
-
-describe('findLinkedList', () => {
-  const list = {
-    items: {
-      1: {
-        id: '1',
-        nextId: '2',
-      },
-      2: {
-        id: '2',
-        nextId: '3',
-      },
-      3: {
-        id: '3',
-        nextId: '4',
-      },
-      4: {
-        id: '1',
-        nextId: null,
-      },
-    },
-    headId: '1',
-  };
-
-  it('should return the right item if it is found', () => {
-    const foundItem = findLinkedList((item) => item.id === '3', list);
-
-    expect(foundItem).toStrictEqual({
-      id: '3',
-      nextId: '4',
-    });
-  });
-
-  it('should return null if no item match the predicate', () => {
-    const foundItem = findLinkedList((item) => item.id === '5', list);
-
-    expect(foundItem).toBeNull();
-  });
-});

package/src/linked-list/__tests__/get-linked-list.test.ts

@@ -1,28 +0,0 @@
-import { getLinkedList } from '../get-linked-list';
-
-describe('getLinkedList', () => {
-  const list = {
-    headId: '1',
-    items: {
-      1: {
-        id: '1',
-        nextId: '2',
-      },
-      2: {
-        id: '2',
-        nextId: null,
-      },
-    },
-  };
-
-  it('should get the item corresponding to the id', () => {
-    expect(getLinkedList('1', list)).toStrictEqual({
-      id: '1',
-      nextId: '2',
-    });
-  });
-
-  it('should return null if the item with the given id does not exist', () => {
-    expect(getLinkedList('5', list)).toBeNull();
-  });
-});