@api-client/core 0.18.6 → 0.18.8

package/data/models/example-generator-api.json

@@ -42065,19 +42065,19 @@
 "@id": "#191"
 },
 {
-"@id": "#200"
+"@id": "#197"
 },
 {
 "@id": "#194"
 },
 {
-"@id": "#197"
+"@id": "#203"
 },
 {
-"@id": "#206"
+"@id": "#200"
 },
 {
-"@id": "#203"
+"@id": "#206"
 },
 {
 "@id": "#209"
@@ -42813,13 +42813,13 @@
 "@id": "#210"
 },
 {
-"@id": "#219"
-},
-{
 "@id": "#213"
 },
 {
 "@id": "#216"
+},
+{
+"@id": "#219"
 }
 ],
 "doc:root": false,
@@ -43478,7 +43478,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "class: '3'\ndescription: '150 - 300'\nnumberOfFte: 5500\nnumberOfEmployees: 5232\n",
+"doc:raw": "addressType: 'REGISTERED-OFFICE-ADDRESS'\nstreetName: 'UITBREIDINGSTRAAT'\nhouseNumber: '84'\nhouseNumberAddition: '/1'\npostalCode: '2600'\ncity: 'BERCHEM (ANTWERPEN)'\ncountry: 'Belgium'\ncountryCode: 'BE'\nfullFormatedAddress: \"UITBREIDINGSTRAAT 84 /1, 2600 BERCHEM (ANTWERPEN), BELIUM\"\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -43499,7 +43499,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "addressType: 'REGISTERED-OFFICE-ADDRESS'\nstreetName: 'UITBREIDINGSTRAAT'\nhouseNumber: '84'\nhouseNumberAddition: '/1'\npostalCode: '2600'\ncity: 'BERCHEM (ANTWERPEN)'\ncountry: 'Belgium'\ncountryCode: 'BE'\nfullFormatedAddress: \"UITBREIDINGSTRAAT 84 /1, 2600 BERCHEM (ANTWERPEN), BELIUM\"\n",
+"doc:raw": "code: 'J'\ndescription: 'Information and communication'\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -43520,7 +43520,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "code: '7487'\ndescription: 'Financial and insurance activities'\ntype: \"PRIMARY\"\nclassificationCode: 'BE_NACEBEL2008'\nactivityGroupCode: 'ABCDE'\n",
+"doc:raw": "class: '3'\ndescription: '150 - 300'\nnumberOfFte: 5500\nnumberOfEmployees: 5232\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -43541,7 +43541,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "code: 'J'\ndescription: 'Information and communication'\n",
+"doc:raw": "code: '7487'\ndescription: 'Financial and insurance activities'\ntype: \"PRIMARY\"\nclassificationCode: 'BE_NACEBEL2008'\nactivityGroupCode: 'ABCDE'\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -44253,7 +44253,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "-\n  type: 'GENERAL'\n  value: 'info@company.be'\n-\n  type: 'IT_DEPT'\n  value: 'it-service@company.be'\n",
+"doc:raw": "type: 'GENERAL'\ncountryDialCode : '+32'\nareaCode : '21'\nsubscriberNumber: '12.87.00'\nformatted: '+32-(0)21 302099'\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -44274,7 +44274,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "type: \"GENERAL\"\nvalue: \"www.company.be\"\n",
+"doc:raw": "-\n  type: 'GENERAL'\n  value: 'info@company.be'\n-\n  type: 'IT_DEPT'\n  value: 'it-service@company.be'\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -44295,7 +44295,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "type: 'GENERAL'\ncountryDialCode : '+32'\nareaCode : '21'\nsubscriberNumber: '12.87.00'\nformatted: '+32-(0)21 302099'\n",
+"doc:raw": "type: \"GENERAL\"\nvalue: \"www.company.be\"\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -44766,22 +44766,22 @@
 {
 "@id": "#199/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#199",
-"sourcemaps:value": "[(1,0)-(5,0)]"
+"sourcemaps:value": "[(1,0)-(10,0)]"
 },
 {
 "@id": "#202/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#202",
-"sourcemaps:value": "[(1,0)-(10,0)]"
+"sourcemaps:value": "[(1,0)-(3,0)]"
 },
 {
 "@id": "#205/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#205",
-"sourcemaps:value": "[(1,0)-(6,0)]"
+"sourcemaps:value": "[(1,0)-(5,0)]"
 },
 {
 "@id": "#208/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#208",
-"sourcemaps:value": "[(1,0)-(3,0)]"
+"sourcemaps:value": "[(1,0)-(6,0)]"
 },
 {
 "@id": "#223/source-map/lexical/element_0",
@@ -45121,17 +45121,17 @@
 {
 "@id": "#215/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#215",
-"sourcemaps:value": "[(1,0)-(7,0)]"
+"sourcemaps:value": "[(1,0)-(6,0)]"
 },
 {
 "@id": "#218/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#218",
-"sourcemaps:value": "[(1,0)-(3,0)]"
+"sourcemaps:value": "[(1,0)-(7,0)]"
 },
 {
 "@id": "#221/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#221",
-"sourcemaps:value": "[(1,0)-(6,0)]"
+"sourcemaps:value": "[(1,0)-(3,0)]"
 },
 {
 "@id": "#338/source-map/synthesized-field/element_1",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@api-client/core",
   "description": "The API Client's core client library. Works in NodeJS and in a ES enabled browser.",
-  "version": "0.18.6",
+  "version": "0.18.8",
   "license": "Apache-2.0",
   "exports": {
     "./browser.js": {

package/src/modeling/importers/CsvImporter.ts

@@ -1,11 +1,43 @@
-import { type CSVOptions, CSVParser, type ParseResult } from '@pawel-up/csv'
+import { type CSVOptions, CSVParser, type ParseResult as ParseResult_ } from '@pawel-up/csv'
 import type { DataDomain } from '../DataDomain.js'
 import { sanitizeInput, toDatabaseColumnName, toDatabaseTableName } from '../helpers/database.js'
 import type { DomainPropertySchema } from '../DomainProperty.js'
 import type { DomainEntity } from '../DomainEntity.js'
 import type { DomainModel } from '../DomainModel.js'
 
-export type { CSVOptions, ParseResult }
+interface ParseResult extends ParseResult_ {
+  /**
+   * The file name of the CSV that was parsed.
+   * If the CSV is provided as a string, it will be named `inline_csv_0`, `inline_csv_1`, etc.
+   */
+  file: string
+}
+
+let increment = 0
+
+interface ImportResult {
+  /**
+   * The DomainEntity created from the CSV data.
+   */
+  entity: DomainEntity
+  /**
+   * The DomainModel that contains the imported entity.
+   */
+  model: DomainModel
+}
+
+interface ImportManyResult {
+  /**
+   * An array of DomainEntity instances created from the CSV data.
+   */
+  entities: DomainEntity[]
+  /**
+   * The DomainModel that contains all imported entities.
+   */
+  model: DomainModel
+}
+
+export type { CSVOptions, ParseResult, ImportResult, ImportManyResult }
 
 /**
  * Imports CSV data into a DataDomain.
@@ -33,8 +65,19 @@ export class CsvImporter {
    * @param csv The CSV content to parse, as a File object or a string.
    * @returns A promise that resolves with the parsed result.
    */
-  public parse(csv: File | string): Promise<ParseResult> {
-    return this.parser.parse(csv)
+  public async parse(csv: File | string): Promise<ParseResult> {
+    const result = await this.parser.parse(csv)
+    return {
+      ...result,
+      file: typeof csv === 'string' ? 'inline_csv_' + increment++ : csv.name,
+    }
+  }
+
+  private removeExtension(name: string): string {
+    if (name.endsWith('.csv')) {
+      name = name.slice(0, -4) // Remove .csv extension if present
+    }
+    return name
   }
 
   /**
@@ -45,7 +88,8 @@ export class CsvImporter {
    * @param modelName The name to be used for the created `DomainModel` and `DomainEntity`.
    * @returns A promise that resolves when the import is complete.
    */
-  public async import(data: ParseResult, modelName: string): Promise<{ entity: DomainEntity; model: DomainModel }> {
+  public async import(data: ParseResult, modelName: string): Promise<ImportResult> {
+    modelName = this.removeExtension(modelName)
     const name = toDatabaseTableName(modelName, 'imported_cvs_data')
     const model = this.domain.addModel({ info: { name } })
     const entity = model.addEntity({ info: { name } })
@@ -88,4 +132,70 @@ export class CsvImporter {
     }
     return { entity, model }
   }
+
+  /**
+   * Imports multiple parsed CSV data structures into the same data model.
+   * Creates a single `DomainModel` with multiple `DomainEntity` instances, one for each CSV data structure.
+   * Each entity represents the structure of its corresponding CSV file.
+   * @param data Array of objects containing parsed CSV data and entity names.
+   * @param modelName The name to be used for the created `DomainModel`.
+   * @returns A promise that resolves with the created model and all entities.
+   */
+  public async importMany(data: ParseResult[], modelName: string): Promise<ImportManyResult> {
+    modelName = this.removeExtension(modelName)
+    const name = toDatabaseTableName(modelName, 'imported_cvs_data')
+    const model = this.domain.addModel({ info: { name } })
+    const sanitizedModelName = sanitizeInput(modelName)
+    if (name !== sanitizedModelName) {
+      model.info.displayName = sanitizedModelName
+    }
+
+    const entities: DomainEntity[] = []
+
+    for (const { format, values, file } of data) {
+      const cleanFile = this.removeExtension(file)
+      const entityDbName = toDatabaseTableName(cleanFile, `entity_${entities.length}`)
+      const entity = model.addEntity({ info: { name: entityDbName } })
+      const sanitizedEntityName = sanitizeInput(cleanFile)
+      if (entityDbName !== sanitizedEntityName) {
+        entity.info.displayName = sanitizedEntityName
+      }
+
+      const exampleRow = values[0]
+      for (const row of format) {
+        const { index, name, type, format } = row
+        const columnName = toDatabaseColumnName(name, `column_${index}`)
+        const schema: Partial<DomainPropertySchema> = {
+          info: { name: columnName },
+          type,
+        }
+        if (format) {
+          schema.bindings = [
+            {
+              type: 'web',
+              schema: {
+                format: format === 'integer' ? 'int64' : 'double',
+              },
+            },
+          ]
+        }
+        if (Array.isArray(exampleRow) && exampleRow[index]) {
+          const value = exampleRow[index]
+          if (value !== undefined && value !== null) {
+            schema.schema = {
+              examples: [sanitizeInput(String(value))],
+            }
+          }
+        }
+        const prop = entity.addProperty(schema)
+        const sn = sanitizeInput(name)
+        if (sn !== columnName) {
+          prop.info.displayName = sn
+        }
+      }
+      entities.push(entity)
+    }
+
+    return { entities, model }
+  }
 }

package/src/modeling/importers/JsonSchemaImporter.ts

@@ -7,6 +7,7 @@ import type { PropertySchema } from '../types.js'
 import type { PropertyWebBindings } from '../Bindings.js'
 import type { DomainPropertyFormat, DomainPropertyType } from '../DataFormat.js'
 import { sanitizeInput, toDatabaseColumnName, toDatabaseTableName } from '../helpers/database.js'
+import { nanoid } from '../../nanoid.js'
 
 /**
  * Represents a single message (info, warning, or error) generated during the import process.
@@ -86,34 +87,52 @@ export class JsonSchemaImporter {
     // Build a flat map of all definitions and $id-indexed schemas
     const definitionMap = new Map<string, JSONSchema7>()
     const idMap = new Map<string, JSONSchema7>()
+    const processedSchemas = new Set<JSONSchema7>() // Track processed schema objects to avoid duplicates
+
     for (const schema of schemas) {
       // Add $id mapping if present
       if (schema.contents.$id) {
         idMap.set(schema.contents.$id, schema.contents)
+        // Add the entire schema to the definitions maps as well as they can be referenced by other schemas.
+        definitionMap.set(schema.contents.$id, schema.contents)
       }
       // Add the schema itself by its path
       definitionMap.set(schema.path, schema.contents)
       // Add all definitions inside this schema
-      const defs = (schema.contents.definitions ||
-        (schema.contents as unknown as { $defs: Record<string, JSONSchema7Definition> }).$defs) as
-        | Record<string, JSONSchema7Definition>
-        | undefined
-      if (defs) {
-        for (const [defName, defSchema] of Object.entries(defs)) {
+      const definitions = schema.contents.definitions
+      const defs = (schema.contents as unknown as { $defs: Record<string, JSONSchema7Definition> }).$defs
+
+      if (definitions) {
+        for (const [defName, defSchema] of Object.entries(definitions)) {
           if (typeof defSchema === 'object') {
-            // Use a JSON pointer for the key
+            // Use a JSON pointer for the key - include both full path and short form
             definitionMap.set(`${schema.path}#/definitions/${defName}`, defSchema as JSONSchema7)
-            // Also allow lookup by just #/definitions/defName for single-file schemas
             definitionMap.set(`#/definitions/${defName}`, defSchema as JSONSchema7)
           }
         }
       }
+
+      if (defs) {
+        for (const [defName, defSchema] of Object.entries(defs)) {
+          if (typeof defSchema === 'object') {
+            // Use a JSON pointer for the key - include both full path and short form
+            definitionMap.set(`${schema.path}#/$defs/${defName}`, defSchema as JSONSchema7)
+            definitionMap.set(`#/$defs/${defName}`, defSchema as JSONSchema7)
+          }
+        }
+      }
     }
 
     // == Pass 1: Create all entities ==
     for (const [key, schema] of definitionMap.entries()) {
+      // Skip if this schema object has already been processed
+      if (processedSchemas.has(schema)) {
+        continue
+      }
+
       if (typeof schema === 'object' && schema.type === 'object') {
         this.createEntity(key, schema, key)
+        processedSchemas.add(schema)
       } else if (this.isEnum(schema)) {
         this.enums.set(key, schema)
       } else {
@@ -122,15 +141,20 @@ export class JsonSchemaImporter {
     }
     // Also create entities for all $id-indexed schemas if not already present
     for (const [id, schema] of idMap.entries()) {
+      // Skip if this schema object has already been processed
+      if (processedSchemas.has(schema)) {
+        continue
+      }
+
       if (!this.refMap.has(id) && typeof schema === 'object' && schema.type === 'object') {
         this.createEntity(id, schema, id)
-      } else if (this.isEnum(schema)) {
+        processedSchemas.add(schema)
+      } else if (this.isEnum(schema) && !this.enums.has(id)) {
         this.enums.set(id, schema)
       } else {
         this.report('warning', `Skipping non-object schema at ${id}`, id)
       }
     }
-
     // == Pass 2: Populate entities ==
     for (const [refPath, entityKey] of this.refMap.entries()) {
       const entity = this.domain.findEntity(entityKey)
@@ -173,10 +197,10 @@ export class JsonSchemaImporter {
     // Try direct match
     if (definitionMap.has(refPath)) return definitionMap.get(refPath)
     if (idMap.has(refPath)) return idMap.get(refPath)
-    // Try to resolve #/definitions/Name from any schema
-    if (refPath.startsWith('#/definitions/')) {
+    // Try to resolve #/definitions/Name or #/$defs/Name from any schema
+    if (refPath.startsWith('#/definitions/') || refPath.startsWith('#/$defs/')) {
       for (const [key, schema] of definitionMap.entries()) {
-        if (key.endsWith(refPath)) return schema
+        if (key === refPath) return schema
       }
     }
     // Try to resolve by $id fragment
@@ -192,7 +216,17 @@ export class JsonSchemaImporter {
    * Helper for entity creation, can be extended for custom logic.
    */
   private createEntity(name: string, schema: JSONSchema7, refPath: string): DomainEntity {
-    const fixedName = schema.title || name
+    let fixedName = schema.title || name
+
+    // Extract just the definition name from JSON pointers (both short and full paths)
+    if (name.includes('#/definitions/')) {
+      const parts = name.split('#/definitions/')
+      fixedName = schema.title || parts[parts.length - 1]
+    } else if (name.includes('#/$defs/')) {
+      const parts = name.split('#/$defs/')
+      fixedName = schema.title || parts[parts.length - 1]
+    }
+
     const cleanName = toDatabaseTableName(fixedName, 'untitled_entity')
     const entity = this.model.addEntity({
       info: {
@@ -210,6 +244,24 @@ export class JsonSchemaImporter {
     return entity
   }
 
+  /**
+   * Generates a meaningful name for inline entities based on their parent context.
+   */
+  private generateInlineEntityName(parentEntityKey: string, propName: string, schema: JSONSchema7): string {
+    // Try to use the schema title first
+    if (schema.title) {
+      return toDatabaseTableName(schema.title, 'untitled_entity')
+    }
+
+    // Find the parent entity to create a meaningful name
+    const parentEntity = this.domain.findEntity(parentEntityKey)
+    const parentName = parentEntity?.info.name || 'unknown'
+
+    // Create a name like "User_Address" or "Order_ShippingInfo"
+    const combinedName = `${parentName}_${propName}`
+    return toDatabaseTableName(combinedName, 'untitled_entity')
+  }
+
   /**
    * Populates a DomainEntity with its properties, associations, and parent relationships.
    */
@@ -285,7 +337,11 @@ export class JsonSchemaImporter {
    * Recursively analyzes a schema definition to find all contained primitive types and `$ref`s.
    * It's used to understand the nature of a property (is it a primitive, an association, or a mix).
    */
-  private collectTypesAndRefs(schema: JSONSchema7Definition): {
+  private collectTypesAndRefs(
+    schema: JSONSchema7Definition,
+    parentEntityKey?: string,
+    propName?: string
+  ): {
     refs: Set<string>
     types: Set<JSONSchema7TypeName>
     isArray: boolean
@@ -308,11 +364,30 @@ export class JsonSchemaImporter {
       }
     }
 
+    // Handle inline object types by creating entities immediately
+    if (schema.type === 'object' && schema.properties && parentEntityKey && propName) {
+      // Create an entity for this inline object immediately
+      const inlineEntityName = this.generateInlineEntityName(parentEntityKey, propName, schema)
+      const inlineEntity = this.createEntity(inlineEntityName, schema, inlineEntityName)
+
+      // Populate it immediately since we have the schema
+      this.populateEntity(inlineEntity, schema)
+
+      // Add a reference to it so it gets treated as an association
+      collected.refs.add(inlineEntityName)
+
+      return collected
+    }
+
     if (schema.type === 'array') {
       collected.isArray = true
       if (typeof schema.items === 'object') {
-        // Recurse into items
-        const itemInfo = this.collectTypesAndRefs(Array.isArray(schema.items) ? schema.items[0] : schema.items)
+        // Recurse into items - pass along parent context for inline objects in arrays
+        const itemInfo = this.collectTypesAndRefs(
+          Array.isArray(schema.items) ? schema.items[0] : schema.items,
+          parentEntityKey,
+          propName ? `${propName}_item` : undefined
+        )
         itemInfo.refs.forEach((r) => collected.refs.add(r))
         itemInfo.types.forEach((t) => collected.types.add(t))
       }
@@ -322,7 +397,7 @@ export class JsonSchemaImporter {
     const choices = schema.anyOf || schema.oneOf
     if (choices) {
       for (const choice of choices) {
-        const choiceInfo = this.collectTypesAndRefs(choice)
+        const choiceInfo = this.collectTypesAndRefs(choice, parentEntityKey)
         choiceInfo.refs.forEach((r) => collected.refs.add(r))
         choiceInfo.types.forEach((t) => collected.types.add(t))
         if (choiceInfo.isArray) {
@@ -331,6 +406,20 @@ export class JsonSchemaImporter {
       }
     }
 
+    if (schema.enum) {
+      // If the schema has an enum, we treat it as a string type with specific values.
+      collected.types.add('string')
+      // consider the following schema: `"enum": ["one", "two", "three"]`
+      const id = nanoid(8)
+      this.enums.set(id, {
+        type: 'string',
+        oneOf: schema.enum.map((value) => ({
+          const: String(value), // Ensure enum values are strings
+        })),
+      })
+      collected.refs.add(id) // Add the enum reference
+    }
+
     return collected
   }
 
@@ -344,8 +433,9 @@ export class JsonSchemaImporter {
     isRequired: boolean
   ): void {
     // Analyze the property schema to understand its composition (primitives, refs, arrays).
-    const analysis = this.collectTypesAndRefs(propSchema)
-
+    // Pass entity context to collectTypesAndRefs for inline object handling
+    const analysis = this.collectTypesAndRefs(propSchema, entity.key, propName)
+    // console.log(`Analyzing property '${propName}' in entity '${entity.info.name}':`, analysis, propSchema)
     // Case 1: If the property has `$ref` to an enum, we treat it as a DomainProperty.
     if (analysis.refs.size === 1 && this.enums.has([...analysis.refs][0])) {
       const prop = this.createEnumProperty(
@@ -635,6 +725,7 @@ export class JsonSchemaImporter {
     }
 
     if (Object.keys(schema).length > 0) {
+      // console.log(`Creating enum property '${propName}' with schema:`, schema)
       prop.schema = schema
     }
     return prop

package/tests/fixtures/schemas/arrays.json

@@ -0,0 +1,35 @@
+{
+  "$id": "https://example.com/arrays.schema.json",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "description": "Arrays of strings and objects",
+  "title": "Arrays",
+  "type": "object",
+  "properties": {
+    "fruits": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "vegetables": {
+      "type": "array",
+      "items": { "$ref": "#/$defs/veggie" }
+    }
+  },
+  "$defs": {
+    "veggie": {
+      "type": "object",
+      "required": [ "veggieName", "veggieLike" ],
+      "properties": {
+        "veggieName": {
+          "type": "string",
+          "description": "The name of the vegetable."
+        },
+        "veggieLike": {
+          "type": "boolean",
+          "description": "Do I like this vegetable?"
+        }
+      }
+    }
+  }
+}

package/tests/fixtures/schemas/complex.json

@@ -0,0 +1,41 @@
+{
+  "$id": "https://example.com/complex-object.schema.json",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "Complex Object",
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string"
+    },
+    "age": {
+      "type": "integer",
+      "minimum": 0
+    },
+    "address": {
+      "type": "object",
+      "properties": {
+        "street": {
+          "type": "string"
+        },
+        "city": {
+          "type": "string"
+        },
+        "state": {
+          "type": "string"
+        },
+        "postalCode": {
+          "type": "string",
+          "pattern": "\\d{5}"
+        }
+      },
+      "required": ["street", "city", "state", "postalCode"]
+    },
+    "hobbies": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": ["name", "age"]
+}

package/tests/fixtures/schemas/enumerated_values.json

@@ -0,0 +1,11 @@
+{
+  "$id": "https://example.com/enumerated-values.schema.json",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "Enumerated Values",
+  "type": "object",
+  "properties": {
+    "data": {
+      "enum": [42, true, "hello", null, [1, 2, 3]]
+    }
+  }
+}

package/tests/fixtures/schemas/person.json

@@ -0,0 +1,21 @@
+{
+  "$id": "https://example.com/person.schema.json",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "Person",
+  "type": "object",
+  "properties": {
+    "firstName": {
+      "type": "string",
+      "description": "The person's first name."
+    },
+    "lastName": {
+      "type": "string",
+      "description": "The person's last name."
+    },
+    "age": {
+      "description": "Age in years which must be equal to or greater than zero.",
+      "type": "integer",
+      "minimum": 0
+    }
+  }
+}

package/tests/fixtures/schemas/regexp.json

@@ -0,0 +1,12 @@
+{
+  "$id": "https://example.com/regex-pattern.schema.json",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "Regular Expression Pattern",
+  "type": "object",
+  "properties": {
+    "code": {
+      "type": "string",
+      "pattern": "^[A-Z]{3}-\\d{3}$"
+    }
+  }
+}