🐛 fetching VPC endpoint services (#5336)

* 🐛 fetching VPC endpoint services

This change uses the API `DescribeVpcEndpoints()` to fetch information
about endpoint services and delays loading of additional data for when
it is accessed.

Fixes #5318

Signed-off-by: Salim Afiune Maya <afiune@mondoo.com>

* 🐛 service endpoints are owned by Amazon

Signed-off-by: Salim Afiune Maya <afiune@mondoo.com>

---------

Signed-off-by: Salim Afiune Maya <afiune@mondoo.com>

Author: afiune

providers-sdk/v1/util/convert/into_generic.go

@@ -0,0 +1,46 @@
+// Copyright (c) Mondoo, Inc.
+// SPDX-License-Identifier: BUSL-1.1
+
+package convert
+
+// Func defines a function type that converts an element of type T to V.
+type Func[T any, V any] func(T) V
+
+// Into converts a slice of type `T` to a slice of type `V` by applying the
+// convert function `Func`.
+//
+// Example usage:
+//
+//  1. Convert a slice of integers to a slice of strings:
+//
+//     ints := []int{1, 2, 3}
+//     strs := Into(ints, func(i int) string {
+//     return fmt.Sprintf("%d", i)
+//     })
+//
+//     // Output: []string{"1", "2", "3"}
+//
+//  2. Convert a slice of structs into a slice of strings:
+//
+//     type Person struct {
+//     Name string
+//     Age  int
+//     }
+//
+//     people := []Person{
+//     {Name: "Alice", Age: 30},
+//     {Name: "Bob", Age: 25},
+//     }
+//
+//     names := Into(people, func(p Person) string {
+//     return p.Name
+//     })
+//
+//     // Output: []string{"Alice", "Bob"}
+func Into[T any, V any](sliceT []T, convertFn Func[T, V]) []V {
+	sliceV := make([]V, len(sliceT))
+	for i, item := range sliceT {
+		sliceV[i] = convertFn(item)
+	}
+	return sliceV
+}

providers-sdk/v1/util/convert/into_generic_test.go

@@ -0,0 +1,116 @@
+// Copyright (c) Mondoo, Inc.
+// SPDX-License-Identifier: BUSL-1.1
+
+package convert_test
+
+import (
+	"strconv"
+	"testing"
+
+	"go.mondoo.com/cnquery/v11/providers-sdk/v1/util/convert"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestInto(t *testing.T) {
+	t.Run("Convert int to string", func(t *testing.T) {
+		input := []int{1, 2, 3, 4, 5}
+		output := convert.Into(input, func(i int) string {
+			return strconv.Itoa(i)
+		})
+		expected := []string{"1", "2", "3", "4", "5"}
+		assert.Equal(t, expected, output)
+	})
+
+	t.Run("Convert float64 to string", func(t *testing.T) {
+		input := []float64{1.1, 2.2, 3.3}
+		output := convert.Into(input, func(f float64) string {
+			return strconv.FormatFloat(f, 'f', 1, 64)
+		})
+		expected := []string{"1.1", "2.2", "3.3"}
+		assert.Equal(t, expected, output)
+	})
+
+	t.Run("Convert struct to string", func(t *testing.T) {
+		type Person struct {
+			Name string
+		}
+		input := []Person{{"Alice"}, {"Bob"}, {"Charlie"}}
+		output := convert.Into(input, func(p Person) string {
+			return p.Name
+		})
+		expected := []string{"Alice", "Bob", "Charlie"}
+		assert.Equal(t, expected, output)
+	})
+
+	t.Run("Convert string to int", func(t *testing.T) {
+		input := []string{"10", "20", "30"}
+		output := convert.Into(input, func(s string) int {
+			i, _ := strconv.Atoi(s)
+			return i
+		})
+		expected := []int{10, 20, 30}
+		assert.Equal(t, expected, output)
+	})
+
+	t.Run("Convert bool to string", func(t *testing.T) {
+		input := []bool{true, false, true}
+		output := convert.Into(input, func(b bool) string {
+			return strconv.FormatBool(b)
+		})
+		expected := []string{"true", "false", "true"}
+		assert.Equal(t, expected, output)
+	})
+
+	t.Run("Handle empty slice", func(t *testing.T) {
+		input := []int{}
+		output := convert.Into(input, func(i int) string {
+			return strconv.Itoa(i)
+		})
+		expected := []string{}
+		assert.Equal(t, expected, output)
+	})
+
+	t.Run("Handle nil slice", func(t *testing.T) {
+		var input []int
+		output := convert.Into(input, func(i int) string {
+			return strconv.Itoa(i)
+		})
+		assert.Empty(t, output)
+	})
+
+	t.Run("Identity function", func(t *testing.T) {
+		input := []string{"apple", "banana", "cherry"}
+		output := convert.Into(input, func(s string) string {
+			return s
+		})
+		expected := []string{"apple", "banana", "cherry"}
+		assert.Equal(t, expected, output)
+	})
+
+	t.Run("Convert complex numbers to string", func(t *testing.T) {
+		input := []complex128{1 + 2i, 3 + 4i}
+		output := convert.Into(input, func(c complex128) string {
+			return strconv.FormatComplex(c, 'f', 1, 128)
+		})
+		expected := []string{"(1.0+2.0i)", "(3.0+4.0i)"}
+		assert.Equal(t, expected, output)
+	})
+
+	t.Run("Convert nested struct", func(t *testing.T) {
+		type Outer struct {
+			Inner struct {
+				Value string
+			}
+		}
+		input := []Outer{
+			{Inner: struct{ Value string }{"one"}},
+			{Inner: struct{ Value string }{"two"}},
+		}
+		output := convert.Into(input, func(o Outer) string {
+			return o.Inner.Value
+		})
+		expected := []string{"one", "two"}
+		assert.Equal(t, expected, output)
+	})
+}

providers/aws/resources/aws.lr

@@ -2754,31 +2754,31 @@ private aws.vpc.natgateway.address {
 // Amazon VPC Service Endpoint
 private aws.vpc.serviceEndpoint {
   // Whether acceptance is required
-  acceptanceRequired bool
+  acceptanceRequired() bool
   // List of availability zones for the service endpoint
-  availabilityZones []string
+  availabilityZones() []string
   // List of base endpoint DNS names for the service endpoint
   dnsNames []string
   // Service ID
   id string
   // Whether the service endpoint manages VPC endpoints
-  managesVpcEndpoints bool
+  managesVpcEndpoints() bool
   // Service name
   name string
   // Service owner
   owner string
   // Service payer responsibility
-  payerResponsibility string
+  payerResponsibility() string
   // Service private DNS name verification state
-  privateDnsNameVerificationState string
+  privateDnsNameVerificationState() string
   // List of service private DNS names
-  privateDnsNames []string
+  privateDnsNames() []string
   // Tags for the service endpoint
   tags map[string]string
   // Service type
   type string
   // Whether the service supports VPC endpoint policy
-  vpcEndpointPolicySupported bool
+  vpcEndpointPolicySupported() bool
 }
 
 // Amazon VPC Peering Connection