878 lines
20 KiB
Rust
878 lines
20 KiB
Rust
use crate::*;
|
|
use serde_json::{json, Value};
|
|
use pgrx::JsonB;
|
|
|
|
// Helper to convert Value to JsonB
|
|
fn jsonb(val: Value) -> JsonB {
|
|
JsonB(val)
|
|
}
|
|
|
|
pub fn simple_schemas() -> JsonB {
|
|
let enums = json!([]);
|
|
let types = json!([]);
|
|
let puncs = json!([{
|
|
"name": "simple",
|
|
"public": false,
|
|
"schemas": [{
|
|
"$id": "simple.request",
|
|
"type": "object",
|
|
"properties": {
|
|
"name": { "type": "string" },
|
|
"age": { "type": "integer", "minimum": 0 }
|
|
},
|
|
"required": ["name", "age"]
|
|
}]
|
|
}]);
|
|
|
|
cache_json_schemas(jsonb(enums), jsonb(types), jsonb(puncs))
|
|
}
|
|
|
|
pub fn invalid_schemas() -> JsonB {
|
|
let enums = json!([]);
|
|
let types = json!([]);
|
|
let puncs = json!([{
|
|
"name": "invalid_punc",
|
|
"public": false,
|
|
"schemas": [{
|
|
"$id": "invalid_punc.request",
|
|
"type": ["invalid_type_value"]
|
|
}]
|
|
}]);
|
|
|
|
cache_json_schemas(jsonb(enums), jsonb(types), jsonb(puncs))
|
|
}
|
|
|
|
pub fn errors_schemas() -> JsonB {
|
|
let enums = json!([]);
|
|
let types = json!([]);
|
|
let puncs = json!([{
|
|
"name": "detailed_errors_test",
|
|
"public": false,
|
|
"schemas": [{
|
|
"$id": "detailed_errors_test.request",
|
|
"type": "object",
|
|
"properties": {
|
|
"address": {
|
|
"type": "object",
|
|
"properties": {
|
|
"street": { "type": "string" },
|
|
"city": { "type": "string", "maxLength": 10 }
|
|
},
|
|
"required": ["street", "city"]
|
|
}
|
|
},
|
|
"required": ["address"]
|
|
}]
|
|
}]);
|
|
|
|
cache_json_schemas(jsonb(enums), jsonb(types), jsonb(puncs))
|
|
}
|
|
|
|
pub fn oneof_schemas() -> JsonB {
|
|
let enums = json!([]);
|
|
let types = json!([]);
|
|
let puncs = json!([{
|
|
"name": "oneof_test",
|
|
"public": false,
|
|
"schemas": [{
|
|
"$id": "oneof_test.request",
|
|
"oneOf": [
|
|
{
|
|
"type": "object",
|
|
"properties": {
|
|
"string_prop": { "type": "string", "maxLength": 5 }
|
|
},
|
|
"required": ["string_prop"]
|
|
},
|
|
{
|
|
"type": "object",
|
|
"properties": {
|
|
"number_prop": { "type": "number", "minimum": 10 }
|
|
},
|
|
"required": ["number_prop"]
|
|
}
|
|
]
|
|
}]
|
|
}]);
|
|
|
|
cache_json_schemas(jsonb(enums), jsonb(types), jsonb(puncs))
|
|
}
|
|
|
|
pub fn root_types_schemas() -> JsonB {
|
|
let enums = json!([]);
|
|
let types = json!([]);
|
|
let puncs = json!([
|
|
{
|
|
"name": "object_test",
|
|
"public": false,
|
|
"schemas": [{
|
|
"$id": "object_test.request",
|
|
"type": "object",
|
|
"properties": {
|
|
"name": { "type": "string" },
|
|
"age": { "type": "integer", "minimum": 0 }
|
|
},
|
|
"required": ["name", "age"]
|
|
}]
|
|
},
|
|
{
|
|
"name": "array_test",
|
|
"public": false,
|
|
"schemas": [{
|
|
"$id": "array_test.request",
|
|
"type": "array",
|
|
"items": {
|
|
"type": "object",
|
|
"properties": {
|
|
"id": { "type": "string", "format": "uuid" }
|
|
}
|
|
}
|
|
}]
|
|
}
|
|
]);
|
|
|
|
cache_json_schemas(jsonb(enums), jsonb(types), jsonb(puncs))
|
|
}
|
|
|
|
pub fn strict_schemas() -> JsonB {
|
|
let enums = json!([]);
|
|
let types = json!([]);
|
|
let puncs = json!([
|
|
{
|
|
"name": "basic_strict_test",
|
|
"public": true,
|
|
"schemas": [{
|
|
"$id": "basic_strict_test.request",
|
|
"type": "object",
|
|
"properties": {
|
|
"name": { "type": "string" }
|
|
}
|
|
}]
|
|
},
|
|
{
|
|
"name": "non_strict_test",
|
|
"public": false,
|
|
"schemas": [{
|
|
"$id": "non_strict_test.request",
|
|
"type": "object",
|
|
"properties": {
|
|
"name": { "type": "string" }
|
|
}
|
|
}]
|
|
},
|
|
{
|
|
"name": "nested_strict_test",
|
|
"public": true,
|
|
"schemas": [{
|
|
"$id": "nested_strict_test.request",
|
|
"type": "object",
|
|
"properties": {
|
|
"user": {
|
|
"type": "object",
|
|
"properties": {
|
|
"name": { "type": "string" }
|
|
}
|
|
},
|
|
"items": {
|
|
"type": "array",
|
|
"items": {
|
|
"type": "object",
|
|
"properties": {
|
|
"id": { "type": "string" }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}]
|
|
},
|
|
{
|
|
"name": "already_unevaluated_test",
|
|
"public": true,
|
|
"schemas": [{
|
|
"$id": "already_unevaluated_test.request",
|
|
"type": "object",
|
|
"properties": {
|
|
"name": { "type": "string" }
|
|
},
|
|
"unevaluatedProperties": true
|
|
}]
|
|
},
|
|
{
|
|
"name": "already_additional_test",
|
|
"public": true,
|
|
"schemas": [{
|
|
"$id": "already_additional_test.request",
|
|
"type": "object",
|
|
"properties": {
|
|
"name": { "type": "string" }
|
|
},
|
|
"additionalProperties": false
|
|
}]
|
|
},
|
|
{
|
|
"name": "conditional_strict_test",
|
|
"public": true,
|
|
"schemas": [{
|
|
"$id": "conditional_strict_test.request",
|
|
"type": "object",
|
|
"properties": {
|
|
"creating": { "type": "boolean" }
|
|
},
|
|
"if": {
|
|
"properties": {
|
|
"creating": { "const": true }
|
|
}
|
|
},
|
|
"then": {
|
|
"properties": {
|
|
"name": { "type": "string" }
|
|
},
|
|
"required": ["name"]
|
|
}
|
|
}]
|
|
}
|
|
]);
|
|
|
|
cache_json_schemas(jsonb(enums), jsonb(types), jsonb(puncs))
|
|
}
|
|
|
|
pub fn required_schemas() -> JsonB {
|
|
let enums = json!([]);
|
|
let types = json!([]);
|
|
let puncs = json!([{
|
|
"name": "basic_validation_test",
|
|
"public": false,
|
|
"schemas": [{
|
|
"$id": "basic_validation_test.request",
|
|
"type": "object",
|
|
"properties": {
|
|
"name": { "type": "string" },
|
|
"age": { "type": "integer", "minimum": 0 }
|
|
},
|
|
"required": ["name", "age"]
|
|
}]
|
|
}]);
|
|
|
|
cache_json_schemas(jsonb(enums), jsonb(types), jsonb(puncs))
|
|
}
|
|
|
|
pub fn dependencies_schemas() -> JsonB {
|
|
let enums = json!([]);
|
|
let types = json!([]);
|
|
let puncs = json!([{
|
|
"name": "dependency_split_test",
|
|
"public": false,
|
|
"schemas": [{
|
|
"$id": "dependency_split_test.request",
|
|
"type": "object",
|
|
"properties": {
|
|
"creating": { "type": "boolean" },
|
|
"name": { "type": "string" },
|
|
"kind": { "type": "string" },
|
|
"description": { "type": "string" }
|
|
},
|
|
"dependencies": {
|
|
"creating": ["name", "kind"]
|
|
}
|
|
}]
|
|
}]);
|
|
|
|
cache_json_schemas(jsonb(enums), jsonb(types), jsonb(puncs))
|
|
}
|
|
|
|
pub fn nested_req_deps_schemas() -> JsonB {
|
|
let enums = json!([]);
|
|
let types = json!([]);
|
|
let puncs = json!([{
|
|
"name": "nested_dep_test",
|
|
"public": false,
|
|
"schemas": [{
|
|
"$id": "nested_dep_test.request",
|
|
"type": "object",
|
|
"properties": {
|
|
"items": {
|
|
"type": "array",
|
|
"items": {
|
|
"type": "object",
|
|
"properties": {
|
|
"id": { "type": "string" },
|
|
"creating": { "type": "boolean" },
|
|
"name": { "type": "string" },
|
|
"kind": { "type": "string" }
|
|
},
|
|
"required": ["id"],
|
|
"dependencies": {
|
|
"creating": ["name", "kind"]
|
|
}
|
|
}
|
|
}
|
|
},
|
|
"required": ["items"]
|
|
}]
|
|
}]);
|
|
|
|
cache_json_schemas(jsonb(enums), jsonb(types), jsonb(puncs))
|
|
}
|
|
|
|
pub fn additional_properties_schemas() -> JsonB {
|
|
let enums = json!([]);
|
|
let types = json!([]);
|
|
let puncs = json!([
|
|
{
|
|
"name": "additional_props_test",
|
|
"public": false,
|
|
"schemas": [{
|
|
"$id": "additional_props_test.request",
|
|
"type": "object",
|
|
"properties": {
|
|
"name": { "type": "string" },
|
|
"age": { "type": "number" }
|
|
},
|
|
"additionalProperties": false
|
|
}]
|
|
},
|
|
{
|
|
"name": "nested_additional_props_test",
|
|
"public": false,
|
|
"schemas": [{
|
|
"$id": "nested_additional_props_test.request",
|
|
"type": "object",
|
|
"properties": {
|
|
"user": {
|
|
"type": "object",
|
|
"properties": {
|
|
"name": { "type": "string" }
|
|
},
|
|
"additionalProperties": false
|
|
}
|
|
}
|
|
}]
|
|
}
|
|
]);
|
|
|
|
cache_json_schemas(jsonb(enums), jsonb(types), jsonb(puncs))
|
|
}
|
|
|
|
pub fn unevaluated_properties_schemas() -> JsonB {
|
|
let enums = json!([]);
|
|
let types = json!([]);
|
|
let puncs = json!([
|
|
{
|
|
"name": "simple_unevaluated_test",
|
|
"public": false,
|
|
"schemas": [{
|
|
"$id": "simple_unevaluated_test.request",
|
|
"type": "object",
|
|
"properties": {
|
|
"name": { "type": "string" },
|
|
"age": { "type": "number" }
|
|
},
|
|
"patternProperties": {
|
|
"^attr_": { "type": "string" }
|
|
},
|
|
"unevaluatedProperties": false
|
|
}]
|
|
},
|
|
{
|
|
"name": "conditional_unevaluated_test",
|
|
"public": false,
|
|
"schemas": [{
|
|
"$id": "conditional_unevaluated_test.request",
|
|
"type": "object",
|
|
"allOf": [
|
|
{
|
|
"properties": {
|
|
"firstName": { "type": "string" }
|
|
}
|
|
},
|
|
{
|
|
"properties": {
|
|
"lastName": { "type": "string" }
|
|
}
|
|
}
|
|
],
|
|
"properties": {
|
|
"age": { "type": "number" }
|
|
},
|
|
"unevaluatedProperties": false
|
|
}]
|
|
}
|
|
]);
|
|
|
|
cache_json_schemas(jsonb(enums), jsonb(types), jsonb(puncs))
|
|
}
|
|
|
|
pub fn format_schemas() -> JsonB {
|
|
let enums = json!([]);
|
|
let types = json!([]);
|
|
let puncs = json!([{
|
|
"name": "format_test",
|
|
"public": false,
|
|
"schemas": [{
|
|
"$id": "format_test.request",
|
|
"type": "object",
|
|
"properties": {
|
|
"uuid": { "type": "string", "format": "uuid" },
|
|
"date_time": { "type": "string", "format": "date-time" },
|
|
"email": { "type": "string", "format": "email" }
|
|
}
|
|
}]
|
|
}]);
|
|
|
|
cache_json_schemas(jsonb(enums), jsonb(types), jsonb(puncs))
|
|
}
|
|
|
|
pub fn property_merging_schemas() -> JsonB {
|
|
let enums = json!([]);
|
|
let types = json!([
|
|
{
|
|
"name": "entity",
|
|
"schemas": [{
|
|
"$id": "entity",
|
|
"type": "object",
|
|
"properties": {
|
|
"id": { "type": "string" },
|
|
"name": { "type": "string" },
|
|
"type": { "type": "string" }
|
|
},
|
|
"required": ["id"]
|
|
}]
|
|
},
|
|
{
|
|
"name": "user",
|
|
"schemas": [{
|
|
"$id": "user",
|
|
"$ref": "entity",
|
|
"properties": {
|
|
"password": { "type": "string", "minLength": 8 }
|
|
},
|
|
"required": ["password"]
|
|
}]
|
|
},
|
|
{
|
|
"name": "person",
|
|
"schemas": [{
|
|
"$id": "person",
|
|
"$ref": "user",
|
|
"properties": {
|
|
"first_name": { "type": "string", "minLength": 1 },
|
|
"last_name": { "type": "string", "minLength": 1 }
|
|
},
|
|
"required": ["first_name", "last_name"]
|
|
}]
|
|
}
|
|
]);
|
|
|
|
let puncs = json!([]);
|
|
|
|
cache_json_schemas(jsonb(enums), jsonb(types), jsonb(puncs))
|
|
}
|
|
|
|
pub fn required_merging_schemas() -> JsonB {
|
|
let enums = json!([]);
|
|
|
|
let types = json!([
|
|
{
|
|
"name": "entity",
|
|
"schemas": [{
|
|
"$id": "entity",
|
|
"type": "object",
|
|
"properties": {
|
|
"id": { "type": "string", "format": "uuid" },
|
|
"type": { "type": "string" },
|
|
"created_by": { "type": "string", "format": "uuid" }
|
|
},
|
|
"required": ["id", "type", "created_by"]
|
|
}]
|
|
},
|
|
{
|
|
"name": "user",
|
|
"schemas": [{
|
|
"$id": "user",
|
|
"$ref": "entity",
|
|
"properties": {
|
|
"password": { "type": "string", "minLength": 8 }
|
|
},
|
|
"if": {
|
|
"properties": { "type": { "const": "user" } }
|
|
},
|
|
"then": {
|
|
"required": ["password"]
|
|
}
|
|
}]
|
|
},
|
|
{
|
|
"name": "person",
|
|
"schemas": [{
|
|
"$id": "person",
|
|
"$ref": "user",
|
|
"properties": {
|
|
"first_name": { "type": "string", "minLength": 1 },
|
|
"last_name": { "type": "string", "minLength": 1 }
|
|
},
|
|
"if": {
|
|
"properties": { "type": { "const": "person" } }
|
|
},
|
|
"then": {
|
|
"required": ["first_name", "last_name"]
|
|
}
|
|
}]
|
|
}
|
|
]);
|
|
|
|
let puncs = json!([]);
|
|
|
|
cache_json_schemas(jsonb(enums), jsonb(types), jsonb(puncs))
|
|
}
|
|
|
|
pub fn dependencies_merging_schemas() -> JsonB {
|
|
let enums = json!([]);
|
|
|
|
let types = json!([
|
|
{
|
|
"name": "entity",
|
|
"schemas": [{
|
|
"$id": "entity",
|
|
"type": "object",
|
|
"properties": {
|
|
"id": { "type": "string", "format": "uuid" },
|
|
"type": { "type": "string" },
|
|
"created_by": { "type": "string", "format": "uuid" },
|
|
"creating": { "type": "boolean" },
|
|
"name": { "type": "string" }
|
|
},
|
|
"required": ["id", "type", "created_by"],
|
|
"dependencies": {
|
|
"creating": ["name"]
|
|
}
|
|
}]
|
|
},
|
|
{
|
|
"name": "user",
|
|
"schemas": [{
|
|
"$id": "user",
|
|
"$ref": "entity",
|
|
"properties": {
|
|
"password": { "type": "string", "minLength": 8 }
|
|
},
|
|
"dependencies": {
|
|
"creating": ["name"]
|
|
}
|
|
}]
|
|
},
|
|
{
|
|
"name": "person",
|
|
"schemas": [{
|
|
"$id": "person",
|
|
"$ref": "user",
|
|
"properties": {
|
|
"first_name": { "type": "string", "minLength": 1 },
|
|
"last_name": { "type": "string", "minLength": 1 }
|
|
},
|
|
"dependencies": {
|
|
"creating": ["first_name", "last_name"]
|
|
}
|
|
}]
|
|
}
|
|
]);
|
|
|
|
let puncs = json!([]);
|
|
|
|
cache_json_schemas(jsonb(enums), jsonb(types), jsonb(puncs))
|
|
}
|
|
|
|
pub fn punc_with_refs_schemas() -> JsonB {
|
|
let enums = json!([]);
|
|
|
|
let types = json!([
|
|
{
|
|
"name": "entity",
|
|
"schemas": [{
|
|
"$id": "entity",
|
|
"type": "object",
|
|
"properties": {
|
|
"id": { "type": "string" },
|
|
"name": { "type": "string" },
|
|
"type": { "type": "string" }
|
|
},
|
|
"required": ["id", "type"]
|
|
}]
|
|
},
|
|
{
|
|
"name": "person",
|
|
"schemas": [{
|
|
"$id": "person",
|
|
"$ref": "entity",
|
|
"properties": {
|
|
"first_name": { "type": "string", "minLength": 1 },
|
|
"last_name": { "type": "string", "minLength": 1 },
|
|
"address": {
|
|
"type": "object",
|
|
"properties": {
|
|
"street": { "type": "string" },
|
|
"city": { "type": "string" }
|
|
},
|
|
"required": ["street", "city"]
|
|
}
|
|
}
|
|
}]
|
|
}
|
|
]);
|
|
|
|
let puncs = json!([
|
|
{
|
|
"name": "public_ref_test",
|
|
"public": true,
|
|
"schemas": [{
|
|
"$id": "public_ref_test.request",
|
|
"$ref": "person"
|
|
}]
|
|
},
|
|
{
|
|
"name": "private_ref_test",
|
|
"public": false,
|
|
"schemas": [{
|
|
"$id": "private_ref_test.request",
|
|
"$ref": "person"
|
|
}]
|
|
}
|
|
]);
|
|
|
|
cache_json_schemas(jsonb(enums), jsonb(types), jsonb(puncs))
|
|
}
|
|
|
|
pub fn enum_schemas() -> JsonB {
|
|
let enums = json!([
|
|
{
|
|
"name": "task_priority",
|
|
"values": ["low", "medium", "high", "urgent"],
|
|
"schemas": [{
|
|
"$id": "task_priority",
|
|
"type": "string",
|
|
"enum": ["low", "medium", "high", "urgent"]
|
|
}]
|
|
}
|
|
]);
|
|
|
|
let types = json!([]);
|
|
|
|
let puncs = json!([{
|
|
"name": "enum_ref_test",
|
|
"public": false,
|
|
"schemas": [{
|
|
"$id": "enum_ref_test.request",
|
|
"type": "object",
|
|
"properties": {
|
|
"priority": { "$ref": "task_priority" }
|
|
},
|
|
"required": ["priority"]
|
|
}]
|
|
}]);
|
|
|
|
cache_json_schemas(jsonb(enums), jsonb(types), jsonb(puncs))
|
|
}
|
|
|
|
pub fn punc_local_refs_schemas() -> JsonB {
|
|
let enums = json!([]);
|
|
|
|
let types = json!([
|
|
{
|
|
"name": "global_thing",
|
|
"schemas": [{
|
|
"$id": "global_thing",
|
|
"type": "object",
|
|
"properties": {
|
|
"id": { "type": "string", "format": "uuid" },
|
|
"type": { "type": "string" }
|
|
},
|
|
"required": ["id", "type"]
|
|
}]
|
|
}
|
|
]);
|
|
|
|
let puncs = json!([
|
|
{
|
|
"name": "punc_with_local_ref_test",
|
|
"public": false,
|
|
"schemas": [
|
|
{
|
|
"$id": "local_address",
|
|
"type": "object",
|
|
"properties": {
|
|
"street": { "type": "string" },
|
|
"city": { "type": "string" }
|
|
},
|
|
"required": ["street", "city"]
|
|
},
|
|
{
|
|
"$id": "punc_with_local_ref_test.request",
|
|
"$ref": "local_address"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
"name": "punc_with_local_ref_to_global_test",
|
|
"public": false,
|
|
"schemas": [
|
|
{
|
|
"$id": "local_user_with_thing",
|
|
"type": "object",
|
|
"properties": {
|
|
"user_name": { "type": "string" },
|
|
"thing": { "$ref": "global_thing" }
|
|
},
|
|
"required": ["user_name", "thing"]
|
|
},
|
|
{
|
|
"$id": "punc_with_local_ref_to_global_test.request",
|
|
"$ref": "local_user_with_thing"
|
|
}
|
|
]
|
|
}
|
|
]);
|
|
|
|
cache_json_schemas(jsonb(enums), jsonb(types), jsonb(puncs))
|
|
}
|
|
|
|
pub fn title_override_schemas() -> JsonB {
|
|
let enums = json!([]);
|
|
|
|
let types = json!([
|
|
{
|
|
"name": "base_with_title",
|
|
"schemas": [{
|
|
"$id": "base_with_title",
|
|
"type": "object",
|
|
"title": "Base Title",
|
|
"properties": {
|
|
"name": { "type": "string" },
|
|
"type": { "type": "string" }
|
|
},
|
|
"required": ["name"]
|
|
}]
|
|
},
|
|
{
|
|
"name": "override_with_title",
|
|
"schemas": [{
|
|
"$id": "override_with_title",
|
|
"$ref": "base_with_title",
|
|
"title": "Override Title"
|
|
}]
|
|
}
|
|
]);
|
|
|
|
let puncs = json!([]);
|
|
|
|
cache_json_schemas(jsonb(enums), jsonb(types), jsonb(puncs))
|
|
}
|
|
|
|
pub fn format_with_ref_schemas() -> JsonB {
|
|
let enums = json!([]);
|
|
let types = json!([
|
|
{
|
|
"name": "entity",
|
|
"schemas": [{
|
|
"$id": "entity",
|
|
"type": "object",
|
|
"properties": {
|
|
"id": { "type": "string", "format": "uuid" },
|
|
"type": { "type": "string" },
|
|
"name": { "type": "string" }
|
|
},
|
|
"required": ["id", "type"]
|
|
}]
|
|
},
|
|
{
|
|
"name": "job",
|
|
"schemas": [{
|
|
"$id": "job",
|
|
"$ref": "entity",
|
|
"properties": {
|
|
"worker_id": { "type": "string", "format": "uuid" }
|
|
}
|
|
}]
|
|
}
|
|
]);
|
|
|
|
let puncs = json!([{
|
|
"name": "save_job",
|
|
"public": true,
|
|
"schemas": [
|
|
{
|
|
"$id": "save_job.request",
|
|
"$ref": "job"
|
|
},
|
|
{
|
|
"$id": "save_job.response",
|
|
"$ref": "job"
|
|
}
|
|
]
|
|
}]);
|
|
|
|
cache_json_schemas(jsonb(enums), jsonb(types), jsonb(puncs))
|
|
}
|
|
|
|
pub fn type_matching_schemas() -> JsonB {
|
|
let enums = json!([]);
|
|
let types = json!([
|
|
{
|
|
"name": "entity",
|
|
"schemas": [{
|
|
"$id": "entity",
|
|
"type": "object",
|
|
"properties": { "type": { "type": "string" }, "name": { "type": "string" } },
|
|
"required": ["type", "name"]
|
|
}]
|
|
},
|
|
{
|
|
"name": "job",
|
|
"schemas": [{
|
|
"$id": "job",
|
|
"$ref": "entity",
|
|
"properties": { "job_id": { "type": "string" } },
|
|
"required": ["job_id"]
|
|
}]
|
|
},
|
|
{
|
|
"name": "super_job",
|
|
"schemas": [
|
|
{
|
|
"$id": "super_job",
|
|
"$ref": "job",
|
|
"properties": { "manager_id": { "type": "string" } },
|
|
"required": ["manager_id"]
|
|
},
|
|
{
|
|
"$id": "super_job.short",
|
|
"$ref": "super_job",
|
|
"properties": { "name": { "maxLength": 10 } }
|
|
}
|
|
]
|
|
}
|
|
]);
|
|
let puncs = json!([{
|
|
"name": "type_test_punc",
|
|
"public": false,
|
|
"schemas": [{
|
|
"$id": "type_test_punc.request",
|
|
"type": "object",
|
|
"properties": {
|
|
"root_job": { "$ref": "job" },
|
|
"nested_or_super_job": {
|
|
"oneOf": [
|
|
{ "$ref": "super_job" },
|
|
{
|
|
"type": "object",
|
|
"properties": {
|
|
"my_job": { "$ref": "job" }
|
|
},
|
|
"required": ["my_job"]
|
|
}
|
|
]
|
|
}
|
|
},
|
|
"required": ["root_job", "nested_or_super_job"]
|
|
}]
|
|
}]);
|
|
cache_json_schemas(jsonb(enums), jsonb(types), jsonb(puncs))
|
|
} |