121 lines
4.2 KiB
JavaScript
121 lines
4.2 KiB
JavaScript
const utils = require('./utils')
|
|
const javaType = require('./java-type')
|
|
|
|
function formatOperationName(operation) {
|
|
let name = operation.method.toLowerCase()
|
|
const parameters = operation.parameters
|
|
|
|
if(operation.body) {
|
|
name += utils.pascalcase(operation.body.type)
|
|
}
|
|
|
|
if(operation.parameters.length) {
|
|
name += `By${parameters.filter(p => p.location === 'Path')
|
|
.map(p => utils.pascalcase(p.name)).join('And')}`
|
|
}
|
|
|
|
return utils.pascalcase(name)
|
|
|
|
}
|
|
|
|
function mapParameter(parameter, namespace, operation, service) {
|
|
parameter.label = utils.camelcase(parameter.name)
|
|
parameter.type = javaType.mapJavaType(parameter.type, namespace, '', service)
|
|
parameter.op = operation
|
|
parameter.isPath = parameter.location === 'Path'
|
|
parameter.default = javaType.mapDefaultValue(parameter.type, parameter.default)
|
|
return parameter
|
|
}
|
|
|
|
function mapOperation(operation, namespace, service) {
|
|
operation.headers = operation.parameters
|
|
.filter(param => param.location === 'Header')
|
|
.map(param => mapParameter(param, namespace, operation, service))
|
|
|
|
operation.query = operation.parameters
|
|
.filter(param => param.location === 'Query')
|
|
.map(param => mapParameter(param, namespace, operation, service))
|
|
|
|
operation.parameters = operation.parameters
|
|
.filter(param => param.location === 'Path')
|
|
.map(param => mapParameter(param, namespace, operation, service))
|
|
|
|
operation.name = formatOperationName(operation)
|
|
operation.camelcase = utils.camelcase(operation.name)
|
|
|
|
operation.pathElements = operation.path.split(/\//g).filter(e => e.length).map(element => {
|
|
let isVariable = element.startsWith(':')
|
|
let pathElement = {
|
|
name: isVariable ? `${element.replace(/:/g, '')}.toString()` : `"${element}"`,
|
|
}
|
|
return pathElement
|
|
})
|
|
|
|
operation.responseTypes = operation.responses.filter(resp => resp.type !== 'unit').map(resp => {
|
|
let type = javaType.mapJavaType(resp.type, namespace)
|
|
return {
|
|
type,
|
|
name: `${utils.camelcase(type.baseType || 'result')}${resp.code.integer.value}`
|
|
}
|
|
})
|
|
operation.responses = operation.responses.map(resp => {
|
|
let type = javaType.mapJavaType(resp.type, namespace, service)
|
|
if(resp.type !== 'unit') {
|
|
resp.label = `${utils.camelcase(type.baseType || 'result')}${resp.code.integer.value}`
|
|
}
|
|
resp.type = type
|
|
return resp
|
|
})
|
|
|
|
if(operation.body) {
|
|
let bodyName = utils.camelcase(operation.body.type)
|
|
operation.parameters = [
|
|
...operation.parameters,
|
|
{
|
|
label: bodyName,
|
|
required: true,
|
|
location: 'Body',
|
|
type: javaType.mapJavaType(operation.body.type, namespace, service)
|
|
}
|
|
]
|
|
operation.body.name = bodyName
|
|
}
|
|
if(operation.parameters.length) {
|
|
operation['parameters'][ operation['parameters'].length - 1 ].last = true;
|
|
}
|
|
|
|
|
|
|
|
|
|
return operation
|
|
}
|
|
|
|
module.exports = {
|
|
mapResources: (resources, namespace, service) => {
|
|
return resources.map(resource => {
|
|
resource.type = javaType.mapJavaType(resource.type, namespace, '', service)
|
|
resource.name = `${utils.pascalcase(resource.plural)}Resource`
|
|
resource.operations = resource.operations.map(op => mapOperation(op, namespace, service))
|
|
resource.package = `${namespace}.client`
|
|
resource.dir = resource.package.replace(/\./g, '/')
|
|
|
|
|
|
let imports = []
|
|
resource.operations.forEach(op => op.parameters.forEach(p => {
|
|
imports = [
|
|
...imports,
|
|
...p.type.imports
|
|
]
|
|
}))
|
|
resource.operations.forEach(op => op.responses.forEach(p => {
|
|
imports = [
|
|
...imports,
|
|
...p.type.imports
|
|
]
|
|
}))
|
|
|
|
resource.imports = [... new Set(imports)]
|
|
return resource
|
|
})
|
|
}
|
|
} |