Method processObjectType

internal/schemagen/structural.go:437–566

processObjectType converts object types to Schema.Struct or Schema.Class.

(t *checker.Type, ctx processingContext)

// processObjectType converts object types to Schema.Struct or Schema.Class.
func (g *StructuralSchemaGen) processObjectType(t *checker.Type, ctx processingContext) (*ast.Node, bool, error) {
	properties := g.Checker.GetPropertiesOfType(t)
	propertyAssignments := make([]*ast.Node, 0, len(properties))

	for _, prop := range properties {
		propName := g.Checker.SymbolToString(prop)
		propType := g.Checker.GetTypeOfSymbol(prop)

		isOptional := prop.Flags&ast.SymbolFlagsOptional != 0

		var schemaExpr *ast.Node
		if isOptional {
			innerExpr, err := g.processType(propType, ctx)
			if err != nil {
				return nil, false, err
			}
			schemaExpr = g.createApiCall("optional", []*ast.Node{innerExpr})
		} else {
			var err error
			schemaExpr, err = g.processType(propType, ctx)
			if err != nil {
				return nil, false, err
			}
		}

		// Create property name node
		var propNameNode *ast.Node
		if validIdentifierRegex.MatchString(propName) {
			propNameNode = g.Tracker.NewIdentifier(propName)
		} else {
			propNameNode = g.Tracker.NewStringLiteral(propName, 0)
		}

		assignment := g.Tracker.NewPropertyAssignment(nil, propNameNode, nil, nil, schemaExpr)
		propertyAssignments = append(propertyAssignments, assignment)
	}

	// Handle index signatures
	indexInfos := checker.Checker_getIndexInfosOfType(g.Checker, t)
	args := []*ast.Node{
		g.Tracker.NewObjectLiteralExpression(g.Tracker.NewNodeList(propertyAssignments), len(propertyAssignments) > 0),
	}

	type recordEntry struct {
		key   *ast.Node
		value *ast.Node
	}
	var records []recordEntry
	for _, info := range indexInfos {
		keyType := checker.IndexInfo_keyType(info)
		valueType := checker.IndexInfo_valueType(info)

		keySchema, err := g.processType(keyType, ctx)
		if err != nil {
			return nil, false, err
		}
		valueSchema, err := g.processType(valueType, ctx)
		if err != nil {