@sparted/shared-library 1.0.7 → 1.0.8-alpha.1

package/src/fp/run-while.ts

@@ -0,0 +1,54 @@
+export type RunWhileConfig<T> = {
+  /**
+   * Return a boolean to keep running the callback or not.
+   */
+  predicate: (current: T) => boolean,
+  /**
+   * The function to run while `predicate` returns `true`
+   */
+  callback: (current: T, iteractionCount: number) => T,
+  /**
+   * `callback` will not be run again if `iterationCount` exceeds this value.
+   * Default to `Infinity`
+   */
+  iterationLimit?: number,
+  /**
+   * The first value passed to the callback.
+   */
+  initialValue: T,
+};
+
+export type RunWhileFn = <T>(config: RunWhileConfig<T>) => {
+  /**
+   * The callback last result.
+   */
+  result: T,
+  iterationCount: number,
+};
+
+/**
+ * Run the callback while the predicate return true. Throws an
+ * error if the iteration count exceeds the iteration limit.
+ */
+export const runWhile: RunWhileFn = ({ predicate, callback, initialValue, iterationLimit = Infinity }) => {
+  let counter = 0;
+  let currentValue = initialValue;
+  let shouldRun = predicate(currentValue);
+
+  while (shouldRun) {
+    if (counter >= iterationLimit) {
+      break;
+    }
+
+    const nextValue = callback(currentValue, counter);
+
+    counter += 1;
+    shouldRun = predicate(nextValue);
+    currentValue = nextValue;
+  }
+
+  return {
+    result: currentValue,
+    iterationCount: counter,
+  };
+};

package/src/github/commits/create-git-blob.ts

@@ -0,0 +1,57 @@
+import type { AxiosInstance } from 'axios';
+import { z } from 'zod';
+
+import { handleError } from './utils';
+
+export type CreateGitBlobArgs = {
+  content: string;
+  encoding: 'utf-8' | 'base64';
+};
+
+export type CreateGitBlobResponse = {
+  sha: string;
+  url: string;
+};
+
+const createGitBlobResponseSchema = z.object({
+  sha: z.string(),
+  url: z.string(),
+});
+
+export type CreateGitBlob = (
+  args: CreateGitBlobArgs
+) => Promise<CreateGitBlobResponse>;
+
+export type CreateGitBlobFactory = (instance: AxiosInstance) => CreateGitBlob;
+
+/**
+ * Create a git blob
+ *
+ * @param owner the owner of the repository
+ * @param repo the name of the repository
+ * @param token the github token
+ * @param content the content of the file
+ * @param encoding the encoding of the content. Default: utf-8
+ * @returns CreateGitBlobResponse
+ * @throws forbidden
+ * @throws resource-not-found
+ * @throws conflict
+ * @throws validation-failed-or-the-endpoint-has-been-spammed
+ */
+export const createGitBlobFactory: CreateGitBlobFactory = (instance) => async (args) => {
+  const { content, encoding = 'utf-8' } = args;
+
+  try {
+    const { data } = await instance.post<CreateGitBlobResponse>(
+      '/git/blobs',
+      {
+        content,
+        encoding,
+      },
+    );
+
+    return createGitBlobResponseSchema.parse(data);
+  } catch (error) {
+    throw handleError(error);
+  }
+};

package/src/github/commits/create-git-commit.ts

@@ -0,0 +1,57 @@
+import type { AxiosInstance } from 'axios';
+import { z } from 'zod';
+
+import { handleError } from './utils';
+
+export type CreateGitCommitArgs = {
+  message: string;
+  treeSha: string;
+  parents: string[];
+};
+
+export type CreateGitCommitResponse = {
+  sha: string;
+  url: string;
+};
+
+const createGitCommitSchema = z.object({
+  sha: z.string(),
+  url: z.string(),
+});
+
+export type CreateGitCommit = (
+  args: CreateGitCommitArgs
+) => Promise<CreateGitCommitResponse>;
+
+export type CreateGitCommitFactory = (
+  instance: AxiosInstance
+) => CreateGitCommit;
+
+/**
+ * Create a git commit
+ * @param owner the owner of the repository
+ * @param repo the name of the repository
+ * @param token the github token
+ * @param message the commit message
+ * @param treeSha the sha of the tree
+ * @param parents the parents of the commit
+ * @returns CreateGitCommitResponse
+ */
+export const createGitCommitFactory: CreateGitCommitFactory = (instance) => async (args) => {
+  const { message, treeSha, parents } = args;
+
+  try {
+    const { data } = await instance.post<CreateGitCommitResponse>(
+      '/git/commits',
+      {
+        message,
+        tree: treeSha,
+        parents,
+      },
+    );
+
+    return createGitCommitSchema.parse(data);
+  } catch (error) {
+    throw handleError(error);
+  }
+};

package/src/github/commits/create-git-tree.ts

@@ -0,0 +1,68 @@
+import type { AxiosInstance } from 'axios';
+import { z } from 'zod';
+
+import { handleError } from './utils';
+
+export type Blob = {
+  path: string;
+  sha: string;
+};
+
+export type CreateGitTreeArgs = {
+  baseTreeSha: string;
+  blobs: Blob[];
+};
+
+export type CreateGitTreeResponse = {
+  sha: string;
+  url: string;
+};
+
+const createGitTreeSchema = z.object({
+  sha: z.string(),
+  url: z.string(),
+});
+
+export type CreateGitTree = (
+  args: CreateGitTreeArgs
+) => Promise<CreateGitTreeResponse>;
+
+export type CreateGitTreeFactory = (instance: AxiosInstance) => CreateGitTree;
+
+/**
+ * Create a git tree
+ *
+ * @param owner the owner of the repository
+ * @param repo the name of the repository
+ * @param token the github token
+ * @param baseTreeSha the sha of the base tree
+ * @param blobs the blobs to add to the tree
+ * @returns CreateGitTreeResponse
+ * @throws forbidden
+ * @throws resource-not-found
+ * @throws validation-failed-or-the-endpoint-has-been-spammed
+ */
+export const createGitTreeFactory: CreateGitTreeFactory = (instance) => async (args) => {
+  const { baseTreeSha, blobs } = args;
+
+  const tree = blobs.map((blob) => ({
+    path: blob.path,
+    mode: '100644',
+    type: 'blob',
+    sha: blob.sha,
+  }));
+
+  try {
+    const { data } = await instance.post<CreateGitTreeResponse>(
+      '/git/trees',
+      {
+        base_tree: baseTreeSha,
+        tree,
+      },
+    );
+
+    return createGitTreeSchema.parse(data);
+  } catch (error) {
+    throw handleError(error);
+  }
+};

package/src/github/commits/get-sha-last-commit-of-branch.ts

@@ -0,0 +1,50 @@
+import type { AxiosInstance } from 'axios';
+import { z } from 'zod';
+
+import { handleError } from './utils';
+
+export type GetShaLastCommitOfBranchArgs = {
+  ref: `/heads/${string}`;
+};
+
+export type GetShaLastCommitOfBranchResponse = {
+  sha: string;
+  url: string;
+};
+
+const getShaLastCommitOfBranchSchema = z.object({
+  sha: z.string(),
+  url: z.string(),
+});
+
+export type GetShaLastCommitOfBranch = (
+  args: GetShaLastCommitOfBranchArgs
+) => Promise<GetShaLastCommitOfBranchResponse>;
+
+export type GetShaLastCommitOfBranchFactory = (
+  instance: AxiosInstance
+) => GetShaLastCommitOfBranch;
+
+/**
+ * Get the sha of the last commit of a branch
+ *
+ * @param owner the owner of the repository
+ * @param repo the name of the repository
+ * @param ref the reference to a branch. Example: /heads/master
+ * @param token the github token
+ * @returns GetShaLastCommitOfBranchResponse
+ * @throws ref-not-found
+ */
+export const getShaLastCommitOfBranchFactory: GetShaLastCommitOfBranchFactory = (instance) => async (args) => {
+  const { ref } = args;
+
+  try {
+    const { data } = await instance.get<{
+      object: GetShaLastCommitOfBranchResponse;
+    }>(`/git/refs/${ref}`);
+
+    return getShaLastCommitOfBranchSchema.parse(data.object);
+  } catch (error) {
+    throw handleError(error);
+  }
+};

package/src/github/commits/get-tree-by-commit-sha.ts

@@ -0,0 +1,52 @@
+import type { AxiosInstance } from 'axios';
+import { z } from 'zod';
+
+import { handleError } from './utils';
+
+export type GetTreeFromCommitShaArgs = {
+  sha: string;
+};
+
+export type GetTreeFromCommitShaResponse = {
+  url: string;
+  sha: string;
+};
+
+const getTreeFromCommitShaSchema = z.object({
+  url: z.string(),
+  sha: z.string(),
+});
+
+export type GetTreeByCommitSha = (
+  args: GetTreeFromCommitShaArgs
+) => Promise<GetTreeFromCommitShaResponse>;
+
+export type GetTreeByCommitShaFactory = (
+  instance: AxiosInstance
+) => GetTreeByCommitSha;
+
+/**
+ * Get the tree of a commit
+ *
+ * @param owner the owner of the repository
+ * @param repo the name of the repository
+ * @param sha the sha of the commit
+ * @param token the github token
+ * @returns GetTreeFromCommitShaResponse
+ * @throws sha-not-found
+ * @throws validation-failed-or-the-endpoint-has-been-spammed
+ * @throws internal-server-error
+ */
+export const getTreeByCommitShaFactory: GetTreeByCommitShaFactory = (instance) => async (args) => {
+  const { sha } = args;
+
+  try {
+    const { data } = await instance.get<{
+      tree: GetTreeFromCommitShaResponse;
+    }>(`/git/commits/${sha}`);
+
+    return getTreeFromCommitShaSchema.parse(data.tree);
+  } catch (error) {
+    throw handleError(error);
+  }
+};

package/src/github/commits/index.ts

@@ -0,0 +1,6 @@
+export * from './create-git-blob';
+export * from './create-git-commit';
+export * from './create-git-tree';
+export * from './get-sha-last-commit-of-branch';
+export * from './get-tree-by-commit-sha';
+export * from './run-new-commit-process';

package/src/github/commits/run-new-commit-process.ts

@@ -0,0 +1,88 @@
+import type { CreateGitBlob } from './create-git-blob';
+import type { CreateGitCommit } from './create-git-commit';
+import type { CreateGitTree } from './create-git-tree';
+import type { GetShaLastCommitOfBranch } from './get-sha-last-commit-of-branch';
+import type { GetTreeByCommitSha } from './get-tree-by-commit-sha';
+
+export type VersionedFile = {
+  path: string;
+  content: string;
+};
+
+export type RunNewCommitProcessArgs = {
+  message: string;
+  ref: `/heads/${string}`;
+  files: VersionedFile[];
+};
+
+export type RunNewCommitProcessResponse = {
+  sha: string;
+  url: string;
+};
+
+export type RunNewCommitProcess = (
+  args: RunNewCommitProcessArgs,
+  updateState?: (state: string) => void
+) => Promise<RunNewCommitProcessResponse>;
+
+export type RunNewCommitProcessFactory = (args: {
+  createGitBlob: CreateGitBlob;
+  createGitCommit: CreateGitCommit;
+  createGitTree: CreateGitTree;
+  getShaLastCommitOfBranch: GetShaLastCommitOfBranch;
+  getTreeByCommitSha: GetTreeByCommitSha;
+}) => RunNewCommitProcess;
+
+export const runNewCommitProcessFactory: RunNewCommitProcessFactory = (args) => async (
+  runNewCommitProcessArgs,
+  updateState = () => {},
+) => {
+  const { createGitBlob, createGitCommit, createGitTree, getShaLastCommitOfBranch, getTreeByCommitSha } = args;
+
+  const { message, ref, files } = runNewCommitProcessArgs;
+
+  updateState('retrieving-sha-last-commit-of-branch');
+  const { sha: shaLastCommit } = await getShaLastCommitOfBranch({
+    ref,
+  });
+  updateState('retrieved-sha-last-commit-of-branch');
+
+  updateState('creating-blobs-from-file');
+  const blobs = await Promise.all(
+    files.map(async (file) => {
+      const blob = await createGitBlob({
+        content: file.content,
+        encoding: 'utf-8',
+      });
+
+      return {
+        path: file.path,
+        sha: blob.sha,
+      };
+    }),
+  );
+  updateState('created-blobs-from-file');
+
+  updateState('retrieving-branch-current-tree');
+  const { sha: lastCommitTreeSha } = await getTreeByCommitSha({
+    sha: shaLastCommit,
+  });
+  updateState('retrieved-branch-current-tree');
+
+  updateState('creating-new-tree-with-changes');
+  const tree = await createGitTree({
+    baseTreeSha: lastCommitTreeSha,
+    blobs,
+  });
+  updateState('created-new-tree-with-changes');
+
+  updateState('creating-new-commit');
+  const commit = await createGitCommit({
+    message,
+    treeSha: tree.sha,
+    parents: [shaLastCommit],
+  });
+  updateState('created-new-commit');
+
+  return commit;
+};

package/src/github/commits/utils.ts

@@ -0,0 +1,31 @@
+import type { AxiosResponse } from 'axios';
+
+export const handleError = (error: unknown): Error => {
+  const { response } = error as any;
+
+  if (response) {
+    const { status } = response as AxiosResponse;
+
+    if (status === 403) {
+      return new Error('forbidden');
+    }
+
+    if (status === 404) {
+      return new Error('resource-not-found');
+    }
+
+    if (status === 409) {
+      return new Error('conflict');
+    }
+
+    if (status === 422) {
+      return new Error('validation-failed-or-the-endpoint-has-been-spammed');
+    }
+
+    if (status === 500) {
+      return new Error('internal-server-error');
+    }
+  }
+
+  return error as Error;
+};

package/src/github/contents/get-file-content.ts

@@ -0,0 +1,50 @@
+import type { AxiosInstance } from 'axios';
+
+import { handleError } from '../commits/utils';
+
+export type GetFileContentArgs = {
+  path: string;
+  branch: string;
+};
+
+type ApiResponse = {
+  encoding: 'base64' | 'utf-8';
+  content: string;
+};
+
+export type GetFileContentResponse = string;
+
+export type GetFileContent = (args: GetFileContentArgs) => Promise<GetFileContentResponse>;
+
+export type GetFileContentFactory = (instance: AxiosInstance) => GetFileContent;
+
+/**
+ * Get the content of a file
+ *
+ * @param path the path of the file
+ * @param branch the branch of the file
+ * @returns GetFileContentResponse
+ * @throws validation-failed-or-the-endpoint-has-been-spammed
+ * @throws internal-server-error
+ * @throws forbidden
+ * @throws resource-not-found
+ */
+export const getFileContentFactory: GetFileContentFactory = (instance) => async (args) => {
+  const { path, branch } = args;
+
+  try {
+    const { data } = await instance.get<ApiResponse>(`/contents/${path}`, {
+      params: {
+        ref: branch,
+      },
+    });
+
+    if (data.encoding === 'base64') {
+      return Buffer.from(data.content, 'base64').toString('utf-8');
+    }
+
+    return data.content;
+  } catch (error) {
+    throw handleError(error);
+  }
+};

package/src/github/github.ts

@@ -0,0 +1,74 @@
+import axios from 'axios';
+
+import {
+  createGitBlobFactory,
+  createGitCommitFactory,
+  createGitTreeFactory,
+  getShaLastCommitOfBranchFactory,
+  getTreeByCommitShaFactory,
+  runNewCommitProcessFactory,
+} from './commits';
+import type {
+  CreateGitTree,
+  CreateGitBlob,
+  CreateGitCommit,
+  GetTreeByCommitSha,
+  GetShaLastCommitOfBranch,
+  RunNewCommitProcess,
+} from './commits';
+import { GetFileContent, getFileContentFactory } from './contents/get-file-content';
+
+export type GithubSdkArgs = {
+  owner: string;
+  repo: string;
+  token: string;
+};
+
+export type GithubSdkInstance = {
+  createGitBlob: CreateGitBlob;
+  createGitCommit: CreateGitCommit;
+  createGitTree: CreateGitTree;
+  getShaLastCommitOfBranch: GetShaLastCommitOfBranch;
+  getTreeByCommitSha: GetTreeByCommitSha;
+  runNewCommitProcess: RunNewCommitProcess;
+  getFileContent: GetFileContent;
+};
+
+export const githubSdk = (args: GithubSdkArgs) => {
+  const { owner, repo, token } = args;
+
+  const instance = axios.create({
+    baseURL: `https://api.github.com/repos/${owner}/${repo}`,
+    headers: {
+      Accept: 'application/vnd.github+json',
+      Authorization: `Bearer ${token}`,
+      'X-GitHub-Api-Version': '2022-11-28',
+    },
+  });
+
+  const createGitBlob = createGitBlobFactory(instance);
+  const createGitCommit = createGitCommitFactory(instance);
+  const createGitTree = createGitTreeFactory(instance);
+  const getShaLastCommitOfBranch = getShaLastCommitOfBranchFactory(instance);
+  const getTreeByCommitSha = getTreeByCommitShaFactory(instance);
+
+  const getFileContent = getFileContentFactory(instance);
+
+  const runNewCommitProcess = runNewCommitProcessFactory({
+    createGitBlob,
+    createGitCommit,
+    createGitTree,
+    getShaLastCommitOfBranch,
+    getTreeByCommitSha,
+  });
+
+  return {
+    createGitBlob,
+    createGitCommit,
+    createGitTree,
+    getShaLastCommitOfBranch,
+    getTreeByCommitSha,
+    runNewCommitProcess,
+    getFileContent,
+  };
+};

package/src/github/index.ts

@@ -0,0 +1 @@
+export * from './github';

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

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,50 @@
+/* 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. ');
+  });
+});