@squiz/dx-common-lib 1.2.1-alpha.107 → 1.2.1-alpha.99

package/src/error/MethodNotImplementedError.ts

@@ -1,7 +0,0 @@
-import { InternalServerError } from './InternalServerError';
-
-export class MethodNotImplementedError extends InternalServerError {
-  constructor(message?: string) {
-    super(message ?? 'method is not implemented');
-  }
-}

package/src/error/ResourceNotFoundError.ts

@@ -1,7 +0,0 @@
-import { ErrorWithHttpStatusCode } from './ErrorWithHttpStatusCode';
-
-export class ResourceNotFoundError extends ErrorWithHttpStatusCode {
-  constructor(message: string) {
-    super(404, message);
-  }
-}

package/src/error/TimeoutError.ts

@@ -1,8 +0,0 @@
-import { ErrorWithHttpStatusCode } from './ErrorWithHttpStatusCode';
-
-export class TimeoutError extends ErrorWithHttpStatusCode {
-  name = 'TimeoutError';
-  constructor(message: string = 'request failed to evaluate within the timeout period') {
-    super(500, message);
-  }
-}

package/src/error/index.ts

@@ -1,6 +0,0 @@
-export * from './BadRequestError';
-export * from './ErrorWithHttpStatusCode';
-export * from './InternalServerError';
-export * from './ResourceNotFoundError';
-export * from './TimeoutError';
-export * from './MethodNotImplementedError';

package/src/util/getNodeEnv.spec.ts

@@ -1,25 +0,0 @@
-import { getNodeEnv } from './getNodeEnv';
-
-describe('getNodeEnv', () => {
-  it('should return production if NODE_ENV equals production', () => {
-    process.env.NODE_ENV = 'production';
-    expect(getNodeEnv()).toEqual('production');
-  });
-
-  it('should return development if NODE_ENV equals development', () => {
-    process.env.NODE_ENV = 'development';
-    expect(getNodeEnv()).toEqual('development');
-  });
-
-  it('should return development if NODE_ENV is not set', () => {
-    delete process.env.NODE_ENV;
-    expect(getNodeEnv()).toEqual('development');
-  });
-
-  it('should throw if NODE_ENV set to non valid environment', () => {
-    process.env.NODE_ENV = 'invalid';
-    expect(() => getNodeEnv()).toThrowError(
-      new Error('NODE_ENV env var can only be values "production" or "development"'),
-    );
-  });
-});

package/src/util/getNodeEnv.ts

@@ -1,11 +0,0 @@
-export function getNodeEnv(): 'production' | 'development' {
-  if (process.env.NODE_ENV == 'production') {
-    return 'production';
-  }
-
-  if (process.env.NODE_ENV == 'development' || process.env.NODE_ENV === undefined) {
-    return 'development';
-  }
-
-  throw new Error('NODE_ENV env var can only be values "production" or "development"');
-}

package/src/util/getPageInfo.ts

@@ -1,23 +0,0 @@
-export type PageInfoResult = {
-  current: number;
-  next: number | null;
-  previous: number | null;
-  totalPages: number;
-  totalItems: number;
-  pageSize: number;
-};
-
-export function getPageInfo(current: number, pageSize: number, totalItems: number): PageInfoResult {
-  const totalPages = Math.ceil(totalItems / pageSize);
-  const next = current + 1 > totalPages ? null : current + 1;
-  const previous = current <= 1 ? null : current - 1;
-
-  return {
-    current,
-    next,
-    previous,
-    totalPages,
-    totalItems,
-    pageSize,
-  };
-}

package/src/util/index.ts

@@ -1,7 +0,0 @@
-export { getNodeEnv } from './getNodeEnv';
-export { isPathTryingToAccessOutsideOfRoot } from './isPathTryingToAccessOutsideOfRoot';
-export { joinAbsoluteUrlPath } from './joinAbsoluteUrlPath';
-export { parseEnvVarForVar } from './parseEnvVarForVar';
-export { isReadable } from './isReadable';
-export { never } from './never';
-export { getPageInfo, PageInfoResult } from './getPageInfo';

package/src/util/isPathTryingToAccessOutsideOfRoot.spec.ts

@@ -1,25 +0,0 @@
-import { isPathTryingToAccessOutsideOfRoot } from './isPathTryingToAccessOutsideOfRoot';
-
-describe('isPathTryingToAccessOutsideOfRoot', () => {
-  it("should return false if filepath doesn't try to access outside of root", () => {
-    expect(isPathTryingToAccessOutsideOfRoot('my-root/', 'hello')).toEqual(false);
-    expect(isPathTryingToAccessOutsideOfRoot('my-root/', './hello')).toEqual(false);
-    expect(isPathTryingToAccessOutsideOfRoot('my-root/', './hello/../')).toEqual(false);
-  });
-
-  it('should resolve a relative root path', () => {
-    expect(isPathTryingToAccessOutsideOfRoot('./my-root/', 'hello')).toEqual(false);
-    expect(isPathTryingToAccessOutsideOfRoot('./my-root/', 'hello/../world')).toEqual(false);
-    expect(isPathTryingToAccessOutsideOfRoot('./my-root/', 'hello/world/..')).toEqual(false);
-    expect(isPathTryingToAccessOutsideOfRoot('./my-root/', './')).toEqual(false);
-    expect(isPathTryingToAccessOutsideOfRoot('./my-root/something', './else')).toEqual(false);
-    expect(isPathTryingToAccessOutsideOfRoot('./my-root/something', './else/1/../../')).toEqual(false);
-  });
-
-  it('should return true if filepath does access outside of the root', () => {
-    expect(isPathTryingToAccessOutsideOfRoot('./my-root/', '../')).toEqual(true);
-    expect(isPathTryingToAccessOutsideOfRoot('./my-root/', '../../')).toEqual(true);
-    expect(isPathTryingToAccessOutsideOfRoot('./my-root/', 'hello/../world/../../')).toEqual(true);
-    expect(isPathTryingToAccessOutsideOfRoot('./my-root/', 'hello/../../')).toEqual(true);
-  });
-});

package/src/util/isPathTryingToAccessOutsideOfRoot.ts

@@ -1,8 +0,0 @@
-import path from 'path';
-
-export function isPathTryingToAccessOutsideOfRoot(rootPath: string, filePath: string) {
-  const resolvedRoot = path.resolve(rootPath);
-
-  const joinedPath = path.join(resolvedRoot, filePath);
-  return !joinedPath.includes(resolvedRoot);
-}

package/src/util/isReadable.ts

@@ -1,12 +0,0 @@
-import path from 'path';
-import fse from 'fs-extra';
-import { constants } from 'fs';
-
-export async function isReadable(basePath: string, file: string): Promise<boolean> {
-  try {
-    await fse.access(path.join(basePath, file), constants.R_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}

package/src/util/joinAbsoluteUrlPath.spec.ts

@@ -1,62 +0,0 @@
-import { joinAbsoluteUrlPath } from './joinAbsoluteUrlPath';
-
-describe('joinAbsoluteUrlPath', () => {
-  it('should return a valid absolute url for protocol based inputs', () => {
-    expect(joinAbsoluteUrlPath('https://example.com', 'aaa', 'bbb')).toEqual('https://example.com/aaa/bbb');
-    expect(joinAbsoluteUrlPath('https://example.com/', '/aaa', 'bbb')).toEqual('https://example.com/aaa/bbb');
-    expect(joinAbsoluteUrlPath('https://example.com/', '/aaa/', '/bbb///')).toEqual('https://example.com/aaa/bbb');
-    expect(joinAbsoluteUrlPath('https://example.com/', './..///', '/bbb///')).toEqual('https://example.com/bbb');
-    expect(joinAbsoluteUrlPath('https://example.com/', './aaa/', '/bbb/')).toEqual('https://example.com/aaa/bbb');
-    expect(joinAbsoluteUrlPath('https://example.com/', '../aaa/', '/bbb')).toEqual('https://example.com/aaa/bbb');
-
-    expect(joinAbsoluteUrlPath('https://example.com/', 'ccc', '../aaa/', '/bbb')).toEqual(
-      'https://example.com/aaa/bbb',
-    );
-    expect(joinAbsoluteUrlPath('https://example.com/', 'ccc', '../../aaa/', '/bbb')).toEqual(
-      'https://example.com/aaa/bbb',
-    );
-    expect(joinAbsoluteUrlPath('https://example.com/', 'ccc', '/../../aaa/', '/bbb')).toEqual(
-      'https://example.com/aaa/bbb',
-    );
-
-    expect(joinAbsoluteUrlPath('https://example.com/', 'ddd', 'eee', 'ccc', '/../../aaa/', '/bbb')).toEqual(
-      'https://example.com/ddd/aaa/bbb',
-    );
-    expect(joinAbsoluteUrlPath('http://localhost:3000', 'aaa', 'bbb')).toEqual('http://localhost:3000/aaa/bbb');
-    expect(joinAbsoluteUrlPath('http://localhost:3000', '/aaa', 'bbb')).toEqual('http://localhost:3000/aaa/bbb');
-    expect(joinAbsoluteUrlPath('http://localhost:3000', '/aaa/', '/bbb///')).toEqual('http://localhost:3000/aaa/bbb');
-    expect(joinAbsoluteUrlPath('http://localhost:3000', './aaa/', '/bbb/')).toEqual('http://localhost:3000/aaa/bbb');
-    expect(joinAbsoluteUrlPath('http://localhost:3000', '../aaa/', '/bbb')).toEqual('http://localhost:3000/aaa/bbb');
-    expect(joinAbsoluteUrlPath('http://localhost:3000', 'ccc', '../aaa/', '/bbb')).toEqual(
-      'http://localhost:3000/aaa/bbb',
-    );
-    expect(joinAbsoluteUrlPath('http://localhost:3000', 'ccc', '../../aaa/', '/bbb')).toEqual(
-      'http://localhost:3000/aaa/bbb',
-    );
-    expect(joinAbsoluteUrlPath('http://localhost:3000', 'ccc', '/../../aaa/', '/bbb')).toEqual(
-      'http://localhost:3000/aaa/bbb',
-    );
-    expect(joinAbsoluteUrlPath('http://localhost:3000/', 'ddd', 'eee', 'ccc', '/../../aaa/', '/bbb')).toEqual(
-      'http://localhost:3000/ddd/aaa/bbb',
-    );
-    expect(joinAbsoluteUrlPath('http://localhost:3000/', 'localhost', 'eee', 'ccc', '/../../aaa/', '/bbb')).toEqual(
-      'http://localhost:3000/localhost/aaa/bbb',
-    );
-  });
-
-  it('should return a valid resolved path for inputs', () => {
-    expect(joinAbsoluteUrlPath('aaa', 'bbb')).toEqual('aaa/bbb');
-    expect(joinAbsoluteUrlPath('/aaa', 'bbb')).toEqual('aaa/bbb');
-    expect(joinAbsoluteUrlPath('/aaa/', '/bbb///')).toEqual('aaa/bbb');
-    expect(joinAbsoluteUrlPath('./aaa/', '/bbb/')).toEqual('aaa/bbb');
-    expect(joinAbsoluteUrlPath('../aaa/', '/bbb')).toEqual('aaa/bbb');
-    expect(joinAbsoluteUrlPath('ccc', '../aaa/', '/bbb')).toEqual('aaa/bbb');
-    expect(joinAbsoluteUrlPath('ccc', '../../aaa/', '/bbb')).toEqual('aaa/bbb');
-    expect(joinAbsoluteUrlPath('ccc', '/../../aaa/', '/bbb')).toEqual('aaa/bbb');
-    expect(joinAbsoluteUrlPath('ddd', 'eee', 'ccc', '/../../aaa/', '/bbb')).toEqual('ddd/aaa/bbb');
-    expect(joinAbsoluteUrlPath('http', 'ccc', '/aaa/', '/bbb')).toEqual('http/ccc/aaa/bbb');
-    expect(joinAbsoluteUrlPath('https', 'ccc', '/aaa/', '/bbb')).toEqual('https/ccc/aaa/bbb');
-    expect(joinAbsoluteUrlPath('https', '../ccc', '/aaa/', '/bbb')).toEqual('ccc/aaa/bbb');
-    expect(joinAbsoluteUrlPath('https', './ccc', '/aaa/', '/bbb')).toEqual('https/ccc/aaa/bbb');
-  });
-});

package/src/util/joinAbsoluteUrlPath.ts

@@ -1,22 +0,0 @@
-export function joinAbsoluteUrlPath(...args: string[]) {
-  const [rootUrl] = args;
-  /**
-   * This method takes any form of input string and resolves them to make an absolute url
-   * Since these paths are web paths and not file paths, we are creating a URL object (https://nodejs.org/api/url.html). http://example.com has just been used as a dummy entry to create a valid url.
-   * Note: path.resolves gives you different output based on the OS node is running on. More reading here https://nodejs.org/api/path.html#windows-vs-posix.
-   */
-  const url = new URL(getSanitisedString(args), 'http://example.com');
-  if (urlIsAbsolute(rootUrl)) {
-    return url.toString();
-  } else {
-    return url.pathname.replace(/(^\/|\/$)/g, '');
-  }
-}
-
-function getSanitisedString(subdirs: string[]) {
-  return subdirs.map((dir) => dir.replace(/(^\.\/+)|(^\/+|\/+$)/g, '')).join('/');
-}
-
-function urlIsAbsolute(url: string) {
-  return url.match(/^http(s?):\/\//);
-}

package/src/util/never.ts

@@ -1,4 +0,0 @@
-export function never(a: never): never {
-  // this should never be executed. This is a compile time check
-  throw new Error(`value ${a} is not valid`);
-}

package/src/util/parseEnvVarForVar.spec.ts

@@ -1,22 +0,0 @@
-import { parseEnvVarForVar } from './parseEnvVarForVar';
-
-describe('parseEnvVarForVar', () => {
-  it('it should read an environment variable from process.env.*', () => {
-    process.env.MY_VAR = 'hello';
-
-    expect(parseEnvVarForVar('MY_VAR')).toEqual('hello');
-  });
-
-  it('it should throw an error if the variable is not available', () => {
-    expect(() => parseEnvVarForVar('DOESNT_EXIST')).toThrowError(new Error('env variable DOESNT_EXIST must be set'));
-  });
-
-  it('it should not throw an error if a default value is provided and env var doesnt exist', () => {
-    expect(parseEnvVarForVar('DOESNT_EXIST', 'default')).toEqual('default');
-  });
-
-  it('it should return env var if its set and a defualt value is set', () => {
-    process.env.MY_VAR = 'hello';
-    expect(parseEnvVarForVar('MY_VAR', 'default')).toEqual('hello');
-  });
-});

package/src/util/parseEnvVarForVar.ts

@@ -1,12 +0,0 @@
-export function parseEnvVarForVar(varName: string, defaultValue: string | undefined = undefined): string {
-  if (process.env[varName] === undefined) {
-    if (defaultValue !== undefined) {
-      return defaultValue;
-    }
-
-    throw new Error(`env variable ${varName} must be set`);
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-  return process.env[varName]!;
-}

package/src/zip/zipDirectory.spec.ts

@@ -1,24 +0,0 @@
-import path from 'path';
-import fs from 'fs';
-import { zipDirectory } from './zipDirectory';
-
-describe('zipDirectory', () => {
-  const inputDir = fs.mkdtempSync('zip-test');
-  const outDir = fs.mkdtempSync('zip-test-out');
-
-  beforeAll(() => {
-    fs.writeFileSync(path.join(inputDir, 'f1.txt'), '1');
-    fs.writeFileSync(path.join(inputDir, 'f2.txt'), '2');
-  });
-
-  afterAll(() => {
-    fs.rmSync(inputDir, { force: true, recursive: true });
-    fs.rmSync(outDir, { force: true, recursive: true });
-  });
-
-  it('should take an input path and an output path and create a export.zip', async () => {
-    await zipDirectory(inputDir, outDir);
-
-    expect(fs.existsSync(path.join(outDir, 'export.zip'))).toEqual(true);
-  });
-});

package/src/zip/zipDirectory.ts

@@ -1,31 +0,0 @@
-import path from 'path';
-import fs from 'fs';
-
-import archiver from 'archiver';
-
-export function zipDirectory(sourceDirectory: string, outputDirectory: string) {
-  return new Promise<string>((resolve, reject) => {
-    const outputZipFile = path.join(outputDirectory, '/export.zip');
-    const output = fs.createWriteStream(outputZipFile);
-
-    const archive = archiver('zip', {
-      zlib: { level: 9 }, // Sets the compression level.
-    });
-
-    output.on('close', function () {
-      resolve(outputZipFile);
-    });
-
-    archive.on('warning', function (err) {
-      reject(err);
-    });
-
-    archive.on('error', function (err) {
-      reject(err);
-    });
-
-    archive.pipe(output);
-    archive.directory(sourceDirectory, false);
-    archive.finalize();
-  });
-}