schema.json

{
    "$schema": "http://json-schema.org/draft-06/schema#",
    "$ref": "#/definitions/Operator",
    "definitions": {
        "Operator": {
            "type": "object",
            "additionalProperties": false,
            "properties": {
                "name": {
                    "$comment": "The name of the operator. Must start with a $",
                    "type": "string",
                    "pattern": "^\\$?[a-z][a-zA-Z0-9]*$"
                },
                "minVersion": {
                    "$comment": "The minimum version of MongoDB that supports this operator.",
                    "type": "string",
                    "pattern": "^[0-9]+\\.[0-9]+\\.[0-9]+$"
                },
                "link": {
                    "$comment": "The link to the operator's documentation on MongoDB's website.",
                    "type": "string",
                    "format": "uri",
                    "pattern": "^https://"
                },
                "type": {
                    "type": "array",
                    "items": {
                        "type": "string",
                        "enum": [
                            "accumulator",
                            "stage",
                            "query",
                            "fieldQuery",
                            "filter",
                            "window",
                            "geometry",
                            "switchBranch",
                            "resolvesToAny",
                            "resolvesToNumber",
                            "resolvesToDouble",
                            "resolvesToString",
                            "resolvesToObject",
                            "resolvesToArray",
                            "resolvesToBinData",
                            "resolvesToObjectId",
                            "resolvesToBool",
                            "resolvesToDate",
                            "resolvesToNull",
                            "resolvesToRegex",
                            "resolvesToJavascript",
                            "resolvesToInt",
                            "resolvesToTimestamp",
                            "resolvesToLong",
                            "resolvesToDecimal",
                            "searchOperator"
                        ]
                    }
                },
                "encode": {
                    "$comment": [
                        "Specifies how operator parameters are encoded.",
                        "array: parameters are encoded as an array of values in the order they are defined by the spec",
                        "object: parameters are encoded as an object with keys matching the parameter names",
                        "single: get the single parameter value",
                        "group: specific for $group stage"
                    ],
                    "type": "string",
                    "enum": ["array", "object", "single"]
                },
                "description": {
                    "$comment": "The description of the operator from MongoDB's documentation.",
                    "type": "string"
                },
                "wrapObject": {
                    "$comment": "Wrap the properties in an object with the operator name",
                    "type": "boolean",
                    "default": true
                },
                "arguments": {
                    "$comment": "An optional list of arguments for the operator.",
                    "type": "array",
                    "items": {
                        "$ref": "#/definitions/Argument"
                    }
                },
                "tests": {
                    "$comment": "An optional list of examples for the operator.",
                    "type": "array",
                    "items": {
                        "$ref": "#/definitions/Test"
                    }
                }
            },
            "required": ["description", "encode", "link", "name", "type"],
            "title": "Operator"
        },
        "Argument": {
            "type": "object",
            "additionalProperties": false,
            "properties": {
                "name": {
                    "type": "string",
                    "pattern": "^([_$]?[a-z][a-zA-Z0-9]*|N)$"
                },
                "minVersion": {
                    "$comment": "The minimum version of MongoDB that supports this argument.",
                    "type": "string",
                    "pattern": "^[0-9]+\\.[0-9]+\\.[0-9]+$"
                },
                "type": {
                    "type": "array",
                    "items": {
                        "type": "string",
                        "enum": [
                            "accumulator",
                            "query",
                            "fieldQuery",
                            "pipeline",
                            "window",
                            "expression",
                            "geometry",
                            "fieldPath",
                            "timeUnit",
                            "sortSpec",
                            "any",
                            "granularity",
                            "fullDocument",
                            "fullDocumentBeforeChange",
                            "accumulatorPercentile",
                            "whenMatched",
                            "whenNotMatched",
                            "outCollection",
                            "range",
                            "sortBy",
                            "geoPoint",
                            "resolvesToNumber",
                            "numberFieldPath",
                            "number",
                            "resolvesToDouble",
                            "doubleFieldPath",
                            "double",
                            "resolvesToString",
                            "stringFieldPath",
                            "string",
                            "resolvesToObject",
                            "objectFieldPath",
                            "object",
                            "resolvesToArray",
                            "arrayFieldPath",
                            "array",
                            "resolvesToBinData",
                            "binDataFieldPath",
                            "binData",
                            "resolvesToObjectId",
                            "objectIdFieldPath",
                            "objectId",
                            "resolvesToBool",
                            "boolFieldPath",
                            "bool",
                            "resolvesToDate",
                            "dateFieldPath",
                            "date",
                            "resolvesToNull",
                            "nullFieldPath",
                            "null",
                            "resolvesToRegex",
                            "regexFieldPath",
                            "regex",
                            "resolvesToJavascript",
                            "javascriptFieldPath",
                            "javascript",
                            "resolvesToInt",
                            "intFieldPath",
                            "int",
                            "resolvesToTimestamp",
                            "timestampFieldPath",
                            "timestamp",
                            "resolvesToLong",
                            "longFieldPath",
                            "long",
                            "resolvesToDecimal",
                            "decimalFieldPath",
                            "decimal",
                            "searchPath",
                            "searchScore",
                            "searchOperator"
                        ]
                    }
                },
                "description": {
                    "$comment": "The description of the argument from MongoDB's documentation.",
                    "type": "string"
                },
                "optional": {
                    "$comment": "Whether the argument is optional or not.",
                    "type": "boolean"
                },
                "valueMin": {
                    "$comment": "The minimum value for a numeric argument.",
                    "type": "number"
                },
                "valueMax": {
                    "$comment": "The maximum value for a numeric argument.",
                    "type": "number"
                },
                "variadic": {
                    "$comment": "Whether the argument is variadic or not.",
                    "type": "string",
                    "enum": ["array", "object"]
                },
                "variadicMin": {
                    "$comment": "The minimum number of arguments for a variadic parameter.",
                    "type": "integer",
                    "minimum": 0
                },
                "default": {
                    "$comment": "The default value for the argument.",
                    "type": ["array", "boolean", "number", "string"]
                },
                "mergeObject": {
                    "$comment": "Skip the name in object encoding and merge the properties of the value into the operator",
                    "type": "boolean",
                    "default": false
                }
            },
            "required": ["name", "type"],
            "title": "Argument"
        },
        "Test": {
            "type": "object",
            "additionalProperties": false,
            "properties": {
                "name": {
                    "type": "string"
                },
                "link": {
                    "type": "string",
                    "format": "uri",
                    "pattern": "^https://"
                },
                "pipeline": {
                    "type": "array",
                    "items": {
                        "type": "object"
                    }
                },
                "schema": {
                    "type": ["object", "string"],
                    "additionalProperties": {
                        "type": "object",
                        "additionalProperties": {
                            "$ref": "#/definitions/SimplifiedSchemaField"
                        }
                    }
                }
            },
            "required": ["name", "pipeline"]
        },
        "SimplifiedSchemaType": {
            "anyOf": [
                {
                    "$ref": "#/definitions/SimplifiedSchemaBaseType"
                },
                {
                    "$ref": "#/definitions/SimplifiedSchemaArrayType"
                },
                {
                    "$ref": "#/definitions/SimplifiedSchemaDocumentType"
                }
            ]
        },
        "SimplifiedSchemaField": {
            "additionalProperties": false,
            "properties": {
                "types": {
                    "items": {
                        "$ref": "#/definitions/SimplifiedSchemaType"
                    },
                    "type": "array"
                }
            },
            "required": ["types"],
            "type": "object"
        },
        "SimplifiedSchemaArrayType": {
            "additionalProperties": false,
            "properties": {
                "bsonType": {
                    "const": "Array",
                    "type": "string"
                },
                "types": {
                    "items": {
                        "type": "object"
                    },
                    "type": "array"
                }
            },
            "required": ["bsonType", "types"],
            "type": "object"
        },
        "SimplifiedSchemaBaseType": {
            "additionalProperties": false,
            "properties": {
                "bsonType": {
                    "enum": [
                        "Array",
                        "Binary",
                        "Boolean",
                        "Code",
                        "CodeWScope",
                        "Date",
                        "Decimal128",
                        "Double",
                        "Int32",
                        "Int64",
                        "Long",
                        "MaxKey",
                        "MinKey",
                        "Null",
                        "ObjectId",
                        "BSONRegExp",
                        "String",
                        "BSONSymbol",
                        "Timestamp",
                        "Undefined",
                        "Document",
                        "Number"
                    ],
                    "type": "string"
                }
            },
            "required": ["bsonType"],
            "type": "object"
        },
        "SimplifiedSchemaDocumentType": {
            "additionalProperties": false,
            "properties": {
                "bsonType": {
                    "const": "Document",
                    "type": "string"
                },
                "fields": {
                    "type": "object",
                    "additionalProperties": {
                        "type": "object"
                    }
                }
            },
            "required": ["bsonType", "fields"],
            "type": "object"
        }
    }
}