Method delete

dsc-bicep-ext/src/main.rs:224–279

(
        &self,
        request: Request<ResourceReference>,
    )

    }

    async fn delete(
        &self,
        request: Request<ResourceReference>,
    ) -> Result<Response<LocalExtensibilityOperationResponse>, Status> {
        let reference = request.into_inner();
        let resource_type = reference.r#type.clone();
        let version = reference.api_version.clone();
        let identifiers = reference.identifiers.clone();

        tracing::debug!(
            "{}",
            t!(
                "bicep.functionCalled",
                function = "Delete",
                resourceType = resource_type,
                version = format!("{version:?}"),
                properties = identifiers
            )
        );

        let type_name = FullyQualifiedTypeName::parse(&resource_type)
            .map_err(|e| Status::invalid_argument(e.to_string()))?;
        let version_req = version.as_deref()
            .map(|v| ResourceVersionReq::parse(&format!("={v}")))
            .transpose()
            .map_err(|e| Status::invalid_argument(e.to_string()))?;

        let mut dsc = DscManager::new();
        let Some(resource) = dsc
            .find_resource(&DiscoveryFilter::new(
                &type_name,
                version_req,
                None,
            ))
            .unwrap_or(None)
        else {
            return Err(Status::not_found(
                t!("dscerror.resourceNotFound").to_string(),
            ));
        };

        resource
            .delete(&identifiers, &ExecutionKind::Actual)
            .map_err(|e| Status::aborted(e.to_string()))?;

        Ok(Response::new(LocalExtensibilityOperationResponse {
            resource: Some(proto::Resource {
                r#type: resource_type,
                api_version: version,
                identifiers,
                properties: "{}".to_string(),
                status: None,
            }),
            error_data: None,
        }))
    }

    async fn get_type_files(