feat(rdb): add support for database

docs/data-sources/rdb_database.md

@@ -0,0 +1,38 @@
+---
+layout: "scaleway"
+page_title: "Scaleway: scaleway_rdb_database"
+description: |-
+  Gets information about an RDB database.
+---
+
+# scaleway_rdb_database
+
+Gets information about a RDB database.
+
+## Example Usage
+
+```hcl
+# Get the database foobar hosted on instance id 11111111-1111-1111-1111-111111111111
+data "scaleway_rdb_database" "my_db" {
+  instance_id = "11111111-1111-1111-1111-111111111111"
+  name        = "foobar"
+}
+```
+
+## Argument Reference
+
+- `instance_id` - (Required) The RDB instance ID.
+
+- `name` - (Required) The name of the RDB instance.
+
+- `region` - (Defaults to [provider](../index.md#region) `region`) The [region](../guides/regions_and_zones.md#zones) in which the RDB instance exists.
+
+- `organization_id` - (Defaults to [provider](../index.md#organization_id) `organization_id`) The ID of the organization the RDB instance is in.
+
+## Attributes Reference
+
+In addition to all arguments above, the following attributes are exported:
+
+- `owner` - The name of the owner of the database.
+- `managed` - Whether or not the database is managed or not.
+- `size` - Size of the database (in bytes).

docs/data-sources/rdb_instance.md

@@ -12,12 +12,12 @@ Gets information about a RDB instance.
 ## Example Usage
 
 ```hcl
-# Get info by IP address
+# Get info by name
 data "scaleway_rdb_instance" "my_instance" {
   name = "foobar"
 }
 
-# Get info by IP ID
+# Get info by instance ID
 data "scaleway_rdb_instance" "my_instance" {
   instance_id = "11111111-1111-1111-1111-111111111111"
 }

docs/resources/rdb_database.md

@@ -0,0 +1,47 @@
+---
+page_title: "Scaleway: scaleway_rdb_database"
+description: |-
+  Manages Scaleway RDB Database.
+---
+
+# scaleway_rdb_database
+
+Creates and manages Scaleway RDB database.
+For more information, see [the documentation](https://developers.scaleway.com/en/products/rdb/api).
+
+## Examples
+
+### Basic
+
+```hcl
+resource "scaleway_rdb_database" "main" {
+  instance_id    = scaleway_rdb_instance.main.id
+  name           = "my-new-database"
+}
+```
+
+## Arguments Reference
+
+The following arguments are supported:
+
+- `instance_id` - (Required) UUID of the instance where to create the database.
+
+~> **Important:** Updates to `instance_id` will recreate the Database.
+
+- `name` - (Required) Name of the database (e.g. `my-new-database`).
+
+## Attributes Reference
+
+In addition to all arguments above, the following attributes are exported:
+
+- `owner` - The name of the owner of the database.
+- `managed` - Whether or not the database is managed or not.
+- `size` - Size of the database (in bytes).
+
+## Import
+
+RDB Database can be imported using the `{region}/{id}/{DBNAME}`, e.g.
+
+```bash
+$ terraform import scaleway_rdb_database.rdb01_mydb fr-par/11111111-1111-1111-1111-111111111111/mydb
+```

scaleway/data_source_rdb_database.go

@@ -0,0 +1,43 @@
+package scaleway
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+)
+
+func dataSourceScalewayRDBDatabase() *schema.Resource {
+	// Generate datasource schema from resource
+	dsSchema := datasourceSchemaFromResourceSchema(resourceScalewayRdbDatabase().Schema)
+
+	fixDatasourceSchemaFlags(dsSchema, true, "instance_id", "name")
+
+	return &schema.Resource{
+		ReadContext: dataSourceScalewayRDBDatabaseRead,
+		Schema:      dsSchema,
+	}
+}
+
+func dataSourceScalewayRDBDatabaseRead(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	_, region, err := rdbAPIWithRegion(d, meta)
+	if err != nil {
+		return diag.FromErr(err)
+	}
+	instanceID, _ := d.GetOk("instance_id")
+	dbName, _ := d.GetOk("name")
+
+	_, _, err = parseLocalizedID(instanceID.(string))
+	regionalID := instanceID
+	if err != nil {
+		regionalID = datasourceNewRegionalizedID(instanceID, region)
+	}
+
+	d.SetId(fmt.Sprintf("%s/%s", regionalID, dbName.(string)))
+	err = d.Set("instance_id", regionalID)
+	if err != nil {
+		return diag.FromErr(err)
+	}
+	return resourceScalewayRdbDatabaseRead(ctx, d, meta)
+}

scaleway/data_source_rdb_database_test.go

@@ -0,0 +1,56 @@
+package scaleway
+
+import (
+	"testing"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
+)
+
+func TestAccScalewayDataSourceRdbDatabase_Basic(t *testing.T) {
+	tt := NewTestTools(t)
+	defer tt.Cleanup()
+	resource.ParallelTest(t, resource.TestCase{
+		PreCheck:          func() { testAccPreCheck(t) },
+		ProviderFactories: tt.ProviderFactories,
+		CheckDestroy:      testAccCheckScalewayRdbInstanceDestroy(tt),
+		Steps: []resource.TestStep{
+			{
+				Config: `
+					resource "scaleway_rdb_instance" "server" {
+						name      = "test-terraform"
+						node_type = "db-dev-s"
+						engine    = "PostgreSQL-11"
+					}
+					resource "scaleway_rdb_database" "database" {
+						name        = "test-terraform"
+						instance_id = scaleway_rdb_instance.server.id
+					}`,
+			},
+			{
+				Config: `
+					resource "scaleway_rdb_instance" "server" {
+						name      = "test-terraform"
+						node_type = "db-dev-s"
+						engine    = "PostgreSQL-11"
+					}
+					resource "scaleway_rdb_database" "database" {
+						name        = "test-terraform"
+						instance_id = scaleway_rdb_instance.server.id
+					}
+					data "scaleway_rdb_database" "find_by_name_and_instance" {
+						name        = scaleway_rdb_database.database.name
+						instance_id = scaleway_rdb_instance.server.id
+					}
+				`,
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckRdbDatabaseExists(tt, "scaleway_rdb_instance.server", "scaleway_rdb_database.database"),
+
+					resource.TestCheckResourceAttr("data.scaleway_rdb_database.find_by_name_and_instance", "name", "test-terraform"),
+					resource.TestCheckResourceAttr("data.scaleway_rdb_database.find_by_name_and_instance", "managed", "true"),
+					resource.TestCheckResourceAttrSet("data.scaleway_rdb_database.find_by_name_and_instance", "owner"),
+					resource.TestCheckResourceAttrSet("data.scaleway_rdb_database.find_by_name_and_instance", "size"),
+				),
+			},
+		},
+	})
+}

scaleway/helpers_rdb.go

@@ -12,28 +12,30 @@ const (
 	defaultRdbInstanceTimeout = 15 * time.Minute
 )
 
+// newRdbAPI returns a new RDB API
+func newRdbAPI(m interface{}) *rdb.API {
+	meta := m.(*Meta)
+	return rdb.NewAPI(meta.scwClient)
+}
+
 // rdbAPIWithRegion returns a new lb API and the region for a Create request
 func rdbAPIWithRegion(d *schema.ResourceData, m interface{}) (*rdb.API, scw.Region, error) {
 	meta := m.(*Meta)
-	rdbAPI := rdb.NewAPI(meta.scwClient)
 
 	region, err := extractRegion(d, meta)
 	if err != nil {
 		return nil, "", err
 	}
-	return rdbAPI, region, nil
+	return newRdbAPI(m), region, nil
 }
 
 // rdbAPIWithRegionAndID returns an lb API with region and ID extracted from the state
 func rdbAPIWithRegionAndID(m interface{}, id string) (*rdb.API, scw.Region, string, error) {
-	meta := m.(*Meta)
-	rdbAPI := rdb.NewAPI(meta.scwClient)
-
 	region, ID, err := parseRegionalID(id)
 	if err != nil {
 		return nil, "", "", err
 	}
-	return rdbAPI, region, ID, nil
+	return newRdbAPI(m), region, ID, nil
 }
 
 func flattenRdbInstanceReadReplicas(readReplicas []*rdb.Endpoint) interface{} {

scaleway/provider.go

@@ -79,6 +79,7 @@ func Provider(config *ProviderConfig) plugin.ProviderFunc {
 				"scaleway_lb_certificate":                resourceScalewayLbCertificate(),
 				"scaleway_lb_frontend":                   resourceScalewayLbFrontend(),
 				"scaleway_registry_namespace":            resourceScalewayRegistryNamespace(),
+				"scaleway_rdb_database":                  resourceScalewayRdbDatabase(),
 				"scaleway_rdb_instance":                  resourceScalewayRdbInstance(),
 				"scaleway_rdb_user":                      resourceScalewayRdbUser(),
 				"scaleway_object_bucket":                 resourceScalewayObjectBucket(),
@@ -93,6 +94,7 @@ func Provider(config *ProviderConfig) plugin.ProviderFunc {
 				"scaleway_instance_volume":         dataSourceScalewayInstanceVolume(),
 				"scaleway_baremetal_offer":         dataSourceScalewayBaremetalOffer(),
 				"scaleway_rdb_instance":            dataSourceScalewayRDBInstance(),
+				"scaleway_rdb_database":            dataSourceScalewayRDBDatabase(),
 				"scaleway_k8s_cluster":             dataSourceScalewayK8SCluster(),
 				"scaleway_k8s_pool":                dataSourceScalewayK8SPool(),
 				"scaleway_lb_ip":                   dataSourceScalewayLbIP(),