@squiz/dx-common-lib 1.2.11 → 1.2.13-alpha.0

package/src/api-key-validation/getApiKeyService.spec.ts

@@ -0,0 +1,32 @@
+import { CloudflareApiKeyService } from './CloudflareApiKeyService';
+import { DevelopmentApiKeyService } from './DevelopmentApiKeyService';
+import { getApiKeyService } from './getApiKeyService';
+
+describe('getApiKeyService', () => {
+  it('should return an instance of DevelopmentApiKeyService when NODE_ENV is development', () => {
+    process.env.NODE_ENV = 'development';
+    expect(getApiKeyService()).toBeInstanceOf(DevelopmentApiKeyService);
+  });
+
+  it('should return an instance of CloudflareApiKeyService when NODE_ENV is production', () => {
+    process.env.NODE_ENV = 'production';
+    expect(getApiKeyService({ deploymentEnvironment: 'any', squizRegion: 'value' })).toBeInstanceOf(
+      CloudflareApiKeyService,
+    );
+  });
+
+  it('should throw an error if no prodEnv values available', () => {
+    process.env.NODE_ENV = 'production';
+    expect(() => getApiKeyService()).toThrow(
+      new Error(`invalid production state, need to have deploymentEnvironment and squiz region set`),
+    );
+  });
+
+  it('should throw an error if NODE_ENV is anything other than development or production', () => {
+    process.env.NODE_ENV = 'something invalid';
+
+    expect(() => getApiKeyService()).toThrow(
+      new Error(`NODE_ENV env var can only be values "production" or "development"`),
+    );
+  });
+});

package/src/api-key-validation/getApiKeyService.ts

@@ -0,0 +1,27 @@
+import { getNodeEnv, never } from '../util';
+import { CloudflareApiKeyService } from './CloudflareApiKeyService';
+import { DevelopmentApiKeyService } from './DevelopmentApiKeyService';
+
+export function getApiKeyService(prodEnv?: {
+  deploymentEnvironment: string;
+  squizRegion: string;
+}): DevelopmentApiKeyService | CloudflareApiKeyService {
+  const env = getNodeEnv();
+
+  switch (env) {
+    // this the DX team dev environment
+    case 'development':
+      return new DevelopmentApiKeyService();
+    case 'production':
+      if (prodEnv == undefined) {
+        throw new Error(`invalid production state, need to have deploymentEnvironment and squiz region set`);
+      }
+
+      return new CloudflareApiKeyService(
+        `dx-${prodEnv.deploymentEnvironment}-${prodEnv.squizRegion}-cmp-cloudflare-keys`,
+      );
+
+    default:
+      never(env);
+  }
+}

package/src/assertions/assertAssignWithDefaultUndefinedValue.ts

@@ -15,8 +15,3 @@ export function assertAssignWithDefaultUndefinedValue<T>(
 
   return assertAssign(value, assertionFunc, errorMessage);
 }
-
-export const isSomeEnum =
-  <TEnum>(enumType: TEnum) =>
-  (token: unknown): token is TEnum[keyof TEnum] =>
-    Object.values(enumType).includes(token as TEnum[keyof TEnum]);

package/src/cache/applyDefaultRulesToCacheControlObject.spec.ts

@@ -0,0 +1,126 @@
+import { applyDefaultRulesToCacheControlObject } from './applyDefaultRulesToCacheControlObject';
+
+describe('applyDefaultRulesToCacheControlObject', () => {
+  const MIN_CACHE_SECONDS = 30;
+  const MAX_CACHE_SECONDS = 1800;
+
+  it('should return a Cache-Control object with the max-age directive clamped to the minimum allowed value if the value is 0', () => {
+    expect(
+      applyDefaultRulesToCacheControlObject({
+        'max-age': 0,
+      }),
+    ).toEqual({
+      'max-age': MIN_CACHE_SECONDS,
+    });
+  });
+  it('should return a Cache-Control object with the max-age directive clamped to the minimum allowed value if it is less than the minimum', () => {
+    expect(
+      applyDefaultRulesToCacheControlObject({
+        'max-age': MIN_CACHE_SECONDS - 1,
+      }),
+    ).toEqual({
+      'max-age': MIN_CACHE_SECONDS,
+    });
+  });
+
+  it('should return a Cache-Control object with the max-age directive clamped to the maximum allowed value if it is greater than the maximum', () => {
+    expect(
+      applyDefaultRulesToCacheControlObject({
+        'max-age': MAX_CACHE_SECONDS + 1,
+      }),
+    ).toEqual({
+      'max-age': MAX_CACHE_SECONDS,
+    });
+  });
+
+  it('should return a Cache-Control object with the s-maxage directive clamped to the minimum allowed value if the value is 0', () => {
+    expect(
+      applyDefaultRulesToCacheControlObject({
+        's-maxage': 0,
+      }),
+    ).toEqual({
+      's-maxage': MIN_CACHE_SECONDS,
+    });
+  });
+
+  it('should return a Cache-Control object with the s-maxage directive clamped to the minimum allowed value if it is less than the minimum', () => {
+    expect(
+      applyDefaultRulesToCacheControlObject({
+        's-maxage': MIN_CACHE_SECONDS - 1,
+      }),
+    ).toEqual({
+      's-maxage': MIN_CACHE_SECONDS,
+    });
+  });
+
+  it('should return a Cache-Control object with the s-maxage directive clamped to the maximum allowed value if it is greater than the maximum', () => {
+    expect(
+      applyDefaultRulesToCacheControlObject({
+        's-maxage': MAX_CACHE_SECONDS + 1,
+      }),
+    ).toEqual({
+      's-maxage': MAX_CACHE_SECONDS,
+    });
+  });
+
+  it('should return a Cache-Control object with the min-fresh directive clamped to the minimum allowed value if the value is 0', () => {
+    expect(
+      applyDefaultRulesToCacheControlObject({
+        'min-fresh': 0,
+      }),
+    ).toEqual({
+      'min-fresh': MIN_CACHE_SECONDS,
+    });
+  });
+  it('should return a Cache-Control object with the min-fresh directive clamped to the maximum allowed value if it is greater than the maximum', () => {
+    expect(
+      applyDefaultRulesToCacheControlObject({
+        'min-fresh': MAX_CACHE_SECONDS + 1,
+      }),
+    ).toEqual({
+      'min-fresh': MAX_CACHE_SECONDS,
+    });
+  });
+
+  it('should remove the no-store directive from the input Cache-Control object', () => {
+    expect(
+      applyDefaultRulesToCacheControlObject({
+        'max-age': MAX_CACHE_SECONDS,
+        'no-store': true,
+      }),
+    ).toEqual({
+      'max-age': MAX_CACHE_SECONDS,
+    });
+  });
+
+  it('should remove the no-cache directive from the input Cache-Control object', () => {
+    expect(
+      applyDefaultRulesToCacheControlObject({
+        'max-age': MAX_CACHE_SECONDS,
+        'no-cache': true,
+      }),
+    ).toEqual({
+      'max-age': MAX_CACHE_SECONDS,
+    });
+  });
+
+  it('should return a Cache-Control object with all other directives unchanged from the input Cache-Control object', () => {
+    expect(
+      applyDefaultRulesToCacheControlObject({
+        'max-age': MAX_CACHE_SECONDS,
+        's-maxage': MAX_CACHE_SECONDS,
+        'min-fresh': MAX_CACHE_SECONDS,
+        'stale-while-revalidate': MAX_CACHE_SECONDS,
+        'stale-if-error': MAX_CACHE_SECONDS,
+        extension: 'foo',
+      }),
+    ).toEqual({
+      'max-age': MAX_CACHE_SECONDS,
+      's-maxage': MAX_CACHE_SECONDS,
+      'min-fresh': MAX_CACHE_SECONDS,
+      'stale-while-revalidate': MAX_CACHE_SECONDS,
+      'stale-if-error': MAX_CACHE_SECONDS,
+      extension: 'foo',
+    });
+  });
+});

package/src/cache/applyDefaultRulesToCacheControlObject.ts

@@ -0,0 +1,23 @@
+import { CacheControl } from './parseCacheControl';
+import { ensureBetween, MIN_CACHE_SECONDS, MAX_CACHE_SECONDS } from './parseAndSanitiseCacheControlHeader';
+
+export function applyDefaultRulesToCacheControlObject(cacheControlInput: CacheControl) {
+  const cacheControl = { ...cacheControlInput };
+
+  if (cacheControl['max-age'] !== undefined) {
+    cacheControl['max-age'] = ensureBetween(cacheControl['max-age'], MIN_CACHE_SECONDS, MAX_CACHE_SECONDS);
+  }
+
+  if (cacheControl['s-maxage'] !== undefined) {
+    cacheControl['s-maxage'] = ensureBetween(cacheControl['s-maxage'], MIN_CACHE_SECONDS, MAX_CACHE_SECONDS);
+  }
+
+  if (cacheControl['min-fresh'] !== undefined) {
+    cacheControl['min-fresh'] = ensureBetween(cacheControl['min-fresh'], MIN_CACHE_SECONDS, MAX_CACHE_SECONDS);
+  }
+
+  delete cacheControl['no-store'];
+  delete cacheControl['no-cache'];
+
+  return cacheControl;
+}

package/src/cache/cacheControlToString.spec.ts

@@ -0,0 +1,43 @@
+import { cacheControlToString } from './cacheControlToString';
+
+describe('cacheControlToString', () => {
+  it('should return an empty string if the input Cache-Control object is empty', () => {
+    expect(cacheControlToString({})).toEqual('');
+  });
+
+  it('should return a Cache-Control header string with a single boolean directive', () => {
+    expect(cacheControlToString({ public: true })).toEqual('public');
+  });
+
+  it('should return a Cache-Control header string with a single numeric directive', () => {
+    expect(cacheControlToString({ 'max-age': 3600 })).toEqual('max-age=3600');
+  });
+
+  it('should return a Cache-Control header string with a single string directive', () => {
+    expect(cacheControlToString({ extension: 'foo' })).toEqual('extension="foo"');
+  });
+
+  it('should return a Cache-Control header string with multiple directives', () => {
+    expect(
+      cacheControlToString({
+        public: true,
+        'max-age': 3600,
+        's-maxage': 86400,
+        'min-fresh': 600,
+        'stale-while-revalidate': 60,
+        'stale-if-error': 86400,
+        extension: 'foo',
+      }),
+    ).toEqual(
+      'public, max-age=3600, s-maxage=86400, min-fresh=600, stale-while-revalidate=60, stale-if-error=86400, extension="foo"',
+    );
+  });
+
+  it('should handle commas in string values in the input Cache-Control object', () => {
+    expect(
+      cacheControlToString({
+        extension: 'foo, bar',
+      }),
+    ).toEqual('extension="foo, bar"');
+  });
+});

package/src/cache/cacheControlToString.ts

@@ -0,0 +1,22 @@
+import { CacheControl } from './parseCacheControl';
+
+export function cacheControlToString(cacheControl: CacheControl): string {
+  const parts: string[] = [];
+  for (const key of Object.keys(cacheControl)) {
+    let value = cacheControl[key];
+
+    if (typeof value === 'boolean' && value === true) {
+      parts.push(key);
+    } else {
+      if (typeof value === 'number') {
+        value = value.toString();
+      } else if (typeof value === 'string') {
+        value = `"${value}"`;
+      }
+
+      parts.push(`${key}=${value}`);
+    }
+  }
+
+  return parts.join(', ');
+}

package/src/cache/index.ts

@@ -0,0 +1,4 @@
+export * from './parseAndSanitiseCacheControlHeader';
+export * from './parseCacheControl';
+export * from './applyDefaultRulesToCacheControlObject';
+export * from './cacheControlToString';

package/src/cache/parseAndSanitiseCacheControlHeader.spec.ts

@@ -0,0 +1,25 @@
+import { parseAndSanitiseCacheControlHeader } from './parseAndSanitiseCacheControlHeader';
+
+describe('parseAndSanitiseCacheControlHeader', () => {
+  it('should return a default Cache-Control header string if the input is undefined', () => {
+    expect(parseAndSanitiseCacheControlHeader(undefined)).toEqual('public, max-age=1800');
+  });
+
+  it('should return a sanitized Cache-Control header string if the input is a valid Cache-Control header string', () => {
+    expect(parseAndSanitiseCacheControlHeader('max-age=3600, s-maxage=86400, min-fresh=600, no-store')).toEqual(
+      'max-age=1800, s-maxage=1800, min-fresh=600',
+    );
+  });
+
+  it('should remove the no-store directive from the input Cache-Control header string', () => {
+    expect(parseAndSanitiseCacheControlHeader('max-age=3600, no-store')).toEqual('max-age=1800');
+  });
+
+  it('should remove the no-cache directive from the input Cache-Control header string', () => {
+    expect(parseAndSanitiseCacheControlHeader('max-age=3600, no-cache')).toEqual('max-age=1800');
+  });
+
+  it('should remove both the no-store and no-cache directives from the input Cache-Control header string', () => {
+    expect(parseAndSanitiseCacheControlHeader('max-age=3600, no-store, no-cache')).toEqual('max-age=1800');
+  });
+});

package/src/cache/parseAndSanitiseCacheControlHeader.ts

@@ -0,0 +1,28 @@
+import { applyDefaultRulesToCacheControlObject } from './applyDefaultRulesToCacheControlObject';
+import { cacheControlToString } from './cacheControlToString';
+import { parseCacheControl } from './parseCacheControl';
+
+export const MIN_CACHE_SECONDS = 30;
+export const MAX_CACHE_SECONDS = minutesToSeconds(30);
+
+export const DEFAULT_CACHE_CONTROL_HEADER = cacheControlToString({ public: true, 'max-age': minutesToSeconds(30) });
+
+export function parseAndSanitiseCacheControlHeader(cacheControlString: string | undefined): string {
+  if (!cacheControlString) {
+    return DEFAULT_CACHE_CONTROL_HEADER;
+  }
+
+  let cacheControl = parseCacheControl(cacheControlString);
+
+  cacheControl = applyDefaultRulesToCacheControlObject(cacheControl);
+
+  return cacheControlToString(cacheControl);
+}
+
+export function ensureBetween(input: number, min: number, max: number): number {
+  return Math.max(min, Math.min(input, max));
+}
+
+function minutesToSeconds(minutes: number): number {
+  return minutes * 60;
+}

package/src/cache/parseCacheControl.spec.ts

@@ -0,0 +1,89 @@
+import { parseCacheControl } from './parseCacheControl';
+
+describe('parseCacheControl', () => {
+  test('no-cache', () => {
+    const header = 'no-cache';
+
+    expect(parseCacheControl(header)).toEqual({ 'no-cache': true });
+  });
+
+  test('public', () => {
+    const header = 'public, max-age=3600';
+
+    expect(parseCacheControl(header)).toEqual({ public: true, 'max-age': 3600 });
+  });
+
+  test('private', () => {
+    const header = 'private, no-transform, max-age=3600';
+
+    expect(parseCacheControl(header)).toEqual({
+      private: true,
+      'no-transform': true,
+      'max-age': 3600,
+    });
+  });
+
+  test('max-age', () => {
+    const header = 'max-age=3600, public';
+
+    expect(parseCacheControl(header)).toEqual({ 'max-age': 3600, public: true });
+  });
+
+  test('s-maxage', () => {
+    const header = 's-maxage=604800, must-revalidate';
+
+    expect(parseCacheControl(header)).toEqual({
+      's-maxage': 604800,
+      'must-revalidate': true,
+    });
+  });
+
+  test('must-revalidate', () => {
+    const header = 'no-store, no-cache, must-revalidate';
+
+    expect(parseCacheControl(header)).toEqual({
+      'no-store': true,
+      'no-cache': true,
+      'must-revalidate': true,
+    });
+  });
+
+  test('no-store', () => {
+    const header = 'no-store';
+
+    expect(parseCacheControl(header)).toEqual({ 'no-store': true });
+  });
+
+  test('no-transform', () => {
+    const header = 'no-transform';
+
+    expect(parseCacheControl(header)).toEqual({ 'no-transform': true });
+  });
+
+  test('quoted string', () => {
+    const header = 'extension="foo, bar", no-transform';
+
+    expect(parseCacheControl(header)).toEqual({
+      extension: 'foo, bar',
+      'no-transform': true,
+    });
+  });
+
+  test('multiple values', () => {
+    const header = 'extension="foo, bar", max-age=3600, s-maxage=604800, no-transform, public';
+
+    expect(parseCacheControl(header)).toEqual({
+      extension: 'foo, bar',
+      'max-age': 3600,
+      's-maxage': 604800,
+      'no-transform': true,
+      public: true,
+    });
+  });
+
+  test('empty value', () => {
+    const header = 'extension="", max-age=3600';
+
+    expect(parseCacheControl(header)).toEqual({ extension: '', 'max-age': 3600 });
+  });
+});

package/src/cache/parseCacheControl.ts

@@ -0,0 +1,74 @@
+// please read https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control
+export interface CacheControl {
+  'max-age'?: number;
+  's-maxage'?: number;
+  'min-fresh'?: number;
+  'stale-while-revalidate'?: number;
+  'stale-if-error'?: number;
+
+  public?: true;
+  private?: true;
+  'no-store'?: true;
+  'no-cache'?: true;
+  'no-transform'?: true;
+  'must-revalidate'?: true;
+  'proxy-revalidate'?: true;
+  'must-understand'?: true;
+  immutable?: true;
+  extension?: string;
+
+  [key: string]: string | boolean | undefined | number;
+}
+
+export function parseCacheControl(header: string): CacheControl {
+  const parts = header.split(/,(?=(?:[^"]|"[^"]*")*$)/);
+  const result: CacheControl = {};
+
+  for (const part of parts) {
+    const [key, value] = part.split('=');
+    const trimmedKey = key.trim();
+
+    const trimmedValue = value !== undefined ? value.trim() : undefined;
+    const strippedValue = trimQuotes(trimmedValue);
+    const parsedValue = parseIntOrString(strippedValue, trimmedKey);
+
+    result[trimmedKey] = parsedValue;
+  }
+
+  return result;
+}
+
+function trimQuotes(str: string | undefined): string | undefined {
+  if (str === undefined) {
+    return str;
+  }
+
+  if (str[0] === '"' && str[str.length - 1] === '"') {
+    return str.substring(1, str.length - 1);
+  }
+
+  return str;
+}
+
+function parseIntOrString(str: string | undefined, key: string): string | number | true | undefined {
+  if (
+    key === 'max-age' ||
+    key === 's-maxage' ||
+    key === 'min-fresh' ||
+    key === 'stale-while-revalidate' ||
+    key === 'stale-if-error'
+  ) {
+    if (str) {
+      const parsedValue = parseInt(str, 10);
+      return isNaN(parsedValue) ? str || true : parsedValue;
+    } else {
+      return 0;
+    }
+  }
+
+  if (str === undefined) {
+    return true;
+  }
+
+  return str;
+}

package/src/error/InvalidTokenError.ts

@@ -0,0 +1,8 @@
+import { ErrorWithHttpStatusCode } from './ErrorWithHttpStatusCode';
+
+export class InvalidTokenError extends ErrorWithHttpStatusCode {
+  name = 'InvalidTokenError';
+  constructor() {
+    super(401, 'Invalid authorization token');
+  }
+}

package/src/error/UnAuthenticatedRequestError.ts

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

package/src/error/UnprivilegedError.ts

@@ -0,0 +1,8 @@
+import { ErrorWithHttpStatusCode } from './ErrorWithHttpStatusCode';
+
+export class UnprivilegedError extends ErrorWithHttpStatusCode {
+  name = 'UnprivilegedError';
+  constructor() {
+    super(403, 'Permission not satisfied');
+  }
+}

package/src/error/index.ts

@@ -4,3 +4,7 @@ export * from './InternalServerError';
 export * from './ResourceNotFoundError';
 export * from './TimeoutError';
 export * from './MethodNotImplementedError';
+
+export * from './InvalidTokenError';
+export * from './UnprivilegedError';
+export * from './UnAuthenticatedRequestError';