Need to mark the custom resource as a singleton even though it has a …

…Delete method

provider/pkg/gen/schema.go

@@ -949,7 +949,7 @@ func (g *packageGenerator) genResourceVariant(apiSpec *openapi.ResourceSpec, res
 		PutParameters:        resourceRequest.parameters,
 		Response:             resourceResponse.properties,
 		DefaultBody:          resource.DefaultBody,
-		Singleton:            resource.PathItem.Delete == nil,
+		Singleton:            isSingleton(resource),
 		PutAsyncStyle:        g.getAsyncStyle(updateOp),
 		DeleteAsyncStyle:     g.getAsyncStyle(resource.PathItem.Delete),
 		ReadMethod:           readMethod,
@@ -970,6 +970,10 @@ func (g *packageGenerator) genResourceVariant(apiSpec *openapi.ResourceSpec, res
 	return nil
 }
 
+func isSingleton(resource *resourceVariant) bool {
+	return resource.PathItem.Delete == nil || customresources.IsSingleton(resource.Path)
+}
+
 func (g *packageGenerator) generateAliases(resource *resourceVariant, typeNameAliases ...string) []pschema.AliasSpec {
 	var aliases []pschema.AliasSpec
 

provider/pkg/gen/schema_test.go

@@ -253,3 +253,38 @@ func TestPropertyDescriptions(t *testing.T) {
 		assert.Equal(t, "This  is not  allowed", desc)
 	})
 }
+
+func TestResourceIsSingleton(t *testing.T) {
+	t.Run("singleton", func(t *testing.T) {
+		res := &resourceVariant{
+			ResourceSpec: &openapi.ResourceSpec{
+				Path:     "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DBforPostgreSQL/flexibleServers/{serverName}/configurations/{configurationName}",
+				PathItem: &spec.PathItem{},
+			},
+		}
+		assert.True(t, isSingleton(res))
+	})
+
+	t.Run("implicit singleton", func(t *testing.T) {
+		res := &resourceVariant{
+			ResourceSpec: &openapi.ResourceSpec{
+				Path:     "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Foo/bar",
+				PathItem: &spec.PathItem{},
+			},
+		}
+		assert.True(t, isSingleton(res))
+	})
+
+	t.Run("not a singleton", func(t *testing.T) {
+		res := &resourceVariant{
+			ResourceSpec: &openapi.ResourceSpec{
+				Path: "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Foo/bar",
+				PathItem: &spec.PathItem{
+					PathItemProps: spec.PathItemProps{
+						Delete: &spec.Operation{},
+					},
+				}},
+		}
+		assert.False(t, isSingleton(res))
+	})
+}

provider/pkg/provider/provider.go

@@ -1429,6 +1429,10 @@ func restoreDefaultInputsForRemovedProperties(inputs resource.PropertyMap, res r
 	return nil
 }
 
+func isSingleton(res *resources.AzureAPIResource) bool {
+	return res.Singleton
+}
+
 // Delete tears down an existing resource with the given ID. If it fails, the resource is assumed
 // to still exist.
 func (k *azureNativeProvider) Delete(ctx context.Context, req *rpc.DeleteRequest) (*pbempty.Empty, error) {
@@ -1469,7 +1473,7 @@ func (k *azureNativeProvider) Delete(ctx context.Context, req *rpc.DeleteRequest
 		if err != nil {
 			return nil, azure.AzureError(err)
 		}
-	case res.Singleton:
+	case isSingleton(res):
 		// Singleton resources can't be deleted (or created), set them to the default state.
 		for _, param := range res.PutParameters {
 			if defaults.SkipDeleteOperation(res.Path, res.APIVersion) {

provider/pkg/resources/customresources/custom_postgres_config.go

@@ -70,6 +70,7 @@ func postgresFlexibleServerConfiguration(crudClientFactory crud.ResourceCrudClie
 			}
 			return nil
 		},
+		isSingleton: true,
 	}, nil
 }
 

provider/pkg/resources/customresources/customresources.go

@@ -68,6 +68,11 @@ type CustomResource struct {
 	Update func(ctx context.Context, id string, news, olds resource.PropertyMap) (map[string]interface{}, error)
 	// Delete an existing resource. Constructs the resource ID based on input values.
 	Delete func(ctx context.Context, id string, properties resource.PropertyMap) error
+	// IsSingleton is true if the resource is a singleton resource that cannot be created or deleted, only initialized
+	// and reset to a default state. Normally, we infer this from whether the `Delete` property is set. In some cases
+	// we need to set it explicitly if the resource is a singleton but does have a `Delete` property implementing a
+	// custom reset to the default state.
+	isSingleton bool
 }
 
 // ResourceDefinition is a combination of the external schema and runtime metadata
@@ -235,6 +240,13 @@ func HasCustomDelete(path string) bool {
 	return false
 }
 
+func IsSingleton(path string) bool {
+	if res, ok := featureLookup[path]; ok {
+		return res.isSingleton
+	}
+	return false
+}
+
 // SchemaMixins returns the map of custom resource schema definitions per resource token.
 func SchemaMixins() map[string]schema.ResourceSpec {
 	specs := map[string]schema.ResourceSpec{}

provider/pkg/resources/customresources/customresources_test.go

@@ -0,0 +1,20 @@
+// Copyright 2024, Pulumi Corporation.  All rights reserved.
+
+package customresources
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestIsSingleton(t *testing.T) {
+	assert.False(t, IsSingleton(""))
+	assert.False(t, IsSingleton("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DBforPostgreSQL/flexibleServers/{serverName}"))
+
+	postgresResource, err := postgresFlexibleServerConfiguration(nil, nil)
+	require.NoError(t, err)
+	assert.True(t, postgresResource.isSingleton)
+	assert.True(t, IsSingleton(postgresResource.path))
+}