compositionrevision_v1alpha1.json

{
  "description": "A CompositionRevision represents a revision in time of a Composition. Revisions are created by Crossplane; they should be treated as immutable.",
  "properties": {
    "apiVersion": {
      "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources",
      "type": "string"
    },
    "kind": {
      "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds",
      "type": "string"
    },
    "metadata": {
      "type": "object"
    },
    "spec": {
      "description": "CompositionRevisionSpec specifies the desired state of the composition revision.",
      "properties": {
        "compositeTypeRef": {
          "description": "CompositeTypeRef specifies the type of composite resource that this composition is compatible with.",
          "properties": {
            "apiVersion": {
              "description": "APIVersion of the type.",
              "type": "string"
            },
            "kind": {
              "description": "Kind of the type.",
              "type": "string"
            }
          },
          "required": [
            "apiVersion",
            "kind"
          ],
          "type": "object",
          "additionalProperties": false
        },
        "patchSets": {
          "description": "PatchSets define a named set of patches that may be included by any resource in this Composition. PatchSets cannot themselves refer to other PatchSets.",
          "items": {
            "description": "A PatchSet is a set of patches that can be reused from all resources within a Composition.",
            "properties": {
              "name": {
                "description": "Name of this PatchSet.",
                "type": "string"
              },
              "patches": {
                "description": "Patches will be applied as an overlay to the base resource.",
                "items": {
                  "description": "Patch objects are applied between composite and composed resources. Their behaviour depends on the Type selected. The default Type, FromCompositeFieldPath, copies a value from the composite resource to the composed resource, applying any defined transformers.",
                  "properties": {
                    "combine": {
                      "description": "Combine is the patch configuration for a CombineFromComposite or CombineToComposite patch.",
                      "properties": {
                        "strategy": {
                          "description": "Strategy defines the strategy to use to combine the input variable values. Currently only string is supported.",
                          "enum": [
                            "string"
                          ],
                          "type": "string"
                        },
                        "string": {
                          "description": "String declares that input variables should be combined into a single string, using the relevant settings for formatting purposes.",
                          "properties": {
                            "fmt": {
                              "description": "Format the input using a Go format string. See https://golang.org/pkg/fmt/ for details.",
                              "type": "string"
                            }
                          },
                          "required": [
                            "fmt"
                          ],
                          "type": "object",
                          "additionalProperties": false
                        },
                        "variables": {
                          "description": "Variables are the list of variables whose values will be retrieved and combined.",
                          "items": {
                            "description": "A CombineVariable defines the source of a value that is combined with others to form and patch an output value. Currently, this only supports retrieving values from a field path.",
                            "properties": {
                              "fromFieldPath": {
                                "description": "FromFieldPath is the path of the field on the source whose value is to be used as input.",
                                "type": "string"
                              }
                            },
                            "required": [
                              "fromFieldPath"
                            ],
                            "type": "object",
                            "additionalProperties": false
                          },
                          "minItems": 1,
                          "type": "array"
                        }
                      },
                      "required": [
                        "strategy",
                        "variables"
                      ],
                      "type": "object",
                      "additionalProperties": false
                    },
                    "fromFieldPath": {
                      "description": "FromFieldPath is the path of the field on the resource whose value is to be used as input. Required when type is FromCompositeFieldPath or ToCompositeFieldPath.",
                      "type": "string"
                    },
                    "patchSetName": {
                      "description": "PatchSetName to include patches from. Required when type is PatchSet.",
                      "type": "string"
                    },
                    "policy": {
                      "description": "Policy configures the specifics of patching behaviour.",
                      "properties": {
                        "fromFieldPath": {
                          "description": "FromFieldPath specifies how to patch from a field path. The default is 'Optional', which means the patch will be a no-op if the specified fromFieldPath does not exist. Use 'Required' if the patch should fail if the specified path does not exist.",
                          "enum": [
                            "Optional",
                            "Required"
                          ],
                          "type": "string"
                        }
                      },
                      "type": "object",
                      "additionalProperties": false
                    },
                    "toFieldPath": {
                      "description": "ToFieldPath is the path of the field on the resource whose value will be changed with the result of transforms. Leave empty if you'd like to propagate to the same path as fromFieldPath.",
                      "type": "string"
                    },
                    "transforms": {
                      "description": "Transforms are the list of functions that are used as a FIFO pipe for the input to be transformed.",
                      "items": {
                        "description": "Transform is a unit of process whose input is transformed into an output with the supplied configuration.",
                        "properties": {
                          "convert": {
                            "description": "Convert is used to cast the input into the given output type.",
                            "properties": {
                              "toType": {
                                "description": "ToType is the type of the output of this transform.",
                                "enum": [
                                  "string",
                                  "int",
                                  "int64",
                                  "bool",
                                  "float64"
                                ],
                                "type": "string"
                              }
                            },
                            "required": [
                              "toType"
                            ],
                            "type": "object",
                            "additionalProperties": false
                          },
                          "map": {
                            "additionalProperties": {
                              "x-kubernetes-preserve-unknown-fields": true
                            },
                            "description": "Map uses the input as a key in the given map and returns the value.",
                            "type": "object"
                          },
                          "math": {
                            "description": "Math is used to transform the input via mathematical operations such as multiplication.",
                            "properties": {
                              "multiply": {
                                "description": "Multiply the value.",
                                "format": "int64",
                                "type": "integer"
                              }
                            },
                            "type": "object",
                            "additionalProperties": false
                          },
                          "string": {
                            "description": "String is used to transform the input into a string or a different kind of string. Note that the input does not necessarily need to be a string.",
                            "properties": {
                              "convert": {
                                "description": "Convert the type of conversion to Upper/Lower case.",
                                "enum": [
                                  "ToUpper",
                                  "ToLower",
                                  "ToBase64",
                                  "FromBase64"
                                ],
                                "type": "string"
                              },
                              "fmt": {
                                "description": "Format the input using a Go format string. See https://golang.org/pkg/fmt/ for details.",
                                "type": "string"
                              },
                              "regexp": {
                                "description": "Extract a match from the input using a regular expression.",
                                "properties": {
                                  "group": {
                                    "description": "Group number to match. 0 (the default) matches the entire expression.",
                                    "type": "integer"
                                  },
                                  "match": {
                                    "description": "Match string. May optionally include submatches, aka capture groups. See https://pkg.go.dev/regexp/ for details.",
                                    "type": "string"
                                  }
                                },
                                "required": [
                                  "match"
                                ],
                                "type": "object",
                                "additionalProperties": false
                              },
                              "trim": {
                                "description": "Trim the prefix or suffix from the input",
                                "type": "string"
                              },
                              "type": {
                                "default": "Format",
                                "description": "Type of the string transform to be run.",
                                "enum": [
                                  "Format",
                                  "Convert",
                                  "TrimPrefix",
                                  "TrimSuffix",
                                  "Regexp"
                                ],
                                "type": "string"
                              }
                            },
                            "type": "object",
                            "additionalProperties": false
                          },
                          "type": {
                            "description": "Type of the transform to be run.",
                            "enum": [
                              "map",
                              "math",
                              "string",
                              "convert"
                            ],
                            "type": "string"
                          }
                        },
                        "required": [
                          "type"
                        ],
                        "type": "object",
                        "additionalProperties": false
                      },
                      "type": "array"
                    },
                    "type": {
                      "default": "FromCompositeFieldPath",
                      "description": "Type sets the patching behaviour to be used. Each patch type may require its' own fields to be set on the Patch object.",
                      "enum": [
                        "FromCompositeFieldPath",
                        "PatchSet",
                        "ToCompositeFieldPath",
                        "CombineFromComposite",
                        "CombineToComposite"
                      ],
                      "type": "string"
                    }
                  },
                  "type": "object",
                  "additionalProperties": false
                },
                "type": "array"
              }
            },
            "required": [
              "name",
              "patches"
            ],
            "type": "object",
            "additionalProperties": false
          },
          "type": "array"
        },
        "publishConnectionDetailsWithStoreConfigRef": {
          "default": {
            "name": "default"
          },
          "description": "PublishConnectionDetailsWithStoreConfig specifies the secret store config with which the connection details of composite resources dynamically provisioned using this composition will be published.",
          "properties": {
            "name": {
              "description": "Name of the referenced StoreConfig.",
              "type": "string"
            }
          },
          "required": [
            "name"
          ],
          "type": "object",
          "additionalProperties": false
        },
        "resources": {
          "description": "Resources is the list of resource templates that will be used when a composite resource referring to this composition is created.",
          "items": {
            "description": "ComposedTemplate is used to provide information about how the composed resource should be processed.",
            "properties": {
              "base": {
                "description": "Base is the target resource that the patches will be applied on.",
                "type": "object",
                "x-kubernetes-embedded-resource": true,
                "x-kubernetes-preserve-unknown-fields": true
              },
              "connectionDetails": {
                "description": "ConnectionDetails lists the propagation secret keys from this target resource to the composition instance connection secret.",
                "items": {
                  "description": "ConnectionDetail includes the information about the propagation of the connection information from one secret to another.",
                  "properties": {
                    "fromConnectionSecretKey": {
                      "description": "FromConnectionSecretKey is the key that will be used to fetch the value from the given target resource's secret.",
                      "type": "string"
                    },
                    "fromFieldPath": {
                      "description": "FromFieldPath is the path of the field on the composed resource whose value to be used as input. Name must be specified if the type is FromFieldPath is specified.",
                      "type": "string"
                    },
                    "name": {
                      "description": "Name of the connection secret key that will be propagated to the connection secret of the composition instance. Leave empty if you'd like to use the same key name.",
                      "type": "string"
                    },
                    "type": {
                      "description": "Type sets the connection detail fetching behaviour to be used. Each connection detail type may require its own fields to be set on the ConnectionDetail object. If the type is omitted Crossplane will attempt to infer it based on which other fields were specified.",
                      "enum": [
                        "FromConnectionSecretKey",
                        "FromFieldPath",
                        "FromValue"
                      ],
                      "type": "string"
                    },
                    "value": {
                      "description": "Value that will be propagated to the connection secret of the composition instance. Typically you should use FromConnectionSecretKey instead, but an explicit value may be set to inject a fixed, non-sensitive connection secret values, for example a well-known port. Supercedes FromConnectionSecretKey when set.",
                      "type": "string"
                    }
                  },
                  "type": "object",
                  "additionalProperties": false
                },
                "type": "array"
              },
              "name": {
                "description": "A Name uniquely identifies this entry within its Composition's resources array. Names are optional but *strongly* recommended. When all entries in the resources array are named entries may added, deleted, and reordered as long as their names do not change. When entries are not named the length and order of the resources array should be treated as immutable. Either all or no entries must be named.",
                "type": "string"
              },
              "patches": {
                "description": "Patches will be applied as overlay to the base resource.",
                "items": {
                  "description": "Patch objects are applied between composite and composed resources. Their behaviour depends on the Type selected. The default Type, FromCompositeFieldPath, copies a value from the composite resource to the composed resource, applying any defined transformers.",
                  "properties": {
                    "combine": {
                      "description": "Combine is the patch configuration for a CombineFromComposite or CombineToComposite patch.",
                      "properties": {
                        "strategy": {
                          "description": "Strategy defines the strategy to use to combine the input variable values. Currently only string is supported.",
                          "enum": [
                            "string"
                          ],
                          "type": "string"
                        },
                        "string": {
                          "description": "String declares that input variables should be combined into a single string, using the relevant settings for formatting purposes.",
                          "properties": {
                            "fmt": {
                              "description": "Format the input using a Go format string. See https://golang.org/pkg/fmt/ for details.",
                              "type": "string"
                            }
                          },
                          "required": [
                            "fmt"
                          ],
                          "type": "object",
                          "additionalProperties": false
                        },
                        "variables": {
                          "description": "Variables are the list of variables whose values will be retrieved and combined.",
                          "items": {
                            "description": "A CombineVariable defines the source of a value that is combined with others to form and patch an output value. Currently, this only supports retrieving values from a field path.",
                            "properties": {
                              "fromFieldPath": {
                                "description": "FromFieldPath is the path of the field on the source whose value is to be used as input.",
                                "type": "string"
                              }
                            },
                            "required": [
                              "fromFieldPath"
                            ],
                            "type": "object",
                            "additionalProperties": false
                          },
                          "minItems": 1,
                          "type": "array"
                        }
                      },
                      "required": [
                        "strategy",
                        "variables"
                      ],
                      "type": "object",
                      "additionalProperties": false
                    },
                    "fromFieldPath": {
                      "description": "FromFieldPath is the path of the field on the resource whose value is to be used as input. Required when type is FromCompositeFieldPath or ToCompositeFieldPath.",
                      "type": "string"
                    },
                    "patchSetName": {
                      "description": "PatchSetName to include patches from. Required when type is PatchSet.",
                      "type": "string"
                    },
                    "policy": {
                      "description": "Policy configures the specifics of patching behaviour.",
                      "properties": {
                        "fromFieldPath": {
                          "description": "FromFieldPath specifies how to patch from a field path. The default is 'Optional', which means the patch will be a no-op if the specified fromFieldPath does not exist. Use 'Required' if the patch should fail if the specified path does not exist.",
                          "enum": [
                            "Optional",
                            "Required"
                          ],
                          "type": "string"
                        }
                      },
                      "type": "object",
                      "additionalProperties": false
                    },
                    "toFieldPath": {
                      "description": "ToFieldPath is the path of the field on the resource whose value will be changed with the result of transforms. Leave empty if you'd like to propagate to the same path as fromFieldPath.",
                      "type": "string"
                    },
                    "transforms": {
                      "description": "Transforms are the list of functions that are used as a FIFO pipe for the input to be transformed.",
                      "items": {
                        "description": "Transform is a unit of process whose input is transformed into an output with the supplied configuration.",
                        "properties": {
                          "convert": {
                            "description": "Convert is used to cast the input into the given output type.",
                            "properties": {
                              "toType": {
                                "description": "ToType is the type of the output of this transform.",
                                "enum": [
                                  "string",
                                  "int",
                                  "int64",
                                  "bool",
                                  "float64"
                                ],
                                "type": "string"
                              }
                            },
                            "required": [
                              "toType"
                            ],
                            "type": "object",
                            "additionalProperties": false
                          },
                          "map": {
                            "additionalProperties": {
                              "x-kubernetes-preserve-unknown-fields": true
                            },
                            "description": "Map uses the input as a key in the given map and returns the value.",
                            "type": "object"
                          },
                          "math": {
                            "description": "Math is used to transform the input via mathematical operations such as multiplication.",
                            "properties": {
                              "multiply": {
                                "description": "Multiply the value.",
                                "format": "int64",
                                "type": "integer"
                              }
                            },
                            "type": "object",
                            "additionalProperties": false
                          },
                          "string": {
                            "description": "String is used to transform the input into a string or a different kind of string. Note that the input does not necessarily need to be a string.",
                            "properties": {
                              "convert": {
                                "description": "Convert the type of conversion to Upper/Lower case.",
                                "enum": [
                                  "ToUpper",
                                  "ToLower",
                                  "ToBase64",
                                  "FromBase64"
                                ],
                                "type": "string"
                              },
                              "fmt": {
                                "description": "Format the input using a Go format string. See https://golang.org/pkg/fmt/ for details.",
                                "type": "string"
                              },
                              "regexp": {
                                "description": "Extract a match from the input using a regular expression.",
                                "properties": {
                                  "group": {
                                    "description": "Group number to match. 0 (the default) matches the entire expression.",
                                    "type": "integer"
                                  },
                                  "match": {
                                    "description": "Match string. May optionally include submatches, aka capture groups. See https://pkg.go.dev/regexp/ for details.",
                                    "type": "string"
                                  }
                                },
                                "required": [
                                  "match"
                                ],
                                "type": "object",
                                "additionalProperties": false
                              },
                              "trim": {
                                "description": "Trim the prefix or suffix from the input",
                                "type": "string"
                              },
                              "type": {
                                "default": "Format",
                                "description": "Type of the string transform to be run.",
                                "enum": [
                                  "Format",
                                  "Convert",
                                  "TrimPrefix",
                                  "TrimSuffix",
                                  "Regexp"
                                ],
                                "type": "string"
                              }
                            },
                            "type": "object",
                            "additionalProperties": false
                          },
                          "type": {
                            "description": "Type of the transform to be run.",
                            "enum": [
                              "map",
                              "math",
                              "string",
                              "convert"
                            ],
                            "type": "string"
                          }
                        },
                        "required": [
                          "type"
                        ],
                        "type": "object",
                        "additionalProperties": false
                      },
                      "type": "array"
                    },
                    "type": {
                      "default": "FromCompositeFieldPath",
                      "description": "Type sets the patching behaviour to be used. Each patch type may require its' own fields to be set on the Patch object.",
                      "enum": [
                        "FromCompositeFieldPath",
                        "PatchSet",
                        "ToCompositeFieldPath",
                        "CombineFromComposite",
                        "CombineToComposite"
                      ],
                      "type": "string"
                    }
                  },
                  "type": "object",
                  "additionalProperties": false
                },
                "type": "array"
              },
              "readinessChecks": {
                "description": "ReadinessChecks allows users to define custom readiness checks. All checks have to return true in order for resource to be considered ready. The default readiness check is to have the \"Ready\" condition to be \"True\".",
                "items": {
                  "description": "ReadinessCheck is used to indicate how to tell whether a resource is ready for consumption",
                  "properties": {
                    "fieldPath": {
                      "description": "FieldPath shows the path of the field whose value will be used.",
                      "type": "string"
                    },
                    "matchInteger": {
                      "description": "MatchInt is the value you'd like to match if you're using \"MatchInt\" type.",
                      "format": "int64",
                      "type": "integer"
                    },
                    "matchString": {
                      "description": "MatchString is the value you'd like to match if you're using \"MatchString\" type.",
                      "type": "string"
                    },
                    "type": {
                      "description": "Type indicates the type of probe you'd like to use.",
                      "enum": [
                        "MatchString",
                        "MatchInteger",
                        "NonEmpty",
                        "None"
                      ],
                      "type": "string"
                    }
                  },
                  "required": [
                    "type"
                  ],
                  "type": "object",
                  "additionalProperties": false
                },
                "type": "array"
              }
            },
            "required": [
              "base"
            ],
            "type": "object",
            "additionalProperties": false
          },
          "type": "array"
        },
        "revision": {
          "description": "Revision number. Newer revisions have larger numbers.",
          "format": "int64",
          "type": "integer"
        },
        "writeConnectionSecretsToNamespace": {
          "description": "WriteConnectionSecretsToNamespace specifies the namespace in which the connection secrets of composite resource dynamically provisioned using this composition will be created. This field is planned to be removed in a future release in favor of PublishConnectionDetailsWithStoreConfigRef. Currently, both could be set independently and connection details would be published to both without affecting each other as long as related fields at MR level specified.",
          "type": "string"
        }
      },
      "required": [
        "compositeTypeRef",
        "resources",
        "revision"
      ],
      "type": "object",
      "additionalProperties": false
    },
    "status": {
      "description": "CompositionRevisionStatus shows the observed state of the composition revision.",
      "properties": {
        "conditions": {
          "description": "Conditions of the resource.",
          "items": {
            "description": "A Condition that may apply to a resource.",
            "properties": {
              "lastTransitionTime": {
                "description": "LastTransitionTime is the last time this condition transitioned from one status to another.",
                "format": "date-time",
                "type": "string"
              },
              "message": {
                "description": "A Message containing details about this condition's last transition from one status to another, if any.",
                "type": "string"
              },
              "reason": {
                "description": "A Reason for this condition's last transition from one status to another.",
                "type": "string"
              },
              "status": {
                "description": "Status of this condition; is it currently True, False, or Unknown?",
                "type": "string"
              },
              "type": {
                "description": "Type of this condition. At most one of each condition type may apply to a resource at any point in time.",
                "type": "string"
              }
            },
            "required": [
              "lastTransitionTime",
              "reason",
              "status",
              "type"
            ],
            "type": "object",
            "additionalProperties": false
          },
          "type": "array"
        }
      },
      "type": "object",
      "additionalProperties": false
    }
  },
  "type": "object"
}