winston-error-format/build/src/options.js

Log errors with Winston

import isPlainObj from"is-plain-obj";
import normalizeException from"normalize-exception";
import{configs}from"triple-beam";



export const applyOptions=(error,level,options={})=>{
const optionsA=typeof options==="function"?options(error):options;
validateOptions(optionsA);
const{level:levelA=level,stack=DEFAULT_STACK,transform}=optionsA;
const errorA=
transform===undefined?error:normalizeException(transform(error));
return{level:levelA,stack,error:errorA}
};


export const DEFAULT_LEVEL="error";
const DEFAULT_STACK=true;

export const validateOptions=(options={})=>{
if(!isPlainObj(options)){
throw new TypeError(`It must be a plain object: ${options}`)
}

const{level,stack,transform,...unknownOpts}=options;
validateLevel(level);
validateStack(stack);
validateTransform(transform);
validateUnknownOpts(unknownOpts)
};



const validateLevel=(level)=>{
if(level===undefined){
return
}

if(typeof level!=="string"){
throw new TypeError(`Option "level" must be a string: ${level}`)
}

if(!LEVELS.has(level)){

const availableLevels=[...LEVELS].sort().join(", ");
throw new TypeError(
`Option "level" must not be "${level}" but one of: ${availableLevels}`
)
}
};

const getAvailableLevels=()=>
new Set(
Reflect.ownKeys(configs).flatMap((name)=>
getAvailableLevel(configs[name])
)
);

const getAvailableLevel=({levels})=>Object.keys(levels);

const LEVELS=getAvailableLevels();



const validateStack=(stack)=>{
if(stack!==undefined&&typeof stack!=="boolean"){
throw new TypeError(`Option "stack" must be a boolean: ${stack}`)
}
};



const validateTransform=(transform)=>{
if(transform!==undefined&&typeof transform!=="function"){
throw new TypeError(`Option "transform" must be a function: ${transform}`)
}
};

const validateUnknownOpts=(unknownOpts)=>{
const[unknownOpt]=Object.keys(unknownOpts);

if(unknownOpt!==undefined){
throw new TypeError(`Option "${unknownOpt}" is unknown.`)
}
};