FrontDoor RuleSet rules using user defined types

[ChristopherGLewis]

The FrontDoor Ruleset rules resource appears simple (name, order, action, conditions) but when you look at the actions or conditions properties, these are arrays of different objects.

For example, the Action array can include objects of the following types:

• AfdUrlSigning
• CacheExpiration
• CacheKeyQueryString
• etc

I'm trying to make a user defined type to allow for passing this information to a module as a validated object.

WHat I have so far is this:

type frondDoorRulsetRulesObject = {
  rules: [ {
      ruleSetName: string
      ruleName: string

      @minValue(1)
      @maxValue(1000)
      @description('The order in which the rules are applied for the endpoint. Rule with order 0 is a special rule. It does not require any condition and actions listed in it will always be applied.')
      order: int

      matchProcessingBehavior: 'Continue' | 'Stop'

      actions: []  
      //actions: [ AfdUrlSigning        | CacheExpiration | CacheKeyQueryString | ModifyRequestHeader | ModifyResponseHeader | OriginGroupOverride | RouteConfigurationOverride | UrlRedirect| UrlRewrite | UrlSigning ]

      conditions: [ {
          name: 'ClientPort' | 'Cookies' | 'HostName' | 'HttpVersion' | 'IsDevice' | 'PostArgs' | 'QueryString' | 'RemoteAddress' | 'RequestBody' | 'RequestHeader' | 'RequestMethod' | 'RequestScheme' | 'RequestUri' | 'ServerPort' | 'SocketAddr' | 'SslProtocol' | 'UrlFileExtension' | 'UrlFileName' | 'UrlPath'

          @description('custom parameters for the condition name')
          parameters: {}
        } ]
    } ]
}

with subtypes as defined

type AfdUrlSigning = {
  name: 'AfdUrlSigning'
  parameters: {
    algorithm: 'SHA256'
    keyGroupReference: {
      id: string
    }
    parameterNameOverride: [
      {
        paramIndicator: string
        paramName: string
      }
    ]
  }
}

type CacheExpiration = {
  name: 'CacheExpiration'
  parameters: {
    cacheBehavior: string
    cacheDuration: string
    cacheType: 'All'
  } }

type CacheKeyQueryString = {
  name: 'CacheKeyQueryString'
  parameters: {
    queryParameters: string
    queryStringBehavior: string
  }
}

type ModifyRequestHeader = {
  name: 'ModifyRequestHeader'
  parameters: {
    headerAction: string
    headerName: string
    value: string
  }
}
type ModifyResponseHeader = {
  name: 'ModifyResponseHeader'
  parameters: {
    headerAction: string
    headerName: string
    value: string
  }
}
--etc--

My actions parameter should be an array objects of the allowed types:

      actions: [ AfdUrlSigning | CacheExpiration ]

However, this throws an error:

All members of a union type declaration must be literal values.bicep(BCP293)
type AfdUrlSigning: Type<{ name: 'AfdUrlSigning', parameters: { algorithm: 'SHA256', keyGroupReference: { id: string }, parameterNameOverride: [{ paramIndicator: string, paramName: string }] } }>

I think what this is saying is that the array of actions all have to be of the same type, I can't have an array of different actions (which is what is allowed by the resource).

How do I code this UDT?

The UDT documentation says you can have a field of objects with different types: https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/user-defined-data-types

so the syntax may be:

type actions = (AfdUrlSigning | CacheExpiration )[]

but that also throws

All members of a union type declaration must be literal values.bicep(BCP293)
type AfdUrlSigning: Type<{ name: 'AfdUrlSigning', parameters: { algorithm: 'SHA256', keyGroupReference: { id: string }, parameterNameOverride: [{ paramIndicator: string, paramName: string }] } }>

Any insights would be helpful.

[johnlokerse]

Hey @ChristopherGLewis, this is a perfect use case for the @discriminator decorator. The Azure Bicep docs have an extensive topic on the discriminator: Microsoft Learn - Declare Tagged Union Type - Discriminator

In the Bicep below I have implemented the discriminator

type AfdUrlSigning = {
  name: 'AfdUrlSigning'
  parameters: {
    algorithm: 'SHA256'
    keyGroupReference: {
      id: string
    }
    parameterNameOverride: [
      {
        paramIndicator: string
        paramName: string
      }
    ]
  }
}

type CacheExpiration = {
  name: 'CacheExpiration'
  parameters: {
    cacheBehavior: string
    cacheDuration: string
    cacheType: 'All'
  }
}

@discriminator('name')
type actionType = AfdUrlSigning | CacheExpiration

type frontDoorRulsetRulesObject = {
  actions: actionType[]
}

param parRulesObject frontDoorRulsetRulesObject = {
  actions: [
    input here
  ]
}

It even auto-completes to either AfdUrlSigning or CacheExpiration:

I hope this helps you 😃