@api-client/core 0.18.6 → 0.18.8

package/tests/unit/modeling/importers/csv_importer.spec.ts

@@ -50,6 +50,7 @@ test.group('CsvImporter: import', (group) => {
       ],
       values: [[1, 'test-item', 99.9]],
       header: ['id', 'name', 'value'],
+      file: 'products.csv',
     }
 
     await importer.import(parseResult, 'My Products')
@@ -87,6 +88,7 @@ test.group('CsvImporter: import', (group) => {
       format: [{ index: 0, name: 'First Name', type: 'string' }],
       values: [['John']],
       header: ['First Name'],
+      file: 'users.csv',
     }
 
     await importer.import(parseResult, 'User List!')
@@ -113,6 +115,7 @@ test.group('CsvImporter: import', (group) => {
       ],
       values: [], // No data rows
       header: ['id', 'email'],
+      file: 'empty.csv',
     }
 
     await importer.import(parseResult, 'users')
@@ -140,6 +143,7 @@ test.group('CsvImporter: import', (group) => {
       // @ts-expect-error TypeScript expects values to be defined
       values: [[null, 'has-value', undefined]],
       header: ['col_a', 'col_b', 'col_c'],
+      file: 'test.csv',
     }
 
     await importer.import(parseResult, 'test_data')
@@ -169,6 +173,7 @@ test.group('CsvImporter: import', (group) => {
       ],
       values: [[123, 45.67]],
       header: ['integer_val', 'float_val'],
+      file: 'numeric.csv',
     }
 
     await importer.import(parseResult, 'Numeric Data')
@@ -187,3 +192,349 @@ test.group('CsvImporter: import', (group) => {
     assert.deepEqual(floatProp!.bindings, [{ type: 'web', schema: { format: 'double' } }])
   })
 })
+
+test.group('CsvImporter: importMany', (group) => {
+  let domain: DataDomain
+
+  group.each.setup(() => {
+    domain = new DataDomain()
+  })
+
+  test('should import multiple CSV structures into a single model', async ({ assert }) => {
+    const importer = new CsvImporter(domain)
+    const parseResults: ParseResult[] = [
+      {
+        format: [
+          { index: 0, name: 'id', type: 'number', format: 'integer' },
+          { index: 1, name: 'name', type: 'string' },
+        ],
+        values: [
+          [1, 'Product A'],
+          [2, 'Product B'],
+        ],
+        header: ['id', 'name'],
+        file: 'products.csv',
+      },
+      {
+        format: [
+          { index: 0, name: 'user_id', type: 'number', format: 'integer' },
+          { index: 1, name: 'email', type: 'string' },
+          { index: 2, name: 'active', type: 'boolean' },
+        ],
+        values: [
+          [100, 'user@example.com', true],
+          [101, 'admin@example.com', false],
+        ],
+        header: ['user_id', 'email', 'active'],
+        file: 'users.csv',
+      },
+    ]
+
+    const result = await importer.importMany(parseResults, 'E-commerce Data')
+
+    // Check model
+    const model = findModelByName(domain, 'e_commerce_data')
+    assert.exists(model)
+    assert.equal(model!.info.displayName, 'E-commerce Data')
+
+    // Check entities
+    assert.lengthOf(result.entities, 2)
+    assert.equal(result.model, model)
+
+    // Check products entity
+    const productsEntity = findEntityByName(domain, 'products')
+    assert.exists(productsEntity)
+    assert.isUndefined(productsEntity!.info.displayName, 'the products entity should not have a displayName')
+
+    const productIdProp = findPropertyByName(productsEntity!, 'id')
+    assert.exists(productIdProp)
+    assert.equal(productIdProp!.type, 'number')
+    assert.deepEqual(productIdProp!.bindings, [{ type: 'web', schema: { format: 'int64' } }])
+    assert.deepEqual(productIdProp!.schema?.examples, ['1'])
+
+    const productNameProp = findPropertyByName(productsEntity!, 'name')
+    assert.exists(productNameProp)
+    assert.equal(productNameProp!.type, 'string')
+    assert.deepEqual(productNameProp!.schema?.examples, ['Product A'])
+
+    // Check users entity
+    const usersEntity = findEntityByName(domain, 'users')
+    assert.exists(usersEntity)
+    assert.isUndefined(usersEntity!.info.displayName, 'the users entity should not have a displayName')
+
+    const userIdProp = findPropertyByName(usersEntity!, 'user_id')
+    assert.exists(userIdProp)
+    assert.equal(userIdProp!.type, 'number')
+    assert.deepEqual(userIdProp!.bindings, [{ type: 'web', schema: { format: 'int64' } }])
+    assert.deepEqual(userIdProp!.schema?.examples, ['100'])
+
+    const emailProp = findPropertyByName(usersEntity!, 'email')
+    assert.exists(emailProp)
+    assert.equal(emailProp!.type, 'string')
+    assert.deepEqual(emailProp!.schema?.examples, ['user@example.com'])
+
+    const activeProp = findPropertyByName(usersEntity!, 'active')
+    assert.exists(activeProp)
+    assert.equal(activeProp!.type, 'boolean')
+    assert.deepEqual(activeProp!.schema?.examples, ['true'])
+  })
+
+  test('should handle name sanitization for model and entities', async ({ assert }) => {
+    const importer = new CsvImporter(domain)
+    const parseResults: ParseResult[] = [
+      {
+        format: [{ index: 0, name: 'First Name', type: 'string' }],
+        values: [['John']],
+        header: ['First Name'],
+        file: 'Employee List!',
+      },
+      {
+        format: [{ index: 0, name: 'Department Name', type: 'string' }],
+        values: [['Engineering']],
+        header: ['Department Name'],
+        file: 'Department Info@',
+      },
+    ]
+
+    await importer.importMany(parseResults, 'HR Data!')
+
+    const model = findModelByName(domain, 'hr_data')
+    assert.exists(model)
+    assert.equal(model!.info.displayName, 'HR Data!')
+
+    const employeeEntity = findEntityByName(domain, 'employee_list')
+    assert.exists(employeeEntity)
+    assert.equal(employeeEntity!.info.displayName, 'Employee List!')
+
+    const departmentEntity = findEntityByName(domain, 'department_info')
+    assert.exists(departmentEntity)
+    assert.equal(departmentEntity!.info.displayName, 'Department Info@')
+
+    const firstNameProp = findPropertyByName(employeeEntity!, 'first_name')
+    assert.exists(firstNameProp)
+    assert.equal(firstNameProp!.info.displayName, 'First Name')
+
+    const deptNameProp = findPropertyByName(departmentEntity!, 'department_name')
+    assert.exists(deptNameProp)
+    assert.equal(deptNameProp!.info.displayName, 'Department Name')
+  })
+
+  test('should handle empty data arrays for some entities', async ({ assert }) => {
+    const importer = new CsvImporter(domain)
+    const parseResults: ParseResult[] = [
+      {
+        format: [
+          { index: 0, name: 'id', type: 'number', format: 'integer' },
+          { index: 1, name: 'title', type: 'string' },
+        ],
+        values: [[1, 'Sample Title']],
+        header: ['id', 'title'],
+        file: 'articles.csv',
+      },
+      {
+        format: [
+          { index: 0, name: 'tag_id', type: 'number' },
+          { index: 1, name: 'tag_name', type: 'string' },
+        ],
+        values: [], // No data rows
+        header: ['tag_id', 'tag_name'],
+        file: 'tags.csv',
+      },
+    ]
+
+    const result = await importer.importMany(parseResults, 'Blog Data')
+
+    assert.lengthOf(result.entities, 2)
+
+    const articlesEntity = findEntityByName(domain, 'articles')
+    assert.exists(articlesEntity)
+
+    const idProp = findPropertyByName(articlesEntity!, 'id')
+    assert.exists(idProp)
+    assert.deepEqual(idProp!.schema?.examples, ['1'])
+
+    const tagsEntity = findEntityByName(domain, 'tags')
+    assert.exists(tagsEntity)
+
+    const tagIdProp = findPropertyByName(tagsEntity!, 'tag_id')
+    assert.exists(tagIdProp)
+    assert.isUndefined(tagIdProp!.schema?.examples, 'should have no examples for empty data')
+
+    const tagNameProp = findPropertyByName(tagsEntity!, 'tag_name')
+    assert.exists(tagNameProp)
+    assert.isUndefined(tagNameProp!.schema?.examples, 'should have no examples for empty data')
+  })
+
+  test('should handle null and undefined values in example rows', async ({ assert }) => {
+    const importer = new CsvImporter(domain)
+    const parseResults: ParseResult[] = [
+      {
+        format: [
+          { index: 0, name: 'col_a', type: 'string' },
+          { index: 1, name: 'col_b', type: 'string' },
+        ],
+        // @ts-expect-error TypeScript expects values to be defined
+        values: [[null, 'valid-value']],
+        header: ['col_a', 'col_b'],
+        file: 'test_data.csv',
+      },
+      {
+        format: [
+          { index: 0, name: 'col_x', type: 'string' },
+          { index: 1, name: 'col_y', type: 'string' },
+        ],
+        // @ts-expect-error TypeScript expects values to be defined
+        values: [['another-value', undefined]],
+        header: ['col_x', 'col_y'],
+        file: 'more_test_data.csv',
+      },
+    ]
+
+    const result = await importer.importMany(parseResults, 'Test Data')
+
+    assert.lengthOf(result.entities, 2)
+
+    const testDataEntity = findEntityByName(domain, 'test_data')
+    assert.exists(testDataEntity)
+
+    const propA = findPropertyByName(testDataEntity!, 'col_a')
+    assert.exists(propA)
+    assert.isUndefined(propA!.schema?.examples, 'should not create example for null')
+
+    const propB = findPropertyByName(testDataEntity!, 'col_b')
+    assert.exists(propB)
+    assert.deepEqual(propB!.schema?.examples, ['valid-value'])
+
+    const moreTestDataEntity = findEntityByName(domain, 'more_test_data')
+    assert.exists(moreTestDataEntity)
+
+    const propX = findPropertyByName(moreTestDataEntity!, 'col_x')
+    assert.exists(propX)
+    assert.deepEqual(propX!.schema?.examples, ['another-value'])
+
+    const propY = findPropertyByName(moreTestDataEntity!, 'col_y')
+    assert.exists(propY)
+    assert.isUndefined(propY!.schema?.examples, 'should not create example for undefined')
+  })
+
+  test('should handle different number formats across entities', async ({ assert }) => {
+    const importer = new CsvImporter(domain)
+    const parseResults: ParseResult[] = [
+      {
+        format: [
+          { index: 0, name: 'int_val', type: 'number', format: 'integer' },
+          { index: 1, name: 'decimal_val', type: 'number', format: 'decimal' },
+        ],
+        values: [[42, 3.14]],
+        header: ['int_val', 'decimal_val'],
+        file: 'numbers.csv',
+      },
+      {
+        format: [
+          { index: 0, name: 'price', type: 'number', format: 'decimal' },
+          { index: 1, name: 'quantity', type: 'number', format: 'integer' },
+        ],
+        values: [[19.99, 5]],
+        header: ['price', 'quantity'],
+        file: 'inventory.csv',
+      },
+    ]
+
+    const result = await importer.importMany(parseResults, 'Numeric Data')
+
+    assert.lengthOf(result.entities, 2)
+
+    const numbersEntity = findEntityByName(domain, 'numbers')
+    assert.exists(numbersEntity)
+
+    const intProp = findPropertyByName(numbersEntity!, 'int_val')
+    assert.exists(intProp)
+    assert.equal(intProp!.type, 'number')
+    assert.deepEqual(intProp!.bindings, [{ type: 'web', schema: { format: 'int64' } }])
+
+    const decimalProp = findPropertyByName(numbersEntity!, 'decimal_val')
+    assert.exists(decimalProp)
+    assert.equal(decimalProp!.type, 'number')
+    assert.deepEqual(decimalProp!.bindings, [{ type: 'web', schema: { format: 'double' } }])
+
+    const inventoryEntity = findEntityByName(domain, 'inventory')
+    assert.exists(inventoryEntity)
+
+    const priceProp = findPropertyByName(inventoryEntity!, 'price')
+    assert.exists(priceProp)
+    assert.equal(priceProp!.type, 'number')
+    assert.deepEqual(priceProp!.bindings, [{ type: 'web', schema: { format: 'double' } }])
+
+    const quantityProp = findPropertyByName(inventoryEntity!, 'quantity')
+    assert.exists(quantityProp)
+    assert.equal(quantityProp!.type, 'number')
+    assert.deepEqual(quantityProp!.bindings, [{ type: 'web', schema: { format: 'int64' } }])
+  })
+
+  test('should handle single CSV data in array', async ({ assert }) => {
+    const importer = new CsvImporter(domain)
+    const parseResults: ParseResult[] = [
+      {
+        format: [
+          { index: 0, name: 'id', type: 'number', format: 'integer' },
+          { index: 1, name: 'name', type: 'string' },
+        ],
+        values: [[1, 'Single Item']],
+        header: ['id', 'name'],
+        file: 'single.csv',
+      },
+    ]
+
+    const result = await importer.importMany(parseResults, 'Single Data')
+
+    const model = findModelByName(domain, 'single_data')
+    assert.exists(model)
+    assert.equal(model!.info.displayName, 'Single Data')
+
+    assert.lengthOf(result.entities, 1)
+    assert.equal(result.model, model)
+
+    const singleEntity = findEntityByName(domain, 'single')
+    assert.exists(singleEntity)
+    assert.isUndefined(singleEntity!.info.displayName, 'the single entity should not have a displayName')
+
+    const idProp = findPropertyByName(singleEntity!, 'id')
+    assert.exists(idProp)
+    assert.equal(idProp!.type, 'number')
+    assert.deepEqual(idProp!.schema?.examples, ['1'])
+
+    const nameProp = findPropertyByName(singleEntity!, 'name')
+    assert.exists(nameProp)
+    assert.equal(nameProp!.type, 'string')
+    assert.deepEqual(nameProp!.schema?.examples, ['Single Item'])
+  })
+
+  test('should handle entities with fallback names when file names are missing', async ({ assert }) => {
+    const importer = new CsvImporter(domain)
+    const parseResults: ParseResult[] = [
+      {
+        format: [{ index: 0, name: 'col1', type: 'string' }],
+        values: [['value1']],
+        header: ['col1'],
+        file: '',
+      },
+      {
+        format: [{ index: 0, name: 'col2', type: 'string' }],
+        values: [['value2']],
+        header: ['col2'],
+        file: '',
+      },
+    ]
+
+    const result = await importer.importMany(parseResults, 'Fallback Data')
+
+    assert.lengthOf(result.entities, 2)
+
+    // Should use fallback names based on entity index
+    const entity0 = findEntityByName(domain, 'entity_0')
+    assert.exists(entity0)
+
+    const entity1 = findEntityByName(domain, 'entity_1')
+    assert.exists(entity1)
+  })
+})

package/tests/unit/modeling/importers/json_schema_importer.spec.ts

@@ -7,6 +7,11 @@ import { DataDomain } from '../../../../src/modeling/DataDomain.js'
 import type { JSONSchema7 } from 'json-schema'
 import type { DomainEntity } from '../../../../src/modeling/DomainEntity.js'
 import { DomainAssociation, DomainProperty } from '../../../../src/browser.js'
+import Person from '../../../fixtures/schemas/person.json' with { type: 'json' }
+import Arrays from '../../../fixtures/schemas/arrays.json' with { type: 'json' }
+import EnumValues from '../../../fixtures/schemas/enumerated_values.json' with { type: 'json' }
+import RegexpSchema from '../../../fixtures/schemas/regexp.json' with { type: 'json' }
+import ComplexSchema from '../../../fixtures/schemas/complex.json' with { type: 'json' }
 
 const input: InMemorySchema[] = []
 for (const [key, value] of Object.entries(schemas)) {
@@ -43,6 +48,13 @@ function findAssociationByName(entity: DomainEntity, name: string): DomainAssoci
   throw new Error(`Association with name "${name}" not found`)
 }
 
+async function importSchemas(input: InMemorySchema[]): Promise<DataDomain> {
+  const domain = new DataDomain({ info: { name: 'Test Domain' } })
+  const importer = new JsonSchemaImporter(domain)
+  await importer.import(input, 'imported_model')
+  return domain
+}
+
 test.group('JsonSchemaImporter', (g) => {
   let domain: DataDomain
 
@@ -449,3 +461,128 @@ test.group('JsonSchemaImporter', (g) => {
     )
   })
 })
+
+test.group('small batch of schemas', () => {
+  test('imports a single schema', async ({ assert }) => {
+    const domain = await importSchemas(input.slice(0, 1))
+    const models = [...domain.listModels()]
+    assert.lengthOf(models, 1, 'Should import one model')
+    const entities = [...domain.listEntities()]
+    assert.lengthOf(entities, 1, 'Should import one entity')
+    assert.equal(entities[0].info.name, '3_d_model', 'Entity should be 3_d_model')
+  })
+
+  test('imports two schemas only', async ({ assert }) => {
+    const domain = await importSchemas(input.slice(0, 2))
+    const models = [...domain.listModels()]
+    assert.lengthOf(models, 1, 'Should import one model')
+    const entities = [...domain.listEntities()]
+    assert.lengthOf(entities, 2, 'Should import two entities')
+    assert.equal(entities[0].info.name, '3_d_model', 'Entity should be 3_d_model')
+    assert.equal(entities[1].info.name, 'am_radio_channel', 'Entity should be am_radio_channel')
+  })
+})
+
+//
+// From the JSON Schema website.
+//
+test.group('JSON Schema Examples', () => {
+  test('imports Person schema correctly', async ({ assert }) => {
+    const domain = await importSchemas([{ path: 'person.json', contents: Person as JSONSchema7 }])
+    const models = [...domain.listModels()]
+    assert.lengthOf(models, 1, 'Should import one model')
+    const entities = [...domain.listEntities()]
+    assert.lengthOf(entities, 1, 'Should import one entity')
+    const [person] = entities
+    const properties = [...person.listProperties()]
+    assert.lengthOf(properties, 3, 'Person should have three properties')
+    assert.equal(properties[0].info.name, 'first_name', 'First property should be first_name')
+    assert.equal(properties[1].info.name, 'last_name', 'Second property should be last_name')
+    assert.equal(properties[2].info.name, 'age', 'Third property should be age')
+    assert.equal(properties[0].type, 'string', 'First property should be string')
+    assert.equal(properties[1].type, 'string', 'Second property should be string')
+    assert.equal(properties[2].type, 'number', 'Third property should be number')
+    assert.strictEqual(properties[2].schema?.minimum, 0, 'Third property should have minimum 0')
+  })
+
+  test('imports Arrays schema correctly', async ({ assert }) => {
+    const domain = await importSchemas([{ path: 'arrays.json', contents: Arrays as JSONSchema7 }])
+    const models = [...domain.listModels()]
+    assert.lengthOf(models, 1, 'Should import one model')
+    const entities = [...domain.listEntities()]
+    assert.lengthOf(entities, 2, 'Should import two entities')
+    const arraysEntity = findEntityByName(domain, 'arrays')
+    const veggieEntity = findEntityByName(domain, 'veggie')
+    assert.exists(arraysEntity, 'arrays entity should exist')
+    assert.exists(veggieEntity, 'veggie entity should exist')
+    const arraysProperties = [...arraysEntity.listProperties()]
+    const arraysAssociations = [...arraysEntity.listAssociations()]
+    assert.lengthOf(arraysProperties, 1, 'Arrays entity should have one property')
+    assert.lengthOf(arraysAssociations, 1, 'Arrays entity should have one association')
+    const veggieProperties = [...veggieEntity.listProperties()]
+    const veggieAssociations = [...veggieEntity.listAssociations()]
+    assert.lengthOf(veggieProperties, 2, 'Veggie entity should have two properties')
+    assert.lengthOf(veggieAssociations, 0, 'Veggie entity should have no associations')
+    const [vp1, vp2] = veggieProperties
+    assert.equal(vp1.info.name, 'veggie_name', 'First veggie property should be veggie_name')
+    assert.equal(vp2.info.name, 'veggie_like', 'Second veggie property should be veggie_like')
+    assert.isTrue(vp1.required, 'veggie_name should be required')
+    assert.isTrue(vp2.required, 'veggie_like should not be required')
+  })
+
+  test('imports EnumValues schema correctly', async ({ assert }) => {
+    const domain = await importSchemas([{ path: 'enumerated_values.json', contents: EnumValues as JSONSchema7 }])
+    const models = [...domain.listModels()]
+    assert.lengthOf(models, 1, 'Should import one model')
+    const entities = [...domain.listEntities()]
+    assert.lengthOf(entities, 1, 'Should import one entity')
+    const enumEntity = findEntityByName(domain, 'enumerated_values')
+    assert.exists(enumEntity, 'EnumeratedValues entity should exist')
+    const properties = [...enumEntity.listProperties()]
+    assert.lengthOf(properties, 1, 'EnumeratedValues entity should have one property')
+    const [p1] = properties
+    assert.equal(p1.info.name, 'data', 'Property should be data')
+    assert.deepEqual(
+      p1.schema?.enum,
+      ['42', 'true', 'hello', 'null', '1,2,3'],
+      'Property should have correct enum values'
+    )
+  })
+
+  test('imports RegexpSchema schema correctly', async ({ assert }) => {
+    const domain = await importSchemas([{ path: 'regexp.json', contents: RegexpSchema as JSONSchema7 }])
+    const models = [...domain.listModels()]
+    assert.lengthOf(models, 1, 'Should import one model')
+    const entities = [...domain.listEntities()]
+    assert.lengthOf(entities, 1, 'Should import one entity')
+    const entity = findEntityByName(domain, 'regular_expression_pattern')
+    assert.exists(entity, 'RegularExpressionPattern entity should exist')
+    const properties = [...entity.listProperties()]
+    assert.lengthOf(properties, 1, 'RegularExpressionPattern entity should have one property')
+    const [p1] = properties
+    assert.equal(p1.info.name, 'code', 'Property should be code')
+    assert.equal(p1.schema?.pattern, '^[A-Z]{3}-\\d{3}$', 'Property should have correct pattern')
+  })
+
+  test('imports ComplexSchema schema correctly', async ({ assert }) => {
+    const domain = await importSchemas([{ path: 'complex.json', contents: ComplexSchema as JSONSchema7 }])
+    const models = [...domain.listModels()]
+    assert.lengthOf(models, 1, 'Should import one model')
+    const entities = [...domain.listEntities()]
+    assert.lengthOf(entities, 2, 'Should import two entities')
+    const entity = findEntityByName(domain, 'complex_object')
+    assert.exists(entity, 'ComplexObject entity should exist')
+    const properties = [...entity.listProperties()]
+    assert.lengthOf(properties, 3, 'ComplexObject entity should have three properties')
+    const [p1, p2, p3] = properties
+    assert.equal(p1.info.name, 'name', 'First property should be name')
+    assert.equal(p2.info.name, 'age', 'Second property should be age')
+    assert.equal(p3.info.name, 'hobbies', 'Third property should be hobbies')
+    const associations = [...entity.listAssociations()]
+    assert.lengthOf(associations, 1, 'ComplexObject entity should have one association')
+    const inlineEntity = findEntityByName(domain, 'complex_object_address')
+    assert.exists(inlineEntity, 'ComplexObjectAddress entity should exist')
+    const [a1] = associations
+    assert.deepEqual(a1.targets, [{ key: inlineEntity.key }], 'Association should target ComplexObjectAddress')
+  })
+})