fix: validate deploying module rather than entire schema

backend/controller/controller.go

@@ -715,7 +715,7 @@ func (s *Service) CreateDeployment(ctx context.Context, req *connect.Request[ftl
 		logger.Errorf(err, "Invalid module schema")
 		return nil, fmt.Errorf("%s: %w", "invalid module schema", err)
 	}
-	module, err = s.validateWholeSchema(ctx, module)
+	module, err = s.validateModuleSchema(ctx, module)
 	if err != nil {
 		logger.Errorf(err, "Invalid module schema")
 		return nil, fmt.Errorf("%s: %w", "invalid module schema", err)
@@ -732,16 +732,17 @@ func (s *Service) CreateDeployment(ctx context.Context, req *connect.Request[ftl
 	return connect.NewResponse(&ftlv1.CreateDeploymentResponse{DeploymentKey: dname.String()}), nil
 }
 
-// Load schemas for existing modules, combine with our new one, and validate as a whole.
-func (s *Service) validateWholeSchema(ctx context.Context, module *schema.Module) (*schema.Module, error) {
+// Load schemas for existing modules, combine with our new one, and validate the new module in the context
+// of the whole schema.
+func (s *Service) validateModuleSchema(ctx context.Context, module *schema.Module) (*schema.Module, error) {
 	existingModules, err := s.dal.GetActiveDeploymentSchemas(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", "could not get existing schemas", err)
 	}
 	schemaMap := ftlmaps.FromSlice(existingModules, func(el *schema.Module) (string, *schema.Module) { return el.Name, el })
 	schemaMap[module.Name] = module
 	fullSchema := &schema.Schema{Modules: maps.Values(schemaMap)}
-	schema, err := schema.Validate(fullSchema)
+	schema, err := schema.ValidateModuleInSchema(fullSchema, optional.Some[*schema.Module](module))
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", "invalid schema", err)
 	}
@@ -1133,7 +1134,7 @@ func (s *Service) getActiveSchema(ctx context.Context) (*schema.Schema, error) {
 	if err != nil {
 		return nil, err
 	}
-	return schema.Validate(&schema.Schema{
+	return schema.ValidateSchema(&schema.Schema{
 		Modules: slices.Map(deployments, func(d dal.Deployment) *schema.Module {
 			return d.Schema
 		}),

backend/schema/parser.go

@@ -168,7 +168,7 @@ func ParseString(filename, input string) (*Schema, error) {
 	if err != nil {
 		return nil, err
 	}
-	return Validate(mod)
+	return ValidateSchema(mod)
 }
 
 func ParseModuleString(filename, input string) (*Module, error) {
@@ -184,7 +184,7 @@ func Parse(filename string, r io.Reader) (*Schema, error) {
 	if err != nil {
 		return nil, err
 	}
-	return Validate(mod)
+	return ValidateSchema(mod)
 }
 
 func ParseModule(filename string, r io.Reader) (*Module, error) {

backend/schema/schema.go

@@ -141,5 +141,5 @@ func FromProto(s *schemapb.Schema) (*Schema, error) {
 	schema := &Schema{
 		Modules: modules,
 	}
-	return Validate(schema)
+	return ValidateSchema(schema)
 }

backend/schema/schema_test.go

@@ -154,7 +154,7 @@ Module
 func TestParserRoundTrip(t *testing.T) {
 	actual, err := ParseString("", testSchema.String())
 	assert.NoError(t, err, "%s", testSchema.String())
-	actual, err = Validate(actual)
+	actual, err = ValidateSchema(actual)
 	assert.NoError(t, err)
 	assert.Equal(t, Normalise(testSchema), Normalise(actual))
 }

backend/schema/validate.go

@@ -38,15 +38,21 @@ var (
 //
 // This is useful for testing.
 func MustValidate(schema *Schema) *Schema {
-	clone, err := Validate(schema)
+	clone, err := ValidateSchema(schema)
 	if err != nil {
 		panic(err)
 	}
 	return clone
 }
 
-// Validate clones, normalises and semantically valies a schema.
-func Validate(schema *Schema) (*Schema, error) {
+// ValidateSchema clones, normalises and semantically validates a schema.
+func ValidateSchema(schema *Schema) (*Schema, error) {
+	return ValidateModuleInSchema(schema, optional.None[*Module]())
+}
+
+// ValidateModuleInSchema clones and normalises a schema and semantically validates a single module within it.
+// If no module is provided, all modules in the schema are validated.
+func ValidateModuleInSchema(schema *Schema, m optional.Option[*Module]) (*Schema, error) {
 	schema = dc.DeepCopy(schema)
 	modules := map[string]bool{}
 	merr := []error{}
@@ -81,6 +87,10 @@ func Validate(schema *Schema) (*Schema, error) {
 		if module.Name == "builtin" {
 			continue
 		}
+		if v, ok := m.Get(); ok && v.Name != module.Name {
+			// Don't validate other modules when validating a single module.
+			continue
+		}
 
 		if _, seen := modules[module.Name]; seen {
 			merr = append(merr, errorf(module, "duplicate module %q", module.Name))