112 lines
4.3 KiB
JavaScript
112 lines
4.3 KiB
JavaScript
const utils = require('./utils')
|
|
const javaType = require('./java-type');
|
|
const { pascalcase } = require('./utils');
|
|
|
|
module.exports = {
|
|
mapJavaJpaEntity: (service, models, namespace, suffix='db') => {
|
|
return models.map(model => {
|
|
|
|
let jpa = model.attributes.find(attr => attr.name == 'jpa_sql').value;
|
|
|
|
model.modelType = `${utils.pascalcase(model.name)}`;
|
|
model.modelName = model.name
|
|
model.modelImport = `${namespace}.models.${model.modelType}`;
|
|
|
|
model.name = `${utils.pascalcase(model.name)}Record`
|
|
model.package = `${namespace}.${suffix}`;
|
|
model.dir = model.package.replace(/\./g, '/')
|
|
model.fields = model.fields.map(field => {
|
|
|
|
let field_attr = field.attributes.find(attr => attr.name == 'jpa_sql')
|
|
|
|
|
|
field_attr = field_attr && field_attr.value || {}
|
|
|
|
field.namePascalCase = utils.pascalcase(field.name);
|
|
field.isEnum = service.enums.find(e => e.name == field.type) != null
|
|
field.name = utils.camelcase(field.name)
|
|
field.type = javaType.mapJavaType(field.type, namespace, field.isEnum || field.name.endsWith('Record') ? '' : 'Record')
|
|
|
|
if(field.type.fullQualifiedName && field.type.fullQualifiedName.includes('models') && !field.isEnum) {
|
|
field.type.fullQualifiedName = field.type.fullQualifiedName.replace('models', suffix)
|
|
field.type.imports = field.type.imports.map(i => i.replace("models", suffix))
|
|
field.isRecord = true
|
|
}
|
|
|
|
field.default = javaType.mapDefaultValue(field.type, field.default)
|
|
field.nullable = !field.required
|
|
field.isPkey = jpa.pkey == field.name
|
|
|
|
|
|
field.unique = field_attr.unique || false
|
|
field.creationTimestamp = field_attr.timestamp == 'create'
|
|
field.updateTimestamp = field_attr.timestamp == 'update'
|
|
field.id_generator = jpa.id_generator
|
|
field.id_type = jpa.id_generator && jpa.id_generator.type
|
|
field.columnType = field_attr.type || ''
|
|
|
|
field.oneToMany = field_attr.constraint == 'OneToMany'
|
|
|
|
|
|
return field
|
|
})
|
|
|
|
let imports = [ model.modelImport ]
|
|
for(let field of model.fields) {
|
|
imports = [ ...imports, ...field.type.imports ]
|
|
}
|
|
model.imports = [ ...new Set(imports) ]
|
|
model.implements = model.implements || []
|
|
if(model.implements.length) {
|
|
model['implements'][ model['implements'].length - 1 ].last = true
|
|
}
|
|
|
|
model.table = jpa.table || model.plural
|
|
model.indexes = jpa.indexes
|
|
|
|
|
|
return model
|
|
})
|
|
},
|
|
mapJavaJpaRepository: (service, models, namespace, suffix='db') => {
|
|
return models.map(model => {
|
|
|
|
let jpa = model.attributes.find(attr => attr.name == 'jpa_sql').value;
|
|
|
|
let repo = { ...model }
|
|
|
|
repo.record_type = model.name;
|
|
repo.type = jpa.repository;
|
|
|
|
repo.pkey_type = model.fields.find(field => field.isPkey).type
|
|
|
|
repo.name = `${utils.pascalcase(model.name)}Repository`
|
|
repo.package = `${namespace}.${suffix}`;
|
|
repo.dir = model.package.replace(/\./g, '/')
|
|
repo.type = jpa.repository
|
|
|
|
let imports = []
|
|
for(let field of model.fields) {
|
|
imports = [ ...imports, ...field.type.imports ]
|
|
}
|
|
|
|
repo.imports = [ ...new Set(imports) ]
|
|
repo.implements = model.implements || []
|
|
if(model.implements.length) {
|
|
model['implements'][ model['implements'].length - 1 ].last = true
|
|
}
|
|
|
|
repo.table = jpa.table || model.plural
|
|
repo.indexes = jpa.indexes && jpa.indexes.map(index => {
|
|
return {
|
|
namePascalCase: utils.pascalcase(index),
|
|
name: index,
|
|
type: model.fields.find(field => field.name == index).type
|
|
}
|
|
});
|
|
|
|
return repo
|
|
})
|
|
},
|
|
|
|
} |