overleaf/services/web/transform/o-error/transform.js
Miguel Serrano 2e8f66ac6b Merge pull request #3075 from overleaf/msm-codemod-oerror-v3-logging
Replaced logger.warn statements with OError.tag()

GitOrigin-RevId: 4d821ec48a0006abb1fcffe07dbb5511c88f5b9a
2020-08-12 02:07:03 +00:00

126 lines
3.9 KiB
JavaScript

function functionArgsFilter(j, path) {
if (path.get('params') && path.get('params').value[0]) {
return ['err', 'error'].includes(path.get('params').value[0].name)
} else {
return false
}
}
function isReturningFunctionCallWithError(path, errorVarName) {
return (
path.value.argument &&
path.value.argument.arguments &&
path.value.argument.arguments[0] &&
path.value.argument.arguments[0].name === errorVarName
)
}
function expressionIsLoggingError(path) {
return ['warn', 'error', 'err'].includes(
path.get('callee').get('property').value.name
)
}
function createTagErrorExpression(j, path, errorVarName) {
let message = 'error'
if (path.value.arguments.length >= 2) {
message = path.value.arguments[1].value || message
}
let info
try {
info = j.objectExpression(
// add properties from original logger info object to the
// OError info object, filtering out the err object itself,
// which is typically one of the args when doing intermediate
// error logging
// TODO: this can fail when the property name does not match
// the variable name. e.g. { err: error } so need to check
// both in the filter
path
.get('arguments')
.value[0].properties.filter(
property => property.key.name !== errorVarName
)
)
} catch (error) {
// if info retrieval fails it remains empty
}
const args = [j.identifier(errorVarName), j.literal(message)]
if (info) {
args.push(info)
}
return j.callExpression(
j.memberExpression(j.identifier('OError'), j.identifier('tag')),
args
)
}
function functionBodyProcessor(j, path) {
// the error variable should be the first parameter to the function
const errorVarName = path.get('params').value[0].name
j(path)
.find(j.IfStatement) // look for if statements
.filter(path =>
j(path)
// find returns inside the if statement where the error from
// the args is explicitly returned
.find(j.ReturnStatement)
.some(path => isReturningFunctionCallWithError(path, errorVarName))
)
.forEach(path => {
j(path)
.find(j.CallExpression, {
callee: {
object: { name: 'logger' }
}
})
.filter(path => expressionIsLoggingError(path))
.replaceWith(path => {
return createTagErrorExpression(j, path, errorVarName)
})
})
}
export default function transformer(file, api) {
const j = api.jscodeshift
let source = file.source
// apply transformer to declared functions
source = j(source)
.find(j.FunctionDeclaration)
.filter(path => functionArgsFilter(j, path))
.forEach(path => functionBodyProcessor(j, path))
.toSource()
// apply transformer to inline-functions
source = j(source)
.find(j.FunctionExpression)
.filter(path => functionArgsFilter(j, path))
.forEach(path => functionBodyProcessor(j, path))
.toSource()
// apply transformer to inline-arrow-functions
source = j(source)
.find(j.ArrowFunctionExpression)
.filter(path => functionArgsFilter(j, path))
.forEach(path => functionBodyProcessor(j, path))
.toSource()
// do a plain text search to see if OError is used but not imported
if (source.includes('OError') && !source.includes('@overleaf/o-error')) {
const root = j(source)
// assume the first variable declaration is an import
// TODO: this should check that there is actually a require/import here
// but in most cases it will be
const imports = root.find(j.VariableDeclaration)
const importOError = "const OError = require('@overleaf/o-error')\n"
// if there were imports insert into list, format can re-order
if (imports.length) {
j(imports.at(0).get()).insertAfter(importOError)
}
// otherwise insert at beginning
else {
root.get().node.program.body.unshift(importOError)
}
source = root.toSource()
}
return source
}