Table of Contents

Manifest Reference

You can reference the manifest JSON-Schema in your manifest.json files by adding the attribute $schema to your descriptor:

{
    "$schema": "https://rmannibucau.github.com/Cezanne/docs/generated/schema/manifest.jsonschema.json"
}
Note

For compatibility with Yupiik BundleBee, alveoli attribute is supported instead of recipes but is not mentionned in the schema for now.

Here is its content:

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "title": "Manifest",
  "description": "Root descriptor holding the recipes.",
  "default": [],
  "example": [
    []
  ],
  "type": "object",
  "properties": {
    "ignoredLintingRules": {
      "type": "array",
      "items": {
        "title": "Name",
        "description": "Name of the rule to ignore.",
        "type": "object",
        "properties": {
          "name": {
            "type": [
              "string",
              "null"
            ]
          }
        }
      }
    },
    "interpolateRecipe": {
      "type": "boolean"
    },
    "recipes": {
      "type": "array",
      "items": {
        "title": "Placeholders",
        "description": "Local placeholders for this particular recipe and its dependencies. It is primarly intended to be able to create a template recipe and inject the placeholders inline.",
        "default": {},
        "example": [
          {}
        ],
        "type": "object",
        "properties": {
          "chainDependencies": {
            "type": [
              "boolean",
              "null"
            ]
          },
          "dependencies": {
            "type": [
              "array",
              "null"
            ],
            "items": {
              "title": "Include If",
              "description": "Conditions to include this dependency. Enables for example to have an environment variable enabling part of the stack (ex: `MONITORING=true`)",
              "type": "object",
              "properties": {
                "includeIf": {
                  "title": "Conditions",
                  "description": "List of condition to match according `operator`.",
                  "default": [],
                  "example": [
                    []
                  ],
                  "type": [
                    "object",
                    "null"
                  ],
                  "properties": {
                    "conditions": {
                      "type": [
                        "array",
                        "null"
                      ],
                      "items": {
                        "title": "Value",
                        "description": "Expected value. If empty/null, `true` is assumed. Note that empty is allowed.",
                        "default": false,
                        "example": [
                          false
                        ],
                        "type": "object",
                        "properties": {
                          "key": {
                            "type": [
                              "string",
                              "null"
                            ]
                          },
                          "negate": {
                            "type": [
                              "boolean",
                              "null"
                            ]
                          },
                          "type": {
                            "description": "Potential values: ENV - Key is read from process environment variables, SYSTEM_PROPERTY - Key is read from application settings, either `cezanne` section or `AppSettings`.",
                            "type": [
                              "string",
                              "null"
                            ],
                            "enum": [
                              "ENV",
                              "SYSTEM_PROPERTY"
                            ]
                          },
                          "value": {
                            "type": [
                              "string",
                              "null"
                            ]
                          }
                        }
                      }
                    },
                    "operator": {
                      "description": "Potential values: ANY - At least one condition must match, ALL - All conditions must match.",
                      "type": [
                        "string",
                        "null"
                      ],
                      "enum": [
                        "ANY",
                        "ALL"
                      ]
                    }
                  }
                },
                "location": {
                  "type": [
                    "string",
                    "null"
                  ]
                },
                "name": {
                  "type": [
                    "string",
                    "null"
                  ]
                }
              }
            }
          },
          "description": {
            "type": [
              "string",
              "null"
            ]
          },
          "descriptors": {
            "type": [
              "array",
              "null"
            ],
            "items": {
              "title": "Include If",
              "description": "Conditions to include this descriptor.",
              "default": false,
              "example": [
                false
              ],
              "type": "object",
              "properties": {
                "await": {
                  "type": "boolean"
                },
                "awaitConditions": {
                  "type": [
                    "array",
                    "null"
                  ],
                  "items": {
                    "title": "Command",
                    "description": "Command to apply these conditions to, if not set it will be applied on `apply` command only. Note that for now only `apply` and `delete` commands are supported, others will be ignored.",
                    "default": "apply",
                    "example": [
                      "apply"
                    ],
                    "type": "object",
                    "properties": {
                      "command": {
                        "type": "string"
                      },
                      "conditions": {
                        "type": "array",
                        "items": {
                          "title": "Value",
                          "description": "When condition type is `JSON_POINTER` and `operatorType` needs a value (`EQUALS` for example), the related value. It can be `Active` if you test namespace `/status/phase` for example. When condition type is `STATUS_CONDITION` it is the expected status.",
                          "default": "EQUALS_VALUE",
                          "example": [
                            "EQUALS_VALUE"
                          ],
                          "type": "object",
                          "properties": {
                            "conditionType": {
                              "type": [
                                "string",
                                "null"
                              ]
                            },
                            "operatorType": {
                              "description": "Potential values: EXISTS - JSON Pointer exists model, MISSING - JSON Pointer does not exist in the resource model, EQUALS - JSON Pointer value is equal to (stringified comparison) value, NOT_EQUALS - JSON Pointer is different from the provided value, EQUALS_IGNORE_CASE - JSON Pointer value is equal (ignoring case) to (stringified comparison) value, NOT_EQUALS_IGNORE_CASE - JSON Pointer is different (ignoring case) from the provided value, CONTAINS - JSON Pointer contains the configured value.",
                              "type": [
                                "string",
                                "null"
                              ],
                              "enum": [
                                "EXISTS",
                                "MISSING",
                                "EQUALS",
                                "NOT_EQUALS",
                                "EQUALS_IGNORE_CASE",
                                "NOT_EQUALS_IGNORE_CASE",
                                "CONTAINS"
                              ]
                            },
                            "pointer": {
                              "type": [
                                "string",
                                "null"
                              ]
                            },
                            "type": {
                              "description": "Potential values: JSON_POINTER - JSON Pointer evaluation (fully custom), STATUS_CONDITION - Evaluate items in `/status/conditions`.",
                              "type": "string",
                              "enum": [
                                "JSON_POINTER",
                                "STATUS_CONDITION"
                              ]
                            },
                            "value": {
                              "type": [
                                "object",
                                "null"
                              ],
                              "properties": {}
                            }
                          },
                          "required": [
                            "type"
                          ]
                        }
                      },
                      "operator": {
                        "description": "Potential values: ANY - At least one condition must match, ALL - All conditions must match.",
                        "type": "string",
                        "enum": [
                          "ANY",
                          "ALL"
                        ]
                      }
                    },
                    "required": [
                      "operator",
                      "conditions",
                      "command"
                    ]
                  }
                },
                "awaitOnDelete": {
                  "type": [
                    "boolean",
                    "null"
                  ]
                },
                "includeIf": {
                  "title": "Conditions",
                  "description": "List of condition to match according `operator`.",
                  "default": [],
                  "example": [
                    []
                  ],
                  "type": [
                    "object",
                    "null"
                  ],
                  "properties": {
                    "conditions": {
                      "type": [
                        "array",
                        "null"
                      ],
                      "items": {
                        "title": "Value",
                        "description": "Expected value. If empty/null, `true` is assumed. Note that empty is allowed.",
                        "default": false,
                        "example": [
                          false
                        ],
                        "type": "object",
                        "properties": {
                          "key": {
                            "type": [
                              "string",
                              "null"
                            ]
                          },
                          "negate": {
                            "type": [
                              "boolean",
                              "null"
                            ]
                          },
                          "type": {
                            "description": "Potential values: ENV - Key is read from process environment variables, SYSTEM_PROPERTY - Key is read from application settings, either `cezanne` section or `AppSettings`.",
                            "type": [
                              "string",
                              "null"
                            ],
                            "enum": [
                              "ENV",
                              "SYSTEM_PROPERTY"
                            ]
                          },
                          "value": {
                            "type": [
                              "string",
                              "null"
                            ]
                          }
                        }
                      }
                    },
                    "operator": {
                      "description": "Potential values: ANY - At least one condition must match, ALL - All conditions must match.",
                      "type": [
                        "string",
                        "null"
                      ],
                      "enum": [
                        "ANY",
                        "ALL"
                      ]
                    }
                  }
                },
                "interpolate": {
                  "type": [
                    "boolean",
                    "null"
                  ]
                },
                "location": {
                  "type": [
                    "string",
                    "null"
                  ]
                },
                "name": {
                  "type": [
                    "string",
                    "null"
                  ]
                },
                "type": {
                  "type": [
                    "string",
                    "null"
                  ]
                }
              },
              "required": [
                "await"
              ]
            }
          },
          "excludedDescriptors": {
            "type": [
              "array",
              "null"
            ],
            "items": {
              "title": "Location",
              "description": "The container of the descriptor (maven coordinates generally).",
              "type": "object",
              "properties": {
                "location": {
                  "type": [
                    "string",
                    "null"
                  ]
                },
                "name": {
                  "type": [
                    "string",
                    "null"
                  ]
                }
              }
            }
          },
          "interpolateDescriptors": {
            "type": [
              "boolean",
              "null"
            ]
          },
          "name": {
            "type": [
              "string",
              "null"
            ]
          },
          "patches": {
            "type": [
              "array",
              "null"
            ],
            "items": {
              "title": "Patch",
              "description": "JSON-Patch to apply on the JSON representation of the descriptor. It enables to inject configuration in descriptors for example, or changing some name/application.",
              "type": "object",
              "properties": {
                "descriptorName": {
                  "type": [
                    "string",
                    "null"
                  ]
                },
                "includeIf": {
                  "title": "Conditions",
                  "description": "List of condition to match according `operator`.",
                  "default": [],
                  "example": [
                    []
                  ],
                  "type": [
                    "object",
                    "null"
                  ],
                  "properties": {
                    "conditions": {
                      "type": [
                        "array",
                        "null"
                      ],
                      "items": {
                        "title": "Value",
                        "description": "Expected value. If empty/null, `true` is assumed. Note that empty is allowed.",
                        "default": false,
                        "example": [
                          false
                        ],
                        "type": "object",
                        "properties": {
                          "key": {
                            "type": [
                              "string",
                              "null"
                            ]
                          },
                          "negate": {
                            "type": [
                              "boolean",
                              "null"
                            ]
                          },
                          "type": {
                            "description": "Potential values: ENV - Key is read from process environment variables, SYSTEM_PROPERTY - Key is read from application settings, either `cezanne` section or `AppSettings`.",
                            "type": [
                              "string",
                              "null"
                            ],
                            "enum": [
                              "ENV",
                              "SYSTEM_PROPERTY"
                            ]
                          },
                          "value": {
                            "type": [
                              "string",
                              "null"
                            ]
                          }
                        }
                      }
                    },
                    "operator": {
                      "description": "Potential values: ANY - At least one condition must match, ALL - All conditions must match.",
                      "type": [
                        "string",
                        "null"
                      ],
                      "enum": [
                        "ANY",
                        "ALL"
                      ]
                    }
                  }
                },
                "interpolate": {
                  "type": [
                    "boolean",
                    "null"
                  ]
                },
                "patch": {
                  "type": [
                    "array",
                    "null"
                  ],
                  "items": {
                    "type": [
                      "object",
                      "null"
                    ]
                  }
                }
              }
            }
          },
          "placeholders": {
            "type": [
              "array",
              "null"
            ],
            "items": {
              "type": "string"
            }
          },
          "version": {
            "type": [
              "string",
              "null"
            ]
          }
        }
      }
    },
    "references": {
      "type": "array",
      "items": {
        "title": "Path",
        "description": "Relative or absolute - starting by a `/` - location (referenced to the base directory of `manifest.json`). For example `my-manifest.json` will resolve to `/path/to/cezanne/my-manifest.json` in a folder and `/cezanne/my-manifest.json` in a jar. Important: for resources (jar/classpath), the classloader is used so ensure your name is unique accross your classpath (we recommend you to prefix it with the module name, ex :`/cezanne/my-module.sub-manifest.json` or use a dedicated subfolder (`/cezanne/my-module/sub.json`).",
        "type": "object",
        "properties": {
          "path": {
            "type": [
              "string",
              "null"
            ]
          }
        }
      }
    },
    "requirements": {
      "type": "array",
      "items": {
        "title": "Forbidden Versions",
        "description": "List of forbidden version (due to a bug or equivalent). Here too snapshot suffix is ignored. `*` is usable there too to replace any digit in a segment (ex: `1.*.*`). Note that `1.*` would *NOT* match `1.*.*`, version are always 3 segments.",
        "default": [],
        "example": [
          []
        ],
        "type": "object",
        "properties": {
          "forbiddenVersions": {
            "type": [
              "array",
              "null"
            ],
            "items": {
              "type": "string"
            }
          },
          "maxBundlebeeVersion": {
            "type": [
              "string",
              "null"
            ]
          },
          "minBundlebeeVersion": {
            "type": [
              "string",
              "null"
            ]
          }
        }
      }
    }
  },
  "required": [
    "ignoredLintingRules",
    "interpolateRecipe",
    "references",
    "requirements",
    "recipes"
  ]
}