Merge pull request #38 from firehydrant/add-manual-mappings

Add manual mappings, ignores related to on call schedules, shifts

Author: jonahlstewart

scripts/overlay/manual-mappings.yaml

@@ -52,6 +52,18 @@ operations:
     method: "get"
     action: "ignore"
 
+  # Ignoring create, update, delete operations for on call schedule shifts
+  # These operations should not be supported in the provider, but read to enable the datasource is supported
+  - path: "/v1/teams/{team_id}/on_call_schedules/{schedule_id}/shifts"
+    method: "post"
+    action: "ignore"
+  - path: "/v1/teams/{team_id}/on_call_schedules/{schedule_id}/shifts/{shift_id}"
+    method: "patch"
+    action: "ignore"
+  - path: "/v1/teams/{team_id}/on_call_schedules/{schedule_id}/shifts/{shift_id}"
+    method: "delete"
+    action: "ignore"
+
   # Manual Entity Mappings
   # Signals Event Sources
   - path: "/v1/signals/event_sources/{transposer_slug}"
@@ -148,6 +160,37 @@ operations:
     action: "match"
     value: "team_id:handoff_step.target.id"
 
+    # Signals On Call Schedules
+  - path: "/v1/teams/{team_id}/on_call_schedules/{schedule_id}"
+    method: "get"
+    action: "match"
+    value: "schedule_id:id"
+
+  - path: "/v1/teams/{team_id}/on_call_schedules/{schedule_id}"
+    method: "patch"
+    action: "match"
+    value: "schedule_id:id"
+
+  - path: "/v1/teams/{team_id}/on_call_schedules/{schedule_id}"
+    method: "delete"
+    action: "match"
+    value: "schedule_id:id"
+
+  - path: "/v1/teams/{team_id}/on_call_schedules/{schedule_id}"
+    method: "get"
+    action: "match"
+    value: "team_id:team.id"
+
+  - path: "/v1/teams/{team_id}/on_call_schedules/{schedule_id}"
+    method: "patch"
+    action: "match"
+    value: "team_id:team.id"
+
+  - path: "/v1/teams/{team_id}/on_call_schedules/{schedule_id}"
+    method: "delete"
+    action: "match"
+    value: "team_id:team.id"
+    
 # Task Lists
   - path: "/v1/task_lists"
     method: "get"

scripts/overlay/terraform-viable.go

@@ -164,15 +164,16 @@ func validateOperationParameters(resource *ResourceInfo, primaryID string, schem
 				}
 			} else if isEntityID(param) {
 				// This is another ID-like parameter without manual mapping
-				// Check if it maps to a field in the entity (not the primary id field)
-				if checkFieldExistsInEntityWithRefResolution(param, entityProps, schemas) {
-					// This parameter maps to a real entity field - it's valid
-					continue
-				} else {
-					// This ID parameter doesn't map to any entity field
+				// Only consider it problematic if it conflicts with the primary ID or claims to be this entity's ID
+				if param != primaryID && mapsToEntityID(param, resource.EntityName) {
+					// This parameter claims to be this entity's ID but isn't the primary ID - that's a conflict
 					hasConflictingEntityIDs = true
 					break
 				}
+
+				// For other ID parameters (like team_id, parent_id, etc.), they're just foreign keys
+				// and don't need to exist in the entity schema - they're fine
+				// we weren't able to map them but they don't conflict with the primary ID
 			}
 			// Non-ID parameters are always OK
 		}
@@ -276,42 +277,48 @@ func checkFieldExistsInEntityWithRefResolution(fieldPath string, entityProps map
 	currentLevel := entityProps
 
 	for i, part := range parts {
+
 		if prop, exists := currentLevel[part]; exists {
+
 			if i == len(parts)-1 {
 				return true
 			}
 
 			if propMap, ok := prop.(map[string]interface{}); ok {
+				// Check if it has direct properties
 				if nestedProps, hasProps := propMap["properties"].(map[string]interface{}); hasProps {
 					currentLevel = nestedProps
 					continue
 				}
 
+				// Check if it has a $ref that needs resolution
 				if ref, hasRef := propMap["$ref"].(string); hasRef {
-					if strings.HasPrefix(ref, "#/components/schemas/") {
-						schemaName := strings.TrimPrefix(ref, "#/components/schemas/")
-
-						if referencedSchema, exists := schemas[schemaName]; exists {
-							specData, _ := json.Marshal(referencedSchema)
-							var schemaMap map[string]interface{}
-							json.Unmarshal(specData, &schemaMap)
-
-							if refProps, hasRefProps := schemaMap["properties"].(map[string]interface{}); hasRefProps {
-								currentLevel = refProps
-								continue
-							}
+
+					resolvedSchema := resolveSchemaRef(ref, schemas)
+					if resolvedSchema != nil {
+
+						if refProps, hasRefProps := resolvedSchema["properties"].(map[string]interface{}); hasRefProps {
+							currentLevel = refProps
+							continue
+						} else {
+							fmt.Printf("    Debug: Resolved schema has no properties\n")
 						}
+					} else {
+						fmt.Printf("    Debug: Failed to resolve $ref '%s'\n", ref)
 					}
 
 					fmt.Printf("    Warning: Cannot resolve $ref for nested property validation: %s (ref: %s)\n", fieldPath, ref)
-					return false // We don't want to assume the ref is valid if we can't resolve it
+					return false
 				}
 			}
 
 			// If we can't navigate deeper but haven't reached the end, the path is invalid
+			fmt.Printf("    Debug: Cannot navigate deeper from part '%s' - not a valid object structure\n", part)
 			fmt.Printf("    Cannot navigate to nested property: %s at part: %s\n", fieldPath, part)
 			return false
 		} else {
+			fmt.Printf("    Debug: Part '%s' not found in current level\n", part)
+			fmt.Printf("    Debug: Available keys in current level: %v\n", getKeys(currentLevel))
 			fmt.Printf("    Field does not exist: %s at part: %s\n", fieldPath, part)
 			return false
 		}
@@ -320,6 +327,55 @@ func checkFieldExistsInEntityWithRefResolution(fieldPath string, entityProps map
 	return false
 }
 
+func getKeys(m map[string]interface{}) []string {
+	keys := make([]string, 0, len(m))
+	for k := range m {
+		keys = append(keys, k)
+	}
+	return keys
+}
+
+func resolveSchemaRef(ref string, schemas map[string]interface{}) map[string]interface{} {
+	if !strings.HasPrefix(ref, "#/components/schemas/") {
+		return nil
+	}
+
+	schemaName := strings.TrimPrefix(ref, "#/components/schemas/")
+
+	if referencedSchema, exists := schemas[schemaName]; exists {
+		specData, _ := json.Marshal(referencedSchema)
+		var schemaMap map[string]interface{}
+		json.Unmarshal(specData, &schemaMap)
+
+		// At time of writing we have validation rules which prevent oneOfs in our swagger generation within laddertruck.
+		// So we only have allOf patterns to work with, these are generally created by our NullableWrappers
+		// NullableWrappers are used to allow nullable properties in the API (also created in laddertruck), so we need to resolve them
+		if allOf, hasAllOf := schemaMap["allOf"].([]interface{}); hasAllOf {
+			for _, item := range allOf {
+				if itemMap, ok := item.(map[string]interface{}); ok {
+					if innerRef, hasInnerRef := itemMap["$ref"].(string); hasInnerRef {
+						resolved := resolveSchemaRef(innerRef, schemas)
+						if resolved != nil {
+							return resolved
+						}
+					}
+					if _, hasProps := itemMap["properties"].(map[string]interface{}); hasProps {
+						return itemMap
+					}
+				}
+			}
+		}
+
+		if _, hasProps := schemaMap["properties"].(map[string]interface{}); hasProps {
+			return schemaMap
+		}
+
+		return schemaMap
+	}
+
+	return nil
+}
+
 func identifyEntityPrimaryID(resource *ResourceInfo, schemas map[string]interface{}) (string, bool) {
 	allParams := make(map[string]bool)
 
@@ -380,14 +436,26 @@ func identifyEntityPrimaryID(resource *ResourceInfo, schemas map[string]interfac
 				}
 			}
 		}
-	}
 
-	if allParams["id"] {
-		return "id", true
+		if allParams["id"] {
+			return "id", true
+		}
 	}
 
 	if len(allParams) == 1 && (hasID || hasSlug) {
 		for param := range allParams {
+			if !strings.Contains(param, "team_id") && !strings.Contains(param, "parent_id") {
+				return param, true
+			}
+		}
+	}
+
+	// For complex cases with multiple parameters, try to identify the most likely primary ID
+	// Look for parameters that end with the entity name or are simple "id"
+	entityBase := strings.ToLower(strings.TrimSuffix(resource.EntityName, "Entity"))
+	for param := range allParams {
+		lowerParam := strings.ToLower(param)
+		if lowerParam == entityBase+"_id" || lowerParam == "id" {
 			return param, true
 		}
 	}

scripts/overlay/terraform-viable_test.go

@@ -129,6 +129,13 @@ func TestValidateOperationParameters(t *testing.T) {
 				"name": map[string]interface{}{"type": "string"},
 			},
 		},
+		"TeamEntity": map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"id":   map[string]interface{}{"type": "string"},
+				"name": map[string]interface{}{"type": "string"},
+			},
+		},
 	}
 
 	tests := []struct {
@@ -203,6 +210,28 @@ func TestValidateOperationParameters(t *testing.T) {
 			primaryID: "id",
 			expected:  1, // Only create should be valid
 		},
+		{
+			name: "operations with foreign keys (should be valid)",
+			resource: &ResourceInfo{
+				EntityName: "UserEntity",
+				Operations: map[string]OperationInfo{
+					"create": {
+						Path:   "/teams/{team_id}/users",
+						Method: "post",
+					},
+					"read": {
+						Path:   "/teams/{team_id}/users/{id}",
+						Method: "get",
+					},
+					"update": {
+						Path:   "/teams/{team_id}/users/{id}",
+						Method: "put",
+					},
+				},
+			},
+			primaryID: "id",
+			expected:  3,
+		},
 	}
 
 	for _, tt := range tests {
@@ -440,6 +469,9 @@ func TestCheckFieldExistsInEntityWithRefResolution(t *testing.T) {
 		"settings": map[string]interface{}{
 			"$ref": "#/components/schemas/UserSettings",
 		},
+		"team": map[string]interface{}{
+			"$ref": "#/components/schemas/NullableSuccinctEntity",
+		},
 	}
 
 	schemas := map[string]interface{}{
@@ -449,6 +481,20 @@ func TestCheckFieldExistsInEntityWithRefResolution(t *testing.T) {
 				"theme": map[string]interface{}{"type": "string"},
 			},
 		},
+		"NullableSuccinctEntity": map[string]interface{}{
+			"allOf": []interface{}{
+				map[string]interface{}{
+					"$ref": "#/components/schemas/SuccinctEntity",
+				},
+			},
+		},
+		"SuccinctEntity": map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"id":   map[string]interface{}{"type": "string"},
+				"name": map[string]interface{}{"type": "string"},
+			},
+		},
 	}
 
 	tests := []struct {
@@ -486,6 +532,21 @@ func TestCheckFieldExistsInEntityWithRefResolution(t *testing.T) {
 			fieldPath: "settings.nonexistent",
 			expected:  false,
 		},
+		{
+			name:      "nullable ref field exists",
+			fieldPath: "team.id",
+			expected:  true,
+		},
+		{
+			name:      "nullable ref field exists - name",
+			fieldPath: "team.name",
+			expected:  true,
+		},
+		{
+			name:      "nullable ref field doesn't exist",
+			fieldPath: "team.nonexistent",
+			expected:  false,
+		},
 		{
 			name:      "invalid path",
 			fieldPath: "name.invalid.path",
@@ -589,20 +650,20 @@ func TestIdentifyEntityPrimaryID(t *testing.T) {
 			expectID: false,
 		},
 		{
-			name: "multiple conflicting parameters - fixed",
+			name: "single parameter with foreign key context",
 			resource: &ResourceInfo{
 				EntityName: "UserEntity",
 				Operations: map[string]OperationInfo{
 					"read": {
-						Path: "/users/{user_id}",
+						Path: "/teams/{team_id}/users/{id}",
 					},
 					"update": {
-						Path: "/users/{user_id}", // Fixed: make them the same to not conflict
+						Path: "/teams/{team_id}/users/{id}",
 					},
 				},
 			},
-			expected: "user_id", // Fixed: now they should match
-			expectID: true,      // Fixed: now should find ID
+			expected: "id",
+			expectID: true,
 		},
 	}