Ignoring struct fields

[danicc097]

Is there a way to ignore certain fields for schema generation? I tried to use a new struct created with reflection based on my own openapi-go:"ignore" tag, but that gives trouble when generating schemas on a struct created with reflection, it generates an anonymous schema:

type SomeStruct struct {
	ActivityID   int    `json:"activityID" db:"activity_id" required:"true"`     // activity_id
	ProjectID    int    `json:"projectID" db:"project_id" required:"true"`       // project_id
	Name         string `json:"name" db:"name" required:"true"`                  // name
	Description  string `json:"description" db:"description" required:"true"`    // description
	IsProductive bool   `json:"isProductive" db:"is_productive" required:"true"` // is_productive

	TimeEntries *[]TimeEntry `json:"timeEntries" db:"time_entries" openapi-go:"ignore"` // O2M
	// xo fields
	_exists, _deleted bool
}

func cloneStructWithoutIgnoredFields(src any) any {
	srcType := reflect.TypeOf(src)

	dstType := reflect.StructOf(filterIgnoredFields(srcType))
	// dstType = reflect.StructOf([]reflect.StructField{{
	// 	Name:    srcType.Name(),
	// 	PkgPath: srcType.PkgPath(),
	// 	Type:    dstType,
	// }})

	dst := reflect.New(dstType).Elem()

	return dst.Interface()
}

// filterIgnoredFields returns all fields that do not have
// the "openapi-go" tag set to "ignore".
func filterIgnoredFields(t reflect.Type) []reflect.StructField {
	var filteredFields []reflect.StructField
	for i := 0; i < t.NumField(); i++ {
		field := t.Field(i)
		if val, ok := field.Tag.Lookup("openapi-go"); !ok || val != "ignore" {
			if field.Type.Kind() == reflect.Struct {
				subFields := filterIgnoredFields(field.Type)
				field.Type = reflect.StructOf(subFields)
			}
			filteredFields = append(filteredFields, field)
		}
	}

	return filteredFields
}


func handleError(err error) {
	if err != nil {
		log.Fatal(err)
	}
}

reflector := openapi3.Reflector{Spec: &openapi3.Spec{}}

st := SomeStruct{}
st = cloneStructWithoutIgnoredFields(st)

dummyOp := openapi3.Operation{}
handleError(reflector.SetJSONResponse(&dummyOp, st, http.StatusTeapot))
handleError(reflector.Spec.AddOperation(http.MethodGet, "/dummy-op", dummyOp))

s, _ := reflector.Spec.MarshalYAML()

is :

spec: openapi: ""
info:
  title: ""
  version: ""
paths:
  /dummy-op-0:
    get:
      responses:
        "418":
          content:
            application/json:
              schema:
                properties:
                  activityID:
                    type: integer
                  description:
                    type: string
                  isProductive:
                    type: boolean
                  name:
                    type: string
                  projectID:
                    type: integer
                required:
                - activityID
                - projectID
                - name
                - description
                - isProductive
                type: object
          description: I'm a teapot

expected output:

spec: openapi: ""
info:
  title: ""
  version: ""
paths:
  /dummy-op-0:
    get:
      responses:
        "418":
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Activity'
          description: I'm a teapot
components:
  schemas:
    Activity:
      properties:
        activityID:
          type: integer
        description:
          type: string
        isProductive:
          type: boolean
        name:
          type: string
        projectID:
          type: integer
      required:
      - activityID
      - projectID
      - name
      - description
      - isProductive
      type: object

So I guess the question is either:

• how can it be created with a given name, since InterceptDefName is not called in this case
• would it be possible to integrate some way to ignore fields in swaggest/refl

[vearutop]

Hi, I think the easiest way would be to use property interceptor and throw jsonschema.ErrSkipProperty on needed condition.

Please check the following example (requires latest openapi-go v0.2.30):
https://go.dev/play/p/gaKqGuMqdP0

	type SomeStruct struct {
		ActivityID   int    `json:"activityID" db:"activity_id" required:"true"`     // activity_id
		ProjectID    int    `json:"projectID" db:"project_id" required:"true"`       // project_id
		Name         string `json:"name" db:"name" required:"true"`                  // name
		Description  string `json:"description" db:"description" required:"true"`    // description
		IsProductive bool   `json:"isProductive" db:"is_productive" required:"true"` // is_productive

		TimeEntries *[]TimeEntry `json:"timeEntries" db:"time_entries" openapi-go:"ignore"` // O2M
		// xo fields
		_exists, _deleted bool
	}

	reflector := openapi3.Reflector{Spec: &openapi3.Spec{}}
	reflector.DefaultOptions = append(reflector.DefaultOptions, jsonschema.InterceptProp(func(params jsonschema.InterceptPropParams) error {
		if params.Field.Tag.Get("openapi-go") == "ignore" {
			println("IGNORING", params.Name)

			return jsonschema.ErrSkipProperty
		}

		return nil
	}))

	st := SomeStruct{}

	dummyOp := openapi3.Operation{}
	handleError(reflector.SetJSONResponse(&dummyOp, st, http.StatusTeapot))
	handleError(reflector.Spec.AddOperation(http.MethodGet, "/dummy-op", dummyOp))

openapi: ""
info:
  title: ""
  version: ""
paths:
  /dummy-op:
    get:
      responses:
        "418":
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SomeStruct'
          description: I'm a teapot
components:
  schemas:
    SomeStruct:
      properties:
        activityID:
          type: integer
        description:
          type: string
        isProductive:
          type: boolean
        name:
          type: string
        projectID:
          type: integer
      required:
      - activityID
      - projectID
      - name
      - description
      - isProductive
      type: object

[danicc097]

Yep, that does the trick. Thanks again for the timely response!