add featureregistry field support for featureview (#9967) (#6962)

[upstream:18666fbc36225b39c6c35756bbd0d71a5da661fc]

Signed-off-by: Modular Magician <[email protected]>

Author: modular-magician

.changelog/9967.txt

@@ -0,0 +1,3 @@
+```release-note:enhancement
+vertexai: added `feature_registry_source` field to `google_vertex_ai_feature_online_store_featureview` resource
+```

google-beta/services/vertexai/resource_vertex_ai_feature_online_store_featureview.go

@@ -89,6 +89,41 @@ func ResourceVertexAIFeatureOnlineStoreFeatureview() *schema.Resource {
 						},
 					},
 				},
+				ExactlyOneOf: []string{"big_query_source", "feature_registry_source"},
+			},
+			"feature_registry_source": {
+				Type:        schema.TypeList,
+				Optional:    true,
+				Description: `Configures the features from a Feature Registry source that need to be loaded onto the FeatureOnlineStore.`,
+				MaxItems:    1,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"feature_groups": {
+							Type:        schema.TypeList,
+							Required:    true,
+							Description: `List of features that need to be synced to Online Store.`,
+							Elem: &schema.Resource{
+								Schema: map[string]*schema.Schema{
+									"feature_group_id": {
+										Type:        schema.TypeString,
+										Required:    true,
+										Description: `Identifier of the feature group.`,
+									},
+									"feature_ids": {
+										Type:        schema.TypeList,
+										Required:    true,
+										Description: `Identifiers of features under the feature group.`,
+										Elem: &schema.Schema{
+											Type: schema.TypeString,
+										},
+									},
+								},
+							},
+						},
+					},
+				},
+				ConflictsWith: []string{"vector_search_config"},
+				ExactlyOneOf:  []string{"big_query_source", "feature_registry_source"},
 			},
 			"labels": {
 				Type:     schema.TypeMap,
@@ -190,6 +225,7 @@ For details on allowed values, see the [API documentation](https://cloud.google.
 						},
 					},
 				},
+				ConflictsWith: []string{"feature_registry_source"},
 			},
 			"create_time": {
 				Type:        schema.TypeString,
@@ -245,6 +281,12 @@ func resourceVertexAIFeatureOnlineStoreFeatureviewCreate(d *schema.ResourceData,
 	} else if v, ok := d.GetOkExists("big_query_source"); !tpgresource.IsEmptyValue(reflect.ValueOf(bigQuerySourceProp)) && (ok || !reflect.DeepEqual(v, bigQuerySourceProp)) {
 		obj["bigQuerySource"] = bigQuerySourceProp
 	}
+	featureRegistrySourceProp, err := expandVertexAIFeatureOnlineStoreFeatureviewFeatureRegistrySource(d.Get("feature_registry_source"), d, config)
+	if err != nil {
+		return err
+	} else if v, ok := d.GetOkExists("feature_registry_source"); !tpgresource.IsEmptyValue(reflect.ValueOf(featureRegistrySourceProp)) && (ok || !reflect.DeepEqual(v, featureRegistrySourceProp)) {
+		obj["featureRegistrySource"] = featureRegistrySourceProp
+	}
 	vectorSearchConfigProp, err := expandVertexAIFeatureOnlineStoreFeatureviewVectorSearchConfig(d.Get("vector_search_config"), d, config)
 	if err != nil {
 		return err
@@ -377,6 +419,9 @@ func resourceVertexAIFeatureOnlineStoreFeatureviewRead(d *schema.ResourceData, m
 	if err := d.Set("big_query_source", flattenVertexAIFeatureOnlineStoreFeatureviewBigQuerySource(res["bigQuerySource"], d, config)); err != nil {
 		return fmt.Errorf("Error reading FeatureOnlineStoreFeatureview: %s", err)
 	}
+	if err := d.Set("feature_registry_source", flattenVertexAIFeatureOnlineStoreFeatureviewFeatureRegistrySource(res["featureRegistrySource"], d, config)); err != nil {
+		return fmt.Errorf("Error reading FeatureOnlineStoreFeatureview: %s", err)
+	}
 	if err := d.Set("vector_search_config", flattenVertexAIFeatureOnlineStoreFeatureviewVectorSearchConfig(res["vectorSearchConfig"], d, config)); err != nil {
 		return fmt.Errorf("Error reading FeatureOnlineStoreFeatureview: %s", err)
 	}
@@ -418,6 +463,12 @@ func resourceVertexAIFeatureOnlineStoreFeatureviewUpdate(d *schema.ResourceData,
 	} else if v, ok := d.GetOkExists("big_query_source"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, bigQuerySourceProp)) {
 		obj["bigQuerySource"] = bigQuerySourceProp
 	}
+	featureRegistrySourceProp, err := expandVertexAIFeatureOnlineStoreFeatureviewFeatureRegistrySource(d.Get("feature_registry_source"), d, config)
+	if err != nil {
+		return err
+	} else if v, ok := d.GetOkExists("feature_registry_source"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, featureRegistrySourceProp)) {
+		obj["featureRegistrySource"] = featureRegistrySourceProp
+	}
 	labelsProp, err := expandVertexAIFeatureOnlineStoreFeatureviewEffectiveLabels(d.Get("effective_labels"), d, config)
 	if err != nil {
 		return err
@@ -441,6 +492,10 @@ func resourceVertexAIFeatureOnlineStoreFeatureviewUpdate(d *schema.ResourceData,
 		updateMask = append(updateMask, "bigQuerySource")
 	}
 
+	if d.HasChange("feature_registry_source") {
+		updateMask = append(updateMask, "featureRegistrySource")
+	}
+
 	if d.HasChange("effective_labels") {
 		updateMask = append(updateMask, "labels")
 	}
@@ -616,6 +671,46 @@ func flattenVertexAIFeatureOnlineStoreFeatureviewBigQuerySourceEntityIdColumns(v
 	return v
 }
 
+func flattenVertexAIFeatureOnlineStoreFeatureviewFeatureRegistrySource(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
+	if v == nil {
+		return nil
+	}
+	original := v.(map[string]interface{})
+	if len(original) == 0 {
+		return nil
+	}
+	transformed := make(map[string]interface{})
+	transformed["feature_groups"] =
+		flattenVertexAIFeatureOnlineStoreFeatureviewFeatureRegistrySourceFeatureGroups(original["featureGroups"], d, config)
+	return []interface{}{transformed}
+}
+func flattenVertexAIFeatureOnlineStoreFeatureviewFeatureRegistrySourceFeatureGroups(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
+	if v == nil {
+		return v
+	}
+	l := v.([]interface{})
+	transformed := make([]interface{}, 0, len(l))
+	for _, raw := range l {
+		original := raw.(map[string]interface{})
+		if len(original) < 1 {
+			// Do not include empty json objects coming back from the api
+			continue
+		}
+		transformed = append(transformed, map[string]interface{}{
+			"feature_group_id": flattenVertexAIFeatureOnlineStoreFeatureviewFeatureRegistrySourceFeatureGroupsFeatureGroupId(original["featureGroupId"], d, config),
+			"feature_ids":      flattenVertexAIFeatureOnlineStoreFeatureviewFeatureRegistrySourceFeatureGroupsFeatureIds(original["featureIds"], d, config),
+		})
+	}
+	return transformed
+}
+func flattenVertexAIFeatureOnlineStoreFeatureviewFeatureRegistrySourceFeatureGroupsFeatureGroupId(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
+	return v
+}
+
+func flattenVertexAIFeatureOnlineStoreFeatureviewFeatureRegistrySourceFeatureGroupsFeatureIds(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
+	return v
+}
+
 func flattenVertexAIFeatureOnlineStoreFeatureviewVectorSearchConfig(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
 	if v == nil {
 		return nil
@@ -775,6 +870,62 @@ func expandVertexAIFeatureOnlineStoreFeatureviewBigQuerySourceEntityIdColumns(v
 	return v, nil
 }
 
+func expandVertexAIFeatureOnlineStoreFeatureviewFeatureRegistrySource(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	l := v.([]interface{})
+	if len(l) == 0 || l[0] == nil {
+		return nil, nil
+	}
+	raw := l[0]
+	original := raw.(map[string]interface{})
+	transformed := make(map[string]interface{})
+
+	transformedFeatureGroups, err := expandVertexAIFeatureOnlineStoreFeatureviewFeatureRegistrySourceFeatureGroups(original["feature_groups"], d, config)
+	if err != nil {
+		return nil, err
+	} else if val := reflect.ValueOf(transformedFeatureGroups); val.IsValid() && !tpgresource.IsEmptyValue(val) {
+		transformed["featureGroups"] = transformedFeatureGroups
+	}
+
+	return transformed, nil
+}
+
+func expandVertexAIFeatureOnlineStoreFeatureviewFeatureRegistrySourceFeatureGroups(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	l := v.([]interface{})
+	req := make([]interface{}, 0, len(l))
+	for _, raw := range l {
+		if raw == nil {
+			continue
+		}
+		original := raw.(map[string]interface{})
+		transformed := make(map[string]interface{})
+
+		transformedFeatureGroupId, err := expandVertexAIFeatureOnlineStoreFeatureviewFeatureRegistrySourceFeatureGroupsFeatureGroupId(original["feature_group_id"], d, config)
+		if err != nil {
+			return nil, err
+		} else if val := reflect.ValueOf(transformedFeatureGroupId); val.IsValid() && !tpgresource.IsEmptyValue(val) {
+			transformed["featureGroupId"] = transformedFeatureGroupId
+		}
+
+		transformedFeatureIds, err := expandVertexAIFeatureOnlineStoreFeatureviewFeatureRegistrySourceFeatureGroupsFeatureIds(original["feature_ids"], d, config)
+		if err != nil {
+			return nil, err
+		} else if val := reflect.ValueOf(transformedFeatureIds); val.IsValid() && !tpgresource.IsEmptyValue(val) {
+			transformed["featureIds"] = transformedFeatureIds
+		}
+
+		req = append(req, transformed)
+	}
+	return req, nil
+}
+
+func expandVertexAIFeatureOnlineStoreFeatureviewFeatureRegistrySourceFeatureGroupsFeatureGroupId(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	return v, nil
+}
+
+func expandVertexAIFeatureOnlineStoreFeatureviewFeatureRegistrySourceFeatureGroupsFeatureIds(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	return v, nil
+}
+
 func expandVertexAIFeatureOnlineStoreFeatureviewVectorSearchConfig(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
 	l := v.([]interface{})
 	if len(l) == 0 || l[0] == nil {

google-beta/services/vertexai/resource_vertex_ai_feature_online_store_featureview_generated_test.go

@@ -129,6 +129,128 @@ data "google_project" "project" {
 `, context)
 }
 
+func TestAccVertexAIFeatureOnlineStoreFeatureview_vertexAiFeatureonlinestoreFeatureviewFeatureRegistryExample(t *testing.T) {
+	t.Parallel()
+
+	context := map[string]interface{}{
+		"random_suffix": acctest.RandString(t, 10),
+	}
+
+	acctest.VcrTest(t, resource.TestCase{
+		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
+		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
+		CheckDestroy:             testAccCheckVertexAIFeatureOnlineStoreFeatureviewDestroyProducer(t),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccVertexAIFeatureOnlineStoreFeatureview_vertexAiFeatureonlinestoreFeatureviewFeatureRegistryExample(context),
+			},
+			{
+				ResourceName:            "google_vertex_ai_feature_online_store_featureview.featureview_featureregistry",
+				ImportState:             true,
+				ImportStateVerify:       true,
+				ImportStateVerifyIgnore: []string{"name", "feature_online_store", "region", "labels", "terraform_labels"},
+			},
+		},
+	})
+}
+
+func testAccVertexAIFeatureOnlineStoreFeatureview_vertexAiFeatureonlinestoreFeatureviewFeatureRegistryExample(context map[string]interface{}) string {
+	return acctest.Nprintf(`
+resource "google_vertex_ai_feature_online_store" "featureonlinestore" {
+  name     = "tf_test_example_feature_view_feature_registry%{random_suffix}"
+  labels = {
+    foo = "bar"
+  }
+  region = "us-central1"
+  bigtable {
+    auto_scaling {
+      min_node_count         = 1
+      max_node_count         = 2
+      cpu_utilization_target = 80
+    }
+  }
+}
+
+resource "google_bigquery_dataset" "sample_dataset" {
+  dataset_id                  = "tf_test_example_feature_view_feature_registry%{random_suffix}"
+  friendly_name               = "test"
+  description                 = "This is a test description"
+  location                    = "US"
+}
+
+resource "google_bigquery_table" "sample_table" {
+  deletion_protection = false
+  dataset_id = google_bigquery_dataset.sample_dataset.dataset_id
+  table_id   = "tf_test_example_feature_view_feature_registry%{random_suffix}"
+
+  schema = <<EOF
+[
+    {
+        "name": "feature_id",
+        "type": "STRING",
+        "mode": "NULLABLE"
+    },
+    {
+        "name": "tf_test_example_feature_view_feature_registry%{random_suffix}",
+        "type": "STRING",
+        "mode": "NULLABLE"
+    },
+    {
+        "name": "feature_timestamp",
+        "type": "TIMESTAMP",
+        "mode": "NULLABLE"
+    }
+]
+EOF
+}
+
+resource "google_vertex_ai_feature_group" "sample_feature_group" {
+  name = "tf_test_example_feature_view_feature_registry%{random_suffix}"
+  description = "A sample feature group"
+  region = "us-central1"
+  labels = {
+      label-one = "value-one"
+  }
+  big_query {
+    big_query_source {
+        # The source table must have a column named 'feature_timestamp' of type TIMESTAMP.
+        input_uri = "bq://${google_bigquery_table.sample_table.project}.${google_bigquery_table.sample_table.dataset_id}.${google_bigquery_table.sample_table.table_id}"
+    }
+    entity_id_columns = ["feature_id"]
+  }
+}
+
+
+
+resource "google_vertex_ai_feature_group_feature" "sample_feature" {
+  name = "tf_test_example_feature_view_feature_registry%{random_suffix}"
+  region = "us-central1"
+  feature_group = google_vertex_ai_feature_group.sample_feature_group.name
+  description = "A sample feature"
+  labels = {
+      label-one = "value-one"
+  }
+}
+
+
+resource "google_vertex_ai_feature_online_store_featureview" "featureview_featureregistry" {
+  name                 = "tf_test_example_feature_view_feature_registry%{random_suffix}"
+  region               = "us-central1"
+  feature_online_store = google_vertex_ai_feature_online_store.featureonlinestore.name
+  sync_config {
+    cron = "0 0 * * *"
+  }
+  feature_registry_source {
+    
+    feature_groups { 
+        feature_group_id = google_vertex_ai_feature_group.sample_feature_group.name
+        feature_ids      = [google_vertex_ai_feature_group_feature.sample_feature.name]
+       }
+  }
+}
+`, context)
+}
+
 func TestAccVertexAIFeatureOnlineStoreFeatureview_vertexAiFeatureonlinestoreFeatureviewWithVectorSearchExample(t *testing.T) {
 	t.Parallel()