func()

in codegen/config/config.go [281:452]

• 147 lines of code
• 43 McCabe index (conditional complexity)

func (c *Config) injectTypesFromSchema() error {
	c.Directives["goModel"] = DirectiveConfig{
		SkipRuntime: true,
	}

	c.Directives["goExtraField"] = DirectiveConfig{
		SkipRuntime: true,
	}

	c.Directives["goField"] = DirectiveConfig{
		SkipRuntime: true,
	}

	c.Directives["goTag"] = DirectiveConfig{
		SkipRuntime: true,
	}

	c.Directives["goEnum"] = DirectiveConfig{
		SkipRuntime: true,
	}

	for _, schemaType := range c.Schema.Types {
		if c.IsRoot(schemaType) {
			continue
		}

		if bd := schemaType.Directives.ForName("goModel"); bd != nil {
			if ma := bd.Arguments.ForName("model"); ma != nil {
				if mv, err := ma.Value.Value(nil); err == nil {
					c.Models.Add(schemaType.Name, mv.(string))
				}
			}

			if ma := bd.Arguments.ForName("models"); ma != nil {
				if mvs, err := ma.Value.Value(nil); err == nil {
					for _, mv := range mvs.([]any) {
						c.Models.Add(schemaType.Name, mv.(string))
					}
				}
			}

			if fg := bd.Arguments.ForName("forceGenerate"); fg != nil {
				if mv, err := fg.Value.Value(nil); err == nil {
					c.Models.ForceGenerate(schemaType.Name, mv.(bool))
				}
			}
		}

		if schemaType.Kind == ast.Object ||
			schemaType.Kind == ast.InputObject ||
			schemaType.Kind == ast.Interface {
			for _, field := range schemaType.Fields {
				if fd := field.Directives.ForName("goField"); fd != nil {
					forceResolver := c.Models[schemaType.Name].Fields[field.Name].Resolver
					if ra := fd.Arguments.ForName("forceResolver"); ra != nil {
						if fr, err := ra.Value.Value(nil); err == nil {
							forceResolver = fr.(bool)
						}
					}

					fieldName := c.Models[schemaType.Name].Fields[field.Name].FieldName
					if na := fd.Arguments.ForName("name"); na != nil {
						if fr, err := na.Value.Value(nil); err == nil {
							fieldName = fr.(string)
						}
					}

					omittable := c.Models[schemaType.Name].Fields[field.Name].Omittable
					if arg := fd.Arguments.ForName("omittable"); arg != nil {
						if k, err := arg.Value.Value(nil); err == nil {
							val := k.(bool)
							omittable = &val
						}
					}

					if c.Models[schemaType.Name].Fields == nil {
						c.Models[schemaType.Name] = TypeMapEntry{
							Model:       c.Models[schemaType.Name].Model,
							ExtraFields: c.Models[schemaType.Name].ExtraFields,
							Fields:      map[string]TypeMapField{},
						}
					}

					c.Models[schemaType.Name].Fields[field.Name] = TypeMapField{
						FieldName: fieldName,
						Resolver:  forceResolver,
						Omittable: omittable,
					}
				}
			}

			if efds := schemaType.Directives.ForNames("goExtraField"); len(efds) != 0 {
				for _, efd := range efds {
					if t := efd.Arguments.ForName("type"); t != nil {
						extraField := ModelExtraField{}

						if tv, err := t.Value.Value(nil); err == nil {
							extraField.Type = tv.(string)
						}

						if extraField.Type == "" {
							return fmt.Errorf(
								"argument 'type' for directive @goExtraField (src: %s, line: %d) cannot by empty",
								efd.Position.Src.Name,
								efd.Position.Line,
							)
						}

						if ot := efd.Arguments.ForName("overrideTags"); ot != nil {
							if otv, err := ot.Value.Value(nil); err == nil {
								extraField.OverrideTags = otv.(string)
							}
						}

						if d := efd.Arguments.ForName("description"); d != nil {
							if dv, err := d.Value.Value(nil); err == nil {
								extraField.Description = dv.(string)
							}
						}

						extraFieldName := ""
						if fn := efd.Arguments.ForName("name"); fn != nil {
							if fnv, err := fn.Value.Value(nil); err == nil {
								extraFieldName = fnv.(string)
							}
						}

						if extraFieldName == "" {
							// Embeddable fields
							typeMapEntry := c.Models[schemaType.Name]
							typeMapEntry.EmbedExtraFields = append(typeMapEntry.EmbedExtraFields, extraField)
							c.Models[schemaType.Name] = typeMapEntry
						} else {
							// Regular fields
							typeMapEntry := c.Models[schemaType.Name]
							if typeMapEntry.ExtraFields == nil {
								typeMapEntry.ExtraFields = make(map[string]ModelExtraField)
							}

							c.Models[schemaType.Name] = typeMapEntry
							c.Models[schemaType.Name].ExtraFields[extraFieldName] = extraField
						}
					}
				}
			}
		}

		if schemaType.Kind == ast.Enum && !strings.HasPrefix(schemaType.Name, "__") {
			values := make(map[string]EnumValue)

			for _, value := range schemaType.EnumValues {
				if directive := value.Directives.ForName("goEnum"); directive != nil {
					if arg := directive.Arguments.ForName("value"); arg != nil {
						if v, err := arg.Value.Value(nil); err == nil {
							values[value.Name] = EnumValue{
								Value: v.(string),
							}
						}
					}
				}
			}

			if len(values) > 0 {
				model := c.Models[schemaType.Name]
				model.EnumValues = values
				c.Models[schemaType.Name] = model
			}
		}
	}

	return nil
}