@gradientedge/cdk-utils 10.7.0 → 11.0.0

package/src/lib/azure/common/stack.ts

@@ -1,150 +0,0 @@
-import { ComponentResource, ComponentResourceOptions, Config } from '@pulumi/pulumi'
-import appRoot from 'app-root-path'
-import fs from 'fs'
-import _ from 'lodash'
-import path from 'path'
-import { isDevStage } from '../../common/index.js'
-import { CommonAzureConstruct } from './construct.js'
-import { registerTagTransformation } from './tagging.js'
-import { CommonAzureStackProps } from './types.js'
-
-/**
- * @classdesc Common stack to use as a base for all higher level constructs using Pulumi
- * @example
- * ```typescript
- * import { CommonAzureStack } from '@gradientedge/cdk-utils'
- *
- * class CustomStack extends CommonAzureStack {
- *   constructor(name: string, props: CommonAzureStackProps) {
- *     super(name, props)
- *     // provision resources
- *   }
- * }
- * ```
- */
-export class CommonAzureStack extends ComponentResource {
-  construct: CommonAzureConstruct
-  props: CommonAzureStackProps
-  config: Config
-
-  constructor(name: string, props: CommonAzureStackProps, options?: ComponentResourceOptions) {
-    super(`custom:azure:Stack:${name}`, name, props, options)
-
-    /* initialise config */
-    this.config = new Config()
-    this.props = this.determineConstructProps(props)
-
-    /* register tag transformation for automatic tag application */
-    if (this.props.defaultTags) {
-      registerTagTransformation(this.props.defaultTags)
-    }
-  }
-
-  /**
-   * @summary Method to determine the core construct properties injected via context
-   * @param props The stack properties
-   * @returns The stack properties
-   */
-  protected determineConstructProps(props: CommonAzureStackProps) {
-    let projectProps: CommonAzureStackProps = props
-    if (!projectProps) {
-      const projectPropsPath = path.join(appRoot.path, 'pulumi.json')
-      if (!fs.existsSync(projectPropsPath)) throw `Context properties unavailable in path:${projectPropsPath}`
-
-      const projectPropsBuffer = fs.readFileSync(projectPropsPath)
-      projectProps = JSON.parse(projectPropsBuffer.toString('utf-8'))
-    }
-
-    return {
-      domainName: projectProps.domainName,
-      extraContexts: projectProps.extraContexts,
-      location: projectProps.location,
-      name: projectProps.resourceGroupName ?? projectProps.name,
-      resourceGroupName: projectProps.resourceGroupName,
-      globalPrefix: projectProps.globalPrefix,
-      globalSuffix: projectProps.globalSuffix,
-      resourceNameOptions: projectProps.resourceNameOptions,
-      resourcePrefix: projectProps.resourcePrefix,
-      resourceSuffix: projectProps.resourceSuffix,
-      skipStageForARecords: projectProps.skipStageForARecords,
-      stage: projectProps.stage,
-      stageContextPath: projectProps.stageContextPath,
-      subDomain: projectProps.subDomain,
-      subscriptionId: projectProps.subscriptionId,
-      tenantId: projectProps.tenantId,
-      clientId: projectProps.clientId,
-      clientSecret: projectProps.clientSecret,
-      defaultTags: projectProps.defaultTags,
-      ...this.determineExtraContexts(props),
-      ...this.determineStageContexts(props),
-    }
-  }
-
-  /**
-   * @summary Method to determine extra contexts apart from the main context
-   * - Sets the properties from the extra contexts
-   * - Primary use is to have layered config in separate files to enable easier maintenance and readability
-   */
-  protected determineExtraContexts(props: CommonAzureStackProps) {
-    if (!props.extraContexts) {
-      if (props.debug) console.debug(`No additional contexts provided. Using default context properties`)
-      return {}
-    }
-
-    let extraContextProps: Record<string, any> = {}
-    _.forEach(props.extraContexts, (context: string) => {
-      const extraContextPath = path.join(appRoot.path, context)
-
-      /* scenario where extra context is configured but absent in file system */
-      if (!fs.existsSync(extraContextPath)) throw `Extra context properties unavailable in path:${extraContextPath}`
-
-      /* read the extra properties */
-      const extraContextPropsBuffer = fs.readFileSync(extraContextPath)
-      if (props.debug) console.debug(`Adding additional contexts provided in ${extraContextPath}`)
-
-      /* parse as JSON properties */
-      extraContextProps = {
-        ...extraContextProps,
-        ...JSON.parse(extraContextPropsBuffer.toString('utf-8')),
-      }
-    })
-    return extraContextProps
-  }
-
-  /**
-   * @summary Method to determine extra stage contexts apart from the main context
-   * - Sets the properties from the extra stage contexts
-   * - Primary use is to have layered config for each environment which is injected into the context
-   */
-  protected determineStageContexts(props: CommonAzureStackProps) {
-    const stageContextFilePath = path.join(appRoot.path, props.stageContextPath ?? 'env', `${props.stage}.json`)
-
-    if (isDevStage(props.stage)) {
-      if (props.debug) console.debug(`Development stage. Using default stage context properties`)
-    }
-
-    /* alert default context usage when extra stage config is missing */
-    if (!fs.existsSync(stageContextFilePath)) {
-      if (props.debug) console.debug(`Stage specific context properties unavailable in path:${stageContextFilePath}`)
-      if (props.debug) console.debug(`Using default stage context properties for ${props.stage} stage`)
-      return {}
-    }
-
-    /* read the extra properties */
-    const stageContextPropsBuffer = fs.readFileSync(stageContextFilePath)
-    if (props.debug) console.debug(`Adding additional stage contexts provided in ${stageContextFilePath}`)
-
-    /* parse as JSON properties */
-    return JSON.parse(stageContextPropsBuffer.toString('utf-8'))
-  }
-
-  /**
-   * @summary Determine the fully qualified domain name based on domainName & subDomain
-   */
-  protected fullyQualifiedDomain() {
-    const domainName = this.props.domainName
-    const subDomain = this.props.subDomain
-
-    return subDomain ? `${subDomain}.${domainName}` : domainName
-  }
-}

package/src/lib/azure/common/tagging.ts

@@ -1,91 +0,0 @@
-import * as pulumi from '@pulumi/pulumi'
-import { RESOURCES_TO_EXCLUDE_TAGS } from './constants.js'
-
-/**
- * @summary Check if a resource type is taggable
- * @param resourceType The Pulumi resource type (e.g., 'azure-native:resources:ResourceGroup')
- * @returns True if the resource supports tags, false otherwise
- */
-export function isTaggableResource(resourceType: string): boolean {
-  // Extract the resource name from the type (e.g., 'ResourceGroup' from 'azure-native:resources:ResourceGroup')
-  const resourceName = resourceType.split(':').pop() || ''
-
-  // Check if this resource is in the exclusion list
-  if (RESOURCES_TO_EXCLUDE_TAGS.has(resourceName)) {
-    return false
-  }
-
-  // Most Azure resources support tags, but we can add more specific checks here if needed
-  return true
-}
-
-/**
- * @summary Register a stack transformation to automatically apply tags to Azure resources
- * @param defaultTags The default tags to apply to all resources
- * @param tagsToIgnore Optional list of tag keys to ignore in lifecycle management
- * @example
- * ```typescript
- * registerTagTransformation({ environment: 'production', team: 'platform' })
- * ```
- */
-export function registerTagTransformation(defaultTags: Record<string, string>, tagsToIgnore: string[] = []): void {
-  pulumi.runtime.registerStackTransformation((args: pulumi.ResourceTransformationArgs) => {
-    // Only process taggable resources
-    if (!isTaggableResource(args.type)) {
-      return undefined
-    }
-
-    // Check if the resource has a tags property
-    if (!args.props || typeof args.props !== 'object') {
-      return undefined
-    }
-
-    // Merge default tags with resource-specific tags (resource tags take precedence)
-    const currentTags = (args.props as any).tags || {}
-    const mergedTags = { ...defaultTags, ...currentTags }
-
-    // Apply the merged tags
-    const newProps = {
-      ...args.props,
-      tags: mergedTags,
-    }
-
-    // Handle tag ignores via Pulumi's ignoreChanges option
-    let newOpts = args.opts
-    if (tagsToIgnore.length > 0) {
-      const ignoreChanges = tagsToIgnore.map(tag => `tags.${tag}`)
-      newOpts = {
-        ...args.opts,
-        ignoreChanges: [...(args.opts?.ignoreChanges || []), ...ignoreChanges],
-      }
-    }
-
-    return {
-      props: newProps,
-      opts: newOpts,
-    }
-  })
-}
-
-/**
- * @summary Helper function to apply tags to a specific resource's properties
- * @param props The resource properties
- * @param defaultTags The default tags to merge with existing tags
- * @returns The properties with merged tags
- * @example
- * ```typescript
- * const resourceGroupProps = applyTags(props, { environment: 'dev' })
- * ```
- */
-export function applyTags<T extends { tags?: Record<string, string> }>(
-  props: T,
-  defaultTags: Record<string, string>
-): T {
-  return {
-    ...props,
-    tags: {
-      ...defaultTags,
-      ...(props.tags || {}),
-    },
-  }
-}

package/src/lib/azure/common/types.ts

@@ -1,47 +0,0 @@
-import { BaseProps } from '../../common/index.js'
-import { AzureRemoteBackend } from './constants.js'
-
-/**
- * @interface CommonAzureStackProps
- * @description Common properties for Azure stack configuration using Pulumi
- */
-export interface CommonAzureStackProps extends BaseProps {
-  resourceGroupName?: string
-  remoteBackend?: AzureRemoteBackendProps
-  globalPrefix?: string
-  globalSuffix?: string
-  resourcePrefix?: string
-  resourceSuffix?: string
-  resourceNameOptions?: { [key: string]: AzureResourceNameFormatterProps }
-  location?: string
-  defaultTags?: { [key: string]: string }
-
-  // Azure Provider properties for Pulumi
-  subscriptionId?: string
-  tenantId?: string
-  clientId?: string
-  clientSecret?: string
-  environment?: string
-  useOidc?: boolean
-  oidcRequestToken?: string
-  oidcRequestUrl?: string
-  useMsi?: boolean
-  msiEndpoint?: string
-}
-
-export interface AzureRemoteBackendProps {
-  type: AzureRemoteBackend
-  storageAccountName?: string
-  containerName?: string
-  resourceGroupName?: string
-  subscriptionId?: string
-  key?: string
-}
-
-export interface AzureResourceNameFormatterProps {
-  exclude?: boolean
-  globalPrefix?: boolean
-  globalSuffix?: boolean
-  prefix?: string
-  suffix?: string
-}

package/src/lib/azure/index.ts

@@ -1,3 +0,0 @@
-export * from './common/index.js'
-export * from './services/index.js'
-export * from './types/index.js'

package/src/lib/azure/services/api-management/index.ts

@@ -1,2 +0,0 @@
-export * from './main.js'
-export * from './types.js'

package/src/lib/azure/services/api-management/main.ts

@@ -1,382 +0,0 @@
-import {
-  Api,
-  ApiManagementService,
-  ApiOperation,
-  ApiOperationPolicy,
-  Backend,
-  BackendProtocol,
-  Cache,
-  getApiManagementServiceOutput,
-  Logger,
-  LoggerType,
-  PolicyContentFormat,
-  Protocol,
-} from '@pulumi/azure-native/apimanagement/index.js'
-import * as redis from '@pulumi/azure-native/redis/index.js'
-import _ from 'lodash'
-import { CommonAzureConstruct } from '../../common/index.js'
-import {
-  ApiManagementApiProps,
-  ApiManagementBackendProps,
-  ApiManagementCustomDomainProps,
-  ApiManagementProps,
-  ResolveApiManagementProps,
-} from './types.js'
-
-/**
- * @classdesc Provides operations on Azure API Management using Pulumi
- * - A new instance of this class is injected into {@link CommonAzureConstruct} constructor.
- * - If a custom construct extends {@link CommonAzureConstruct}, an instance is available within the context.
- * @example
- * ```typescript
- * import { CommonAzureConstruct, CommonAzureStackProps } from '@gradientedge/cdk-utils'
- *
- * class CustomConstruct extends CommonAzureConstruct {
- *   constructor(name: string, props: CommonAzureStackProps) {
- *     super(name, props)
- *     this.props = props
- *     this.apiManagementManager.createApiManagement('MyApiManagement', this, props)
- *   }
- * }
- * ```
- */
-export class AzureApiManagementManager {
-  /**
-   * @summary Method to create a new API Management service
-   * @param id scoped id of the resource
-   * @param scope scope in which this resource is defined
-   * @param props API Management properties
-   * @param applicationInsightsKey Optional Application Insights instrumentation key for logging
-   * @param externalRedisCache Optional external Redis cache for API Management caching
-   * @see [Pulumi Azure Native API Management]{@link https://www.pulumi.com/registry/packages/azure-native/api-docs/apimanagement/apimanagementservice/}
-   */
-  public createApiManagementService(
-    id: string,
-    scope: CommonAzureConstruct,
-    props: ApiManagementProps,
-    applicationInsightsKey?: string,
-    externalRedisCache?: redis.Redis
-  ) {
-    if (!props) throw `Props undefined for ${id}`
-
-    // Get resource group name
-    const resourceGroupName = scope.props.resourceGroupName
-      ? scope.resourceNameFormatter.format(scope.props.resourceGroupName)
-      : props.resourceGroupName
-
-    if (!resourceGroupName) throw `Resource group name undefined for ${id}`
-
-    const apiManagementService = new ApiManagementService(
-      `${id}-am`,
-      {
-        ...props,
-        serviceName: scope.resourceNameFormatter.format(
-          props.serviceName?.toString(),
-          scope.props.resourceNameOptions?.apiManagement
-        ),
-        resourceGroupName: resourceGroupName,
-        location: props.location ?? scope.props.location,
-        publisherEmail: props.publisherEmail ?? 'noreply@example.com',
-        publisherName: props.publisherName ?? 'Default Publisher',
-        tags: props.tags ?? {
-          environment: scope.props.stage,
-        },
-      },
-      { parent: scope }
-    )
-
-    // Create logger if Application Insights key is provided
-    if (applicationInsightsKey) {
-      new Logger(
-        `${id}-am-logger`,
-        {
-          loggerId: scope.resourceNameFormatter.format(
-            props.serviceName?.toString(),
-            scope.props.resourceNameOptions?.apiManagementLogger
-          ),
-          resourceGroupName: resourceGroupName,
-          serviceName: apiManagementService.name,
-          loggerType: LoggerType.ApplicationInsights,
-          credentials: {
-            instrumentationKey: applicationInsightsKey,
-          },
-        },
-        { parent: scope }
-      )
-    }
-
-    // Create Redis cache connection if external Redis is provided
-    if (externalRedisCache) {
-      new Cache(
-        `${id}-am-redis-cache`,
-        {
-          cacheId: scope.resourceNameFormatter.format(
-            props.serviceName?.toString(),
-            scope.props.resourceNameOptions?.apiManagementRedisCache
-          ),
-          serviceName: apiManagementService.name,
-          resourceGroupName: resourceGroupName,
-          connectionString: externalRedisCache.hostName.apply(
-            hostName =>
-              `${hostName}:10000,password=${externalRedisCache.accessKeys.apply(k => k?.primaryKey)},ssl=True,abortConnect=False`
-          ),
-          useFromLocation: externalRedisCache.location,
-          resourceId: externalRedisCache.id,
-        },
-        { parent: scope }
-      )
-    }
-
-    return apiManagementService
-  }
-
-  /**
-   * @summary Method to resolve an existing API Management service
-   * @param id scoped id of the resource
-   * @param scope scope in which this resource is defined
-   * @param props API Management lookup properties
-   * @see [Pulumi Azure Native API Management Lookup]{@link https://www.pulumi.com/registry/packages/azure-native/api-docs/apimanagement/apimanagementservice/}
-   */
-  public resolveApiManagementService(id: string, scope: CommonAzureConstruct, props: ResolveApiManagementProps) {
-    if (!props) throw `Props undefined for ${id}`
-
-    return getApiManagementServiceOutput(
-      {
-        serviceName: scope.resourceNameFormatter.format(
-          props.serviceName?.toString(),
-          scope.props.resourceNameOptions?.dataAzurermApiManagement
-        ),
-        resourceGroupName: scope.props.resourceGroupName
-          ? `${scope.props.resourceGroupName}-${scope.props.stage}`
-          : props.resourceGroupName,
-      },
-      { parent: scope }
-    )
-  }
-
-  /**
-   * @summary Method to create a new API Management backend
-   * @param id scoped id of the resource
-   * @param scope scope in which this resource is defined
-   * @param props API Management backend properties
-   * @see [Pulumi Azure Native API Management Backend]{@link https://www.pulumi.com/registry/packages/azure-native/api-docs/apimanagement/backend/}
-   */
-  public createBackend(id: string, scope: CommonAzureConstruct, props: ApiManagementBackendProps) {
-    if (!props) throw `Props undefined for ${id}`
-
-    return new Backend(
-      `${id}-am-be`,
-      {
-        ...props,
-        backendId: scope.resourceNameFormatter.format(
-          props.backendId?.toString(),
-          scope.props.resourceNameOptions?.apiManagementBackend
-        ),
-        description: props.description ?? `Backend for ${(props as any).name || id}-${scope.props.stage}`,
-        protocol: props.protocol ?? BackendProtocol.Http,
-      },
-      { parent: scope }
-    )
-  }
-
-  /**
-   * @summary Method to create a new API Management API with operations and policies
-   * @param id scoped id of the resource
-   * @param scope scope in which this resource is defined
-   * @param props API Management API properties
-   * @see [Pulumi Azure Native API Management API]{@link https://www.pulumi.com/registry/packages/azure-native/api-docs/apimanagement/api/}
-   */
-  public createApi(id: string, scope: CommonAzureConstruct, props: ApiManagementApiProps) {
-    if (!props) throw `Props undefined for ${id}`
-
-    const api = new Api(
-      `${id}-am-api`,
-      {
-        ...props,
-        apiId: scope.resourceNameFormatter.format(
-          props.apiId?.toString(),
-          scope.props.resourceNameOptions?.apiManagementApi
-        ),
-        displayName: props.displayName ?? props.apiId,
-        apiRevision: props.apiRevision ?? '1',
-        protocols: props.protocols ?? [Protocol.Https],
-      },
-      { parent: scope }
-    )
-
-    // Create operations and policies
-    _.forEach(props.operations, operation => {
-      const operationId = `${operation.displayName}-${operation.method}`
-      const apimOperation = new ApiOperation(
-        `${id}-apim-api-operation-${operation.displayName}-${operation.method}`,
-        {
-          operationId: operationId,
-          method: (operation.method as string)?.toUpperCase() || 'GET',
-          serviceName: props.serviceName!,
-          resourceGroupName: props.resourceGroupName!,
-          apiId: api.name,
-          displayName: operation.displayName,
-          urlTemplate: operation.urlTemplate,
-          templateParameters: operation.templateParameters,
-        },
-        { parent: scope }
-      )
-
-      // Define Caching Policy if enabled
-      let cacheSetVariablePolicy = ''
-      let cacheInvalidateInboundPolicy = ''
-      let cacheSetInboundPolicy = ''
-      let cacheSetOutboundPolicy = ''
-
-      if (operation.caching) {
-        cacheSetVariablePolicy = `<!-- Generate a comprehensive custom cache key (without query params or Accept header) -->
-              <set-variable name="customCacheKey" value="@{
-                  // Instance identification
-
-                  // API identification
-                  string apiName = context.Api.Name.Replace(" ", "").ToLower();
-                  string apiVersion = context.Api.Version ?? "v1";
-
-                  // Full path construction (without query parameters)
-                  string fullPath = context.Request.Url.Path.ToLower();
-
-                  // Query parameters
-                  string query = context.Request.Url.QueryString.ToLower();
-
-                  // Construct final cache key (no Accept header needed for JSON-only APIs)
-                  return $"{apiName}:{apiVersion}:{fullPath}:{query}";
-              }" />
-              <set-variable name="bypassCache" value="@(context.Request.Headers.GetValueOrDefault("X-Cache-Bypass", "false").ToLower())" />`
-
-        if (operation.caching.enableCacheSet) {
-          cacheSetInboundPolicy = `<choose>
-                  <when condition="@((string)context.Variables["bypassCache"] != "true")">
-                      <!-- Attempt to retrieve cached response -->
-                      <cache-lookup-value key="@((string)context.Variables["customCacheKey"])" variable-name="cachedResponse" caching-type="${operation.caching.cachingType || 'prefer-external'}" />
-
-                      <!-- If cache hit, return cached response -->
-                      <choose>
-                          <when condition="@(context.Variables.ContainsKey("cachedResponse"))">
-                              <return-response>
-                                  <set-status code="200" reason="OK" />
-                                  <set-header name="Content-Type" exists-action="override">
-                                      <value>application/json</value>
-                                  </set-header>
-                                  <set-header name="X-Apim-Cache-Status" exists-action="override">
-                                      <value>HIT</value>
-                                  </set-header>
-                                  <set-header name="X-Apim-Cache-Key" exists-action="override">
-                                      <value>@((string)context.Variables["customCacheKey"])</value>
-                                  </set-header>
-                                  <set-body>@((string)context.Variables["cachedResponse"])</set-body>
-                              </return-response>
-                          </when>
-                      </choose>
-                  </when>
-                  <when condition="@((string)context.Variables["bypassCache"] == "true")">
-                      <cache-remove-value key="@((string)context.Variables["customCacheKey"])" caching-type="${operation.caching.cachingType || 'prefer-external'}" />
-                  </when>
-              </choose>`
-          cacheSetOutboundPolicy = `<!-- Store the response body in cache -->
-              <choose>
-                  <when condition="@(context.Response.StatusCode == 200)">
-                      <cache-store-value key="@((string)context.Variables["customCacheKey"])" value="@(context.Response.Body.As<string>(preserveContent: true))" duration="${operation.caching.ttlInSecs ?? 900}" caching-type="${operation.caching.cachingType || 'prefer-external'}" />
-                      <!-- Add cache status header -->
-                      <set-header name="X-Apim-Cache-Status" exists-action="override">
-                          <value>MISS</value>
-                      </set-header>
-                  </when>
-              </choose>
-              <!-- Add debug headers -->
-              <set-header name="X-Apim-Cache-Key" exists-action="override">
-                  <value>@((string)context.Variables["customCacheKey"])</value>
-              </set-header>
-              <set-header name="X-Apim-API-Name" exists-action="override">
-                  <value>@(context.Api.Name)</value>
-              </set-header>`
-        }
-
-        if (operation.caching.enableCacheInvalidation) {
-          cacheInvalidateInboundPolicy = `<set-variable name="clearCache" value="@(context.Request.Headers.GetValueOrDefault("X-Apim-Clear-Cache", "false").ToLower())" />
-              <!-- Allow admin to clear specific cache entries -->
-              <choose>
-                  <when condition="@((string)context.Variables["clearCache"] == "true")">
-                      <cache-remove-value key="@((string)context.Variables["customCacheKey"])" caching-type="${operation.caching.cachingType || 'prefer-external'}" />
-                      <return-response>
-                          <set-status code="200" reason="OK" />
-                          <set-body>Cache entry removed successfully</set-body>
-                      </return-response>
-                  </when>
-              </choose>`
-        }
-      }
-
-      // Inject rate limiting policy (if configured)
-      let rateLimitPolicy = ''
-      if (props.rateLimit && scope.props.subscriptionId) {
-        rateLimitPolicy = `<rate-limit-by-key calls="${props.rateLimit.calls}" renewal-period="${props.rateLimit.renewalPeriodInSecs}" counter-key="${scope.props.subscriptionId}-${operationId}"/>`
-      }
-
-      const policyXmlContent = `<policies>
-        <inbound>
-          <base />
-          ${rateLimitPolicy}
-          ${cacheSetVariablePolicy}
-          ${cacheInvalidateInboundPolicy}
-          ${cacheSetInboundPolicy}
-          ${props.commonInboundPolicyXml ?? ''}
-        </inbound>
-        <backend>
-          <base />
-        </backend>
-        <outbound>
-          <base />
-          ${cacheSetOutboundPolicy}
-          ${props.commonOutboundPolicyXml ?? ''}
-        </outbound>
-        <on-error>
-            <base />
-        </on-error>
-      </policies>`
-
-      new ApiOperationPolicy(
-        `${id}-apim-api-operation-policy-${operation.displayName}-${operation.method}`,
-        {
-          serviceName: props.serviceName!,
-          resourceGroupName: props.resourceGroupName!,
-          apiId: api.name,
-          operationId: operationId,
-          policyId: 'policy',
-          value: policyXmlContent,
-          format: PolicyContentFormat.Xml,
-        },
-        { parent: scope }
-      )
-    })
-
-    return api
-  }
-
-  /**
-   * @summary Method to create a new API Management custom domain
-   * @param id scoped id of the resource
-   * @param scope scope in which this resource is defined
-   * @param props API Management custom domain properties
-   * @note In Pulumi Azure Native, custom domains are configured as part of the API Management service resource,
-   * not as a separate resource. Use the hostnameConfigurations property when creating the service.
-   */
-  public createApiManagementCustomDomain(
-    id: string,
-    scope: CommonAzureConstruct,
-    props: ApiManagementCustomDomainProps
-  ) {
-    if (!props) throw `Props undefined for ${id}`
-
-    // Note: In Pulumi Azure Native, custom domains are part of the ApiManagementService
-    // This method is provided for API compatibility but should be configured
-    // via the hostnameConfigurations property of ApiManagementService instead
-    throw new Error(
-      'Custom domains should be configured via the hostnameConfigurations property of ApiManagementService in Pulumi Azure Native'
-    )
-  }
-}