Add enum and pattern constraints to properties in JSON Schema

Author: Neofox

src/jscheam.gleam

@@ -2,9 +2,9 @@ import gleam/json
 import gleam/list
 import gleam/option
 import jscheam/property.{
-  type AdditionalProperties, type Property, type Type, AllowAny, AllowExplicit,
-  Array, Boolean, Disallow, Float, Integer, Null, Object, Property, Schema,
-  String, Union,
+  type AdditionalProperties, type Constraint, type Property, type Type, AllowAny,
+  AllowExplicit, Array, Boolean, Disallow, Enum, Float, Integer, Null, Object,
+  Pattern, Property, Schema, String, Union,
 }
 
 // Property builders
@@ -16,6 +16,7 @@ pub fn prop(name: String, property_type: Type) -> Property {
     property_type: property_type,
     is_required: True,
     description: option.None,
+    constraints: [],
   )
 }
 
@@ -66,6 +67,13 @@ pub fn union(types: List(Type)) -> Type {
   Union(types)
 }
 
+/// Adds an enum constraint to a property that restricts values to a fixed set
+/// Example: prop("color", string()) |> enum(enum_strings(["red", "green", "blue"]))
+pub fn enum(property: Property, values: List(json.Json)) -> Property {
+  let new_constraint = Enum(values: values)
+  Property(..property, constraints: [new_constraint, ..property.constraints])
+}
+
 /// Creates an object type with the specified properties
 /// By default allows any additional properties (JSON Schema default behavior - omits the field)
 pub fn object(properties: List(Property)) -> Type {
@@ -157,69 +165,100 @@ fn type_to_json_value(property_type: Type) -> json.Json {
 }
 
 fn property_to_field(property: Property) -> #(String, json.Json) {
-  let Property(name, property_type, _is_required, description) = property
-  let base_schema = type_to_json_value(property_type)
-
-  // Add description if provided
-  let schema_with_description = case description {
-    option.Some(desc) -> {
-      case base_schema {
-        _ -> {
-          case property_type {
-            String | Integer | Boolean | Float | Null ->
-              json.object([
-                #("type", json.string(type_to_type_string(property_type))),
-                #("description", json.string(desc)),
-              ])
-            Array(item_type) ->
-              json.object([
-                #("type", json.string(type_to_type_string(property_type))),
-                #("items", type_to_json_value(item_type)),
-                #("description", json.string(desc)),
-              ])
-            Object(properties: props, additional_properties: add_props) -> {
-              let properties_json =
-                list.map(props, property_to_field) |> json.object
-              let required_json = fields_to_required(props)
-              let additional_props_fields =
-                additional_properties_to_json(add_props)
-
-              let base_fields = [
-                #("type", json.string(type_to_type_string(property_type))),
-                #("properties", properties_json),
-                #("required", required_json),
-                #("description", json.string(desc)),
-              ]
-
-              json.object(list.append(base_fields, additional_props_fields))
-            }
-            Union(types) -> {
-              let type_strings = list.map(types, type_to_type_string)
-              json.object([
-                #("type", json.array(type_strings, json.string)),
-                #("description", json.string(desc)),
-              ])
-            }
-          }
-        }
-      }
+  let Property(name, property_type, _is_required, description, constraints) =
+    property
+
+  let base_fields = get_base_type_fields(property_type)
+  let fields_with_constraints = add_constraint_fields(base_fields, constraints)
+  let final_fields = case description {
+    option.Some(desc) -> [
+      #("description", json.string(desc)),
+      ..fields_with_constraints
+    ]
+    option.None -> fields_with_constraints
+  }
+
+  #(name, json.object(final_fields))
+}
+
+fn get_base_type_fields(property_type: Type) -> List(#(String, json.Json)) {
+  case property_type {
+    String | Integer | Boolean | Null | Float -> [
+      #("type", json.string(type_to_type_string(property_type))),
+    ]
+    Array(item_type) -> [
+      #("type", json.string(type_to_type_string(property_type))),
+      #("items", type_to_json_value(item_type)),
+    ]
+    Object(properties: props, additional_properties: add_props) -> {
+      let properties_json = list.map(props, property_to_field) |> json.object
+      let required_json = fields_to_required(props)
+      let additional_props_fields = additional_properties_to_json(add_props)
+
+      let base_fields = [
+        #("type", json.string(type_to_type_string(property_type))),
+        #("properties", properties_json),
+        #("required", required_json),
+      ]
+
+      list.append(base_fields, additional_props_fields)
+    }
+    Union(types) -> {
+      let type_strings = list.map(types, type_to_type_string)
+      [#("type", json.array(type_strings, json.string))]
     }
-    option.None -> base_schema
   }
+}
 
-  #(name, schema_with_description)
+fn add_constraint_fields(
+  base_fields: List(#(String, json.Json)),
+  constraints: List(Constraint),
+) -> List(#(String, json.Json)) {
+  case constraints {
+    [] -> base_fields
+    [constraint, ..rest] -> {
+      let fields_with_constraint =
+        add_single_constraint_field(base_fields, constraint)
+      add_constraint_fields(fields_with_constraint, rest)
+    }
+  }
+}
+
+fn add_single_constraint_field(
+  fields: List(#(String, json.Json)),
+  constraint: Constraint,
+) -> List(#(String, json.Json)) {
+  case constraint {
+    Enum(values: values) -> [
+      #("enum", json.array(values, fn(x) { x })),
+      ..fields
+    ]
+    Pattern(regex: regex) -> [#("pattern", json.string(regex)), ..fields]
+  }
 }
 
 fn fields_to_required(fields: List(Property)) -> json.Json {
   let required_fields =
     list.filter(fields, fn(property) {
-      let Property(_name, _property_type, is_required, _description) = property
+      let Property(
+        _name,
+        _property_type,
+        is_required,
+        _description,
+        _constraints,
+      ) = property
       is_required
     })
 
   let names =
     list.map(required_fields, fn(property) {
-      let Property(name, _property_type, _is_required, _description) = property
+      let Property(
+        name,
+        _property_type,
+        _is_required,
+        _description,
+        _constraints,
+      ) = property
       json.string(name)
     })
   json.array(names, fn(x) { x })

src/jscheam/property.gleam

@@ -1,12 +1,22 @@
+import gleam/json
 import gleam/option
 
+/// Constraints that can be applied to properties
+pub type Constraint {
+  /// Restrict values to a fixed set of values (can be any JSON value)
+  Enum(values: List(json.Json))
+  /// Pattern constraint using regex 
+  Pattern(regex: String)
+}
+
 /// A property in a JSON Schema object
 pub type Property {
   Property(
     name: String,
     property_type: Type,
     is_required: Bool,
     description: option.Option(String),
+    constraints: List(Constraint),
   )
 }
 

test/jscheam_test.gleam

@@ -3,7 +3,9 @@ import gleam/string
 import gleeunit
 import gleeunit/should
 import jscheam
-import jscheam/property.{Array, Boolean, Float, Integer, Null, String, Union}
+import jscheam/property.{
+  Array, Boolean, Enum, Float, Integer, Null, Property, String, Union,
+}
 
 pub fn main() -> Nil {
   gleeunit.main()
@@ -180,7 +182,31 @@ pub fn union_type_test() {
   let json = jscheam.to_json(schema) |> json.to_string()
 
   string.contains(json, "\"type\":\"object\"") |> should.be_true()
-  string.contains(json, "\"units\":{\"type\":[\"string\",\"null\"]")
+  string.contains(json, "\"units\":{") |> should.be_true()
+  string.contains(json, "\"type\":[\"string\",\"null\"]") |> should.be_true()
+  string.contains(
+    json,
+    "\"description\":\"Units the temperature will be returned in.\"",
+  )
+  |> should.be_true()
+  string.contains(json, "\"required\":[\"units\"]") |> should.be_true()
+}
+
+// Test enum with string base type
+pub fn enum_string_test() {
+  let schema =
+    jscheam.object([
+      jscheam.prop("units", jscheam.string())
+      |> jscheam.enum([json.string("celsius"), json.string("fahrenheit")])
+      |> jscheam.description("Units the temperature will be returned in."),
+    ])
+
+  let json = jscheam.to_json(schema) |> json.to_string()
+
+  string.contains(json, "\"type\":\"object\"") |> should.be_true()
+  string.contains(json, "\"units\":{") |> should.be_true()
+  string.contains(json, "\"type\":\"string\"") |> should.be_true()
+  string.contains(json, "\"enum\":[\"celsius\",\"fahrenheit\"]")
   |> should.be_true()
   string.contains(
     json,
@@ -189,3 +215,82 @@ pub fn union_type_test() {
   |> should.be_true()
   string.contains(json, "\"required\":[\"units\"]") |> should.be_true()
 }
+
+// Test enum with union base type (as in your example)
+pub fn enum_union_test() {
+  let schema =
+    jscheam.object([
+      jscheam.prop("location", jscheam.string())
+        |> jscheam.description("City and country e.g. Bogotá, Colombia"),
+      jscheam.prop("units", jscheam.union([jscheam.string(), jscheam.null()]))
+        |> jscheam.enum([json.string("celsius"), json.string("fahrenheit")])
+        |> jscheam.description("Units the temperature will be returned in."),
+    ])
+    |> jscheam.disallow_additional_props()
+
+  let json = jscheam.to_json(schema) |> json.to_string()
+
+  string.contains(json, "\"type\":\"object\"") |> should.be_true()
+  string.contains(json, "\"location\":{") |> should.be_true()
+  string.contains(json, "\"units\":{") |> should.be_true()
+  string.contains(json, "\"type\":[\"string\",\"null\"]") |> should.be_true()
+  string.contains(json, "\"enum\":[\"celsius\",\"fahrenheit\"]")
+  |> should.be_true()
+  string.contains(json, "\"required\":[\"location\",\"units\"]")
+  |> should.be_true()
+  string.contains(json, "\"additionalProperties\":false") |> should.be_true()
+}
+
+// Test enum constraint application
+pub fn enum_constraint_test() {
+  let expected_values = [
+    json.string("red"),
+    json.string("green"),
+    json.string("blue"),
+  ]
+  let property =
+    jscheam.prop("color", jscheam.string())
+    |> jscheam.enum(expected_values)
+
+  // Test that the constraint was applied
+  let Property(_name, _type, _required, _description, constraints) = property
+  case constraints {
+    [Enum(values: values)] -> values |> should.equal(expected_values)
+    _ -> should.fail()
+  }
+}
+
+// Test mixed-type enum (strings, numbers, null)
+pub fn enum_mixed_types_test() {
+  let mixed_values = [
+    json.string("red"),
+    json.string("amber"),
+    json.string("green"),
+    json.null(),
+    json.int(42),
+  ]
+
+  let schema =
+    jscheam.object([
+      jscheam.prop(
+        "status",
+        jscheam.union([jscheam.string(), jscheam.null(), jscheam.integer()]),
+      )
+      |> jscheam.enum(mixed_values)
+      |> jscheam.description("Traffic light status with special values"),
+    ])
+
+  let json = jscheam.to_json(schema) |> json.to_string()
+
+  string.contains(json, "\"type\":\"object\"") |> should.be_true()
+  string.contains(json, "\"status\":{") |> should.be_true()
+  string.contains(json, "\"type\":[\"string\",\"null\",\"number\"]")
+  |> should.be_true()
+  string.contains(json, "\"enum\":[\"red\",\"amber\",\"green\",null,42]")
+  |> should.be_true()
+  string.contains(
+    json,
+    "\"description\":\"Traffic light status with special values\"",
+  )
+  |> should.be_true()
+}