chore: fix glob pattern and apply provider resources in batch

Author: adityachoudhari26

cmd/ctrlc/root/apply/cmd.go

@@ -61,31 +61,30 @@ func expandGlob(patterns []string) ([]string, error) {
 		}
 
 		if len(matches) == 0 {
-			// Check if it's a literal file path that exists
-			if _, err := os.Stat(pattern); err == nil {
-				if !seen[pattern] {
-					seen[pattern] = true
-					files = append(files, pattern)
-				}
-			} else {
-				return nil, fmt.Errorf("no files matched pattern: %s", pattern)
-			}
-			continue
+			return nil, fmt.Errorf("no files matched pattern: %s", pattern)
 		}
 
+		added := 0
 		for _, match := range matches {
+			info, err := os.Stat(match)
+			if err != nil || info.IsDir() {
+				continue
+			}
 			if !seen[match] {
 				seen[match] = true
 				files = append(files, match)
+				added++
 			}
 		}
+		if added == 0 {
+			return nil, fmt.Errorf("no files matched pattern: %s", pattern)
+		}
 	}
 
 	return files, nil
 }
 
 func runApply(ctx context.Context, filePatterns []string) error {
-	// Expand glob patterns to file paths
 	files, err := expandGlob(filePatterns)
 	if err != nil {
 		return err
@@ -95,7 +94,6 @@ func runApply(ctx context.Context, filePatterns []string) error {
 		return fmt.Errorf("no files to apply")
 	}
 
-	// Create API client
 	apiURL := viper.GetString("url")
 	apiKey := viper.GetString("api-key")
 	workspace := viper.GetString("workspace")
@@ -107,7 +105,6 @@ func runApply(ctx context.Context, filePatterns []string) error {
 
 	workspaceID := client.GetWorkspaceID(ctx, workspace)
 
-	// Parse all files and collect documents
 	var documents []Document
 	for _, filePath := range files {
 		docs, err := ParseFile(filePath)
@@ -124,30 +121,42 @@ func runApply(ctx context.Context, filePatterns []string) error {
 
 	log.Info("Applying resources", "count", len(documents), "files", len(files))
 
-	// Create document context
 	docCtx := NewDocContext(workspaceID.String(), client)
 	docCtx.Context = ctx
 
-	// Sort documents by Order (lower number = processed first)
-	// Sort documents by Order (higher number = higher priority = processed first)
-	sort.Slice(documents, func(i, j int) bool {
-		return documents[i].Order() > documents[j].Order()
+	var resourceDocs []*ResourceDocument
+	var otherDocs []Document
+	for _, doc := range documents {
+		if rd, ok := doc.(*ResourceDocument); ok {
+			resourceDocs = append(resourceDocs, rd)
+		} else {
+			otherDocs = append(otherDocs, doc)
+		}
+	}
+
+	sort.Slice(otherDocs, func(i, j int) bool {
+		return otherDocs[i].Order() > otherDocs[j].Order()
 	})
 
-	// Apply all documents
 	var results []ApplyResult
-	for _, doc := range documents {
+	for _, doc := range otherDocs {
 		result, err := doc.Apply(docCtx)
 		if err != nil {
 			log.Error("Failed to apply document", "error", err)
 		}
 		results = append(results, result)
 	}
 
-	// Print summary
+	if len(resourceDocs) > 0 {
+		resourceResults, err := applyResourcesBatch(docCtx, resourceDocs)
+		if err != nil {
+			log.Error("Failed to apply resources batch", "error", err)
+		}
+		results = append(results, resourceResults...)
+	}
+
 	printResults(results)
 
-	// Check for errors
 	for _, r := range results {
 		if r.Error != nil {
 			return fmt.Errorf("one or more resources failed to apply")

cmd/ctrlc/root/apply/doc_resource.go

@@ -174,3 +174,112 @@ func (d *ResourceDocument) Delete(ctx *DocContext) (DeleteResult, error) {
 		Name: d.Name,
 	}, fmt.Errorf("delete not implemented for resources")
 }
+
+func applyResourcesBatch(ctx *DocContext, docs []*ResourceDocument) ([]ApplyResult, error) {
+	providerGroups := make(map[string][]*ResourceDocument)
+	for _, doc := range docs {
+		providerName := doc.Provider
+		if providerName == "" {
+			providerName = "ctrlc-apply"
+		}
+		providerGroups[providerName] = append(providerGroups[providerName], doc)
+	}
+
+	var results []ApplyResult
+
+	for providerName, groupDocs := range providerGroups {
+		groupResults, err := applyProviderResources(ctx, providerName, groupDocs)
+		if err != nil {
+			for _, doc := range groupDocs {
+				results = append(results, ApplyResult{
+					Type:  TypeResource,
+					Name:  doc.Name,
+					Error: err,
+				})
+			}
+			continue
+		}
+		results = append(results, groupResults...)
+	}
+
+	return results, nil
+}
+
+func applyProviderResources(ctx *DocContext, providerName string, docs []*ResourceDocument) ([]ApplyResult, error) {
+	providerID, err := getProviderIDByName(ctx, providerName)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get resource provider: %w", err)
+	}
+
+	resources := make([]api.ResourceProviderResource, 0, len(docs))
+	for _, doc := range docs {
+		metadata := doc.Metadata
+		if metadata == nil {
+			metadata = make(map[string]string)
+		}
+		config := doc.Config
+		if config == nil {
+			config = make(map[string]any)
+		}
+
+		resources = append(resources, api.ResourceProviderResource{
+			Identifier: doc.Identifier,
+			Name:       doc.Name,
+			Kind:       doc.Kind,
+			Version:    doc.Version,
+			Config:     config,
+			Metadata:   metadata,
+		})
+	}
+
+	resp, err := ctx.Client.SetResourceProvidersResourcesPatchWithResponse(ctx.Context, ctx.WorkspaceID, providerID, api.SetResourceProvidersResourcesPatchJSONRequestBody{
+		Resources: resources,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("failed to upsert resources: %w", err)
+	}
+
+	if resp.JSON202 == nil {
+		return nil, fmt.Errorf("failed to upsert resources: %s", string(resp.Body))
+	}
+
+	var results []ApplyResult
+	for _, doc := range docs {
+		result := ApplyResult{
+			Type:   TypeResource,
+			Name:   doc.Name,
+			ID:     doc.Identifier,
+			Action: "upserted",
+		}
+
+		if err := doc.syncVariables(ctx); err != nil {
+			result.Error = fmt.Errorf("failed to sync resource variables: %w", err)
+		}
+
+		results = append(results, result)
+	}
+
+	return results, nil
+}
+
+func getProviderIDByName(ctx *DocContext, providerName string) (string, error) {
+	providerResp, err := ctx.Client.GetResourceProviderByNameWithResponse(ctx.Context, ctx.WorkspaceID, providerName)
+	if err != nil {
+		return "", fmt.Errorf("failed to get resource provider: %w", err)
+	}
+
+	if providerResp.JSON200 != nil {
+		return providerResp.JSON200.Id, nil
+	}
+
+	createResp, err := ctx.Client.UpsertResourceProviderWithResponse(ctx.Context, ctx.WorkspaceID, api.UpsertResourceProviderJSONRequestBody{
+		Name: providerName,
+	})
+	if err != nil {
+		return "", fmt.Errorf("failed to create resource provider: %w", err)
+	}
+	if createResp.JSON200 == nil {
+		return "", fmt.Errorf("failed to create resource provider: %s", string(createResp.Body))
+	}
+	return createResp.JSON200.Id, nil
+}