fix: carry the dotted-name rule in the meta-schema only

Drops the Go walk in favour of the meta-schema rule. Coverage is
narrower — a name hidden under $defs, allOf, or items is not caught —
but the rule now lives with the dialect, so an editor flags it while
authoring rather than the server rejecting it after the fact.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: vitorbari

.changeset/reject-dotted-schema-property-names.md

@@ -1,7 +1,9 @@
 ---
 "@zitadel/server": minor
+"@zitadel/config": minor
 ---
 
-A user schema property name may no longer contain a dot. Nested values are stored
-under their dotted path, so `{"a.b": …}` and `{"a": {"b": …}}` would produce the
-same attribute key and become indistinguishable.
+A user schema property name must be a single attribute name and may no longer
+contain a dot. The rule lives in the user-schema meta-schema, so an editor
+validating against the shipped dialect flags it while authoring, and the server
+rejects it on create.

internal/domain/json_schema.go

@@ -81,10 +81,6 @@ func NewJSONSchema(projectID string, schemabs []byte) (_ *JSONSchema, err error)
 		}
 	}
 
-	if err := rejectDottedPropertyNames(schema); err != nil {
-		return nil, err
-	}
-
 	var objectType *string
 	if ot, ok := maputil.Get[string](schema, "objectType"); ok {
 		objectType = &ot
@@ -99,35 +95,6 @@ func NewJSONSchema(projectID string, schemabs []byte) (_ *JSONSchema, err error)
 	}, nil
 }
 
-// rejectDottedPropertyNames rejects a property name holding a dot. The
-// user-schema meta-schema carries the same rule so an editor flags it
-// while authoring; this copy enforces it, and reaches `$defs`, `allOf`,
-// and `items`, which the meta-schema leaves unconstrained.
-func rejectDottedPropertyNames(node any) error {
-	switch v := node.(type) {
-	case map[string]any:
-		if props, ok := v["properties"].(map[string]any); ok {
-			for name := range props {
-				if strings.Contains(name, ".") {
-					return ErrJSONSchemaInvalid().WithMessage(fmt.Sprintf("schema property %q cannot contain a dot", name))
-				}
-			}
-		}
-		for _, val := range v {
-			if err := rejectDottedPropertyNames(val); err != nil {
-				return err
-			}
-		}
-	case []any:
-		for _, item := range v {
-			if err := rejectDottedPropertyNames(item); err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
-
 //go:generate go tool mockgen -typed -package domainmock -destination ./mock/json_schema.mock.go . JSONSchemaStore
 
 // JSONSchemaStore is the persistence port for JSON schemas used by

internal/domain/json_schema_test.go

@@ -474,57 +474,6 @@ func TestNewJSONSchema_ReservedProperties(t *testing.T) {
 		}
 	})
 
-	// A nested value is keyed by its dotted path in the attribute store and
-	// addressed by that same path in a flow step's fields, so a literal dot
-	// in a property name would be indistinguishable from nesting.
-	t.Run("dotted property names", func(t *testing.T) {
-		t.Run("rejected", func(t *testing.T) {
-			tests := []struct {
-				name    string
-				schema  string
-				message string
-			}{
-				{
-					name:    "at the top level",
-					schema:  `{"type":"object","properties":{"address.street":{"type":"string"}}}`,
-					message: `schema property "address.street" cannot contain a dot`,
-				},
-				{
-					name:    "inside a nested object",
-					schema:  `{"type":"object","properties":{"address":{"type":"object","properties":{"zip.code":{"type":"string"}}}}}`,
-					message: `schema property "zip.code" cannot contain a dot`,
-				},
-				{
-					name:    "under $defs behind a $ref",
-					schema:  `{"type":"object","$defs":{"address":{"type":"object","properties":{"zip.code":{"type":"string"}}}},"properties":{"address":{"$ref":"#/$defs/address"}}}`,
-					message: `schema property "zip.code" cannot contain a dot`,
-				},
-				{
-					name:    "inside an allOf branch",
-					schema:  `{"type":"object","allOf":[{"properties":{"zip.code":{"type":"string"}}}]}`,
-					message: `schema property "zip.code" cannot contain a dot`,
-				},
-			}
-
-			for _, tt := range tests {
-				t.Run(tt.name, func(t *testing.T) {
-					schema, err := domain.NewJSONSchema(projectID, []byte(tt.schema))
-					require.Error(t, err)
-					assert.Nil(t, schema)
-					assert.ErrorIs(t, err, domain.ErrJSONSchemaInvalid())
-					assert.EqualError(t, err, tt.message)
-				})
-			}
-		})
-
-		t.Run("an ordinary nested schema is accepted", func(t *testing.T) {
-			const content = `{"type":"object","properties":{"address":{"type":"object","properties":{"street":{"type":"string"}}}}}`
-			schema, err := domain.NewJSONSchema(projectID, []byte(content))
-			require.NoError(t, err)
-			require.NotNil(t, schema)
-		})
-	})
-
 	t.Run("a reserved key with a null value is not rejected", func(t *testing.T) {
 		// Characterisation test, not an endorsement: maputil.Get[any] reports a
 		// JSON null as absent, because a type assertion on a nil interface