chore: migrate types to its own package

cmd/tftemplate/datasource.go.tmpl

@@ -39,8 +39,8 @@ func dataSourceScaleway{{.Resource}}Read(ctx context.Context, d *schema.Resource
     if !{{.ResourceCleanLow}}IDExists {
         res, err := api.List{{.ResourceClean}}s(&{{.API}}.List{{.ResourceClean}}sRequest{
             {{.LocalityUpper}}:     {{.Locality}},
-            Name:       expandStringPtr(d.Get("name")),
-            ProjectID:  expandStringPtr(d.Get("project_id")),
+            Name:       types.ExpandStringPtr(d.Get("name")),
+            ProjectID:  types.ExpandStringPtr(d.Get("project_id")),
         })
         if err != nil {
             return diag.FromErr(err)

cmd/tftemplate/resource.go.tmpl

@@ -42,7 +42,7 @@ func resourceScaleway{{ .Resource }}Create(ctx context.Context, d *schema.Resour
 	{{ .ResourceCleanLow }}, err := api.Create{{ .ResourceClean }}(&{{ .API }}.Create{{ .ResourceClean }}Request{
 		{{.LocalityUpper}}: {{.Locality}},
 		ProjectID: d.Get("project_id").(string),
-		Name: expandOrGenerateString(d.Get("name").(string), "{{ .ResourceCleanLow }}"),
+		Name: types.ExpandOrGenerateString(d.Get("name").(string), "{{ .ResourceCleanLow }}"),
 	}, scw.WithContext(ctx))
 	if err != nil {
 		return diag.FromErr(err)
@@ -109,7 +109,7 @@ func resourceScaleway{{ .Resource }}Update(ctx context.Context, d *schema.Resour
 	}
 
 	if d.HasChange("name") {
-		req.Name = expandUpdatedStringPtr(d.Get("name"))
+		req.Name = types.ExpandUpdatedStringPtr(d.Get("name"))
 	}
 
 	if _, err := api.Update{{ .ResourceClean }}(req, scw.WithContext(ctx)); err != nil {

internal/types/bool.go

@@ -0,0 +1,17 @@
+package types
+
+import "github.com/scaleway/scaleway-sdk-go/scw"
+
+func FlattenBoolPtr(b *bool) interface{} {
+	if b == nil {
+		return nil
+	}
+	return *b
+}
+
+func ExpandBoolPtr(data interface{}) *bool {
+	if data == nil {
+		return nil
+	}
+	return scw.BoolPtr(data.(bool))
+}

internal/types/ip.go

@@ -0,0 +1,38 @@
+package types
+
+import (
+	"encoding/json"
+	"fmt"
+	"net"
+	"strconv"
+
+	"github.com/scaleway/scaleway-sdk-go/scw"
+)
+
+func ExpandIPNet(raw string) (scw.IPNet, error) {
+	if raw == "" {
+		return scw.IPNet{}, nil
+	}
+	var ipNet scw.IPNet
+	err := json.Unmarshal([]byte(strconv.Quote(raw)), &ipNet)
+	if err != nil {
+		return scw.IPNet{}, fmt.Errorf("%s could not be marshaled: %v", raw, err)
+	}
+
+	return ipNet, nil
+}
+
+func FlattenIPPtr(ip *net.IP) interface{} {
+	if ip == nil {
+		return ""
+	}
+	return ip.String()
+}
+
+func FlattenIPNet(ipNet scw.IPNet) (string, error) {
+	raw, err := json.Marshal(ipNet)
+	if err != nil {
+		return "", err
+	}
+	return string(raw[1 : len(raw)-1]), nil // remove quotes
+}

internal/types/map.go

@@ -0,0 +1,60 @@
+package types
+
+func FlattenMap(m map[string]string) interface{} {
+	if m == nil {
+		return nil
+	}
+	flattenedMap := make(map[string]interface{})
+	for k, v := range m {
+		flattenedMap[k] = v
+	}
+	return flattenedMap
+}
+
+func FlattenMapStringStringPtr(m map[string]*string) interface{} {
+	if m == nil {
+		return nil
+	}
+	flattenedMap := make(map[string]interface{})
+	for k, v := range m {
+		if v != nil {
+			flattenedMap[k] = *v
+		} else {
+			flattenedMap[k] = ""
+		}
+	}
+	return flattenedMap
+}
+
+func ExpandMapPtrStringString(data interface{}) *map[string]string {
+	if data == nil {
+		return nil
+	}
+	m := make(map[string]string)
+	for k, v := range data.(map[string]interface{}) {
+		m[k] = v.(string)
+	}
+	return &m
+}
+
+func ExpandMapStringStringPtr(data interface{}) map[string]*string {
+	if data == nil {
+		return nil
+	}
+	m := make(map[string]*string)
+	for k, v := range data.(map[string]interface{}) {
+		m[k] = ExpandStringPtr(v)
+	}
+	return m
+}
+
+func ExpandMapStringString(data any) map[string]string {
+	if data == nil {
+		return nil
+	}
+	m := make(map[string]string)
+	for k, v := range data.(map[string]interface{}) {
+		m[k] = v.(string)
+	}
+	return m
+}

internal/types/number.go

@@ -0,0 +1,31 @@
+package types
+
+import "github.com/scaleway/scaleway-sdk-go/scw"
+
+func FlattenInt32Ptr(i *int32) interface{} {
+	if i == nil {
+		return 0
+	}
+	return *i
+}
+
+func FlattenUint32Ptr(i *uint32) interface{} {
+	if i == nil {
+		return 0
+	}
+	return *i
+}
+
+func ExpandInt32Ptr(data interface{}) *int32 {
+	if data == nil || data == "" {
+		return nil
+	}
+	return scw.Int32Ptr(int32(data.(int)))
+}
+
+func ExpandUint32Ptr(data interface{}) *uint32 {
+	if data == nil || data == "" {
+		return nil
+	}
+	return scw.Uint32Ptr(uint32(data.(int)))
+}

internal/types/scw.go

@@ -0,0 +1,10 @@
+package types
+
+import "github.com/scaleway/scaleway-sdk-go/scw"
+
+func FlattenSize(size *scw.Size) interface{} {
+	if size == nil {
+		return 0
+	}
+	return *size
+}

internal/types/string.go

@@ -0,0 +1,155 @@
+package types
+
+import (
+	"github.com/scaleway/scaleway-sdk-go/namegenerator"
+	"github.com/scaleway/scaleway-sdk-go/scw"
+	"github.com/scaleway/terraform-provider-scaleway/v2/internal/locality"
+	"github.com/scaleway/terraform-provider-scaleway/v2/internal/locality/zonal"
+)
+
+func FlattenStringPtr(s *string) interface{} {
+	if s == nil {
+		return ""
+	}
+	return *s
+}
+
+func ExpandStringPtr(data interface{}) *string {
+	if data == nil || data == "" {
+		return nil
+	}
+	return scw.StringPtr(data.(string))
+}
+
+// NewRandomName returns a random name prefixed for terraform.
+func NewRandomName(prefix string) string {
+	return namegenerator.GetRandomName("tf", prefix)
+}
+
+func ExpandOrGenerateString(data interface{}, prefix string) string {
+	if data == nil || data == "" {
+		return NewRandomName(prefix)
+	}
+	return data.(string)
+}
+
+func ExpandStringWithDefault(data interface{}, defaultValue string) string {
+	if data == nil || data.(string) == "" {
+		return defaultValue
+	}
+	return data.(string)
+}
+
+func ExpandSliceStringPtr(data interface{}) []*string {
+	if data == nil {
+		return nil
+	}
+	stringSlice := []*string(nil)
+	for _, s := range data.([]interface{}) {
+		stringSlice = append(stringSlice, ExpandStringPtr(s))
+	}
+	return stringSlice
+}
+
+func FlattenSliceStringPtr(s []*string) interface{} {
+	res := make([]interface{}, 0, len(s))
+	for _, strPtr := range s {
+		res = append(res, FlattenStringPtr(strPtr))
+	}
+	return res
+}
+
+func FlattenSliceString(s []string) interface{} {
+	res := make([]interface{}, 0, len(s))
+	for _, strPtr := range s {
+		res = append(res, strPtr)
+	}
+	return res
+}
+
+func ExpandUpdatedStringPtr(data interface{}) *string {
+	str := ""
+	if data != nil {
+		str = data.(string)
+	}
+	return &str
+}
+
+func ExpandStrings(data interface{}) []string {
+	stringSlice := make([]string, 0, len(data.([]interface{})))
+	for _, s := range data.([]interface{}) {
+		// zero-value is nil, ["foo", ""]
+		if s == nil {
+			s = ""
+		}
+		stringSlice = append(stringSlice, s.(string))
+	}
+	return stringSlice
+}
+
+func ExpandStringsPtr(data interface{}) *[]string {
+	stringSlice := make([]string, 0, len(data.([]interface{})))
+	if _, ok := data.([]interface{}); !ok || data == nil {
+		return nil
+	}
+	for _, s := range data.([]interface{}) {
+		// zero-value is nil, ["foo", ""]
+		if s == nil {
+			s = ""
+		}
+		stringSlice = append(stringSlice, s.(string))
+	}
+	if len(stringSlice) == 0 {
+		return nil
+	}
+
+	return &stringSlice
+}
+
+// ExpandUpdatedStringsPtr expands a string slice but will default to an empty list.
+// Should be used on schema update so emptying a list will update resource.
+func ExpandUpdatedStringsPtr(data interface{}) *[]string {
+	stringSlice := []string{}
+	if _, ok := data.([]interface{}); !ok || data == nil {
+		return &stringSlice
+	}
+	for _, s := range data.([]interface{}) {
+		// zero-value is nil, ["foo", ""]
+		if s == nil {
+			s = ""
+		}
+		stringSlice = append(stringSlice, s.(string))
+	}
+	return &stringSlice
+}
+
+func ExpandSliceIDsPtr(rawIDs interface{}) *[]string {
+	stringSlice := make([]string, 0, len(rawIDs.([]interface{})))
+	if _, ok := rawIDs.([]interface{}); !ok || rawIDs == nil {
+		return &stringSlice
+	}
+	for _, s := range rawIDs.([]interface{}) {
+		stringSlice = append(stringSlice, locality.ExpandID(s.(string)))
+	}
+	return &stringSlice
+}
+
+func ExpandStringsOrEmpty(data interface{}) []string {
+	stringSlice := make([]string, 0, len(data.([]interface{})))
+	if _, ok := data.([]interface{}); !ok || data == nil {
+		return stringSlice
+	}
+	for _, s := range data.([]interface{}) {
+		stringSlice = append(stringSlice, s.(string))
+	}
+	return stringSlice
+}
+
+func FlattenSliceIDs(certificates []string, zone scw.Zone) interface{} {
+	res := []interface{}(nil)
+	for _, certificateID := range certificates {
+		res = append(res, zonal.NewIDString(zone, certificateID))
+	}
+
+	return res
+}

internal/types/string_test.go

@@ -0,0 +1,14 @@
+package types_test
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/scaleway/terraform-provider-scaleway/v2/internal/types"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestGetRandomName(t *testing.T) {
+	name := types.NewRandomName("test")
+	assert.True(t, strings.HasPrefix(name, "tf-test-"))
+}

internal/types/time.go

@@ -0,0 +1,28 @@
+package types
+
+import "time"
+
+func FlattenDuration(duration *time.Duration) interface{} {
+	if duration != nil {
+		return duration.String()
+	}
+	return ""
+}
+
+func ExpandDuration(data interface{}) (*time.Duration, error) {
+	if data == nil || data == "" {
+		return nil, nil
+	}
+	d, err := time.ParseDuration(data.(string))
+	if err != nil {
+		return nil, err
+	}
+	return &d, nil
+}
+
+func FlattenTime(date *time.Time) interface{} {
+	if date != nil {
+		return date.Format(time.RFC3339)
+	}
+	return ""
+}