@api-client/core 0.18.17 → 0.18.19

package/tests/unit/modeling/DataDomain.search.spec.ts

@@ -0,0 +1,188 @@
+import { test } from '@japa/runner'
+import { DataDomain } from '../../../src/modeling/DataDomain.js'
+import { DomainEntityKind, DomainNamespaceKind, DomainPropertyKind } from '../../../src/models/kinds.js'
+
+test.group('DataDomain Search', () => {
+  test('should return all nodes when no search criteria provided', ({ assert }) => {
+    const domain = new DataDomain({
+      key: 'test-domain',
+      info: { name: 'Test Domain' },
+    })
+
+    const namespace = domain.addNamespace({ info: { name: 'TestNamespace' } })
+    const model = namespace.addModel({ info: { name: 'TestModel' } })
+    const entity = model.addEntity({ info: { name: 'TestEntity' } })
+    entity.addProperty({ info: { name: 'testProperty' }, type: 'string' })
+
+    const results = domain.search()
+
+    assert.isAtLeast(results.length, 4) // namespace, model, entity, property
+    assert.isTrue(results.every((result) => result.matchedFields.length === 0))
+  })
+
+  test('should search by text query in name field', ({ assert }) => {
+    const domain = new DataDomain({
+      key: 'test-domain',
+      info: { name: 'Test Domain' },
+    })
+
+    const namespace = domain.addNamespace({ info: { name: 'UserNamespace' } })
+    const model = namespace.addModel({ info: { name: 'UserModel' } })
+    const entity = model.addEntity({ info: { name: 'User' } })
+    entity.addProperty({ info: { name: 'email' }, type: 'string' })
+
+    const results = domain.search({ query: 'User' })
+
+    assert.equal(results.length, 3) // namespace, model, entity
+    assert.isTrue(results.every((result) => result.matchedFields.includes('name')))
+  })
+
+  test('should search by text query in displayName field', ({ assert }) => {
+    const domain = new DataDomain({
+      key: 'test-domain',
+      info: { name: 'Test Domain' },
+    })
+
+    domain.addNamespace({ info: { name: 'TestNamespace', displayName: 'User Management' } })
+
+    const results = domain.search({ query: 'Management' })
+
+    assert.equal(results.length, 1)
+    assert.equal(results[0].node.kind, DomainNamespaceKind)
+    assert.isTrue(results[0].matchedFields.includes('displayName'))
+  })
+
+  test('should search by text query in description field', ({ assert }) => {
+    const domain = new DataDomain({
+      key: 'test-domain',
+      info: { name: 'Test Domain' },
+    })
+
+    domain.addNamespace({
+      info: { name: 'TestNamespace', description: 'Handles user authentication' },
+    })
+
+    const results = domain.search({ query: 'authentication' })
+
+    assert.equal(results.length, 1)
+    assert.equal(results[0].node.kind, DomainNamespaceKind)
+    assert.isTrue(results[0].matchedFields.includes('description'))
+  })
+
+  test('should filter by node type', ({ assert }) => {
+    const domain = new DataDomain({
+      key: 'test-domain',
+      info: { name: 'Test Domain' },
+    })
+
+    const namespace = domain.addNamespace({ info: { name: 'UserNamespace' } })
+    const model = namespace.addModel({ info: { name: 'UserModel' } })
+    const entity = model.addEntity({ info: { name: 'User' } })
+    entity.addProperty({ info: { name: 'userId' }, type: 'string' })
+
+    const entityResults = domain.search({ nodeTypes: [DomainEntityKind] })
+    const propertyResults = domain.search({ nodeTypes: [DomainPropertyKind] })
+
+    assert.equal(entityResults.length, 1)
+    assert.equal(entityResults[0].node.kind, DomainEntityKind)
+
+    assert.equal(propertyResults.length, 1)
+    assert.equal(propertyResults[0].node.kind, DomainPropertyKind)
+  })
+
+  test('should combine text query and node type filters', ({ assert }) => {
+    const domain = new DataDomain({
+      key: 'test-domain',
+      info: { name: 'Test Domain' },
+    })
+
+    const namespace = domain.addNamespace({ info: { name: 'UserNamespace' } })
+    const model = namespace.addModel({ info: { name: 'UserModel' } })
+    const entity = model.addEntity({ info: { name: 'User' } })
+    entity.addProperty({ info: { name: 'userName' }, type: 'string' })
+
+    const results = domain.search({
+      query: 'User',
+      nodeTypes: [DomainEntityKind, DomainPropertyKind],
+    })
+
+    assert.equal(results.length, 2) // entity and property
+    assert.isTrue(
+      results.every((result) => result.node.kind === DomainEntityKind || result.node.kind === DomainPropertyKind)
+    )
+  })
+
+  test('should support case-sensitive search', ({ assert }) => {
+    const domain = new DataDomain({
+      key: 'test-domain',
+      info: { name: 'Test Domain' },
+    })
+
+    domain.addNamespace({ info: { name: 'user' } })
+    domain.addNamespace({ info: { name: 'User' } })
+
+    const caseSensitiveResults = domain.search({ query: 'User', caseSensitive: true })
+    const caseInsensitiveResults = domain.search({ query: 'User', caseSensitive: false })
+
+    assert.equal(caseSensitiveResults.length, 1)
+    assert.equal(caseInsensitiveResults.length, 2)
+  })
+
+  test('should support regex queries', ({ assert }) => {
+    const domain = new DataDomain({
+      key: 'test-domain',
+      info: { name: 'Test Domain' },
+    })
+
+    domain.addNamespace({ info: { name: 'user1' } })
+    domain.addNamespace({ info: { name: 'user2' } })
+    domain.addNamespace({ info: { name: 'admin' } })
+
+    const results = domain.search({ query: /^user\d+$/ })
+
+    assert.equal(results.length, 2)
+    assert.isTrue(results.every((result) => /^user\d+$/.test(result.node.info.name || '')))
+  })
+
+  test('should identify foreign nodes correctly', ({ assert }) => {
+    const foreignDomain = new DataDomain({
+      key: 'foreign-domain',
+      info: { name: 'Foreign Domain', version: '1.0.0' },
+    })
+    foreignDomain.addNamespace({ info: { name: 'ForeignNamespace' } })
+
+    const domain = new DataDomain({
+      key: 'main-domain',
+      info: { name: 'Main Domain' },
+    })
+    domain.registerForeignDomain(foreignDomain)
+
+    const resultsWithoutForeign = domain.search({ query: 'Foreign' })
+    const resultsWithForeign = domain.search({ query: 'Foreign', includeForeignDomains: true })
+
+    assert.equal(resultsWithoutForeign.length, 0)
+    assert.equal(resultsWithForeign.length, 1)
+    assert.isTrue(resultsWithForeign[0].isForeign)
+  })
+
+  test('should handle multiple matched fields', ({ assert }) => {
+    const domain = new DataDomain({
+      key: 'test-domain',
+      info: { name: 'Test Domain' },
+    })
+
+    domain.addNamespace({
+      info: {
+        name: 'TestNamespace',
+        displayName: 'Test Display',
+        description: 'Test description',
+      },
+    })
+
+    const results = domain.search({ query: 'Test' })
+
+    assert.equal(results.length, 1)
+    assert.equal(results[0].matchedFields.length, 3)
+    assert.includeMembers(results[0].matchedFields, ['name', 'displayName', 'description'])
+  })
+})

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

@@ -456,7 +456,7 @@ test.group('Validation Tests', () => {
     assert.throws(() => domain.toJSON())
   }).tags(['@modeling', '@serialization', '@validation'])
 
-  test('should throw validation error when association has no target entities', ({ assert }) => {
+  test('should not throw validation error when association has no target entities', ({ assert }) => {
     const domain = new DataDomain()
     const m1 = domain.addModel()
     const e1 = m1.addEntity()
@@ -466,7 +466,11 @@ test.group('Validation Tests', () => {
     // Remove the association target edge
     domain.graph.removeEdge(a1.key, e2.key)
 
-    assert.throws(() => domain.toJSON())
+    // Note, we specifically removed this from the validation as it would throw errors
+    // when associations were created without targets. This is not a structural issue and because
+    // of that, it shouldn't be considered a validation error in this context.
+    // It is reported through the validator, though.
+    assert.doesNotThrow(() => domain.toJSON())
   }).tags(['@modeling', '@serialization', '@validation'])
 
   test('should throw validation error when association references non-existent target', ({ assert }) => {

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

@@ -908,3 +908,379 @@ test.group('DomainAssociation.hasSemantic()', () => {
     assert.isFalse(association.hasSemantic(SemanticType.ResourceOwnerIdentifier))
   })
 })
+
+test.group('DomainAssociation.duplicate()', () => {
+  test('duplicates an association successfully', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const targetEntity = model.addEntity()
+
+    const association = entity.addAssociation({ key: targetEntity.key })
+    association.info.name = 'originalAssociation'
+    association.required = true
+    association.multiple = false
+
+    const duplicate = association.duplicate()
+
+    assert.isDefined(duplicate)
+    assert.notEqual(duplicate.key, association.key)
+    assert.equal(duplicate.info.name, 'originalAssociation_copy')
+    assert.equal(duplicate.required, true)
+    assert.equal(duplicate.multiple, false)
+  })
+
+  test('places duplicate right after original association in fields list', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const targetEntity = model.addEntity()
+
+    // Add multiple fields to test ordering
+    const property1 = entity.addProperty({ info: { name: 'first' } })
+    const association1 = entity.addAssociation({ key: targetEntity.key })
+    association1.info.name = 'originalAssoc'
+    const property2 = entity.addProperty({ info: { name: 'second' } })
+
+    const duplicate = association1.duplicate()
+
+    // Check that duplicate is placed right after association1
+    const fieldKeys = entity.fields.map((f) => f.key)
+    const association1Index = fieldKeys.indexOf(association1.key)
+    const duplicateIndex = fieldKeys.indexOf(duplicate.key)
+
+    assert.equal(duplicateIndex, association1Index + 1)
+    assert.deepEqual(fieldKeys, [property1.key, association1.key, duplicate.key, property2.key])
+  })
+
+  test('generates unique name when base name conflicts', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const targetEntity = model.addEntity()
+
+    const association = entity.addAssociation({ key: targetEntity.key })
+    association.info.name = 'test'
+    // Add another association that conflicts with the first generated name
+    const conflictAssoc = entity.addAssociation({ key: targetEntity.key })
+    conflictAssoc.info.name = 'test_copy'
+
+    const duplicate = association.duplicate()
+
+    assert.equal(duplicate.info.name, 'test_copy_2')
+  })
+
+  test('uses fallback name when original association has no name', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const targetEntity = model.addEntity()
+
+    const association = entity.addAssociation({ key: targetEntity.key })
+    // The association gets the default name "new_association" from schema creation
+    assert.equal(association.info.name, 'new_association')
+
+    const duplicate = association.duplicate()
+
+    assert.equal(duplicate.info.name, 'new_association_copy')
+  })
+
+  test('uses field fallback when association name is explicitly undefined', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const targetEntity = model.addEntity()
+
+    const association = entity.addAssociation({ key: targetEntity.key })
+    association.info.name = 'test'
+    // Manually set name to undefined to test the fallback logic
+    association.info.name = undefined
+
+    const duplicate = association.duplicate()
+
+    assert.equal(duplicate.info.name, 'field_copy')
+  })
+
+  test('does not copy key property', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const targetEntity = model.addEntity()
+
+    const association = entity.addAssociation({ key: targetEntity.key })
+    const originalKey = association.key
+
+    const duplicate = association.duplicate()
+
+    assert.notEqual(duplicate.key, originalKey)
+  })
+
+  test('does not copy targets initially but recreates them', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const targetEntity1 = model.addEntity()
+    const targetEntity2 = model.addEntity()
+
+    const association = entity.addAssociation({ key: targetEntity1.key })
+    association.addTarget(targetEntity2.key)
+    association.info.name = 'multiTarget'
+
+    const duplicate = association.duplicate()
+
+    // Should have the same targets but different association instance
+    const originalTargets = [...association.listTargets()]
+    const duplicateTargets = [...duplicate.listTargets()]
+
+    assert.equal(originalTargets.length, duplicateTargets.length)
+    assert.equal(originalTargets.length, 2)
+
+    // Check that target keys match
+    const originalKeys = originalTargets.map((t) => t.key).sort()
+    const duplicateKeys = duplicateTargets.map((t) => t.key).sort()
+    assert.deepEqual(originalKeys, duplicateKeys)
+  })
+
+  test('copies all other association attributes', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const targetEntity = model.addEntity()
+
+    const association = entity.addAssociation({ key: targetEntity.key })
+    association.info.name = 'complexAssociation'
+    association.info.description = 'A complex association'
+    association.required = true
+    association.multiple = true
+    association.readOnly = true
+    association.onDelete = 'cascade'
+    association.semantics = [{ id: SemanticType.ResourceOwnerIdentifier }]
+    association.schema = { linked: true, unionType: 'allOf' }
+    association.bindings = [{ type: 'web', schema: { hidden: true } }]
+
+    const duplicate = association.duplicate()
+
+    assert.equal(duplicate.info.name, 'complexAssociation_copy')
+    assert.equal(duplicate.info.description, 'A complex association')
+    assert.equal(duplicate.required, true)
+    assert.equal(duplicate.multiple, true)
+    assert.equal(duplicate.readOnly, true)
+    assert.equal(duplicate.onDelete, 'cascade')
+    assert.deepEqual(duplicate.semantics, [{ id: SemanticType.ResourceOwnerIdentifier }])
+    assert.deepEqual(duplicate.schema, { linked: true, unionType: 'allOf' })
+    assert.deepEqual(duplicate.bindings, [{ type: 'web', schema: { hidden: true } }])
+  })
+
+  test('creates independent copy of schema and bindings', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const targetEntity = model.addEntity()
+
+    const association = entity.addAssociation({ key: targetEntity.key })
+    association.info.name = 'original'
+    association.schema = { linked: false, unionType: 'anyOf' }
+    association.bindings = [{ type: 'web', schema: { hidden: false } }]
+
+    const duplicate = association.duplicate()
+
+    // Modify original schema and bindings
+    association.schema!.linked = true
+    association.bindings[0].schema = { hidden: true }
+
+    // Duplicate should be unaffected
+    assert.equal(duplicate.schema!.linked, false)
+    assert.deepEqual(duplicate.bindings[0].schema, { hidden: false })
+  })
+
+  test('copies targets correctly', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+
+    const targetEntity1 = model.addEntity()
+    const targetEntity2 = model.addEntity()
+
+    const association = entity.addAssociation()
+    association.addTarget(targetEntity1.key)
+    association.addTarget(targetEntity2.key)
+    association.info.name = 'multiTargetAssoc'
+
+    // Check that original association has targets
+    const originalTargets = [...association.listTargets()]
+    assert.equal(originalTargets.length, 2)
+
+    const duplicate = association.duplicate()
+
+    // Check targets on duplicate
+    const duplicateTargets = [...duplicate.listTargets()]
+    const duplicateTargetObjects = duplicate.targets
+
+    // Check targets array structure
+    assert.equal(duplicateTargetObjects.length, 2)
+    assert.equal(duplicateTargetObjects[0].key, targetEntity1.key)
+    assert.equal(duplicateTargetObjects[1].key, targetEntity2.key)
+
+    // Check resolved targets
+    assert.equal(duplicateTargets.length, 2)
+    const duplicateKeys = duplicateTargets.map((t) => t.key).sort()
+    const expectedKeys = [targetEntity1.key, targetEntity2.key].sort()
+    assert.deepEqual(duplicateKeys, expectedKeys)
+  })
+
+  test('notifies domain of changes', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const targetEntity = model.addEntity()
+
+    const association = entity.addAssociation({ key: targetEntity.key })
+    association.info.name = 'test'
+
+    let notificationCalled = false
+    const originalNotify = dataDomain.notifyChange
+    dataDomain.notifyChange = () => {
+      notificationCalled = true
+      originalNotify.call(dataDomain)
+    }
+
+    association.duplicate()
+
+    assert.isTrue(notificationCalled)
+
+    // Restore original method
+    dataDomain.notifyChange = originalNotify
+  })
+
+  test('throws error when association has no parent entity', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const association = new DomainAssociation(dataDomain, 'non-existent-parent', {
+      info: { name: 'orphan' },
+    })
+
+    assert.throws(() => {
+      association.duplicate()
+    }, 'Cannot duplicate association')
+  })
+
+  test('throws error when association is not in parent entity fields list', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const association = new DomainAssociation(dataDomain, entity.key, {
+      info: { name: 'detached' },
+    })
+
+    // Add association to graph but not to entity fields
+    dataDomain.graph.setNode(association.key, association)
+
+    assert.throws(() => {
+      association.duplicate()
+    }, 'does not exist on the parent entity fields list')
+  })
+
+  test('works with empty entity fields list', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const targetEntity = model.addEntity()
+    const association = entity.addAssociation({ key: targetEntity.key })
+    association.info.name = 'only'
+
+    const duplicate = association.duplicate()
+
+    assert.equal(entity.fields.length, 2)
+    assert.equal(entity.fields[0].key, association.key)
+    assert.equal(entity.fields[1].key, duplicate.key)
+  })
+
+  test('handles duplication with mixed field types', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const targetEntity = model.addEntity()
+
+    const property1 = entity.addProperty({ info: { name: 'prop1' } })
+    const association1 = entity.addAssociation({ key: targetEntity.key })
+    association1.info.name = 'assoc1'
+    const property2 = entity.addProperty({ info: { name: 'prop2' } })
+
+    const duplicate = association1.duplicate()
+
+    // Should maintain correct order
+    const fieldKeys = entity.fields.map((f) => f.key)
+    assert.deepEqual(fieldKeys, [property1.key, association1.key, duplicate.key, property2.key])
+  })
+
+  test('preserves field types correctly', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const targetEntity = model.addEntity()
+    const association = entity.addAssociation({ key: targetEntity.key })
+
+    const duplicate = association.duplicate()
+
+    // Check that both original and duplicate have correct field type
+    const originalField = entity.fields.find((f) => f.key === association.key)
+    const duplicateField = entity.fields.find((f) => f.key === duplicate.key)
+
+    assert.equal(originalField?.type, 'association')
+    assert.equal(duplicateField?.type, 'association')
+  })
+
+  test('handles multiple target entities correctly', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const targetEntity1 = model.addEntity()
+    const targetEntity2 = model.addEntity()
+    const targetEntity3 = model.addEntity()
+
+    const association = entity.addAssociation()
+    association.addTarget(targetEntity1.key)
+    association.addTarget(targetEntity2.key)
+    association.addTarget(targetEntity3.key)
+    association.info.name = 'multiTarget'
+
+    const duplicate = association.duplicate()
+
+    const originalTargets = [...association.listTargets()]
+    const duplicateTargets = [...duplicate.listTargets()]
+
+    assert.equal(originalTargets.length, 3)
+    assert.equal(duplicateTargets.length, 3)
+
+    // Verify all targets are copied correctly
+    const originalKeys = originalTargets.map((t) => t.key).sort()
+    const duplicateKeys = duplicateTargets.map((t) => t.key).sort()
+    assert.deepEqual(originalKeys, duplicateKeys)
+  })
+
+  test('handles foreign domains correctly', ({ assert }) => {
+    const fd = new DataDomain()
+    const fd1 = fd.addModel()
+    const fe1 = fd1.addEntity()
+    fd.info.version = '1.0.0'
+
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    dataDomain.registerForeignDomain(fd)
+
+    const association = entity.addAssociation({ key: fe1.key, domain: fd.key })
+
+    const duplicate = association.duplicate()
+
+    const originalTargets = [...association.listTargets()]
+    const duplicateTargets = [...duplicate.listTargets()]
+
+    assert.equal(originalTargets.length, 1)
+    assert.equal(duplicateTargets.length, 1)
+
+    // Verify all targets are copied correctly
+    const originalKeys = originalTargets.map((t) => t.key).sort()
+    const duplicateKeys = duplicateTargets.map((t) => t.key).sort()
+    assert.deepEqual(originalKeys, duplicateKeys)
+  })
+})