errors.ts

// This will eventually contain all the error classes thrown by the engine

export class EngineError extends Error {
  source = 'engine';

  severity = '-'; // subclasses MUST provide this!
}

// This is thrown if a workflow takes too long to run
// It is generated by workerpool and thrown if the workerpool promise fails to resolve
export class TimeoutError extends EngineError {
  severity = 'kill';
  name = 'TimeoutError';
  duration;
  constructor(durationInMs: number) {
    super();
    this.duration = durationInMs;

    if (durationInMs) {
      this.message = `Workflow failed to return within ${durationInMs}ms`;
    } else {
      this.message = `Workflow failed to return within the specified time limit`;
    }
  }
}

// This is a catch-all error thrown during execution
export class ExecutionError extends EngineError {
  severity = 'exception';
  name = 'ExecutionError';
  message;

  original: any; // this is the original error

  constructor(original: any) {
    super();
    this.original = original;

    this.message = original.message;
    this.stack = original.stack;
  }
}

export class CompileError extends EngineError {
  severity = 'crash'; // Syntax errors are crashes, but what if we get a module resolution thing?
  type = 'CompileError';
  subtype;
  message;
  jobId;

  constructor(error: any, jobId: string) {
    super();

    this.jobId = jobId;
    this.message = `${jobId}: ${error.message}`;
    this.name = error.constructor.name ?? error.name ?? error.type;
    // TODO remove?
    this.subtype = error.type || error.constructor.name;
  }
}

export class AutoinstallError extends EngineError {
  severity = 'exception'; // Syntax errors are crashes, but what if we get a module resolution thing?
  name = 'AutoinstallError';
  message;

  constructor(specifier: string, error: any) {
    super();

    this.message = `Error installing ${specifier}: ${error.message}`;
  }
}

// Where an OOM kill came from:
// - 'heap'   the V8 heap limit (thread resourceLimits or --max-old-space-size)
// - 'cgroup' the OS cgroup memory.max ceiling (kernel SIGKILL)
export type OOMSource = 'heap' | 'cgroup';

export class OOMError extends EngineError {
  severity = 'kill';
  name = 'OOMError';
  message;
  source: OOMSource;

  constructor(source: OOMSource = 'heap') {
    super();

    this.source = source;
    this.message = `Run exceeded maximum memory usage`;
  }
}

export class ExitError extends EngineError {
  severity = 'crash';
  name = 'ExitError';
  code;
  message;

  constructor(code: number) {
    super();
    this.code = code;
    this.message = `Process exited with code: ${code}`;
    // Remove the stack trace
    // It contains no useful information
    this.stack = '';
  }
}

export type CredentialErrorObj = { id: string; step: string; error: string };

// Error lazy-loading a credenial
export class CredentialLoadError extends EngineError {
  severity = 'exception';
  name = 'CredentialLoadError';
  message;

  original: any; // this is the original error
  constructor(errors: CredentialErrorObj[]) {
    super();
    const ids: Record<string, true> = {};
    this.message = errors
      .filter((e) => {
        if (!ids[e.id]) {
          ids[e.id] = true;
          return true;
        }
      })
      .map(
        (e) =>
          `Failed to load credential ${e.id}${e.error ? `: ${e.error}` : ''}`
      )
      .join('\n');
  }
}