lutaml-jsonschema 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 80d56fbc558fd39c49bc397b01a2cd3cdf5d19b475483fbe50968b6cc7c8e6f6
-  data.tar.gz: 6cee07bff101bcbd7ed60639af85d99376c2b899c23be949a73401ecda5d6cb8
+  metadata.gz: fcb6ad4f8e4b98d7610fb58a9556af739f9c3c1ba348de4faf9dfdd83b39f8fc
+  data.tar.gz: f772f3eb0c0e204d3217ff5c72377ae4a6568daf29015f143eafd7e22d7ed6a6
 SHA512:
-  metadata.gz: fd8be87137f96a96c1cfc5ebc608a8cdc8a6726541ab1812e99e25f502db980efb83a464baa3e43b92520b2e25bacbb396c91792778cca6235efeb021ba3f9e3
-  data.tar.gz: 479d21b5e4df3626fe75c6c4c88ee61f16db6467b9774e024c0f4c6e120c6aa1e86a599819b3ff766896d2a867593aa7ca0b080142e4307aeae224da245f2d55
+  metadata.gz: 2b8238500b470d461a05119853f1aad9049c2dd92ced3afb7c2c072ccca9e890f0c08a1ac86600dbdd42df47bc21cc2c5893eecf4de4bb0f59e2cdac62897c79
+  data.tar.gz: 7ec354115ae70763afff045959ba6a2fce37d9f14c1221f254c653a241fc0bae9f2696e3490eb2e5f23b491f140c554b6ec83615d00481529130e9f1af7f636e

data/frontend/src/__tests__/useSchemaTypes.test.ts

@@ -11,6 +11,7 @@ import {
   isObjectProperty,
   hasConstraints,
   parsePropertyValue,
+  humanizeConstraints,
 } from '../composables/useSchemaTypes'
 import type { SpaProperty } from '../types'
 
@@ -205,6 +206,79 @@ describe('hasConstraints', () => {
   it('returns true for const', () => {
     expect(hasConstraints(prop({ const: 'fixed' }))).toBe(true)
   })
+
+  it('returns true for exclusiveMinimum', () => {
+    expect(hasConstraints(prop({ exclusiveMinimum: 0 }))).toBe(true)
+  })
+
+  it('returns true for exclusiveMaximum', () => {
+    expect(hasConstraints(prop({ exclusiveMaximum: 100 }))).toBe(true)
+  })
+
+  it('returns true for contentMediaType', () => {
+    expect(hasConstraints(prop({ contentMediaType: 'text/html' }))).toBe(true)
+  })
+
+  it('returns true for contentEncoding', () => {
+    expect(hasConstraints(prop({ contentEncoding: 'base64' }))).toBe(true)
+  })
+})
+
+describe('humanizeConstraints', () => {
+  it('returns string range constraint', () => {
+    const chips = humanizeConstraints(prop({ type: 'string', minLength: 1, maxLength: 100 }))
+    expect(chips).toEqual([{ label: '1..100 characters' }])
+  })
+
+  it('returns numeric >= and <= constraints', () => {
+    const chips = humanizeConstraints(prop({ type: 'integer', minimum: 0, maximum: 100 }))
+    expect(chips.map(c => c.label)).toEqual(['>= 0', '<= 100'])
+  })
+
+  it('returns exclusive bounds with > and <', () => {
+    const chips = humanizeConstraints(prop({ type: 'number', exclusiveMinimum: 0, exclusiveMaximum: 100 }))
+    expect(chips.map(c => c.label)).toEqual(['> 0', '< 100'])
+  })
+
+  it('returns array range constraint', () => {
+    const chips = humanizeConstraints(prop({ type: 'array', minItems: 1, maxItems: 10 }))
+    expect(chips).toEqual([{ label: '1..10 items' }])
+  })
+
+  it('returns unique for uniqueItems', () => {
+    const chips = humanizeConstraints(prop({ type: 'array', uniqueItems: true }))
+    expect(chips.map(c => c.label)).toEqual(['unique'])
+  })
+
+  it('returns const chip', () => {
+    const chips = humanizeConstraints(prop({ const: 'v1' }))
+    expect(chips.map(c => c.label)).toEqual(['const: v1'])
+  })
+
+  it('returns pattern chip', () => {
+    const chips = humanizeConstraints(prop({ pattern: '^[a-z]+$' }))
+    expect(chips.map(c => c.label)).toEqual(['^[a-z]+$'])
+  })
+
+  it('returns default chip', () => {
+    const chips = humanizeConstraints(prop({ default: 'hello' }))
+    expect(chips.map(c => c.label)).toEqual(['default: hello'])
+  })
+
+  it('returns multipleOf chip', () => {
+    const chips = humanizeConstraints(prop({ type: 'integer', multipleOf: 5 }))
+    expect(chips.map(c => c.label)).toEqual(['multiple of 5'])
+  })
+
+  it('returns empty array for no constraints', () => {
+    const chips = humanizeConstraints(prop({ type: 'string' }))
+    expect(chips).toEqual([])
+  })
+
+  it('returns contentMediaType and contentEncoding', () => {
+    const chips = humanizeConstraints(prop({ contentMediaType: 'text/html', contentEncoding: 'base64' }))
+    expect(chips.map(c => c.label)).toEqual(['content-type: text/html', 'encoding: base64'])
+  })
 })
 
 describe('parsePropertyValue', () => {

data/frontend/src/components/SchemaBuilder.vue

@@ -113,20 +113,10 @@
         <div v-if="field.prop.description" class="field-desc text-secondary">{{ field.prop.description }}</div>
 
         <div v-if="hasConstraints(field.prop) || field.prop.ref" class="field-constraints">
-          <span v-if="field.prop.ref" class="constraint-chip">ref → {{ field.resolvedDef?.title || field.resolvedDef?.name || field.prop.ref }}</span>
+          <span v-if="field.prop.ref" class="constraint-chip chip-ref">ref → {{ field.resolvedDef?.title || field.resolvedDef?.name || field.prop.ref }}</span>
           <span v-if="field.prop.enum?.length && isObjectProperty(field.prop)" class="constraint-chip">enum: {{ field.prop.enum.join(' | ') }}</span>
-          <span v-if="field.prop.pattern" class="constraint-chip font-mono">/{{ field.prop.pattern }}/</span>
-          <span v-if="field.prop.minimum != null" class="constraint-chip">min: {{ field.prop.minimum }}</span>
-          <span v-if="field.prop.maximum != null" class="constraint-chip">max: {{ field.prop.maximum }}</span>
-          <span v-if="field.prop.minLength != null" class="constraint-chip">minLength: {{ field.prop.minLength }}</span>
-          <span v-if="field.prop.maxLength != null" class="constraint-chip">maxLength: {{ field.prop.maxLength }}</span>
-          <span v-if="field.prop.default != null" class="constraint-chip">default: {{ field.prop.default }}</span>
-          <span v-if="field.prop.const != null" class="constraint-chip">const: {{ field.prop.const }}</span>
-          <span v-if="field.prop.minItems != null" class="constraint-chip">minItems: {{ field.prop.minItems }}</span>
-          <span v-if="field.prop.maxItems != null" class="constraint-chip">maxItems: {{ field.prop.maxItems }}</span>
-          <span v-if="field.prop.uniqueItems" class="constraint-chip">unique</span>
-          <span v-if="field.prop.multipleOf != null" class="constraint-chip">multipleOf: {{ field.prop.multipleOf }}</span>
-          <span v-if="field.prop.examples?.length" class="constraint-chip">e.g. {{ field.prop.examples.join(', ') }}</span>
+          <span v-for="(chip, idx) in humanizeConstraints(field.prop)" :key="idx" class="constraint-chip" :class="chip.class">{{ chip.label }}</span>
+          <span v-if="field.prop.additionalProperties === false" class="constraint-chip chip-locked">no additional properties</span>
         </div>
 
         <!-- Nested object builder -->
@@ -169,7 +159,7 @@
             {{ copied ? 'Copied!' : 'Copy' }}
           </button>
         </div>
-        <pre class="json-block"><code>{{ outputJson }}</code></pre>
+        <pre class="json-block"><code v-html="highlightedJson"></code></pre>
       </div>
     </div>
   </div>
@@ -186,6 +176,7 @@ import {
   arrayDefaultValue,
   isObjectProperty,
   hasConstraints,
+  humanizeConstraints,
 } from '../composables/useSchemaTypes'
 import {
   createField,
@@ -236,6 +227,23 @@ const outputObj = computed(() => {
 
 watch(outputObj, (v) => { emit('update:json', v) }, { immediate: true, deep: true })
 
+const highlightedJson = computed(() => syntaxHighlight(outputJson.value))
+
+function syntaxHighlight(json: string): string {
+  return json.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+    .replace(/("(\\u[\da-fA-F]{4}|\\[^u]|[^\\"])*"(\s*:)?|\b(true|false|null)\b|-?\d+(?:\.\d*)?(?:[eE][+-]?\d+)?)/g, (match) => {
+      let cls = 'json-number'
+      if (/^"/.test(match)) {
+        cls = /:$/.test(match) ? 'json-key' : 'json-string'
+      } else if (/true|false/.test(match)) {
+        cls = 'json-boolean'
+      } else if (/null/.test(match)) {
+        cls = 'json-null'
+      }
+      return `<span class="${cls}">${match}</span>`
+    })
+}
+
 async function copyJson() {
   try {
     await navigator.clipboard.writeText(outputJson.value)
@@ -463,6 +471,16 @@ async function copyJson() {
   border-radius: var(--radius-sm);
 }
 
+.constraint-chip.chip-pattern {
+  font-family: var(--font-mono);
+}
+
+.constraint-chip.chip-locked {
+  color: var(--color-orange);
+  background: var(--color-orange-alpha);
+  font-weight: 500;
+}
+
 .nested-section {
   margin-left: 22px;
   margin-top: var(--space-2);
@@ -535,6 +553,15 @@ async function copyJson() {
   color: var(--text-primary);
 }
 
+.json-block :deep(.json-key) { color: var(--color-primary-dark); }
+.json-block :deep(.json-string) { color: var(--color-green); }
+.json-block :deep(.json-number) { color: var(--color-orange); }
+.json-block :deep(.json-boolean) { color: var(--color-accent); }
+.json-block :deep(.json-null) { color: var(--text-muted); }
+
+:root[data-theme="dark"] .json-block :deep(.json-key) { color: var(--color-primary-light); }
+:root[data-theme="dark"] .json-block :deep(.json-string) { color: var(--color-teal); }
+
 .empty-hint {
   padding: var(--space-8);
   text-align: center;

data/frontend/src/composables/useSchemaTypes.ts

@@ -132,7 +132,11 @@ export function hasConstraints(prop: SpaProperty): boolean {
     prop.maxItems != null ||
     prop.uniqueItems ||
     prop.multipleOf != null ||
-    prop.const != null
+    prop.const != null ||
+    prop.exclusiveMinimum != null ||
+    prop.exclusiveMaximum != null ||
+    prop.contentMediaType ||
+    prop.contentEncoding
   )
 }
 
@@ -155,3 +159,46 @@ export function parsePropertyValue(rawValue: string, prop: SpaProperty): unknown
   if (t === 'object' && !prop.ref) return {}
   return rawValue
 }
+
+export interface ConstraintChip {
+  label: string
+  class?: string
+}
+
+export function humanizeConstraints(prop: SpaProperty): ConstraintChip[] {
+  const chips: ConstraintChip[] = []
+  const t = primaryType(prop.type)
+
+  if (prop.const != null) chips.push({ label: `const: ${prop.const}`, class: 'chip-const' })
+
+  if (t === 'string' || !t || t === 'any') {
+    if (prop.minLength != null && prop.maxLength != null)
+      chips.push({ label: `${prop.minLength}..${prop.maxLength} characters` })
+    else if (prop.minLength != null) chips.push({ label: `>= ${prop.minLength} characters` })
+    else if (prop.maxLength != null) chips.push({ label: `<= ${prop.maxLength} characters` })
+  }
+
+  if (t === 'integer' || t === 'number') {
+    if (prop.minimum != null) chips.push({ label: `>= ${prop.minimum}` })
+    if (prop.exclusiveMinimum != null) chips.push({ label: `> ${prop.exclusiveMinimum}` })
+    if (prop.maximum != null) chips.push({ label: `<= ${prop.maximum}` })
+    if (prop.exclusiveMaximum != null) chips.push({ label: `< ${prop.exclusiveMaximum}` })
+    if (prop.multipleOf != null) chips.push({ label: `multiple of ${prop.multipleOf}` })
+  }
+
+  if (t === 'array') {
+    if (prop.minItems != null && prop.maxItems != null)
+      chips.push({ label: `${prop.minItems}..${prop.maxItems} items` })
+    else if (prop.minItems != null) chips.push({ label: `>= ${prop.minItems} items` })
+    else if (prop.maxItems != null) chips.push({ label: `<= ${prop.maxItems} items` })
+    if (prop.uniqueItems) chips.push({ label: 'unique', class: 'chip-unique' })
+  }
+
+  if (prop.pattern) chips.push({ label: `${prop.pattern}`, class: 'chip-pattern' })
+  if (prop.default != null) chips.push({ label: `default: ${prop.default}`, class: 'chip-default' })
+  if (prop.examples?.length) chips.push({ label: `e.g. ${prop.examples.join(', ')}`, class: 'chip-example' })
+  if (prop.contentMediaType) chips.push({ label: `content-type: ${prop.contentMediaType}` })
+  if (prop.contentEncoding) chips.push({ label: `encoding: ${prop.contentEncoding}` })
+
+  return chips
+}

data/frontend/src/types.ts

@@ -34,6 +34,11 @@ export interface SpaProperty {
   uniqueItems?: boolean
   multipleOf?: number
   const?: string
+  exclusiveMinimum?: number
+  exclusiveMaximum?: number
+  additionalProperties?: boolean
+  contentMediaType?: string
+  contentEncoding?: string
 }
 
 export interface SpaDefinition {

data/lib/lutaml/jsonschema/spa/spa_builder.rb

@@ -30,7 +30,7 @@ module Lutaml
         end
 
         def build_schemas
-          @schema_set.schemas.map do |name, schema|
+          @schema_set.schemas.to_a.map do |name, schema|
             build_spa_schema(name, schema)
           end
         end
@@ -154,6 +154,11 @@ all_required = root_schema.required)
               unique_items: resolved.unique_items,
               multiple_of: resolved.multiple_of,
               const_value: resolved.const,
+              exclusive_minimum: resolved.exclusive_minimum,
+              exclusive_maximum: resolved.exclusive_maximum,
+              additional_properties: resolved.additional_properties,
+              content_type: resolved.content_type,
+              content_encoding: resolved.content_encoding,
             )
           end
         end

data/lib/lutaml/jsonschema/spa/spa_property.rb

@@ -28,6 +28,11 @@ module Lutaml
         attribute :unique_items, :boolean
         attribute :multiple_of, :float
         attribute :const_value, :string
+        attribute :exclusive_minimum, :float
+        attribute :exclusive_maximum, :float
+        attribute :additional_properties, :boolean
+        attribute :content_type, :string
+        attribute :content_encoding, :string
 
         json do
           map "name", to: :name
@@ -54,6 +59,11 @@ module Lutaml
           map "uniqueItems", to: :unique_items
           map "multipleOf", to: :multiple_of
           map "const", to: :const_value
+          map "exclusiveMinimum", to: :exclusive_minimum
+          map "exclusiveMaximum", to: :exclusive_maximum
+          map "additionalProperties", to: :additional_properties
+          map "contentMediaType", to: :content_type
+          map "contentEncoding", to: :content_encoding
         end
       end
     end

data/lib/lutaml/jsonschema/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Jsonschema
-    VERSION = "0.1.2"
+    VERSION = "0.1.3"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-jsonschema
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Ribose Inc.