@api-client/core 0.18.2 → 0.18.4

package/tests/unit/modeling/api_model.spec.ts

@@ -21,7 +21,7 @@ test.group('ApiModel.createSchema()', (g) => {
     assert.isNotEmpty(schema.key)
     assert.deepInclude(schema.info, { name: 'Unnamed API' })
     assert.deepEqual(schema.exposes, [])
-    assert.isUndefined(schema.userKey)
+    assert.isUndefined(schema.user)
     assert.isUndefined(schema.dependencyList)
     assert.isUndefined(schema.authentication)
     assert.isUndefined(schema.authorization)
@@ -38,7 +38,7 @@ test.group('ApiModel.createSchema()', (g) => {
       key: 'test-api',
       info: { name: 'Test API', description: 'A test API' },
       exposes: [{ key: 'entity1', actions: [] }],
-      userKey: 'user-entity',
+      user: { key: 'user-entity' },
       dependencyList: [{ key: 'domain1', version: '1.0.0' }],
       authentication: { strategy: 'UsernamePassword' },
       authorization: { strategy: 'RBAC', roleKey: 'role' } as RolesBasedAccessControl,
@@ -55,7 +55,7 @@ test.group('ApiModel.createSchema()', (g) => {
     assert.equal(schema.key, 'test-api')
     assert.deepInclude(schema.info, { name: 'Test API', description: 'A test API' })
     assert.deepEqual(schema.exposes, [{ key: 'entity1', actions: [] }])
-    assert.equal(schema.userKey, 'user-entity')
+    assert.deepEqual(schema.user, { key: 'user-entity' })
     assert.deepEqual(schema.dependencyList, [{ key: 'domain1', version: '1.0.0' }])
     assert.deepEqual(schema.authentication, { strategy: 'UsernamePassword' })
     assert.deepEqual(schema.authorization, { strategy: 'RBAC', roleKey: 'role' })
@@ -90,7 +90,7 @@ test.group('ApiModel.constructor()', (g) => {
     assert.isNotEmpty(model.key)
     assert.equal(model.info.name, 'Unnamed API')
     assert.deepEqual(model.exposes, [])
-    assert.isUndefined(model.userKey)
+    assert.isUndefined(model.user)
     assert.isUndefined(model.authentication)
     assert.isUndefined(model.authorization)
     assert.isUndefined(model.session)
@@ -108,7 +108,7 @@ test.group('ApiModel.constructor()', (g) => {
       key: 'test-api',
       info: { name: 'Test API', description: 'A test API' },
       exposes: [{ key: 'entity1', actions: [] }],
-      userKey: 'user-entity',
+      user: { key: 'user-entity' },
       dependencyList: [{ key: 'domain1', version: '1.0.0' }],
       authentication: { strategy: 'UsernamePassword' },
       authorization: { strategy: 'RBAC', roleKey: 'role' } as RolesBasedAccessControl,
@@ -124,7 +124,7 @@ test.group('ApiModel.constructor()', (g) => {
     assert.equal(model.key, 'test-api')
     assert.equal(model.info.name, 'Test API')
     assert.deepEqual(model.exposes, [{ key: 'entity1', actions: [] }])
-    assert.equal(model.userKey, 'user-entity')
+    assert.deepEqual(model.user, { key: 'user-entity' })
     assert.deepEqual(model.dependencyList, [{ key: 'domain1', version: '1.0.0' }])
     assert.deepEqual(model.authentication, { strategy: 'UsernamePassword' })
     assert.deepEqual(model.authorization, { strategy: 'RBAC', roleKey: 'role' })
@@ -172,7 +172,7 @@ test.group('ApiModel.toJSON()', (g) => {
     assert.equal(json.key, model.key)
     assert.deepInclude(json.info, { name: 'Unnamed API' })
     assert.deepEqual(json.exposes, [])
-    assert.isUndefined(json.userKey)
+    assert.isUndefined(json.user)
     assert.isUndefined(json.dependencyList)
     assert.isUndefined(json.authentication)
     assert.isUndefined(json.authorization)
@@ -190,7 +190,7 @@ test.group('ApiModel.toJSON()', (g) => {
       key: 'test-api',
       info: { name: 'Test API', description: 'A test API' },
       exposes: [{ key: 'entity1', actions: [] }],
-      userKey: 'user-entity',
+      user: { key: 'user-entity' },
       dependencyList: [{ key: 'domain1', version: '1.0.0' }],
       authentication: { strategy: 'UsernamePassword' },
       authorization: { strategy: 'RBAC', roleKey: 'role' } as RolesBasedAccessControl,
@@ -207,7 +207,7 @@ test.group('ApiModel.toJSON()', (g) => {
     assert.equal(json.key, 'test-api')
     assert.deepInclude(json.info, { name: 'Test API', description: 'A test API' })
     assert.deepEqual(json.exposes, [{ key: 'entity1', actions: [] }])
-    assert.equal(json.userKey, 'user-entity')
+    assert.deepEqual(json.user, { key: 'user-entity' })
     assert.deepEqual(json.dependencyList, [{ key: 'domain1', version: '1.0.0' }])
     assert.deepEqual(json.authentication, { strategy: 'UsernamePassword' })
     assert.deepEqual(json.authorization, { strategy: 'RBAC', roleKey: 'role' })

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

@@ -0,0 +1,189 @@
+import { test } from '@japa/runner'
+
+import { DataDomain } from '../../../../src/modeling/DataDomain.js'
+import { DomainModel } from '../../../../src/modeling/DomainModel.js'
+import { DomainEntity } from '../../../../src/modeling/DomainEntity.js'
+import { DomainProperty } from '../../../../src/modeling/DomainProperty.js'
+import { CsvImporter, type ParseResult } from '../../../../src/modeling/importers/CsvImporter.js'
+
+function findModelByName(domain: DataDomain, name: string): DomainModel {
+  for (const model of domain.listModels()) {
+    if (model.info.name === name || model.info.displayName === name) {
+      return model
+    }
+  }
+  throw new Error(`Model with name "${name}" not found`)
+}
+
+function findEntityByName(domain: DataDomain, name: string): DomainEntity {
+  for (const entity of domain.listEntities()) {
+    if (entity.info.name === name || entity.info.displayName === name) {
+      return entity
+    }
+  }
+  throw new Error(`Entity with name "${name}" not found`)
+}
+
+function findPropertyByName(entity: DomainEntity, name: string): DomainProperty {
+  for (const prop of entity.listProperties()) {
+    if (prop.info.name === name || prop.info.displayName === name) {
+      return prop
+    }
+  }
+  throw new Error(`Property with name "${name}" not found`)
+}
+
+test.group('CsvImporter: import', (group) => {
+  let domain: DataDomain
+
+  group.each.setup(() => {
+    domain = new DataDomain()
+  })
+
+  test('should import a basic CSV structure', async ({ assert }) => {
+    const importer = new CsvImporter(domain)
+    const parseResult: ParseResult = {
+      format: [
+        { index: 0, name: 'id', type: 'number', format: 'integer' },
+        { index: 1, name: 'name', type: 'string' },
+        { index: 2, name: 'value', type: 'number', format: 'decimal' },
+      ],
+      values: [[1, 'test-item', 99.9]],
+      header: ['id', 'name', 'value'],
+    }
+
+    await importer.import(parseResult, 'My Products')
+
+    const model = findModelByName(domain, 'my_products')
+    assert.exists(model)
+
+    const entity = findEntityByName(domain, 'my_products')
+    assert.exists(entity)
+    assert.equal(entity!.info.displayName, 'My Products')
+
+    const idProp = findPropertyByName(entity!, 'id')
+    assert.exists(idProp)
+    assert.equal(idProp!.type, 'number')
+    assert.deepEqual(idProp!.bindings, [{ type: 'web', schema: { format: 'int64' } }])
+    assert.deepEqual(idProp!.schema?.examples, ['1'])
+
+    const nameProp = findPropertyByName(entity!, 'name')
+    assert.exists(nameProp)
+    assert.equal(nameProp!.type, 'string')
+    assert.isEmpty(nameProp!.bindings)
+    assert.deepEqual(nameProp!.schema?.examples, ['test-item'])
+    assert.isUndefined(nameProp!.info.displayName, 'should not have displayName set')
+
+    const valueProp = findPropertyByName(entity!, 'value')
+    assert.exists(valueProp)
+    assert.equal(valueProp!.type, 'number')
+    assert.deepEqual(valueProp!.bindings, [{ type: 'web', schema: { format: 'double' } }])
+    assert.deepEqual(valueProp!.schema?.examples, ['99.9'])
+  })
+
+  test('should handle name sanitization for model and properties', async ({ assert }) => {
+    const importer = new CsvImporter(domain)
+    const parseResult: ParseResult = {
+      format: [{ index: 0, name: 'First Name', type: 'string' }],
+      values: [['John']],
+      header: ['First Name'],
+    }
+
+    await importer.import(parseResult, 'User List!')
+
+    const model = findModelByName(domain, 'user_list')
+    assert.exists(model)
+    assert.equal(model!.info.displayName, 'User List!')
+
+    const entity = findEntityByName(domain, 'user_list')
+    assert.exists(entity)
+    assert.equal(entity!.info.displayName, 'User List!')
+
+    const prop = findPropertyByName(entity!, 'first_name')
+    assert.exists(prop)
+    assert.equal(prop!.info.displayName, 'First Name')
+  })
+
+  test('should import with no data rows (headers only)', async ({ assert }) => {
+    const importer = new CsvImporter(domain)
+    const parseResult: ParseResult = {
+      format: [
+        { index: 0, name: 'id', type: 'number' },
+        { index: 1, name: 'email', type: 'string' },
+      ],
+      values: [], // No data rows
+      header: ['id', 'email'],
+    }
+
+    await importer.import(parseResult, 'users')
+
+    const entity = findEntityByName(domain, 'users')
+    assert.exists(entity)
+
+    const idProp = findPropertyByName(entity!, 'id')
+    assert.exists(idProp)
+    assert.isUndefined(idProp!.schema?.examples, 'should have no examples')
+
+    const emailProp = findPropertyByName(entity!, 'email')
+    assert.exists(emailProp)
+    assert.isUndefined(emailProp!.schema?.examples, 'should have no examples')
+  })
+
+  test('should handle null and undefined values in example row', async ({ assert }) => {
+    const importer = new CsvImporter(domain)
+    const parseResult: ParseResult = {
+      format: [
+        { index: 0, name: 'col_a', type: 'string' },
+        { index: 1, name: 'col_b', type: 'string' },
+        { index: 2, name: 'col_c', type: 'string' },
+      ],
+      // @ts-expect-error TypeScript expects values to be defined
+      values: [[null, 'has-value', undefined]],
+      header: ['col_a', 'col_b', 'col_c'],
+    }
+
+    await importer.import(parseResult, 'test_data')
+
+    const entity = findEntityByName(domain, 'test_data')
+    assert.exists(entity)
+
+    const propA = findPropertyByName(entity!, 'col_a')
+    assert.exists(propA)
+    assert.isUndefined(propA!.schema?.examples, 'should not create example for null')
+
+    const propB = findPropertyByName(entity!, 'col_b')
+    assert.exists(propB)
+    assert.deepEqual(propB!.schema?.examples, ['has-value'])
+
+    const propC = findPropertyByName(entity!, 'col_c')
+    assert.exists(propC)
+    assert.isUndefined(propC!.schema?.examples, 'should not create example for undefined')
+  })
+
+  test('should handle integer and float number formats correctly', async ({ assert }) => {
+    const importer = new CsvImporter(domain)
+    const parseResult: ParseResult = {
+      format: [
+        { index: 0, name: 'integer_val', type: 'number', format: 'integer' },
+        { index: 1, name: 'float_val', type: 'number', format: 'decimal' },
+      ],
+      values: [[123, 45.67]],
+      header: ['integer_val', 'float_val'],
+    }
+
+    await importer.import(parseResult, 'Numeric Data')
+
+    const entity = findEntityByName(domain, 'numeric_data')
+    assert.exists(entity)
+
+    const intProp = findPropertyByName(entity!, 'integer_val')
+    assert.exists(intProp)
+    assert.equal(intProp!.type, 'number')
+    assert.deepEqual(intProp!.bindings, [{ type: 'web', schema: { format: 'int64' } }])
+
+    const floatProp = findPropertyByName(entity!, 'float_val')
+    assert.exists(floatProp)
+    assert.equal(floatProp!.type, 'number')
+    assert.deepEqual(floatProp!.bindings, [{ type: 'web', schema: { format: 'double' } }])
+  })
+})