@api-client/core 0.18.16 → 0.18.18

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)
+  })
+})

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

@@ -729,3 +729,150 @@ test.group('DomainEntity.isChildOf()', () => {
     assert.isTrue(entity.isChildOf(dataDomain.key))
   })
 })
+
+test.group('DomainEntity.generateUniqueName()', () => {
+  test('generates unique name when no fields exist', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+
+    const uniqueName = entity.generateUniqueName('test')
+    assert.equal(uniqueName, 'test_copy')
+  })
+
+  test('generates unique name when base name does not conflict', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+
+    // Add a property with a different name
+    entity.addProperty({ info: { name: 'existing_field' } })
+
+    const uniqueName = entity.generateUniqueName('test')
+    assert.equal(uniqueName, 'test_copy')
+  })
+
+  test('generates unique name when base_copy conflicts with existing property', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+
+    // Add a property that conflicts with the first generated name
+    entity.addProperty({ info: { name: 'test_copy' } })
+
+    const uniqueName = entity.generateUniqueName('test')
+    assert.equal(uniqueName, 'test_copy_2')
+  })
+
+  test('generates unique name when multiple conflicts exist with properties', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+
+    // Add properties that conflict with multiple generated names
+    entity.addProperty({ info: { name: 'test_copy' } })
+    entity.addProperty({ info: { name: 'test_copy_2' } })
+    entity.addProperty({ info: { name: 'test_copy_3' } })
+
+    const uniqueName = entity.generateUniqueName('test')
+    assert.equal(uniqueName, 'test_copy_4')
+  })
+
+  test('generates unique name when conflicts exist with associations', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const targetEntity = model.addEntity()
+
+    // Add an association that conflicts with the first generated name
+    const association = entity.addAssociation({ key: targetEntity.key })
+    association.info.name = 'test_copy'
+
+    const uniqueName = entity.generateUniqueName('test')
+    assert.equal(uniqueName, 'test_copy_2')
+  })
+
+  test('generates unique name when conflicts exist with both properties and associations', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const targetEntity = model.addEntity()
+
+    // Add property and association with conflicting names
+    entity.addProperty({ info: { name: 'test_copy' } })
+    const association = entity.addAssociation({ key: targetEntity.key })
+    association.info.name = 'test_copy_2'
+
+    const uniqueName = entity.generateUniqueName('test')
+    assert.equal(uniqueName, 'test_copy_3')
+  })
+
+  test('handles fields with undefined names', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const targetEntity = model.addEntity()
+
+    // Add property without a name (undefined name)
+    entity.addProperty({ info: {} })
+    // Add association without a name
+    entity.addAssociation({ key: targetEntity.key })
+
+    const uniqueName = entity.generateUniqueName('test')
+    assert.equal(uniqueName, 'test_copy')
+  })
+
+  test('generates incrementing counter correctly', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+
+    // Add many conflicting properties to test counter increment
+    for (let i = 0; i < 10; i++) {
+      const name = i === 0 ? 'test_copy' : `test_copy_${i + 1}`
+      entity.addProperty({ info: { name } })
+    }
+
+    const uniqueName = entity.generateUniqueName('test')
+    assert.equal(uniqueName, 'test_copy_11')
+  })
+
+  test('works with different base names', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+
+    entity.addProperty({ info: { name: 'user_copy' } })
+    entity.addProperty({ info: { name: 'product_copy' } })
+
+    const userUnique = entity.generateUniqueName('user')
+    const productUnique = entity.generateUniqueName('product')
+    const orderUnique = entity.generateUniqueName('order')
+
+    assert.equal(userUnique, 'user_copy_2')
+    assert.equal(productUnique, 'product_copy_2')
+    assert.equal(orderUnique, 'order_copy')
+  })
+
+  test('handles empty base name', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+
+    const uniqueName = entity.generateUniqueName('')
+    assert.equal(uniqueName, '_copy')
+  })
+
+  test('case sensitive name comparison', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+
+    // Add property with uppercase name
+    entity.addProperty({ info: { name: 'TEST_COPY' } })
+
+    // Should not conflict because comparison is case-sensitive
+    const uniqueName = entity.generateUniqueName('test')
+    assert.equal(uniqueName, 'test_copy')
+  })
+})