- Multiple Schema analysis.

- Works with xml as well.

Author: general-kroll-4-life

anysdk/expectedResponse.go

@@ -10,6 +10,8 @@ type ExpectedResponse interface {
 	GetOpenAPIDocKey() string
 	GetObjectKey() string
 	GetSchema() Schema
+	GetProjectionMap() map[string]string
+	GetProjection(string) (string, bool)
 	getOverrideSchema() (*LocalSchemaRef, bool)
 	getAsyncOverrideSchema() (*LocalSchemaRef, bool)
 	setOverrideSchemaValue(Schema)
@@ -21,17 +23,33 @@ type ExpectedResponse interface {
 }
 
 type standardExpectedResponse struct {
-	OverrideBodyMediaType      string `json:"overrideMediaType,omitempty" yaml:"overrideMediaType,omitempty"`
-	AsyncOverrideBodyMediaType string `json:"asyncOverrideMediaType,omitempty" yaml:"asyncOverrideMediaType,omitempty"`
-	BodyMediaType              string `json:"mediaType,omitempty" yaml:"mediaType,omitempty"`
-	OpenAPIDocKey              string `json:"openAPIDocKey,omitempty" yaml:"openAPIDocKey,omitempty"`
-	ObjectKey                  string `json:"objectKey,omitempty" yaml:"objectKey,omitempty"`
+	OverrideBodyMediaType      string            `json:"overrideMediaType,omitempty" yaml:"overrideMediaType,omitempty"`
+	AsyncOverrideBodyMediaType string            `json:"asyncOverrideMediaType,omitempty" yaml:"asyncOverrideMediaType,omitempty"`
+	BodyMediaType              string            `json:"mediaType,omitempty" yaml:"mediaType,omitempty"`
+	OpenAPIDocKey              string            `json:"openAPIDocKey,omitempty" yaml:"openAPIDocKey,omitempty"`
+	ObjectKey                  string            `json:"objectKey,omitempty" yaml:"objectKey,omitempty"`
+	ProjectionMap              map[string]string `json:"projection_map,omitempty" yaml:"projection_map,omitempty"`
 	Schema                     Schema
 	OverrideSchema             *LocalSchemaRef    `json:"schema_override,omitempty" yaml:"schema_override,omitempty"`
 	AsyncOverrideSchema        *LocalSchemaRef    `json:"async_schema_override,omitempty" yaml:"async_schema_override,omitempty"`
 	Transform                  *standardTransform `json:"transform,omitempty" yaml:"transform,omitempty"`
 }
 
+func (er *standardExpectedResponse) GetProjectionMap() map[string]string {
+	if er.ProjectionMap == nil {
+		return make(map[string]string)
+	}
+	return er.ProjectionMap
+}
+
+func (er *standardExpectedResponse) GetProjection(key string) (string, bool) {
+	if er.ProjectionMap == nil {
+		return "", false
+	}
+	v, ok := er.ProjectionMap[key]
+	return v, ok
+}
+
 func (er *standardExpectedResponse) setBodyMediaType(s string) {
 	er.BodyMediaType = s
 }

anysdk/operation_store.go

@@ -144,7 +144,10 @@ type StandardOperationStore interface {
 	GetRequestBodyMediaType() string
 	getRequestBodyMediaType() string
 	getRequestBodyMediaTypeNormalised() string
+	GetXMLDeclaration() string
 	getXMLDeclaration() string
+	GetXMLRootAnnotation() string
+	GetXMLTransform() string
 	// getRequestBodyAttributeLineage(string) (string, error)
 }
 
@@ -180,6 +183,10 @@ func (op *standardOpenAPIOperationStore) GetInline() []string {
 	return []string{}
 }
 
+func (op *standardOpenAPIOperationStore) GetXMLDeclaration() string {
+	return op.getXMLDeclaration()
+}
+
 func (op *standardOpenAPIOperationStore) getXMLDeclaration() string {
 	rv := ""
 	if op.Request != nil {
@@ -201,6 +208,10 @@ func (op *standardOpenAPIOperationStore) getServiceNameForProvider() string {
 	return ""
 }
 
+func (op *standardOpenAPIOperationStore) GetXMLRootAnnotation() string {
+	return op.getXMLRootAnnotation()
+}
+
 func (op *standardOpenAPIOperationStore) getXMLRootAnnotation() string {
 	rv := ""
 	if op.Request != nil {
@@ -209,6 +220,10 @@ func (op *standardOpenAPIOperationStore) getXMLRootAnnotation() string {
 	return rv
 }
 
+func (op *standardOpenAPIOperationStore) GetXMLTransform() string {
+	return op.getXMLTransform()
+}
+
 func (op *standardOpenAPIOperationStore) getXMLTransform() string {
 	rv := ""
 	if op.Request != nil {
@@ -1198,15 +1213,15 @@ func (op *standardOpenAPIOperationStore) MarshalBody(body interface{}, expectedR
 func (op *standardOpenAPIOperationStore) marshalBody(body interface{}, expectedRequest ExpectedRequest) ([]byte, error) {
 	mediaType := expectedRequest.GetBodyMediaType()
 	if expectedRequest.GetSchema() != nil {
-		mediaType = expectedRequest.GetSchema().extractMediaTypeSynonym(mediaType)
+		mediaType = expectedRequest.GetSchema().ExtractMediaTypeSynonym(mediaType)
 	}
 	switch mediaType {
 	case media.MediaTypeJson:
 		return json.Marshal(body)
 	case media.MediaTypeXML, media.MediaTypeTextXML:
 		return xmlmap.MarshalXMLUserInput(
 			body,
-			expectedRequest.GetSchema().getXMLALiasOrName(),
+			expectedRequest.GetSchema().GetXMLALiasOrName(),
 			op.getXMLTransform(),
 			op.getXMLDeclaration(),
 			op.getXMLRootAnnotation(),
@@ -1215,139 +1230,6 @@ func (op *standardOpenAPIOperationStore) marshalBody(body interface{}, expectedR
 	return nil, fmt.Errorf("media type = '%s' not supported", expectedRequest.GetBodyMediaType())
 }
 
-type AnalyzedInput interface {
-	GetQueryParams() map[string]any
-	GetHeaderParam(string) (string, bool)
-	GetPathParam(string) (string, bool)
-	GetServerVars() map[string]any
-	GetREquestBody() any
-}
-
-func (op *standardOpenAPIOperationStore) parameterizeFromAnalyzedInput(prov Provider, parentDoc Service, inputParams AnalyzedInput) (*openapi3filter.RequestValidationInput, error) {
-
-	params := op.OperationRef.Value.Parameters
-	pathParams := make(map[string]string)
-	q := make(url.Values)
-	prefilledHeader := make(http.Header)
-
-	queryParamsRemaining := inputParams.GetQueryParams()
-	for _, p := range params {
-		if p.Value == nil {
-			continue
-		}
-		name := p.Value.Name
-
-		if p.Value.In == openapi3.ParameterInHeader {
-			val, present := inputParams.GetHeaderParam(p.Value.Name)
-			if present {
-				prefilledHeader.Set(name, fmt.Sprintf("%v", val))
-			} else if p.Value != nil && p.Value.Schema != nil && p.Value.Schema.Value != nil && p.Value.Schema.Value.Default != nil {
-				prefilledHeader.Set(name, fmt.Sprintf("%v", p.Value.Schema.Value.Default))
-			} else if isOpenapi3ParamRequired(p.Value) {
-				return nil, fmt.Errorf("standardOpenAPIOperationStore.parameterize() failure; missing required header '%s'", name)
-			}
-		}
-		if p.Value.In == openapi3.ParameterInPath {
-			val, present := inputParams.GetPathParam(p.Value.Name)
-			if present {
-				pathParams[name] = fmt.Sprintf("%v", val)
-			}
-			if !present && isOpenapi3ParamRequired(p.Value) {
-				return nil, fmt.Errorf("standardOpenAPIOperationStore.parameterize() failure; missing required path parameter '%s'", name)
-			}
-		} else if p.Value.In == openapi3.ParameterInQuery {
-
-			pVal, present := queryParamsRemaining[p.Value.Name]
-			if present {
-				switch val := pVal.(type) {
-				case []interface{}:
-					for _, v := range val {
-						q.Add(name, fmt.Sprintf("%v", v))
-					}
-				default:
-					q.Set(name, fmt.Sprintf("%v", val))
-				}
-				delete(queryParamsRemaining, name)
-			}
-		}
-	}
-	for k, v := range queryParamsRemaining {
-		q.Set(k, fmt.Sprintf("%v", v))
-		delete(queryParamsRemaining, k)
-	}
-	openapiSvc, openapiSvcOk := op.OpenAPIService.(OpenAPIService)
-	if !openapiSvcOk {
-		return nil, fmt.Errorf("could not cast OpenAPIService to standardOpenAPIServiceStore")
-	}
-	router, err := queryrouter.NewRouter(openapiSvc.getT())
-	if err != nil {
-		return nil, err
-	}
-	servers, _ := op.getServers()
-	serverParams := inputParams.GetServerVars()
-	if err != nil {
-		return nil, err
-	}
-	sv, err := selectServer(servers, serverParams)
-	if err != nil {
-		return nil, err
-	}
-	contentTypeHeaderRequired := false
-	var bodyReader io.Reader
-
-	requestBody := inputParams.GetREquestBody()
-
-	predOne := !util.IsNil(requestBody)
-	predTwo := !util.IsNil(op.Request)
-	if predOne && predTwo {
-		b, err := op.marshalBody(requestBody, op.Request)
-		if err != nil {
-			return nil, err
-		}
-		bodyReader = bytes.NewReader(b)
-		contentTypeHeaderRequired = true
-	}
-	// TODO: clean up
-	sv = strings.TrimSuffix(sv, "/")
-	path := replaceSimpleStringVars(fmt.Sprintf("%s%s", sv, op.OperationRef.extractPathItem()), pathParams)
-	u, err := url.Parse(fmt.Sprintf("%s?%s", path, q.Encode()))
-	if strings.Contains(path, "?") {
-		if len(q) > 0 {
-			u, err = url.Parse(fmt.Sprintf("%s&%s", path, q.Encode()))
-		} else {
-			u, err = url.Parse(path)
-		}
-	}
-	if err != nil {
-		return nil, err
-	}
-	httpReq, err := http.NewRequest(strings.ToUpper(op.OperationRef.extractMethodItem()), u.String(), bodyReader)
-	if err != nil {
-		return nil, err
-	}
-	if contentTypeHeaderRequired {
-		if prefilledHeader.Get("Content-Type") != "" {
-			prefilledHeader.Set("Content-Type", op.Request.BodyMediaType)
-		}
-	}
-	httpReq.Header = prefilledHeader
-	route, checkedPathParams, err := router.FindRoute(httpReq)
-	if err != nil {
-		return nil, err
-	}
-	options := &openapi3filter.Options{
-		AuthenticationFunc: openapi3filter.NoopAuthenticationFunc,
-	}
-	// Validate request
-	requestValidationInput := &openapi3filter.RequestValidationInput{
-		Options:    options,
-		PathParams: checkedPathParams,
-		Request:    httpReq,
-		Route:      route,
-	}
-	return requestValidationInput, nil
-}
-
 func (op *standardOpenAPIOperationStore) parameterize(prov Provider, parentDoc Service, inputParams HttpParameters, requestBody interface{}) (*openapi3filter.RequestValidationInput, error) {
 
 	params := op.OperationRef.Value.Parameters

anysdk/schema.go

@@ -67,6 +67,7 @@ type Schema interface {
 	getDescendent(path []string) (Schema, bool)
 	getFatItemsSchema(srs openapi3.SchemaRefs) Schema
 	getItemsRef() (*openapi3.SchemaRef, bool)
+	GetXMLALiasOrName() string
 	getXMLALiasOrName() string
 	getKey() string
 	getOpenapiSchema() (*openapi3.Schema, bool)
@@ -86,6 +87,7 @@ type Schema interface {
 	setKey(string)
 	setRawProperty(string, *openapi3.SchemaRef)
 	setXml(interface{})
+	ExtractMediaTypeSynonym(mediaType string) string
 	extractMediaTypeSynonym(mediaType string) string // TODO: implement upwards-searchable configurable type set matching
 	toFlatDescriptionMap(extended bool) map[string]interface{}
 	unmarshalJSONResponseBody(body io.Reader, path string) (interface{}, interface{}, error)
@@ -466,6 +468,10 @@ func (s *standardSchema) getName() string {
 	return getPathSuffix(s.key)
 }
 
+func (s *standardSchema) GetXMLALiasOrName() string {
+	return s.getXMLALiasOrName()
+}
+
 func (s *standardSchema) getXMLALiasOrName() string {
 	xa := s.getXmlAlias()
 	if xa != "" {
@@ -791,6 +797,10 @@ func (schema *standardSchema) GetSelectSchema(itemsKey, mediaType string) (Schem
 	return nil, "", fmt.Errorf("unable to complete schema.GetSelectSchema() for schema = '%v' and itemsKey = '%s'", schema, itemsKey)
 }
 
+func (schema *standardSchema) ExtractMediaTypeSynonym(mediaType string) string {
+	return schema.extractMediaTypeSynonym(mediaType)
+}
+
 func (schema *standardSchema) extractMediaTypeSynonym(mediaType string) string {
 	m, ok := media.DefaultMediaFuzzyMatcher.Find(mediaType)
 	if ok {

anysdk/service.go

@@ -34,6 +34,7 @@ type OpenAPIService interface {
 	getPaginationRequestTokenSemantic() (TokenSemantic, bool)
 	getPaginationResponseTokenSemantic() (TokenSemantic, bool)
 	getQueryTransposeAlgorithm() string
+	GetT() *openapi3.T
 	getT() *openapi3.T
 	iDiscoveryDoc()
 	isObjectSchemaImplicitlyUnioned() bool
@@ -56,6 +57,10 @@ type localTemplatedService struct {
 	Provider        Provider                     `json:"-" yaml:"-"` // upwards traversal
 }
 
+func (sv *localTemplatedService) GetT() *openapi3.T {
+	return sv.OpenapiSvc
+}
+
 func (sv *localTemplatedService) getT() *openapi3.T {
 	return sv.OpenapiSvc
 }
@@ -174,6 +179,10 @@ func (sv *standardService) setResourceMap(rsc map[string]*standardResource) {
 
 func (sv *standardService) iDiscoveryDoc() {}
 
+func (sv *standardService) GetT() *openapi3.T {
+	return sv.getT()
+}
+
 func (sv *standardService) getT() *openapi3.T {
 	return sv.T
 }

docs/aliasing.md

@@ -49,6 +49,7 @@ Request and response **sub-component** (body, header) attributes can be exposed
 - Not exposing response header attributes at all.
 - Heuristics that effectively clobber any input attribute that collides with a server variable.
 - Routing request body attributes based on a prefix eg: `data__`.  This is undesirable on the grounds of poor encapsulation and weakened semantics.
+  - Interesting schema search implementation in `getSelectItemsSchema()`.
 
 ### Proposed HTTP implementation
 

pkg/xmlmap/xmlmap.go

@@ -367,11 +367,16 @@ func (s permissableMapWrapper) MarshalXML(e *xml.Encoder, start xml.StartElement
 	tokens := []xml.Token{start}
 
 	for key, value := range s.m {
-		t := xml.StartElement{Name: xml.Name{"", key}}
-		tokens = append(tokens, t, xml.CharData(fmt.Sprintf("%v", value)), xml.EndElement{t.Name})
+		t := xml.StartElement{Name: xml.Name{
+			Space: "",
+			Local: key,
+		}}
+		tokens = append(tokens, t, xml.CharData(fmt.Sprintf("%v", value)), xml.EndElement{Name: t.Name})
 	}
 
-	tokens = append(tokens, xml.EndElement{start.Name})
+	tokens = append(tokens, xml.EndElement{
+		Name: start.Name,
+	})
 
 	for _, t := range tokens {
 		err := e.EncodeToken(t)