function generateModelDefs()

in packages/codegen.go/src/models.ts [147:226]
75 lines of code
33 McCabe index (conditional complexity)

function generateModelDefs(modelImports: ImportManager, serdeImports: ImportManager, codeModel: go.CodeModel): Array<ModelDef> {
  const models = codeModel.models;
  const modelDefs = new Array<ModelDef>();
  for (const model of models) {
    for (const field of model.fields) {
      const descriptionMods = new Array<string>();
      if (field.annotations.readOnly) {
        descriptionMods.push('READ-ONLY');
      } else if (field.annotations.required && (!go.isLiteralValue(field.type) || model.usage === go.UsageFlags.Output)) {
        descriptionMods.push('REQUIRED');
      } else if (go.isLiteralValue(field.type)) {
        if (!field.annotations.required) {
          descriptionMods.push('FLAG');
        }
        descriptionMods.push('CONSTANT');
      }
      if (go.isLiteralValue(field.type) && model.usage !== go.UsageFlags.Output) {
        // add a comment with the const value for const properties that are sent over the wire
        if (field.docs.description) {
          field.docs.description += '\n';
        }
        field.docs.description += `Field has constant value ${helpers.formatLiteralValue(field.type, false)}, any specified value is ignored.`;
      }
      if (field.docs.description) {
        descriptionMods.push(field.docs.description);
      } else if (go.isSliceType(field.type) && field.type.rawJSONAsBytes) {
        // add a basic description if one isn't available
        descriptionMods.push('The contents of this field are raw JSON.');
      }
      field.docs.description = descriptionMods.join('; ');
    }

    const serDeFormat = helpers.getSerDeFormat(model, codeModel);
    const modelDef = new ModelDef(model.name, serDeFormat, model.fields, model.docs);
    for (const field of values(modelDef.Fields)) {
      modelImports.addImportForType(field.type);
    }

    if (go.isModelType(model) && serDeFormat === 'XML' && !model.annotations.omitSerDeMethods) {
      serdeImports.add('encoding/xml');
      let needsDateTimeMarshalling = false;
      let byteArrayFormat = false;
      for (const field of values(model.fields)) {
        serdeImports.addImportForType(field.type);
        if (go.isTimeType(field.type)) {
          needsDateTimeMarshalling = true;
        } else if (go.isBytesType(field.type)) {
          byteArrayFormat = true;
        }
      }
      // due to differences in XML marshallers/unmarshallers, we use different codegen than for JSON
      if (needsDateTimeMarshalling || model.xml?.wrapper || needsXMLArrayMarshalling(model) || byteArrayFormat) {
        generateXMLMarshaller(model, modelDef, serdeImports);
        if (needsDateTimeMarshalling || byteArrayFormat) {
          generateXMLUnmarshaller(model, modelDef, serdeImports);
        }
      } else if (needsXMLDictionaryHelper(model)) {
        generateXMLMarshaller(model, modelDef, serdeImports);
        generateXMLUnmarshaller(model, modelDef, serdeImports);
      }
      modelDefs.push(modelDef);
      continue;
    }
    if (go.isPolymorphicType(model)) {
      generateDiscriminatorMarkerMethod(model.interface, modelDef);
      for (let parent = model.interface.parent; parent !== undefined; parent = parent.parent) {
        generateDiscriminatorMarkerMethod(parent, modelDef);
      }
    }
    if (model.annotations.multipartFormData) {
      generateToMultipartForm(modelDef);
      modelDef.SerDe.needsJSONPopulateMultipart = true;
    } else if (!model.annotations.omitSerDeMethods) {
      generateJSONMarshaller(model, modelDef, serdeImports);
      generateJSONUnmarshaller(model, modelDef, serdeImports, codeModel.options);
    }
    modelDefs.push(modelDef);
  }
  return modelDefs;
}