@squiz/optimization-utils 2.0.1 → 2.0.2

package/src/httpClient/__tests__/FetchHttpClient.spec.ts

@@ -1,146 +0,0 @@
-import {
-  HttpClient,
-  HttpMethod,
-  HttpRequestOptions,
-  HttpResponse,
-} from '../HttpClient';
-import { Container } from 'inversify';
-import { FetchHttpClient } from '../FetchHttpClient';
-import fetch from 'node-fetch-commonjs';
-import { faker } from '@faker-js/faker';
-import Mock = jest.Mock;
-import { Logger } from '../../logger/Logger';
-import {
-  createLoggerMock,
-  createResponse,
-  FetchMock,
-} from '../../testing/mock';
-
-jest.mock('node-fetch-commonjs');
-
-describe('FetchHttpClient', () => {
-  let httpClient: HttpClient;
-  let mockFetch: FetchMock;
-  let params: HttpRequestOptions;
-
-  beforeEach(() => {
-    const container = new Container();
-
-    container.bind(Logger).toConstantValue(createLoggerMock());
-    container.bind(HttpClient).to(FetchHttpClient);
-    mockFetch = fetch as Mock;
-    mockFetch.mockReset();
-    httpClient = container.get(HttpClient);
-
-    params = {
-      url: faker.internet.url(),
-      body: faker.word.words(),
-      headers: {
-        'example-header': faker.word.words(),
-      },
-      method: faker.helpers.arrayElement(Object.values(HttpMethod)),
-    };
-  });
-
-  describe('passing params to fetch', () => {
-    it('should call the fetch with passed parameters', async () => {
-      mockFetch.mockResolvedValueOnce(createResponse(200, {}));
-
-      await httpClient.sendRequest(params);
-
-      expect(mockFetch).toHaveBeenCalledWith(params.url, {
-        body: params.body,
-        method: params.method,
-        headers: params.headers,
-      });
-    });
-
-    it('should parse request body to JSON if passed Content-Type: application/json', async () => {
-      mockFetch.mockResolvedValueOnce(createResponse(200, {}));
-      const body = { example: faker.word.words() };
-
-      await httpClient.sendRequest({
-        ...params,
-        body,
-        headers: {
-          'Content-Type': 'application/json',
-        },
-      });
-
-      expect(mockFetch).toHaveBeenCalledWith(params.url, {
-        body: JSON.stringify(body),
-        method: params.method,
-        headers: {
-          'Content-Type': 'application/json',
-        },
-      });
-    });
-  });
-
-  describe('handling response', () => {
-    it('should return a JSON if the response contains Content-Type: application/json in the response', async () => {
-      const expectedResponse = JSON.stringify({ example: faker.word.words() });
-
-      mockFetch.mockResolvedValueOnce(
-        createResponse(200, expectedResponse, {
-          'Content-Type': 'application/json',
-        }),
-      );
-
-      const response = await httpClient.sendRequest(params);
-
-      expect(response).toEqual(
-        new HttpResponse({
-          statusCode: 200,
-          body: expectedResponse,
-        }),
-      );
-    });
-
-    it('should return text if the response do not contain the Content-Type: application/json in the response', async () => {
-      mockFetch.mockResolvedValueOnce(createResponse(200, {}));
-
-      const response = await httpClient.sendRequest(params);
-
-      expect(response).toEqual({
-        statusCode: 200,
-        body: expect.any(String),
-      });
-    });
-
-    it('should throw exception if the response is not OK', async () => {
-      mockFetch.mockResolvedValueOnce(
-        createResponse(faker.number.int({ min: 400 }), {}),
-      );
-
-      await expect(() => httpClient.sendRequest(params)).rejects.toThrow();
-    });
-  });
-
-  describe('handleHttpErrorStatusCodes', () => {
-    it('should throw exception if the handleHttpErrorStatusCodes does not contain the status code to handle', async () => {
-      mockFetch.mockResolvedValueOnce(createResponse(404, {}));
-
-      await expect(() =>
-        httpClient.sendRequest({
-          ...params,
-          handleHttpErrorStatusCodes: [401],
-        }),
-      ).rejects.toThrow();
-    });
-
-    it('should return response if the handleHttpErrorStatusCodes contains the status code to handle', async () => {
-      mockFetch.mockResolvedValueOnce(createResponse(404, {}));
-
-      const response = await httpClient.sendRequest({
-        ...params,
-        handleHttpErrorStatusCodes: [404],
-      });
-
-      expect(response).toEqual({
-        statusCode: 404,
-        body: expect.anything(),
-      });
-    });
-  });
-});

package/src/httpClient/__tests__/HttpClient.spec.ts

@@ -1,52 +0,0 @@
-import { HttpResponse } from '../HttpClient';
-import { faker } from '@faker-js/faker';
-
-describe('HttpResponse', () => {
-  describe('hasHttpStatus', () => {
-    it('should return true if the statusCode is as expected', () => {
-      const httpResponse = new HttpResponse({
-        statusCode: 200,
-        body: undefined,
-      });
-
-      const result = httpResponse.hasHttpStatus(200);
-
-      expect(result).toBeTruthy();
-    });
-
-    it('should return false if the statusCode is not as expected', () => {
-      const httpResponse = new HttpResponse({
-        statusCode: 200,
-        body: undefined,
-      });
-
-      const result = httpResponse.hasHttpStatus(faker.number.int({ min: 201 }));
-
-      expect(result).toBeFalsy();
-    });
-  });
-
-  describe('isNotFound', () => {
-    it('should return true if the statusCode is 404', () => {
-      const httpResponse = new HttpResponse({
-        statusCode: 404,
-        body: undefined,
-      });
-
-      const result = httpResponse.isNotFound();
-
-      expect(result).toBeTruthy();
-    });
-
-    it('should return false if the statusCode is different than 404', () => {
-      const httpResponse = new HttpResponse({
-        statusCode: 200,
-        body: undefined,
-      });
-
-      const result = httpResponse.isNotFound();
-
-      expect(result).toBeFalsy();
-    });
-  });
-});

package/src/httpClient/__tests__/httpRequestBuilder.spec.ts

@@ -1,75 +0,0 @@
-import { Container } from 'inversify';
-import { faker } from '@faker-js/faker';
-import {
-  HttpClient,
-  HttpMethod,
-  HttpRequestOptions,
-  HttpResponse,
-} from '../HttpClient';
-import { HttpRequestBuilderFactory } from '../HttpRequestBuilder';
-import { createHttpClientMock } from '../../testing/mock';
-
-describe('HttpRequestBuilder', () => {
-  let httpClient: HttpClient;
-  let httpRequestBuilderFactory: HttpRequestBuilderFactory;
-
-  beforeEach(() => {
-    const container = new Container();
-
-    container.bind(HttpClient).toConstantValue(createHttpClientMock());
-    container.bind(HttpRequestBuilderFactory).to(HttpRequestBuilderFactory);
-
-    httpClient = container.get(HttpClient);
-    httpRequestBuilderFactory = container.get(HttpRequestBuilderFactory);
-  });
-
-  it('should compose all params and call HttpClient from builder', async () => {
-    const expectedResponse = new HttpResponse({
-      statusCode: 200,
-      body: undefined,
-    });
-    const params = {
-      url: faker.internet.url(),
-      method: faker.helpers.arrayElement(Object.values(HttpMethod)),
-      headers: {
-        example: faker.word.words(),
-      },
-      body: {
-        exampleBody: faker.word.words(),
-      },
-      handleHttpErrorStatusCodes: [401, 403, 404],
-    };
-    const bearerToken = faker.word.words();
-    const apiKey = faker.word.words();
-
-    jest
-      .spyOn(httpClient, 'sendRequest')
-      .mockResolvedValueOnce(expectedResponse);
-
-    const response = await httpRequestBuilderFactory
-      .create()
-      .url(params.url)
-      .method(params.method)
-      .body(params.body)
-      .headers(params.headers)
-      .applicationJson()
-      .authorizationByBearer(bearerToken)
-      .authorizationByXApiKey(apiKey)
-      .handleErrorStatusCode(params.handleHttpErrorStatusCodes[0])
-      .handleErrorStatusCode(params.handleHttpErrorStatusCodes[1])
-      .handleNotFound()
-      .sendRequest();
-
-    expect(response).toEqual(expectedResponse);
-    expect(httpClient.sendRequest).toHaveBeenCalledWith({
-      ...params,
-      headers: expect.objectContaining({
-        ...params.headers,
-        Authorization: `Bearer ${bearerToken}`,
-        'x-api-key': apiKey,
-        'Content-Type': 'application/json',
-      }),
-      handleHttpErrorStatusCodes: params.handleHttpErrorStatusCodes,
-    } as HttpRequestOptions);
-  });
-});

package/src/logger/Logger.ts

@@ -1,40 +0,0 @@
-import {
-  createLogger as createWinstonLogger,
-  format,
-  LeveledLogMethod,
-  Logform,
-  LogMethod,
-  transports,
-} from 'winston';
-
-export abstract class Logger {
-  abstract log: LogMethod;
-  abstract error: LeveledLogMethod;
-  abstract warn: LeveledLogMethod;
-  abstract info: LeveledLogMethod;
-  abstract debug: LeveledLogMethod;
-  abstract verbose: LeveledLogMethod;
-}
-
-const lambdaFormat = (): Logform.Format => {
-  return format.printf(({ ...attrs }) => {
-    // https://docs.aws.amazon.com/lambda/latest/dg/configuration-envvars.html#configuration-envvars-runtime
-    return JSON.stringify({
-      type: 'app',
-      env: process.env.ENV,
-      name: process.env.AWS_LAMBDA_FUNCTION_NAME,
-      version: process.env.AWS_LAMBDA_FUNCTION_VERSION,
-      region: process.env.AWS_REGION,
-      trace: process.env._X_AMZN_TRACE_ID,
-      ...attrs,
-    });
-  });
-};
-
-export function createLogger(): Logger {
-  return createWinstonLogger({
-    level: process.env.LOGGING_LEVEL || 'debug',
-    format: format.combine(format.timestamp(), format.splat(), lambdaFormat()),
-    transports: [new transports.Console()],
-  });
-}

package/src/logger/LoggerMessage.ts

@@ -1,179 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { randomUUID } from 'crypto';
-import { TenantId } from '../valueObject/TenantId';
-
-type ValueOf = {
-  valueOf(): string;
-};
-
-const normalizeCaller = <T extends abstract new (...args: any) => any>(
-  stringOrClassInstance: string | InstanceType<T>,
-): string =>
-  typeof stringOrClassInstance === 'string'
-    ? stringOrClassInstance
-    : stringOrClassInstance.constructor.name;
-
-/**
- * @deprecated
- */
-export function createLogMessage<T extends abstract new (...args: any) => any>(
-  ...metadata: Array<string | InstanceType<T>>
-): (message?: string) => string {
-  const context = randomUUID();
-
-  const formattedMetadata = [...metadata, `Context: ${context}`]
-    .filter((data) => !!data)
-    .map((data) => `[${normalizeCaller(data)}]`)
-    .join('');
-
-  return (message) => `${formattedMetadata} ${message ?? ''}`;
-}
-
-export const TENANT_ID_METADATA = (
-  tenantId: string | ValueOf,
-): {
-  tenantId: string;
-} => ({
-  tenantId: typeof tenantId === 'string' ? tenantId : tenantId.valueOf(),
-});
-
-export const PROCESSABLE_LOG_METADATA = { processable: true } as const;
-export const REMOTE_LOG_METADATA = { remote: true } as const;
-
-export interface LogMessage {
-  (message: string | any): [string | any, ...Array<any>];
-
-  remote(message: string | any): [string | any, ...Array<any>];
-
-  remote(
-    message: string | any,
-    /**
-     * The param is not needed if it is passed in the metadata
-     */
-    tenantId: TenantId,
-  ): [string | any, ...Array<any>];
-}
-
-export type CreateLog = {
-  attachMetadata: (metadata: Record<string, unknown>) => CreateLog;
-  attachEventName: (eventName: string) => CreateLog;
-  attachCorrelationId: (id: string) => CreateLog;
-  attachTenantId: (tenantId: string | ValueOf) => CreateLog;
-  attachExperimentId: (experimentId: string | ValueOf) => CreateLog;
-  attachCaller: <T extends abstract new (...args: any) => any>(
-    caller: InstanceType<T> | string,
-  ) => CreateLog;
-  isProcessable: () => CreateLog;
-  remote: () => CreateLog;
-  getMetadata: () => Record<string, unknown>;
-  create: <T extends abstract new (...args: any) => any>(
-    caller?: InstanceType<T> | string,
-  ) => LogMessage;
-};
-
-export function createLog(opts?: {
-  message?: string;
-  metadata?: Record<string, string | boolean | unknown>;
-}): CreateLog {
-  opts = {
-    metadata: {
-      context: randomUUID(),
-      ...opts?.metadata,
-    },
-    message: opts?.message,
-  };
-
-  const attachMetadata = (
-    metadata: Record<string, string | boolean | unknown>,
-  ): CreateLog => {
-    return createLog({
-      ...(opts && opts),
-      metadata: {
-        ...opts?.metadata,
-        ...metadata,
-      },
-    });
-  };
-
-  const attachTenantId = (tenantId: string | ValueOf): CreateLog => {
-    return attachMetadata(TENANT_ID_METADATA(tenantId));
-  };
-
-  const attachExperimentId = (experimentId: string | ValueOf): CreateLog => {
-    return attachMetadata({
-      experimentId:
-        typeof experimentId === 'string'
-          ? experimentId
-          : experimentId.valueOf(),
-    });
-  };
-
-  const attachEventName = (eventName: string): CreateLog => {
-    return attachMetadata({
-      eventName,
-    });
-  };
-
-  const attachCorrelationId = (id: string): CreateLog => {
-    return attachMetadata({
-      correlationId: id,
-    });
-  };
-
-  const isProcessable = (): CreateLog => {
-    return attachMetadata(PROCESSABLE_LOG_METADATA);
-  };
-
-  const remote = (): CreateLog => {
-    return attachMetadata(REMOTE_LOG_METADATA);
-  };
-
-  const attachCaller = <T extends abstract new (...args: any) => any>(
-    caller: T | string,
-  ): CreateLog => {
-    return attachMetadata({
-      caller: normalizeCaller(caller),
-    });
-  };
-
-  const create = <T extends abstract new (...args: any) => any>(
-    caller?: T | string,
-  ): LogMessage => {
-    const metadata = {
-      ...opts?.metadata,
-      ...(caller && {
-        caller: normalizeCaller(caller),
-      }),
-    };
-
-    function log(message: string | any) {
-      return [message, metadata];
-    }
-
-    log.remote = (message: string | any, tenantId?: TenantId) => {
-      return [
-        message,
-        {
-          ...metadata,
-          ...REMOTE_LOG_METADATA,
-          ...(tenantId && { ...TENANT_ID_METADATA(tenantId) }),
-        },
-      ];
-    };
-
-    return log as LogMessage;
-  };
-
-  return {
-    attachMetadata,
-    attachTenantId,
-    attachExperimentId,
-    attachEventName,
-    attachCorrelationId,
-    isProcessable,
-    attachCaller,
-    getMetadata: () => opts?.metadata ?? {},
-    remote,
-    create,
-  };
-}

package/src/logger/LogsHandler.ts

@@ -1,66 +0,0 @@
-import type { CloudWatchLogsEvent } from 'aws-lambda';
-import zlib from 'zlib';
-import { inject, injectable } from 'inversify';
-import { inspect } from 'util';
-import type { CloudWatchLogsLogEvent } from 'aws-lambda/trigger/cloudwatch-logs';
-import { REMOTE_LOG_SCHEMA, RemoteLog, RemoteLogger } from './RemoteLogger';
-import { Logger } from './Logger';
-import { createLog, LogMessage } from './LoggerMessage';
-
-@injectable()
-export class LogsHandler {
-  constructor(
-    @inject(RemoteLogger)
-    private readonly remoteLogger: RemoteLogger,
-    @inject(Logger)
-    private readonly logger: Logger,
-  ) {}
-
-  async handle(event: CloudWatchLogsEvent): Promise<void> {
-    const logMessage = createLog().create(this);
-
-    this.logger.debug(...logMessage(`started mapping CloudWatchLogsEvent`));
-    const remoteLogs = this.mapLogs(event, logMessage);
-
-    this.logger.debug(logMessage(`finished mapping CloudWatchLogsEvent`));
-
-    this.logger.debug(
-      logMessage(
-        `started sending logs (count: ${remoteLogs.length}) into the RemoteLogger`,
-      ),
-    );
-    await this.remoteLogger.log(remoteLogs);
-    this.logger.debug(
-      logMessage('finished sending logs into the RemoteLogger'),
-    );
-  }
-
-  private mapLogs(
-    event: CloudWatchLogsEvent,
-    logMessage: LogMessage,
-  ): Array<RemoteLog> {
-    const logs = this.decodeLogs(event);
-
-    this.logger.debug(
-      logMessage(`received decoded logs: ${inspect(logs, { depth: 4 })}`),
-    );
-    const isRemoteLog = (log: undefined | RemoteLog): log is RemoteLog => !!log;
-
-    return logs
-      .map((log) => {
-        const result = REMOTE_LOG_SCHEMA.safeParse(JSON.parse(log.message));
-
-        return result.success ? result.data : undefined;
-      })
-      .filter(isRemoteLog);
-  }
-
-  private decodeLogs(
-    event: CloudWatchLogsEvent,
-  ): Array<CloudWatchLogsLogEvent> {
-    const payload = Buffer.from(event.awslogs.data, 'base64');
-    const logs = JSON.parse(zlib.unzipSync(payload).toString());
-
-    return logs.logEvents;
-  }
-}

package/src/logger/RemoteLogger.ts

@@ -1,32 +0,0 @@
-import { TenantId } from './../valueObject/TenantId';
-import { injectable } from 'inversify';
-import { z } from 'zod';
-
-export enum RemoteLogLevel {
-  INFO = 'info',
-  WARN = 'warn',
-  ERROR = 'error',
-}
-
-export const REMOTE_LOG_SCHEMA = z.object({
-  tenantId: z.string().transform((v) => new TenantId(v)),
-  message: z.string(),
-  timestamp: z
-    .string()
-    .datetime()
-    .transform((v) => new Date(v))
-    .optional(),
-  level: z.nativeEnum(RemoteLogLevel),
-});
-export type RemoteLog = z.infer<typeof REMOTE_LOG_SCHEMA>;
-
-@injectable()
-export abstract class RemoteLogger {
-  abstract info(log: Omit<RemoteLog, 'level'>): Promise<void>;
-
-  abstract warn(log: Omit<RemoteLog, 'level'>): Promise<void>;
-
-  abstract error(log: Omit<RemoteLog, 'level'>): Promise<void>;
-
-  abstract log(logs: ReadonlyArray<RemoteLog>): Promise<void>;
-}