Consider isLocalDevelopment flag, export formatAxiosError

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devrev/ts-adaas",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Typescript library containing the ADaaS(AirDrop as a Service) control protocol.",
   "type": "commonjs",
   "main": "./dist/index.js",

src/common/control-protocol.ts

@@ -34,7 +34,7 @@ export const emit = async ({
   };
 
   return new Promise<void>(async (resolve, reject) => {
-    console.info('Emitting event', newEvent);
+    console.info('Emitting event', JSON.stringify(newEvent));
 
     try {
       await axios.post(
@@ -63,7 +63,7 @@ export const emit = async ({
           error
         );
       }
-      reject(error);
+      reject();
     }
   });
 };

src/index.ts

@@ -12,3 +12,5 @@ export { processTask } from './workers/process-task';
 export { spawn } from './workers/spawn';
 
 export * from './types/workers';
+
+export { formatAxiosError } from './logger/logger';

src/logger/logger.interfaces.ts

@@ -1,3 +1,11 @@
+import { AirdropEvent } from '../types/extraction';
+import { WorkerAdapterOptions } from '../types/workers';
+
+export interface LoggerFactoryInterface {
+  event: AirdropEvent;
+  options?: WorkerAdapterOptions;
+}
+
 export enum LogLevel {
   INFO = 'info',
   WARN = 'warn',

src/logger/logger.ts

@@ -1,16 +1,26 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
 import log from 'lambda-log';
 import { Console } from 'node:console';
 
-import { LogLevel, PrintableArray, PrintableState } from './logger.interfaces';
-import { AirdropEvent } from '../types';
+import {
+  LoggerFactoryInterface,
+  LogLevel,
+  PrintableArray,
+  PrintableState,
+} from './logger.interfaces';
 import { isMainThread, parentPort } from 'node:worker_threads';
-import { WorkerMessageSubject } from '../types/workers';
+import { WorkerAdapterOptions, WorkerMessageSubject } from '../types/workers';
 import { AxiosError } from 'axios';
+import { AirdropEvent } from '../types/extraction';
 
 export class Logger extends Console {
-  constructor(event: AirdropEvent) {
+  private event: AirdropEvent;
+  private options?: WorkerAdapterOptions;
+
+  constructor({ event, options }: LoggerFactoryInterface) {
     super(process.stdout, process.stderr);
+    this.event = event;
+    this.options = options;
+
     log.options.levelKey = null;
     log.options.tagsKey = null;
     log.options.messageKey = 'message';
@@ -21,7 +31,11 @@ export class Logger extends Console {
 
   logFn(args: unknown[], level: LogLevel): void {
     if (isMainThread) {
-      log.log(level, JSON.stringify(args));
+      if (this.options?.isLocalDevelopment) {
+        console[level](...args);
+      } else {
+        log.log(level, JSON.stringify(args));
+      }
     } else {
       parentPort?.postMessage({
         subject: WorkerMessageSubject.WorkerMessageLog,
@@ -87,6 +101,7 @@ export function formatAxiosError(error: AxiosError): object {
       method: error.config?.method,
       baseURL: error.config?.baseURL,
       url: error.config?.url,
+      payload: error.config?.data,
     };
   }
 

src/types/index.ts

@@ -24,7 +24,11 @@ export {
 } from './extraction';
 
 // Repo
-export { NormalizedItem, NormalizedAttachment } from '../repo/repo.interfaces';
+export {
+  NormalizedItem,
+  NormalizedAttachment,
+  RepoInterface,
+} from '../repo/repo.interfaces';
 
 // State
 export { AdapterState } from '../state/state.interfaces';

src/types/workers.ts

@@ -19,7 +19,7 @@ export interface WorkerAdapterInterface<ConnectorState> {
   event: AirdropEvent;
   adapterState: State<ConnectorState>;
   parentPort: MessagePort;
-  options: WorkerAdapterOptions;
+  options?: WorkerAdapterOptions;
 }
 
 /**
@@ -46,7 +46,7 @@ export type SpawnResolve = (value: boolean | PromiseLike<boolean>) => void;
 export interface SpawnInterface {
   event: AirdropEvent;
   worker: Worker;
-  options: WorkerAdapterOptions | null;
+  options?: WorkerAdapterOptions;
   resolve: SpawnResolve;
 }
 
@@ -159,4 +159,5 @@ export interface WorkerData<ConnectorState> {
 export interface GetWorkerPathInterface {
   event: AirdropEvent;
   connectorWorkerPath?: string | null;
+  options?: WorkerAdapterOptions;
 }

src/workers/create-worker.ts

@@ -8,16 +8,19 @@ async function createWorker<ConnectorState>(
 ): Promise<Worker> {
   return new Promise<Worker>((resolve, reject) => {
     if (isMainThread) {
-      const logger = new Logger(workerData.event);
+      const logger = new Logger({
+        event: workerData.event,
+        options: workerData.options,
+      });
       const workerFile = __dirname + '/worker.js';
 
       const worker: Worker = new Worker(workerFile, {
         workerData,
       } as WorkerOptions);
 
-      worker.on(WorkerEvent.WorkerError, (error: Error) => {
-        logger.error('Worker error', error);
-        reject(error);
+      worker.on(WorkerEvent.WorkerError, () => {
+        logger.error('Worker error');
+        reject();
       });
       worker.on(WorkerEvent.WorkerOnline, () => {
         resolve(worker);

src/workers/process-task.ts

@@ -18,7 +18,7 @@ export function processTask<ConnectorState>({
       const event = workerData.event;
       const initialState = workerData.initialState as ConnectorState;
       const options = workerData.options;
-      console = new Logger(event);
+      console = new Logger({ event, options });
 
       const adapterState = await createAdapterState<ConnectorState>({
         event,

src/workers/spawn.ts

@@ -20,8 +20,9 @@ import { LogLevel } from '../logger/logger.interfaces';
 function getWorkerPath({
   event,
   connectorWorkerPath,
+  options,
 }: GetWorkerPathInterface): string | null {
-  const logger = new Logger(event);
+  const logger = new Logger({ event, options });
 
   if (!ALLOWED_EVENT_TYPES.includes(event.payload.event_type)) {
     return null;
@@ -79,10 +80,11 @@ export async function spawn<ConnectorState>({
 }: SpawnFactoryInterface<ConnectorState>): Promise<
   boolean | PromiseLike<boolean>
 > {
-  const logger = new Logger(event);
+  const logger = new Logger({ event, options });
   const script = getWorkerPath({
     event,
     connectorWorkerPath: workerPath,
+    options,
   });
 
   if (script) {
@@ -98,7 +100,7 @@ export async function spawn<ConnectorState>({
         new Spawn({
           event,
           worker,
-          options: options || null,
+          options,
           resolve,
         });
       });
@@ -141,7 +143,7 @@ export class Spawn {
       }
     }, this.lambdaTimeout);
 
-    this.logger = new Logger(event);
+    this.logger = new Logger({ event, options });
     this.worker = worker;
     worker.on(WorkerEvent.WorkerExit, async (code) => {
       this.logger.info('Worker exited with exit code: ' + code + '.');

src/workers/worker-adapter.ts

@@ -47,7 +47,7 @@ export function createWorkerAdapter<ConnectorState>({
  */
 export class WorkerAdapter<ConnectorState> {
   readonly event: AirdropEvent;
-  readonly options: WorkerAdapterOptions;
+  readonly options?: WorkerAdapterOptions;
 
   private adapterState: State<ConnectorState>;
   private _artifacts: Artifact[];