441 lines
15 KiB
Go
441 lines
15 KiB
Go
package tfprotov6
|
|
|
|
import "github.com/hashicorp/terraform-plugin-go/tftypes"
|
|
|
|
const (
|
|
// SchemaNestedBlockNestingModeInvalid indicates that the nesting mode
|
|
// for a nested block in the schema is invalid. This generally
|
|
// indicates a nested block that was created incorrectly.
|
|
SchemaNestedBlockNestingModeInvalid SchemaNestedBlockNestingMode = 0
|
|
|
|
// SchemaNestedBlockNestingModeSingle indicates that the nested block
|
|
// should be treated as a single block with no labels, and there should
|
|
// not be more than one of these blocks in the containing block. The
|
|
// block will appear in config and state values as a tftypes.Object.
|
|
SchemaNestedBlockNestingModeSingle SchemaNestedBlockNestingMode = 1
|
|
|
|
// SchemaNestedBlockNestingModeList indicates that multiple instances
|
|
// of the nested block should be permitted, with no labels, and that
|
|
// the instances of the block should appear in config and state values
|
|
// as a tftypes.List, with an ElementType of tftypes.Object.
|
|
SchemaNestedBlockNestingModeList SchemaNestedBlockNestingMode = 2
|
|
|
|
// SchemaNestedBlockNestingModeSet indicates that multiple instances
|
|
// of the nested block should be permitted, with no labels, and that
|
|
// the instances of the block should appear in config and state values
|
|
// as a tftypes.Set, with an ElementType of tftypes.Object.
|
|
SchemaNestedBlockNestingModeSet SchemaNestedBlockNestingMode = 3
|
|
|
|
// SchemaNestedBlockNestingModeMap indicates that multiple instances of
|
|
// the nested block should be permitted, each with a single label, and
|
|
// that they should be represented in state and config values as a
|
|
// tftypes.Map, with an ElementType of tftypes.Object. The labels on
|
|
// the blocks will be used as the map keys. It is an error, therefore,
|
|
// to use the same label value on multiple block instances.
|
|
SchemaNestedBlockNestingModeMap SchemaNestedBlockNestingMode = 4
|
|
|
|
// SchemaNestedBlockNestingModeGroup indicates that the nested block
|
|
// should be treated as a single block with no labels, and there should
|
|
// not be more than one of these blocks in the containing block. The
|
|
// block will appear in config and state values as a tftypes.Object.
|
|
//
|
|
// SchemaNestedBlockNestingModeGroup is distinct from
|
|
// SchemaNestedBlockNestingModeSingle in that it guarantees that the
|
|
// block will never be null. If it is omitted from a config, the block
|
|
// will still be set, but its attributes and nested blocks will all be
|
|
// null. This is an exception to the rule that any block not set in the
|
|
// configuration cannot be set in config by the provider; this ensures
|
|
// the block is always considered "set" in the configuration, and is
|
|
// therefore settable in state by the provider.
|
|
SchemaNestedBlockNestingModeGroup SchemaNestedBlockNestingMode = 5
|
|
|
|
// SchemaObjectNestingModeInvalid indicates that the nesting mode
|
|
// for a nested type in the schema is invalid. This generally
|
|
// indicates a nested type that was created incorrectly.
|
|
SchemaObjectNestingModeInvalid SchemaObjectNestingMode = 0
|
|
|
|
// SchemaObjectNestingModeSingle indicates that the nested type should
|
|
// be treated as a single object. The block will appear in config and state
|
|
// values as a tftypes.Object.
|
|
SchemaObjectNestingModeSingle SchemaObjectNestingMode = 1
|
|
|
|
// SchemaObjectNestingModeList indicates that multiple instances of the
|
|
// nested type should be permitted, and that the nested type should appear
|
|
// in config and state values as a tftypes.List, with an ElementType of
|
|
// tftypes.Object.
|
|
SchemaObjectNestingModeList SchemaObjectNestingMode = 2
|
|
|
|
// SchemaObjectNestingModeSet indicates that multiple instances of the
|
|
// nested type should be permitted, and that the nested type should appear in
|
|
// config and state values as a tftypes.Set, with an ElementType of
|
|
// tftypes.Object.
|
|
SchemaObjectNestingModeSet SchemaObjectNestingMode = 3
|
|
|
|
// SchemaObjectNestingModeMap indicates that multiple instances of the
|
|
// nested type should be permitted, and that they should be appear in state
|
|
// and config values as a tftypes.Map, with an ElementType of
|
|
// tftypes.Object.
|
|
SchemaObjectNestingModeMap SchemaObjectNestingMode = 4
|
|
)
|
|
|
|
// Schema is how Terraform defines the shape of data. It can be thought of as
|
|
// the type information for resources, data sources, provider configuration,
|
|
// and all the other data that Terraform sends to providers. It is how
|
|
// providers express their requirements for that data.
|
|
type Schema struct {
|
|
// Version indicates which version of the schema this is. Versions
|
|
// should be monotonically incrementing numbers. When Terraform
|
|
// encounters a resource stored in state with a schema version lower
|
|
// that the schema version the provider advertises for that resource,
|
|
// Terraform requests the provider upgrade the resource's state.
|
|
Version int64
|
|
|
|
// Block is the root level of the schema, the collection of attributes
|
|
// and blocks that make up a resource, data source, provider, or other
|
|
// configuration block.
|
|
Block *SchemaBlock
|
|
}
|
|
|
|
// ValueType returns the tftypes.Type for a Schema.
|
|
//
|
|
// If Schema is missing, an empty Object is returned.
|
|
func (s *Schema) ValueType() tftypes.Type {
|
|
if s == nil {
|
|
return tftypes.Object{
|
|
AttributeTypes: map[string]tftypes.Type{},
|
|
}
|
|
}
|
|
|
|
return s.Block.ValueType()
|
|
}
|
|
|
|
// SchemaBlock represents a block in a schema. Blocks are how Terraform creates
|
|
// groupings of attributes. In configurations, they don't use the equals sign
|
|
// and use dynamic instead of list comprehensions.
|
|
//
|
|
// Blocks will show up in state and config Values as a tftypes.Object, with the
|
|
// attributes and nested blocks defining the tftypes.Object's AttributeTypes.
|
|
type SchemaBlock struct {
|
|
// TODO: why do we have version in the block, too?
|
|
Version int64
|
|
|
|
// Attributes are the attributes defined within the block. These are
|
|
// the fields that users can set using the equals sign or reference in
|
|
// interpolations.
|
|
Attributes []*SchemaAttribute
|
|
|
|
// BlockTypes are the nested blocks within the block. These are used to
|
|
// have blocks within blocks.
|
|
BlockTypes []*SchemaNestedBlock
|
|
|
|
// Description offers an end-user friendly description of what the
|
|
// block is for. This will be surfaced to users through editor
|
|
// integrations, documentation generation, and other settings.
|
|
Description string
|
|
|
|
// DescriptionKind indicates the formatting and encoding that the
|
|
// Description field is using.
|
|
DescriptionKind StringKind
|
|
|
|
// Deprecated, when set to true, indicates that a block should no
|
|
// longer be used and users should migrate away from it. At the moment
|
|
// it is unused and will have no impact, but it will be used in future
|
|
// tooling that is powered by provider schemas to enable richer user
|
|
// experiences. Providers should set it when deprecating blocks in
|
|
// preparation for these tools.
|
|
Deprecated bool
|
|
}
|
|
|
|
// ValueType returns the tftypes.Type for a SchemaBlock.
|
|
//
|
|
// If SchemaBlock is missing, an empty Object is returned.
|
|
func (s *SchemaBlock) ValueType() tftypes.Type {
|
|
if s == nil {
|
|
return tftypes.Object{
|
|
AttributeTypes: map[string]tftypes.Type{},
|
|
}
|
|
}
|
|
|
|
attributeTypes := map[string]tftypes.Type{}
|
|
|
|
for _, attribute := range s.Attributes {
|
|
if attribute == nil {
|
|
continue
|
|
}
|
|
|
|
attributeType := attribute.ValueType()
|
|
|
|
if attributeType == nil {
|
|
continue
|
|
}
|
|
|
|
attributeTypes[attribute.Name] = attributeType
|
|
}
|
|
|
|
for _, block := range s.BlockTypes {
|
|
if block == nil {
|
|
continue
|
|
}
|
|
|
|
blockType := block.ValueType()
|
|
|
|
if blockType == nil {
|
|
continue
|
|
}
|
|
|
|
attributeTypes[block.TypeName] = blockType
|
|
}
|
|
|
|
return tftypes.Object{
|
|
AttributeTypes: attributeTypes,
|
|
}
|
|
}
|
|
|
|
// SchemaAttribute represents a single attribute within a schema block.
|
|
// Attributes are the fields users can set in configuration using the equals
|
|
// sign, can assign to variables, can interpolate, and can use list
|
|
// comprehensions on.
|
|
type SchemaAttribute struct {
|
|
// Name is the name of the attribute. This is what the user will put
|
|
// before the equals sign to assign a value to this attribute.
|
|
Name string
|
|
|
|
// Type indicates the type of data the attribute expects. See the
|
|
// documentation for the tftypes package for information on what types
|
|
// are supported and their behaviors.
|
|
Type tftypes.Type
|
|
|
|
// NestedType indicates that this is a NestedBlock-style object masquerading
|
|
// as an attribute. This field conflicts with Type.
|
|
NestedType *SchemaObject
|
|
|
|
// Description offers an end-user friendly description of what the
|
|
// attribute is for. This will be surfaced to users through editor
|
|
// integrations, documentation generation, and other settings.
|
|
Description string
|
|
|
|
// Required, when set to true, indicates that this attribute must have
|
|
// a value assigned to it by the user or Terraform will throw an error.
|
|
Required bool
|
|
|
|
// Optional, when set to true, indicates that the user does not need to
|
|
// supply a value for this attribute, but may.
|
|
Optional bool
|
|
|
|
// Computed, when set to true, indicates the the provider will supply a
|
|
// value for this field. If Optional and Required are false and
|
|
// Computed is true, the user will not be able to specify a value for
|
|
// this field without Terraform throwing an error. If Optional is true
|
|
// and Computed is true, the user can specify a value for this field,
|
|
// but the provider may supply a value if the user does not. It is
|
|
// always a violation of Terraform's protocol to substitute a value for
|
|
// what the user entered, even if Computed is true.
|
|
Computed bool
|
|
|
|
// Sensitive, when set to true, indicates that the contents of this
|
|
// attribute should be considered sensitive and not included in output.
|
|
// This does not encrypt or otherwise protect these values in state, it
|
|
// only offers protection from them showing up in plans or other
|
|
// output.
|
|
Sensitive bool
|
|
|
|
// DescriptionKind indicates the formatting and encoding that the
|
|
// Description field is using.
|
|
DescriptionKind StringKind
|
|
|
|
// Deprecated, when set to true, indicates that a attribute should no
|
|
// longer be used and users should migrate away from it. At the moment
|
|
// it is unused and will have no impact, but it will be used in future
|
|
// tooling that is powered by provider schemas to enable richer user
|
|
// experiences. Providers should set it when deprecating attributes in
|
|
// preparation for these tools.
|
|
Deprecated bool
|
|
}
|
|
|
|
// ValueType returns the tftypes.Type for a SchemaAttribute.
|
|
//
|
|
// If SchemaAttribute is missing, nil is returned.
|
|
func (s *SchemaAttribute) ValueType() tftypes.Type {
|
|
if s == nil {
|
|
return nil
|
|
}
|
|
|
|
// It is not valid to set both NestedType and Type.
|
|
if s.NestedType != nil {
|
|
return s.NestedType.ValueType()
|
|
}
|
|
|
|
return s.Type
|
|
}
|
|
|
|
// SchemaNestedBlock is a nested block within another block. See SchemaBlock
|
|
// for more information on blocks.
|
|
type SchemaNestedBlock struct {
|
|
// TypeName is the name of the block. It is what the user will specify
|
|
// when using the block in configuration.
|
|
TypeName string
|
|
|
|
// Block is the block being nested inside another block. See the
|
|
// SchemaBlock documentation for more information on blocks.
|
|
Block *SchemaBlock
|
|
|
|
// Nesting is the kind of nesting the block is using. Different nesting
|
|
// modes have different behaviors and imply different kinds of data.
|
|
Nesting SchemaNestedBlockNestingMode
|
|
|
|
// MinItems is the minimum number of instances of this block that a
|
|
// user must specify or Terraform will return an error.
|
|
//
|
|
// MinItems can only be set for SchemaNestedBlockNestingModeList and
|
|
// SchemaNestedBlockNestingModeSet. SchemaNestedBlockNestingModeSingle
|
|
// can also set MinItems and MaxItems both to 1 to indicate that the
|
|
// block is required to be set. All other SchemaNestedBlockNestingModes
|
|
// must leave MinItems set to 0.
|
|
MinItems int64
|
|
|
|
// MaxItems is the maximum number of instances of this block that a
|
|
// user may specify before Terraform returns an error.
|
|
//
|
|
// MaxItems can only be set for SchemaNestedBlockNestingModeList and
|
|
// SchemaNestedBlockNestingModeSet. SchemaNestedBlockNestingModeSingle
|
|
// can also set MinItems and MaxItems both to 1 to indicate that the
|
|
// block is required to be set. All other SchemaNestedBlockNestingModes
|
|
// must leave MaxItems set to 0.
|
|
MaxItems int64
|
|
}
|
|
|
|
// ValueType returns the tftypes.Type for a SchemaNestedBlock.
|
|
//
|
|
// If SchemaNestedBlock is missing or the Nesting mode is invalid, nil is
|
|
// returned.
|
|
func (s *SchemaNestedBlock) ValueType() tftypes.Type {
|
|
if s == nil {
|
|
return nil
|
|
}
|
|
|
|
blockType := s.Block.ValueType()
|
|
|
|
switch s.Nesting {
|
|
case SchemaNestedBlockNestingModeGroup:
|
|
return blockType
|
|
case SchemaNestedBlockNestingModeList:
|
|
return tftypes.List{
|
|
ElementType: blockType,
|
|
}
|
|
case SchemaNestedBlockNestingModeMap:
|
|
return tftypes.Map{
|
|
ElementType: blockType,
|
|
}
|
|
case SchemaNestedBlockNestingModeSet:
|
|
return tftypes.Set{
|
|
ElementType: blockType,
|
|
}
|
|
case SchemaNestedBlockNestingModeSingle:
|
|
return blockType
|
|
default:
|
|
return nil
|
|
}
|
|
}
|
|
|
|
// SchemaNestedBlockNestingMode indicates the nesting mode for
|
|
// SchemaNestedBlocks. The nesting mode determines the number of instances of
|
|
// the block allowed, how many labels the block expects, and the data structure
|
|
// used for the block in config and state values.
|
|
type SchemaNestedBlockNestingMode int32
|
|
|
|
func (s SchemaNestedBlockNestingMode) String() string {
|
|
switch s {
|
|
case 0:
|
|
return "INVALID"
|
|
case 1:
|
|
return "SINGLE"
|
|
case 2:
|
|
return "LIST"
|
|
case 3:
|
|
return "SET"
|
|
case 4:
|
|
return "MAP"
|
|
case 5:
|
|
return "GROUP"
|
|
}
|
|
return "UNKNOWN"
|
|
}
|
|
|
|
// SchemaObject represents a nested-block-stype object in an Attribute.
|
|
type SchemaObject struct {
|
|
// Attributes are the attributes defined within the Object.
|
|
Attributes []*SchemaAttribute
|
|
|
|
Nesting SchemaObjectNestingMode
|
|
}
|
|
|
|
// ValueType returns the tftypes.Type for a SchemaObject.
|
|
//
|
|
// If SchemaObject is missing or the Nesting mode is invalid, nil is returned.
|
|
func (s *SchemaObject) ValueType() tftypes.Type {
|
|
if s == nil {
|
|
return nil
|
|
}
|
|
|
|
attributeTypes := map[string]tftypes.Type{}
|
|
|
|
for _, attribute := range s.Attributes {
|
|
if attribute == nil {
|
|
continue
|
|
}
|
|
|
|
attributeType := attribute.ValueType()
|
|
|
|
if attributeType == nil {
|
|
continue
|
|
}
|
|
|
|
attributeTypes[attribute.Name] = attributeType
|
|
}
|
|
|
|
objectType := tftypes.Object{
|
|
AttributeTypes: attributeTypes,
|
|
}
|
|
|
|
switch s.Nesting {
|
|
case SchemaObjectNestingModeList:
|
|
return tftypes.List{
|
|
ElementType: objectType,
|
|
}
|
|
case SchemaObjectNestingModeMap:
|
|
return tftypes.Map{
|
|
ElementType: objectType,
|
|
}
|
|
case SchemaObjectNestingModeSet:
|
|
return tftypes.Set{
|
|
ElementType: objectType,
|
|
}
|
|
case SchemaObjectNestingModeSingle:
|
|
return objectType
|
|
default:
|
|
return nil
|
|
}
|
|
}
|
|
|
|
// SchemaObjectNestingMode indicates the nesting mode for
|
|
// SchemaNestedBlocks. The nesting mode determines the number of instances of
|
|
// the nested type allowed and the data structure used for the block in config
|
|
// and state values.
|
|
type SchemaObjectNestingMode int32
|
|
|
|
func (s SchemaObjectNestingMode) String() string {
|
|
switch s {
|
|
case 0:
|
|
return "INVALID"
|
|
case 1:
|
|
return "SINGLE"
|
|
case 2:
|
|
return "LIST"
|
|
case 3:
|
|
return "SET"
|
|
case 4:
|
|
return "MAP"
|
|
}
|
|
return "UNKNOWN"
|
|
}
|