func (g *gensql) populateMessage(file *generator.FileDescriptor, msg *generator.Descriptor) {
model := limbo.GetModel(msg)
model.MessageType = "." + file.GetPackage() + "." + msg.GetName()
{ // default scanner
var found bool
for _, scanner := range model.Scanner {
if scanner.Name == "" {
found = true
break
}
}
if !found {
model.Scanner = append(model.Scanner, &limbo.ScannerDescriptor{Fields: "*"})
}
}
for _, scanner := range model.Scanner {
scanner.MessageType = "." + file.GetPackage() + "." + msg.GetName()
}
for _, field := range msg.GetField() {
if column := limbo.GetColumn(field); column != nil {
column.MessageType = "." + file.GetPackage() + "." + msg.GetName()
column.FieldName = field.GetName()
if column.Name == "" {
column.Name = field.GetName()
}
model.Column = append(model.Column, column)
}
if join := limbo.GetJoin(field); join != nil {
if field.GetType() != pb.FieldDescriptorProto_TYPE_MESSAGE {
g.gen.Fail(field.GetName(), "in", msg.GetName(), "must be a message")
}
join.MessageType = "." + file.GetPackage() + "." + msg.GetName()
join.FieldName = field.GetName()
join.ForeignMessageType = field.GetTypeName()
if join.Name == "" {
join.Name = field.GetName()
}
if join.Key == "" {
join.Key = field.GetName() + "_id"
}
if join.ForeignKey == "" {
join.ForeignKey = "id"
}
model.Join = append(model.Join, join)
}
}
sort.Sort(limbo.SortedColumnDescriptors(model.Column))
sort.Sort(limbo.SortedJoinDescriptors(model.Join))
sort.Sort(limbo.SortedScannerDescriptors(model.Scanner))
}
func (g *jsonschema) messageToSchema(file *generator.FileDescriptor, desc *generator.Descriptor) (interface{}, []string) {
typeName := file.GetPackage() + "." + strings.Join(desc.TypeName(), ".")
typeName = strings.TrimPrefix(typeName, ".")
title := desc.TypeName()[len(desc.TypeName())-1]
var (
dependencies []string
properties = make(map[string]interface{})
requiredProperties []string
)
for i, field := range desc.GetField() {
if field.OneofIndex != nil {
continue
}
f, dep := g.fieldToSchema(field)
if f == nil {
continue
}
if limbo.IsRequiredProperty(field) {
requiredProperties = append(requiredProperties, getJSONName(field))
}
{
comment := g.gen.Comments(fmt.Sprintf("%s,%d,%d", desc.Path(), 2, i))
comment = strings.TrimSpace(comment)
if comment != "" {
f["description"] = comment
}
}
properties[getJSONName(field)] = f
if dep != "" {
dependencies = append(dependencies, dep)
}
}
schema := map[string]interface{}{
"type": "object",
"properties": properties,
}
if len(requiredProperties) > 0 {
schema["required"] = requiredProperties
}
if len(desc.OneofDecl) > 0 {
allOffDefs := make([]interface{}, 0, 1+len(desc.OneofDecl))
oneOfDefs := make([][]interface{}, len(desc.OneofDecl))
for i, field := range desc.GetField() {
if field.OneofIndex == nil {
continue
}
oneofIndex := *field.OneofIndex
f, dep := g.fieldToSchema(field)
if f == nil {
continue
}
if field.IsRepeated() {
f = map[string]interface{}{
"type": "array",
"items": f,
}
}
{
comment := g.gen.Comments(fmt.Sprintf("%s,%d,%d", desc.Path(), 2, i))
comment = strings.TrimSpace(comment)
if comment != "" {
f["description"] = comment
}
}
def := map[string]interface{}{
"type": "object",
"properties": map[string]interface{}{
getJSONName(field): f,
},
"required": []string{getJSONName(field)},
}
oneOfDefs[oneofIndex] = append(oneOfDefs[oneofIndex], def)
if dep != "" {
dependencies = append(dependencies, dep)
}
}
allOffDefs = append(allOffDefs, schema)
for i, defs := range oneOfDefs {
def := map[string]interface{}{
"oneOf": defs,
}
{
comment := g.gen.Comments(fmt.Sprintf("%s,%d,%d", desc.Path(), 8, i))
comment = strings.TrimSpace(comment)
if comment != "" {
def["description"] = comment
}
}
allOffDefs = append(allOffDefs, def)
}
schema = map[string]interface{}{
"type": "object",
"allOf": allOffDefs,
}
}
{
comment := g.gen.Comments(desc.Path())
comment = strings.TrimSpace(comment)
if comment != "" {
schema["description"] = comment
}
}
{
schema["title"] = title
// schema["id"] = typeName
}
{
dependencies = uniqStrings(dependencies)
}
return schema, dependencies
}