123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212
import { isPrimitiveValue, lowerFirst } from './utils.ts';import { ErrItem } from './ok-computer.ts';
interface IError<T = unknown> {  // `toPrimitiveError` gives error objects the opportunity to serialize into a primitive value (if possible)  readonly toPrimitiveError: () => T;}
export const isIError = (val: any): val is IError => {  try {    return typeof val.toPrimitiveError === 'function';  } catch (ex) {    return false;  }};
const STRUCTURE = Symbol('ok-computer.structure');
export interface IStructure {  readonly [STRUCTURE]: true;}
export const isIStructure = (val: any): val is IStructure => {  try {    return val[STRUCTURE] === true;  } catch (ex) {    return false;  }};
export const asStructure = <T>(val: T): T & IStructure => {  if (val == null) {    throw new Error('Expected object');  }  Object.defineProperty(val, STRUCTURE, {    value: true,    enumerable: false,    configurable: false,    writable: false  });  return val as T & IStructure;};
interface ILogicalOperator<T> {  readonly type: string;  readonly operator: string;  readonly errors: T[];}
export class LogicalOperatorError<  // NOTE: `extends any[]` so it can be treated as a tuple if desired  // e.g. new LogicalOperatorError<[number, string, boolean]>('OK', [1, 'two', true])  T extends any[]> implements ILogicalOperator<T>, IError<ILogicalOperator<T> | string>{  type: string;  operator: string;  errors: T;  constructor(operator: string, errors: T) {    this.type = `${operator}Error`;    this.operator = operator;    this.errors = errors;    if (this.errors.length < 1) {      throw new Error(`Expected at least 1 error: ${this.operator}`);    }    // TODO: Check `errors` are actually errors w/ `isError`?  }  toPrimitiveError(): string | ILogicalOperator<T> {    // If possible, serialize into string    const primitiveErrors = this.errors.map((err) =>      isIError(err) ? err.toPrimitiveError() : err    );    if (primitiveErrors.every(isPrimitiveValue)) {      const str = primitiveErrors        .map((err, i) =>          err == null            ? `${err}`            : i === 0 || typeof err !== 'string'            ? err.toString()            : lowerFirst(err)        )        .join(` ${this.operator.toLowerCase()} `);      return primitiveErrors.length > 1 ? `(${str})` : str;    }    // Otherwise just serialize to `ILogicalOperator`    return {      type: this.type,      operator: this.operator,      errors: this.errors    };  }  toJSON() {    return this.toPrimitiveError();  }  toString() {    const error = this.toPrimitiveError();    return typeof error === 'string' ? error : `[object ${this.type}]`;  }  // Undecided if this is a good idea; could make console.log debugging v. confusing  // [Symbol.for('nodejs.util.inspect.custom')]() {  //   return this.toPrimitiveError();  // }}
export class ORError<T extends any[]> extends LogicalOperatorError<T> {  constructor(errors: T) {    super('OR', errors);  }}
export class ANDError<T extends any[]> extends LogicalOperatorError<T> {  constructor(errors: T) {    super('AND', errors);  }}
export class XORError<T extends any[]> extends LogicalOperatorError<T> {  constructor(errors: T) {    super('XOR', errors);  }}
interface IPeerError<T> {  readonly type: string;  readonly key: string;  readonly error: T;}
export class PeerError<T>  implements IPeerError<T>, IError<IPeerError<T> | string>{  type: string;  key: string;  error: T;  constructor(key: string, error: T) {    this.type = 'PeerError';    this.key = key;    this.error = error;  }  toPrimitiveError(): string | IPeerError<T> {    // If possible, serialize into string    const primitiveError = isIError(this.error)      ? this.error.toPrimitiveError()      : this.error;    // Otherwise just serialize to `IPeerError`    return typeof primitiveError === 'string'      ? `Peer "${this.key}" ${lowerFirst(primitiveError)}`      : { type: this.type, key: this.key, error: this.error };  }  toJSON() {    return this.toPrimitiveError();  }  toString() {    const primitive = this.toPrimitiveError();    return typeof primitive === 'string' ? primitive : `[object ${this.type}]`;  }  // [Symbol.for('nodejs.util.inspect.custom')]() {  //   return this.toPrimitiveError();  // }}
interface INegateError<T> {  readonly type: string;  readonly error: T;}
export class NegateError<T>  implements INegateError<T>, IError<INegateError<T> | string>{  type: string;  error: T;  constructor(error: T) {    this.type = 'NegateError';    this.error = error;  }  toPrimitiveError(): string | INegateError<T> {    return typeof this.error === 'string'      ? `not("${this.error}")`      : { type: this.type, error: this.error };  }  toJSON() {    return this.toPrimitiveError();  }  toString() {    const json = this.toPrimitiveError();    return typeof json === 'string' ? json : `[object ${this.type}]`;  }  // [Symbol.for('nodejs.util.inspect.custom')]() {  //   return this.toPrimitiveError();  // }}
export class AssertError extends Error {  public errors: ErrItem<any>[];  constructor(errors: ErrItem<any>[]) {    super();    try {      const firstError = errors[0];      this.message = `Invalid: first of ${errors.length} errors: ${        firstError.path      }: ${        firstError.err.toString() !== '[object Object]'          ? firstError.err          : JSON.stringify(firstError.err)      }`;    } catch (ex) {      this.message = 'Invalid';    }    this.errors = errors;  }}