updated airtablepat error checking, table shape

pkg/analyzer/analyzers/airtable/airtablepat/airtable.go

@@ -48,10 +48,16 @@
 	scopeStatusMap[common.PermissionStrings[common.UserEmailRead]] = userInfo.Email != nil
 
 	var basesInfo *common.AirtableBases
-	if granted, _ := determineScope(token, common.SchemaBasesRead, nil); granted {
-		basesInfo, _ = common.FetchAirtableBases(token)
+	if granted, err := determineScope(token, common.SchemaBasesRead, nil); granted {
+		if err != nil {
+			return nil, err
+		}
+		basesInfo, err = common.FetchAirtableBases(token)
+		if err != nil {
+			return nil, err
+		}
 		// If bases are fetched, determine the token scopes
 		determineScopes(token, basesInfo)
 	}
 
 	return mapToAnalyzerResult(userInfo, basesInfo), nil
@@ -74,7 +80,7 @@
 			return
 		}
 		basesInfo, _ = common.FetchAirtableBases(token)
 		determineScopes(token, basesInfo)
 	}
 
 	color.Green("[!] Valid Airtable Personal Access Token\n\n")
@@ -124,35 +130,52 @@
 	return true, nil
 }
 
-func determineScopes(token string, basesInfo *common.AirtableBases) {
+func determineScopes(token string, basesInfo *common.AirtableBases) error {
 	if basesInfo != nil && len(basesInfo.Bases) > 0 {
 		for _, base := range basesInfo.Bases {
 			if base.Schema != nil && len(base.Schema.Tables) > 0 {
 				ids := map[string]string{"baseID": base.ID}
 				tableScopesDetermined := false
 
 				// Verify token "webhooks:manage" permission
-				determineScope(token, common.WebhookManage, ids)
+				_, err := determineScope(token, common.WebhookManage, ids)
+				if err != nil {
+					return err
+				}
 				// Verify token "block:manage" permission
-				determineScope(token, common.BlockManage, ids)
+				_, err = determineScope(token, common.BlockManage, ids)
+				if err != nil {
+					return err
+				}
 
 				// Verifying scopes that require an existing table
 				for _, table := range base.Schema.Tables {
 					ids["tableID"] = table.ID
 
 					if !tableScopesDetermined {
-						determineScope(token, common.SchemaBasesWrite, ids)
-						determineScope(token, common.DataRecordsWrite, ids)
+						_, err = determineScope(token, common.SchemaBasesWrite, ids)
+						if err != nil {
+							return err
+						}
+						_, err = determineScope(token, common.DataRecordsWrite, ids)
+						if err != nil {
+							return err
+						}
 						tableScopesDetermined = true
 					}
 
-					if granted, _ := determineScope(token, common.DataRecordsRead, ids); granted {
+					if granted, err := determineScope(token, common.DataRecordsRead, ids); err != nil {
+						return err
+					} else if granted {
 						// Verifying scopes that require an existing record and record read permission
 						records, err := fetchAirtableRecords(token, base.ID, table.ID)
 						if err != nil || len(records) > 0 {
 							for _, record := range records {
 								ids["recordID"] = record.ID
-								determineScope(token, common.DataRecordcommentsRead, ids)
+								_, err = determineScope(token, common.DataRecordcommentsRead, ids)
+								if err != nil {
+									return err
+								}
 								break
 							}
 							break
@@ -162,6 +185,7 @@
 			}
 		}
 	}
+	return nil
 }
 
 func mapToAnalyzerResult(userInfo *common.AirtableUserInfo, basesInfo *common.AirtableBases) *analyzers.AnalyzerResult {

pkg/analyzer/analyzers/airtable/airtablepat/requests.go

@@ -13,27 +13,6 @@ type AirtableRecordsResponse struct {
 	Records []common.AirtableEntity `json:"records"`
 }
 
-func fetchBaseSchema(baseID, token string) (*common.Schema, error) {
-	endpoint := getEndpoint(common.GetBaseSchemaEndpoint)
-	url := strings.Replace(endpoint.URL, "{baseID}", baseID, -1)
-	resp, err := common.CallAirtableAPI(token, endpoint.Method, url)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		return nil, fmt.Errorf("failed to fetch schema for base %s, status: %d", baseID, resp.StatusCode)
-	}
-
-	var schema common.Schema
-	if err := json.NewDecoder(resp.Body).Decode(&schema); err != nil {
-		return nil, err
-	}
-
-	return &schema, nil
-}
-
 func fetchAirtableRecords(token string, baseID string, tableID string) ([]common.AirtableEntity, error) {
 	endpoint := getEndpoint(common.ListRecordsEndpoint)
 	url := strings.Replace(strings.Replace(endpoint.URL, "{baseID}", baseID, -1), "{tableID}", tableID, -1)

pkg/analyzer/analyzers/airtable/common/common.go

@@ -173,6 +173,7 @@ func PrintUserAndPermissions(info *AirtableUserInfo, scopeStatusMap map[string]b
 			t2.AppendRow(table.Row{color.GreenString(scopeString), color.GreenString(permission), color.GreenString(scopeStatus)})
 			scopeStatus = ""
 		}
+		t2.AppendSeparator()
 	}
 	t2.Render()
 	fmt.Printf("%s: https://airtable.com/developers/web/api/scopes\n", color.GreenString("Ref"))