// DefaultMedia sets a resource default media type by identifier or by reference using a value
// returned by MediaType:
//
// var _ = Resource("bottle", func() {
// DefaultMedia(BottleMedia)
// // ...
// })
//
// var _ = Resource("region", func() {
// DefaultMedia("vnd.goa.region")
// // ...
// })
//
// The default media type is used to build OK response definitions when no specific media type is
// given in the Response function call. The default media type is also used to set the default
// properties of attributes listed in action payloads. So if a media type defines an attribute
// "name" with associated validations then simply calling Attribute("name") inside a request
// Payload defines the payload attribute with the same type and validations.
func DefaultMedia(val interface{}) {
if r, ok := resourceDefinition(true); ok {
if m, ok := val.(*design.MediaTypeDefinition); ok {
if m.UserTypeDefinition == nil {
ReportError("invalid media type specification, media type is not initialized")
} else {
r.MediaType = design.CanonicalIdentifier(m.Identifier)
m.Resource = r
}
} else if identifier, ok := val.(string); ok {
r.MediaType = design.CanonicalIdentifier(identifier)
} else {
ReportError("media type must be a string or a *design.MediaTypeDefinition, got %#v", val)
}
}
}
// CollectionOf creates a collection media type from its element media type. A collection media
// type represents the content of responses that return a collection of resources such as "list"
// actions. This function can be called from any place where a media type can be used.
// The resulting media type identifier is built from the element media type by appending the media
// type parameter "type" with value "collection".
func CollectionOf(v interface{}, dsl ...func()) *design.MediaTypeDefinition {
if generatedMediaTypes == nil {
generatedMediaTypes = make(map[string]*design.MediaTypeDefinition)
}
var m *design.MediaTypeDefinition
var ok bool
m, ok = v.(*design.MediaTypeDefinition)
if !ok {
if id, ok := v.(string); ok {
m = design.Design.MediaTypes[design.CanonicalIdentifier(id)]
}
}
if m == nil {
ReportError("invalid CollectionOf argument: not a media type and not a known media type identifier")
return nil
}
id := m.Identifier
mediatype, params, err := mime.ParseMediaType(id)
if err != nil {
ReportError("invalid media type identifier %#v: %s", id, err)
return nil
}
hasType := false
for param := range params {
if param == "type" {
hasType = true
break
}
}
if !hasType {
params["type"] = "collection"
}
id = mime.FormatMediaType(mediatype, params)
typeName := m.TypeName + "Collection"
if mt, ok := generatedMediaTypes[typeName]; ok {
// Already have a type for this collection, reuse it.
return mt
}
mt := design.NewMediaTypeDefinition(typeName, id, func() {
if mt, ok := mediaTypeDefinition(true); ok {
mt.TypeName = typeName
mt.AttributeDefinition = &design.AttributeDefinition{Type: ArrayOf(m)}
if len(dsl) > 0 {
executeDSL(dsl[0], mt)
}
if mt.Views == nil {
// If the DSL didn't create any views (or there is no DSL at all)
// then inherit the views from the collection element.
mt.Views = make(map[string]*design.ViewDefinition)
for n, v := range m.Views {
mt.Views[n] = v
}
}
}
})
// Do not execute the DSL right away, will be done last to make sure the element DSL has run
// first.
generatedMediaTypes[mt.TypeName] = mt
return mt
}
// RunDSL runs all the registered top level DSLs and returns any error.
// This function is called by the client package init.
// goagen creates that function during code generation.
func RunDSL() error {
if design.Design == nil {
return nil
}
Errors = nil
// First run the top level API DSL to initialize responses and
// response templates needed by resources.
executeDSL(design.Design.DSL, design.Design)
// Then all the versions
for _, v := range design.Design.APIVersions {
executeDSL(v.DSL, v)
}
// Then run the user type DSLs
for _, t := range design.Design.Types {
executeDSL(t.DSL, t.AttributeDefinition)
}
// Then the media type DSLs
for _, mt := range design.Design.MediaTypes {
executeDSL(mt.DSL, mt)
}
// And now that we have everything the resources.
for _, r := range design.Design.Resources {
executeDSL(r.DSL, r)
}
// Now execute any generated media type definitions.
for _, mt := range generatedMediaTypes {
canonicalID := design.CanonicalIdentifier(mt.Identifier)
design.Design.MediaTypes[canonicalID] = mt
executeDSL(mt.DSL, mt)
}
generatedMediaTypes = make(map[string]*design.MediaTypeDefinition)
// Don't attempt to validate syntactically incorrect DSL
if Errors != nil {
return Errors
}
// Validate DSL
if err := design.Design.Validate(); err != nil {
return err
}
if Errors != nil {
return Errors
}
// Second pass post-validation does final merges with defaults and base types.
for _, t := range design.Design.Types {
finalizeType(t)
}
for _, mt := range design.Design.MediaTypes {
finalizeMediaType(mt)
}
for _, r := range design.Design.Resources {
finalizeResource(r)
}
return nil
}
func responseSpecFromDefinition(s *Swagger, api *design.APIDefinition, r *design.ResponseDefinition) (*Response, error) {
var schema *genschema.JSONSchema
if r.MediaType != "" {
if mt, ok := api.MediaTypes[design.CanonicalIdentifier(r.MediaType)]; ok {
schema = genschema.TypeSchema(api, mt)
}
}
headers, err := headersFromDefinition(r.Headers)
if err != nil {
return nil, err
}
return &Response{
Description: r.Description,
Schema: schema,
Headers: headers,
}, nil
}
func okResp(a *design.ActionDefinition, v string) map[string]interface{} {
var ok *design.ResponseDefinition
for _, resp := range a.Responses {
if resp.Status == 200 {
ok = resp
break
}
}
if ok == nil {
return nil
}
var mt *design.MediaTypeDefinition
var ok2 bool
if mt, ok2 = design.Design.MediaTypes[design.CanonicalIdentifier(ok.MediaType)]; !ok2 {
return nil
}
var pkg string
if v == "" {
pkg = TargetPackage
} else {
pkg = codegen.VersionPackage(v)
}
name := codegen.GoTypeRef(mt, mt.AllRequired(), 1)
var pointer string
if strings.HasPrefix(name, "*") {
name = name[1:]
pointer = "*"
}
typeref := fmt.Sprintf("%s%s.%s", pointer, pkg, name)
if strings.HasPrefix(typeref, "*") {
typeref = "&" + typeref[1:]
}
return map[string]interface{}{
"Name": ok.Name,
"HasMultipleViews": len(mt.Views) > 1,
"GoType": codegen.GoNativeType(mt),
"TypeRef": typeref,
}
}
// MediaType implements the media type definition DSL. A media type definition describes the
// representation of a resource used in a response body. This includes listing all the *potential*
// resource attributes that can appear in the body. Views specify which of the attributes are
// actually rendered so that the same media type definition may represent multiple rendering of a
// given resource representation.
//
// All media types must define a view named "default". This view is used to render the media type in
// response bodies when no other view is specified.
//
// A media type definition may also define links to other media types. This is done by first
// defining an attribute for the linked-to media type and then referring to that attribute in the
// Links DSL. Views may then elect to render one or the other or both. Links are rendered using the
// special "link" view. Media types that are linked to must define that view. Here is an example
// showing all the possible media type sub-definitions:
//
// MediaType("application/vnd.goa.example.bottle", func() {
// Description("A bottle of wine")
// APIVersion("1.0")
// Attributes(func() {
// Attribute("id", Integer, "ID of bottle")
// Attribute("href", String, "API href of bottle")
// Attribute("account", Account, "Owner account")
// Attribute("origin", Origin, "Details on wine origin")
// Links(func() {
// Link("account") // Defines a link to the Account media type
// Link("origin", "tiny") // Overrides the default view used to render links
// })
// Required("id", "href")
// })
// View("default", func() {
// Attribute("id")
// Attribute("href")
// Attribute("links") // Default view renders links
// })
// View("extended", func() {
// Attribute("id")
// Attribute("href")
// Attribute("account") // Extended view renders account inline
// Attribute("origin") // Extended view renders origin inline
// Attribute("links") // Extended view also renders links
// })
// })
//
// This function returns the media type definition so it can be referred to throughout the DSL.
func MediaType(identifier string, dsl func()) *design.MediaTypeDefinition {
if design.Design == nil {
InitDesign()
}
if design.Design.MediaTypes == nil {
design.Design.MediaTypes = make(map[string]*design.MediaTypeDefinition)
}
if topLevelDefinition(true) {
// Validate Media Type
identifier, params, err := mime.ParseMediaType(identifier)
if err != nil {
ReportError("invalid media type identifier %#v: %s",
identifier, err)
// We don't return so that other errors may be
// captured in this one run.
identifier = "plain/text"
}
canonicalID := design.CanonicalIdentifier(identifier)
// Validate that media type identifier doesn't clash
if _, ok := design.Design.MediaTypes[canonicalID]; ok {
ReportError("media type %#v is defined twice", identifier)
return nil
}
parts := strings.Split(identifier, "+")
// Make sure it has the `+json` suffix (TBD update when goa supports other encodings)
if len(parts) > 1 {
parts = parts[1:]
found := false
for _, part := range parts {
if part == "json" {
found = true
break
}
}
if !found {
identifier += "+json"
}
}
identifier = mime.FormatMediaType(identifier, params)
// Concoct a Go type name from the identifier, should it be possible to set it in the DSL?
// pros: control the type name generated, cons: not needed in DSL, adds one more thing to worry about
lastPart := identifier
lastPartIndex := strings.LastIndex(identifier, "/")
if lastPartIndex > -1 {
lastPart = identifier[lastPartIndex+1:]
}
plusIndex := strings.Index(lastPart, "+")
if plusIndex > 0 {
lastPart = lastPart[:plusIndex]
}
lastPart = strings.TrimPrefix(lastPart, "vnd.")
elems := strings.Split(lastPart, ".")
for i, e := range elems {
elems[i] = strings.Title(e)
}
typeName := strings.Join(elems, "")
if typeName == "" {
mediaTypeCount++
typeName = fmt.Sprintf("MediaType%d", mediaTypeCount)
}
// Now save the type in the API media types map
mt := design.NewMediaTypeDefinition(typeName, identifier, dsl)
design.Design.MediaTypes[canonicalID] = mt
return mt
}
return nil
}