expose source for KeyAuth/JWT key/token validation/parsing function to allow custom logic depending from where key/token value was extracted

aldas · aldas · commit 2b4c5a4097ea · 2022-05-22T00:37:19.000+03:00
diff --git a/middleware/basic_auth.go b/middleware/basic_auth.go
@@ -74,7 +74,7 @@ func (config BasicAuthConfig) ToMiddleware() (echo.MiddlewareFunc, error) {
 
 				b, errDecode := base64.StdEncoding.DecodeString(auth[l+1:])
 				if errDecode != nil {
-					lastError = fmt.Errorf("invalid basic auth value: %w", errDecode)
+					lastError = echo.ErrUnauthorized.WithInternal(fmt.Errorf("invalid basic auth value: %w", errDecode))
 					continue
 				}
 				idx := bytes.IndexByte(b, ':')
diff --git a/middleware/basic_auth_test.go b/middleware/basic_auth_test.go
@@ -56,7 +56,7 @@ func TestBasicAuth(t *testing.T) {
 			name:        "nok, not base64 Authorization header",
 			givenConfig: defaultConfig,
 			whenAuth:    []string{strings.ToUpper(basic) + " NOT_BASE64"},
-			expectErr:   "invalid basic auth value: illegal base64 data at input byte 3",
+			expectErr:   "code=401, message=Unauthorized, internal=invalid basic auth value: illegal base64 data at input byte 3",
 		},
 		{
 			name:         "nok, missing Authorization header",
diff --git a/middleware/csrf.go b/middleware/csrf.go
@@ -144,7 +144,7 @@ func (config CSRFConfig) ToMiddleware() (echo.MiddlewareFunc, error) {
 				var lastTokenErr error
 			outer:
 				for _, extractor := range extractors {
-					clientTokens, err := extractor(c)
+					clientTokens, _, err := extractor(c)
 					if err != nil {
 						lastExtractorErr = err
 						continue
diff --git a/middleware/extractor.go b/middleware/extractor.go
@@ -13,6 +13,24 @@ const (
 	extractorLimit = 20
 )
 
+// ExtractorSource is type to indicate source for extracted value
+type ExtractorSource string
+
+const (
+	// ExtractorSourceHeader means value was extracted from request header
+	ExtractorSourceHeader ExtractorSource = "header"
+	// ExtractorSourceQuery means value was extracted from request query parameters
+	ExtractorSourceQuery ExtractorSource = "query"
+	// ExtractorSourcePathParam means value was extracted from route path parameters
+	ExtractorSourcePathParam ExtractorSource = "param"
+	// ExtractorSourceCookie means value was extracted from request cookies
+	ExtractorSourceCookie ExtractorSource = "cookie"
+	// ExtractorSourceForm means value was extracted from request form values
+	ExtractorSourceForm ExtractorSource = "form"
+	// ExtractorSourceCustom means value was extracted by custom extractor
+	ExtractorSourceCustom ExtractorSource = "custom"
+)
+
 // ValueExtractorError is error type when middleware extractor is unable to extract value from lookups
 type ValueExtractorError struct {
 	message string
@@ -31,7 +49,7 @@ var errCookieExtractorValueMissing = &ValueExtractorError{message: "missing valu
 var errFormExtractorValueMissing = &ValueExtractorError{message: "missing value in the form"}
 
 // ValuesExtractor defines a function for extracting values (keys/tokens) from the given context.
-type ValuesExtractor func(c echo.Context) ([]string, error)
+type ValuesExtractor func(c echo.Context) ([]string, ExtractorSource, error)
 
 func createExtractors(lookups string) ([]ValuesExtractor, error) {
 	if lookups == "" {
@@ -75,10 +93,10 @@ func valuesFromHeader(header string, valuePrefix string) ValuesExtractor {
 	prefixLen := len(valuePrefix)
 	// standard library parses http.Request header keys in canonical form but we may provide something else so fix this
 	header = textproto.CanonicalMIMEHeaderKey(header)
-	return func(c echo.Context) ([]string, error) {
+	return func(c echo.Context) ([]string, ExtractorSource, error) {
 		values := c.Request().Header.Values(header)
 		if len(values) == 0 {
-			return nil, errHeaderExtractorValueMissing
+			return nil, ExtractorSourceHeader, errHeaderExtractorValueMissing
 		}
 
 		result := make([]string, 0)
@@ -100,30 +118,30 @@ func valuesFromHeader(header string, valuePrefix string) ValuesExtractor {
 
 		if len(result) == 0 {
 			if prefixLen > 0 {
-				return nil, errHeaderExtractorValueInvalid
+				return nil, ExtractorSourceHeader, errHeaderExtractorValueInvalid
 			}
-			return nil, errHeaderExtractorValueMissing
+			return nil, ExtractorSourceHeader, errHeaderExtractorValueMissing
 		}
-		return result, nil
+		return result, ExtractorSourceHeader, nil
 	}
 }
 
 // valuesFromQuery returns a function that extracts values from the query string.
 func valuesFromQuery(param string) ValuesExtractor {
-	return func(c echo.Context) ([]string, error) {
+	return func(c echo.Context) ([]string, ExtractorSource, error) {
 		result := c.QueryParams()[param]
 		if len(result) == 0 {
-			return nil, errQueryExtractorValueMissing
+			return nil, ExtractorSourceQuery, errQueryExtractorValueMissing
 		} else if len(result) > extractorLimit-1 {
 			result = result[:extractorLimit]
 		}
-		return result, nil
+		return result, ExtractorSourceQuery, nil
 	}
 }
 
 // valuesFromParam returns a function that extracts values from the url param string.
 func valuesFromParam(param string) ValuesExtractor {
-	return func(c echo.Context) ([]string, error) {
+	return func(c echo.Context) ([]string, ExtractorSource, error) {
 		result := make([]string, 0)
 		for i, p := range c.PathParams() {
 			if param == p.Name {
@@ -134,18 +152,18 @@ func valuesFromParam(param string) ValuesExtractor {
 			}
 		}
 		if len(result) == 0 {
-			return nil, errParamExtractorValueMissing
+			return nil, ExtractorSourcePathParam, errParamExtractorValueMissing
 		}
-		return result, nil
+		return result, ExtractorSourcePathParam, nil
 	}
 }
 
 // valuesFromCookie returns a function that extracts values from the named cookie.
 func valuesFromCookie(name string) ValuesExtractor {
-	return func(c echo.Context) ([]string, error) {
+	return func(c echo.Context) ([]string, ExtractorSource, error) {
 		cookies := c.Cookies()
 		if len(cookies) == 0 {
-			return nil, errCookieExtractorValueMissing
+			return nil, ExtractorSourceCookie, errCookieExtractorValueMissing
 		}
 
 		result := make([]string, 0)
@@ -158,26 +176,26 @@ func valuesFromCookie(name string) ValuesExtractor {
 			}
 		}
 		if len(result) == 0 {
-			return nil, errCookieExtractorValueMissing
+			return nil, ExtractorSourceCookie, errCookieExtractorValueMissing
 		}
-		return result, nil
+		return result, ExtractorSourceCookie, nil
 	}
 }
 
 // valuesFromForm returns a function that extracts values from the form field.
 func valuesFromForm(name string) ValuesExtractor {
-	return func(c echo.Context) ([]string, error) {
+	return func(c echo.Context) ([]string, ExtractorSource, error) {
 		if c.Request().Form == nil {
 			_ = c.Request().ParseMultipartForm(32 << 20) // same what `c.Request().FormValue(name)` does
 		}
 		values := c.Request().Form[name]
 		if len(values) == 0 {
-			return nil, errFormExtractorValueMissing
+			return nil, ExtractorSourceForm, errFormExtractorValueMissing
 		}
 		if len(values) > extractorLimit-1 {
 			values = values[:extractorLimit]
 		}
 		result := append([]string{}, values...)
-		return result, nil
+		return result, ExtractorSourceForm, nil
 	}
 }
diff --git a/middleware/extractor_test.go b/middleware/extractor_test.go
@@ -20,6 +20,7 @@ func TestCreateExtractors(t *testing.T) {
 		givenPathParams   echo.PathParams
 		whenLoopups       string
 		expectValues      []string
+		expectSource      ExtractorSource
 		expectCreateError string
 		expectError       string
 	}{
@@ -32,6 +33,7 @@ func TestCreateExtractors(t *testing.T) {
 			},
 			whenLoopups:  "header:Authorization:Bearer ",
 			expectValues: []string{"token"},
+			expectSource: ExtractorSourceHeader,
 		},
 		{
 			name: "ok, form",
@@ -45,6 +47,7 @@ func TestCreateExtractors(t *testing.T) {
 			},
 			whenLoopups:  "form:name",
 			expectValues: []string{"Jon Snow"},
+			expectSource: ExtractorSourceForm,
 		},
 		{
 			name: "ok, cookie",
@@ -55,6 +58,7 @@ func TestCreateExtractors(t *testing.T) {
 			},
 			whenLoopups:  "cookie:_csrf",
 			expectValues: []string{"token"},
+			expectSource: ExtractorSourceCookie,
 		},
 		{
 			name: "ok, param",
@@ -63,6 +67,7 @@ func TestCreateExtractors(t *testing.T) {
 			},
 			whenLoopups:  "param:id",
 			expectValues: []string{"123"},
+			expectSource: ExtractorSourcePathParam,
 		},
 		{
 			name: "ok, query",
@@ -72,6 +77,7 @@ func TestCreateExtractors(t *testing.T) {
 			},
 			whenLoopups:  "query:id",
 			expectValues: []string{"999"},
+			expectSource: ExtractorSourceQuery,
 		},
 		{
 			name:              "nok, invalid lookup",
@@ -102,8 +108,9 @@ func TestCreateExtractors(t *testing.T) {
 			assert.NoError(t, err)
 
 			for _, e := range extractors {
-				values, eErr := e(c)
+				values, source, eErr := e(c)
 				assert.Equal(t, tc.expectValues, values)
+				assert.Equal(t, tc.expectSource, source)
 				if tc.expectError != "" {
 					assert.EqualError(t, eErr, tc.expectError)
 					return
@@ -228,8 +235,9 @@ func TestValuesFromHeader(t *testing.T) {
 
 			extractor := valuesFromHeader(tc.whenName, tc.whenValuePrefix)
 
-			values, err := extractor(c)
+			values, source, err := extractor(c)
 			assert.Equal(t, tc.expectValues, values)
+			assert.Equal(t, ExtractorSourceHeader, source)
 			if tc.expectError != "" {
 				assert.EqualError(t, err, tc.expectError)
 			} else {
@@ -289,8 +297,9 @@ func TestValuesFromQuery(t *testing.T) {
 
 			extractor := valuesFromQuery(tc.whenName)
 
-			values, err := extractor(c)
+			values, source, err := extractor(c)
 			assert.Equal(t, tc.expectValues, values)
+			assert.Equal(t, ExtractorSourceQuery, source)
 			if tc.expectError != "" {
 				assert.EqualError(t, err, tc.expectError)
 			} else {
@@ -368,8 +377,9 @@ func TestValuesFromParam(t *testing.T) {
 
 			extractor := valuesFromParam(tc.whenName)
 
-			values, err := extractor(c)
+			values, source, err := extractor(c)
 			assert.Equal(t, tc.expectValues, values)
+			assert.Equal(t, ExtractorSourcePathParam, source)
 			if tc.expectError != "" {
 				assert.EqualError(t, err, tc.expectError)
 			} else {
@@ -448,8 +458,9 @@ func TestValuesFromCookie(t *testing.T) {
 
 			extractor := valuesFromCookie(tc.whenName)
 
-			values, err := extractor(c)
+			values, source, err := extractor(c)
 			assert.Equal(t, tc.expectValues, values)
+			assert.Equal(t, ExtractorSourceCookie, source)
 			if tc.expectError != "" {
 				assert.EqualError(t, err, tc.expectError)
 			} else {
@@ -578,8 +589,9 @@ func TestValuesFromForm(t *testing.T) {
 
 			extractor := valuesFromForm(tc.whenName)
 
-			values, err := extractor(c)
+			values, source, err := extractor(c)
 			assert.Equal(t, tc.expectValues, values)
+			assert.Equal(t, ExtractorSourceForm, source)
 			if tc.expectError != "" {
 				assert.EqualError(t, err, tc.expectError)
 			} else {
diff --git a/middleware/jwt.go b/middleware/jwt.go
@@ -64,7 +64,7 @@ type JWTConfig struct {
 	// ParseTokenFunc defines a user-defined function that parses token from given auth. Returns an error when token
 	// parsing fails or parsed token is invalid.
 	// Defaults to implementation using `github.com/golang-jwt/jwt` as JWT implementation library
-	ParseTokenFunc func(c echo.Context, auth string) (interface{}, error)
+	ParseTokenFunc func(c echo.Context, auth string, source ExtractorSource) (interface{}, error)
 }
 
 // JWTSuccessHandler defines a function which is executed for a valid token.
@@ -101,7 +101,7 @@ var DefaultJWTConfig = JWTConfig{
 // For missing token, it returns "400 - Bad Request" error.
 //
 // See: https://jwt.io/introduction
-func JWT(parseTokenFunc func(c echo.Context, auth string) (interface{}, error)) echo.MiddlewareFunc {
+func JWT(parseTokenFunc func(c echo.Context, auth string, source ExtractorSource) (interface{}, error)) echo.MiddlewareFunc {
 	c := DefaultJWTConfig
 	c.ParseTokenFunc = parseTokenFunc
 	return JWTWithConfig(c)
@@ -152,13 +152,13 @@ func (config JWTConfig) ToMiddleware() (echo.MiddlewareFunc, error) {
 			var lastExtractorErr error
 			var lastTokenErr error
 			for _, extractor := range extractors {
-				auths, extrErr := extractor(c)
+				auths, source, extrErr := extractor(c)
 				if extrErr != nil {
 					lastExtractorErr = extrErr
 					continue
 				}
 				for _, auth := range auths {
-					token, err := config.ParseTokenFunc(c, auth)
+					token, err := config.ParseTokenFunc(c, auth, source)
 					if err != nil {
 						lastTokenErr = err
 						continue
diff --git a/middleware/jwt_external_test.go b/middleware/jwt_external_test.go
@@ -21,7 +21,7 @@ import (
 // This is one of the options to provide a token validation key.
 // The order of precedence is a user-defined SigningKeys and SigningKey.
 // Required if signingKey is not provided
-func CreateJWTGoParseTokenFunc(signingKey interface{}, signingKeys map[string]interface{}) func(c echo.Context, auth string) (interface{}, error) {
+func CreateJWTGoParseTokenFunc(signingKey interface{}, signingKeys map[string]interface{}) func(c echo.Context, auth string, source middleware.ExtractorSource) (interface{}, error) {
 	// keyFunc defines a user-defined function that supplies the public key for a token validation.
 	// The function shall take care of verifying the signing algorithm and selecting the proper key.
 	// A user-defined KeyFunc can be useful if tokens are issued by an external party.
@@ -41,7 +41,7 @@ func CreateJWTGoParseTokenFunc(signingKey interface{}, signingKeys map[string]in
 		return nil, fmt.Errorf("unexpected jwt key id=%v", t.Header["kid"])
 	}
 
-	return func(c echo.Context, auth string) (interface{}, error) {
+	return func(c echo.Context, auth string, source middleware.ExtractorSource) (interface{}, error) {
 		token, err := jwt.ParseWithClaims(auth, jwt.MapClaims{}, keyFunc) // you could add your default claims here
 		if err != nil {
 			return nil, err
diff --git a/middleware/jwt_test.go b/middleware/jwt_test.go
diff --git a/middleware/key_auth.go b/middleware/key_auth.go
diff --git a/middleware/key_auth_test.go b/middleware/key_auth_test.go

Original file line number	Diff line number	Diff line change
`@@ -74,7 +74,7 @@ func (config BasicAuthConfig) ToMiddleware() (echo.MiddlewareFunc, error) {`
`74`	`74`
`75`	`75`	`b, errDecode := base64.StdEncoding.DecodeString(auth[l+1:])`
`76`	`76`	`if errDecode != nil {`
`77`		`- lastError = fmt.Errorf("invalid basic auth value: %w", errDecode)`
	`77`	`+ lastError = echo.ErrUnauthorized.WithInternal(fmt.Errorf("invalid basic auth value: %w", errDecode))`
`78`	`78`	`continue`
`79`	`79`	`}`
`80`	`80`	`idx := bytes.IndexByte(b, ':')`
Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ func TestBasicAuth(t *testing.T) {`
`56`	`56`	`name: "nok, not base64 Authorization header",`
`57`	`57`	`givenConfig: defaultConfig,`
`58`	`58`	`whenAuth: []string{strings.ToUpper(basic) + " NOT_BASE64"},`
`59`		`- expectErr: "invalid basic auth value: illegal base64 data at input byte 3",`
	`59`	`+ expectErr: "code=401, message=Unauthorized, internal=invalid basic auth value: illegal base64 data at input byte 3",`
`60`	`60`	`},`
`61`	`61`	`{`
`62`	`62`	`name: "nok, missing Authorization header",`
Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,24 @@ const (`
`13`	`13`	`extractorLimit = 20`
`14`	`14`	`)`
`15`	`15`
	`16`	`+// ExtractorSource is type to indicate source for extracted value`
	`17`	`+type ExtractorSource string`
	`18`	`+`
	`19`	`+const (`
	`20`	`+ // ExtractorSourceHeader means value was extracted from request header`
	`21`	`+ ExtractorSourceHeader ExtractorSource = "header"`
	`22`	`+ // ExtractorSourceQuery means value was extracted from request query parameters`
	`23`	`+ ExtractorSourceQuery ExtractorSource = "query"`
	`24`	`+ // ExtractorSourcePathParam means value was extracted from route path parameters`
	`25`	`+ ExtractorSourcePathParam ExtractorSource = "param"`
	`26`	`+ // ExtractorSourceCookie means value was extracted from request cookies`
	`27`	`+ ExtractorSourceCookie ExtractorSource = "cookie"`
	`28`	`+ // ExtractorSourceForm means value was extracted from request form values`
	`29`	`+ ExtractorSourceForm ExtractorSource = "form"`
	`30`	`+ // ExtractorSourceCustom means value was extracted by custom extractor`
	`31`	`+ ExtractorSourceCustom ExtractorSource = "custom"`
	`32`	`+)`
	`33`	`+`
`16`	`34`	`// ValueExtractorError is error type when middleware extractor is unable to extract value from lookups`
`17`	`35`	`type ValueExtractorError struct {`
`18`	`36`	`message string`
`@@ -31,7 +49,7 @@ var errCookieExtractorValueMissing = &ValueExtractorError{message: "missing valu`
`31`	`49`	`var errFormExtractorValueMissing = &ValueExtractorError{message: "missing value in the form"}`
`32`	`50`
`33`	`51`	`// ValuesExtractor defines a function for extracting values (keys/tokens) from the given context.`
`34`		`-type ValuesExtractor func(c echo.Context) ([]string, error)`
	`52`	`+type ValuesExtractor func(c echo.Context) ([]string, ExtractorSource, error)`
`35`	`53`
`36`	`54`	`func createExtractors(lookups string) ([]ValuesExtractor, error) {`
`37`	`55`	`if lookups == "" {`
`@@ -75,10 +93,10 @@ func valuesFromHeader(header string, valuePrefix string) ValuesExtractor {`
`75`	`93`	`prefixLen := len(valuePrefix)`
`76`	`94`	`// standard library parses http.Request header keys in canonical form but we may provide something else so fix this`
`77`	`95`	`header = textproto.CanonicalMIMEHeaderKey(header)`
`78`		`- return func(c echo.Context) ([]string, error) {`
	`96`	`+ return func(c echo.Context) ([]string, ExtractorSource, error) {`
`79`	`97`	`values := c.Request().Header.Values(header)`
`80`	`98`	`if len(values) == 0 {`
`81`		`- return nil, errHeaderExtractorValueMissing`
	`99`	`+ return nil, ExtractorSourceHeader, errHeaderExtractorValueMissing`
`82`	`100`	`}`
`83`	`101`
`84`	`102`	`result := make([]string, 0)`
`@@ -100,30 +118,30 @@ func valuesFromHeader(header string, valuePrefix string) ValuesExtractor {`
`100`	`118`
`101`	`119`	`if len(result) == 0 {`
`102`	`120`	`if prefixLen > 0 {`
`103`		`- return nil, errHeaderExtractorValueInvalid`
	`121`	`+ return nil, ExtractorSourceHeader, errHeaderExtractorValueInvalid`
`104`	`122`	`}`
`105`		`- return nil, errHeaderExtractorValueMissing`
	`123`	`+ return nil, ExtractorSourceHeader, errHeaderExtractorValueMissing`
`106`	`124`	`}`
`107`		`- return result, nil`
	`125`	`+ return result, ExtractorSourceHeader, nil`
`108`	`126`	`}`
`109`	`127`	`}`
`110`	`128`
`111`	`129`	`// valuesFromQuery returns a function that extracts values from the query string.`
`112`	`130`	`func valuesFromQuery(param string) ValuesExtractor {`
`113`		`- return func(c echo.Context) ([]string, error) {`
	`131`	`+ return func(c echo.Context) ([]string, ExtractorSource, error) {`
`114`	`132`	`result := c.QueryParams()[param]`
`115`	`133`	`if len(result) == 0 {`
`116`		`- return nil, errQueryExtractorValueMissing`
	`134`	`+ return nil, ExtractorSourceQuery, errQueryExtractorValueMissing`
`117`	`135`	`} else if len(result) > extractorLimit-1 {`
`118`	`136`	`result = result[:extractorLimit]`
`119`	`137`	`}`
`120`		`- return result, nil`
	`138`	`+ return result, ExtractorSourceQuery, nil`
`121`	`139`	`}`
`122`	`140`	`}`
`123`	`141`
`124`	`142`	`// valuesFromParam returns a function that extracts values from the url param string.`
`125`	`143`	`func valuesFromParam(param string) ValuesExtractor {`
`126`		`- return func(c echo.Context) ([]string, error) {`
	`144`	`+ return func(c echo.Context) ([]string, ExtractorSource, error) {`
`127`	`145`	`result := make([]string, 0)`
`128`	`146`	`for i, p := range c.PathParams() {`
`129`	`147`	`if param == p.Name {`
`@@ -134,18 +152,18 @@ func valuesFromParam(param string) ValuesExtractor {`
`134`	`152`	`}`
`135`	`153`	`}`
`136`	`154`	`if len(result) == 0 {`
`137`		`- return nil, errParamExtractorValueMissing`
	`155`	`+ return nil, ExtractorSourcePathParam, errParamExtractorValueMissing`
`138`	`156`	`}`
`139`		`- return result, nil`
	`157`	`+ return result, ExtractorSourcePathParam, nil`
`140`	`158`	`}`
`141`	`159`	`}`
`142`	`160`
`143`	`161`	`// valuesFromCookie returns a function that extracts values from the named cookie.`
`144`	`162`	`func valuesFromCookie(name string) ValuesExtractor {`
`145`		`- return func(c echo.Context) ([]string, error) {`
	`163`	`+ return func(c echo.Context) ([]string, ExtractorSource, error) {`
`146`	`164`	`cookies := c.Cookies()`
`147`	`165`	`if len(cookies) == 0 {`
`148`		`- return nil, errCookieExtractorValueMissing`
	`166`	`+ return nil, ExtractorSourceCookie, errCookieExtractorValueMissing`
`149`	`167`	`}`
`150`	`168`
`151`	`169`	`result := make([]string, 0)`
`@@ -158,26 +176,26 @@ func valuesFromCookie(name string) ValuesExtractor {`
`158`	`176`	`}`
`159`	`177`	`}`
`160`	`178`	`if len(result) == 0 {`
`161`		`- return nil, errCookieExtractorValueMissing`
	`179`	`+ return nil, ExtractorSourceCookie, errCookieExtractorValueMissing`
`162`	`180`	`}`
`163`		`- return result, nil`
	`181`	`+ return result, ExtractorSourceCookie, nil`
`164`	`182`	`}`
`165`	`183`	`}`
`166`	`184`
`167`	`185`	`// valuesFromForm returns a function that extracts values from the form field.`
`168`	`186`	`func valuesFromForm(name string) ValuesExtractor {`
`169`		`- return func(c echo.Context) ([]string, error) {`
	`187`	`+ return func(c echo.Context) ([]string, ExtractorSource, error) {`
`170`	`188`	`if c.Request().Form == nil {`
`171`	`189`	_ = c.Request().ParseMultipartForm(32 << 20) // same what `c.Request().FormValue(name)` does
`172`	`190`	`}`
`173`	`191`	`values := c.Request().Form[name]`
`174`	`192`	`if len(values) == 0 {`
`175`		`- return nil, errFormExtractorValueMissing`
	`193`	`+ return nil, ExtractorSourceForm, errFormExtractorValueMissing`
`176`	`194`	`}`
`177`	`195`	`if len(values) > extractorLimit-1 {`
`178`	`196`	`values = values[:extractorLimit]`
`179`	`197`	`}`
`180`	`198`	`result := append([]string{}, values...)`
`181`		`- return result, nil`
	`199`	`+ return result, ExtractorSourceForm, nil`
`182`	`200`	`}`
`183`	`201`	`}`