@api-client/core 0.19.30 → 0.19.32

package/tests/unit/modeling/amf/shape_generator.spec.ts

@@ -762,6 +762,9 @@ test.group('associationProperty()', (group) => {
   })
 
   test('returns basic shape definition', ({ assert }) => {
+    a1.schema = {
+      embedded: true,
+    }
     const result = a1.toApiShape()
     assert.typeOf(result, 'object')
 
@@ -812,8 +815,8 @@ test.group('associationProperty()', (group) => {
     assert.equal(result.path, AmfNamespace.aml.vocabularies.data.key + 'a1', 'has the path')
   })
 
-  test('returns a link definition when created on the schema', ({ assert }) => {
-    a1.schema = { linked: true }
+  test('returns a reference definition when not embedded', ({ assert }) => {
+    a1.schema = { embedded: false }
     const result = a1.toApiShape()
     const range = result.range as Shapes.IApiScalarShape
     assert.equal(range.id, `link-${a1.key}`)
@@ -824,6 +827,9 @@ test.group('associationProperty()', (group) => {
   test('returns a default union type', ({ assert }) => {
     const e3 = m1.addEntity({ key: 'e3', info: { name: 'e3' } })
     a1.addTarget(e3)
+    a1.schema = {
+      embedded: true,
+    }
     const result = a1.toApiShape()
     const range = result.range as Shapes.IApiUnionShape
 
@@ -841,12 +847,18 @@ test.group('associationProperty()', (group) => {
 
   test('has no range when no associations', ({ assert }) => {
     a1.removeTarget(e2)
+    a1.schema = {
+      embedded: true,
+    }
     const result = a1.toApiShape()
     assert.isUndefined(result.range)
   })
 
   test('returns an array shape when multiple', ({ assert }) => {
     a1.multiple = true
+    a1.schema = {
+      embedded: true,
+    }
     const result = a1.toApiShape()
     const range = result.range as Shapes.IApiArrayShape
     assert.deepEqual(range.types, AmfTypes.IAmfArrayTypes)
@@ -859,7 +871,7 @@ test.group('associationProperty()', (group) => {
   })
 
   test('creates the "anyOf" union', ({ assert }) => {
-    a1.schema = { unionType: 'anyOf' }
+    a1.schema = { unionType: 'anyOf', embedded: true }
 
     const e3 = m1.addEntity({ key: 'e3', info: { name: 'e3' } })
     a1.addTarget(e3)
@@ -879,7 +891,7 @@ test.group('associationProperty()', (group) => {
   })
 
   test('creates the "allOf" union', ({ assert }) => {
-    a1.schema = { unionType: 'allOf' }
+    a1.schema = { unionType: 'allOf', embedded: true }
 
     const e3 = m1.addEntity({ key: 'e3', info: { name: 'e3' } })
     a1.addTarget(e3)
@@ -899,7 +911,7 @@ test.group('associationProperty()', (group) => {
   })
 
   test('creates the "oneOf" union', ({ assert }) => {
-    a1.schema = { unionType: 'oneOf' }
+    a1.schema = { unionType: 'oneOf', embedded: true }
 
     const e3 = m1.addEntity({ key: 'e3', info: { name: 'e3' } })
     a1.addTarget(e3)
@@ -919,7 +931,7 @@ test.group('associationProperty()', (group) => {
   })
 
   test('creates the "not" union', ({ assert }) => {
-    a1.schema = { unionType: 'not' }
+    a1.schema = { unionType: 'not', embedded: true }
 
     const e3 = m1.addEntity({ key: 'e3', info: { name: 'e3' } })
     a1.addTarget(e3)
@@ -938,7 +950,7 @@ test.group('associationProperty()', (group) => {
   })
 
   test('creates the "not" shape', ({ assert }) => {
-    a1.schema = { unionType: 'not' }
+    a1.schema = { unionType: 'not', embedded: true }
 
     const result = a1.toApiShape()
     const range = result.range as Shapes.IApiUnionShape
@@ -956,7 +968,7 @@ test.group('associationProperty()', (group) => {
 
   test('wraps the union in the array shape', ({ assert }) => {
     a1.multiple = true
-    a1.schema = { unionType: 'anyOf' }
+    a1.schema = { unionType: 'anyOf', embedded: true }
 
     const e3 = m1.addEntity({ key: 'e3', info: { name: 'e3' } })
     a1.addTarget(e3)
@@ -978,8 +990,8 @@ test.group('associationProperty()', (group) => {
     assert.lengthOf(p2.properties, 0, 'p2 has the properties')
   })
 
-  test('handles linked schema', ({ assert }) => {
-    a1.schema = { linked: true }
+  test('handles not embedded schema', ({ assert }) => {
+    a1.schema = { embedded: false }
     const result = a1.toApiShape()
     const range = result.range as Shapes.IApiScalarShape
     assert.equal(range.dataType, AmfNamespace.w3.xmlSchema.string)
@@ -988,13 +1000,16 @@ test.group('associationProperty()', (group) => {
   test('handles multiple associations', ({ assert }) => {
     const e3 = m1.addEntity({ key: 'e3', info: { name: 'e3' } })
     a1.addTarget(e3)
+    a1.schema = {
+      embedded: true,
+    }
     const result = a1.toApiShape()
     const range = result.range as Shapes.IApiUnionShape
     assert.lengthOf(range.anyOf, 2)
   })
 
   test('handles unionType', ({ assert }) => {
-    a1.schema = { unionType: 'allOf' }
+    a1.schema = { unionType: 'allOf', embedded: true }
     const e3 = m1.addEntity({ key: 'e3', info: { name: 'e3' } })
     a1.addTarget(e3)
     const result = a1.toApiShape()
@@ -1004,7 +1019,7 @@ test.group('associationProperty()', (group) => {
 
   test('handles multiple and unionType', ({ assert }) => {
     a1.multiple = true
-    a1.schema = { unionType: 'allOf' }
+    a1.schema = { unionType: 'allOf', embedded: true }
     const e3 = m1.addEntity({ key: 'e3', info: { name: 'e3' } })
     a1.addTarget(e3)
     const result = a1.toApiShape()
@@ -1119,9 +1134,9 @@ test.group('AI Generated tests', (group) => {
     assert.equal(items.format, AmfNamespace.w3.xmlSchema.integer)
   })
 
-  test('handles multiple associations with schema', ({ assert }) => {
+  test('handles multiple associations not embedded', ({ assert }) => {
     a1.multiple = true
-    a1.schema = { linked: false }
+    a1.schema = { embedded: true }
     const result = a1.toApiShape()
     const range = result.range as Shapes.IApiArrayShape
     assert.include(range.types, AmfNamespace.aml.vocabularies.shapes.ArrayShape)
@@ -1139,6 +1154,9 @@ test.group('AI Generated tests', (group) => {
         },
       },
     ]
+    a1.schema = {
+      embedded: true,
+    }
     const result = a1.toApiShape()
     const range = result.range as Shapes.IApiArrayShape
     assert.include(range.types, AmfNamespace.aml.vocabularies.shapes.ArrayShape)

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

@@ -53,7 +53,7 @@ test.group('ApiModel.createSchema()', () => {
       user: { key: 'user-entity' },
       dependencyList: [{ key: 'domain1', version: '1.0.0' }],
       authentication: { strategy: 'UsernamePassword' },
-      authorization: { strategy: 'RBAC', roleKey: 'role' } as RolesBasedAccessControl,
+      authorization: { strategy: 'RBAC' } as RolesBasedAccessControl,
       session: { secret: 'secret', properties: ['email'] },
       accessRule: [{ type: 'public' }],
       rateLimiting: { rules: [] },
@@ -72,7 +72,7 @@ test.group('ApiModel.createSchema()', () => {
     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' })
+    assert.deepEqual(schema.authorization, { strategy: 'RBAC' })
     assert.deepEqual(schema.session, { secret: 'secret', properties: ['email'] })
     assert.deepEqual(schema.accessRule, [{ type: 'public' }])
     assert.deepEqual(schema.rateLimiting, { rules: [] })
@@ -132,7 +132,7 @@ test.group('ApiModel.constructor()', () => {
       user: { key: 'user-entity' },
       dependencyList: [{ key: 'domain1', version: '1.0.0' }],
       authentication: { strategy: 'UsernamePassword' },
-      authorization: { strategy: 'RBAC', roleKey: 'role' } as RolesBasedAccessControl,
+      authorization: { strategy: 'RBAC' } as RolesBasedAccessControl,
       session: { secret: 'secret', properties: ['email'] },
       accessRule: [{ type: 'allowPublic' }],
       rateLimiting: { rules: [] },
@@ -150,7 +150,7 @@ test.group('ApiModel.constructor()', () => {
     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' })
+    assert.deepEqual(model.authorization, { strategy: 'RBAC' })
     assert.deepEqual(model.session, { secret: 'secret', properties: ['email'] })
     assert.deepEqual(model.accessRule, [new AllowPublicAccessRule(model)])
     assert.deepEqual(model.rateLimiting, new RateLimitingConfiguration())
@@ -289,7 +289,7 @@ test.group('ApiModel.toJSON()', () => {
       user: { key: 'user-entity' },
       dependencyList: [{ key: 'domain1', version: '1.0.0' }],
       authentication: { strategy: 'UsernamePassword' },
-      authorization: { strategy: 'RBAC', roleKey: 'role' } as RolesBasedAccessControl,
+      authorization: { strategy: 'RBAC' } as RolesBasedAccessControl,
       session: { secret: 'secret', properties: ['email'] },
       accessRule: [{ type: 'allowPublic' }],
       rateLimiting: { rules: [] },
@@ -308,7 +308,7 @@ test.group('ApiModel.toJSON()', () => {
     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' })
+    assert.deepEqual(json.authorization, { strategy: 'RBAC' })
     assert.deepEqual(json.session, { secret: 'secret', properties: ['email'] })
     assert.deepEqual(json.accessRule, [{ type: 'allowPublic' }])
     assert.deepEqual(json.rateLimiting, { rules: [] })

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

@@ -664,7 +664,7 @@ test.group('DomainAssociation change observers', (g) => {
     const e1 = m1.addEntity()
     const a1 = e1.addAssociation()
     await sleep(1)
-    a1.schema = { linked: true }
+    a1.schema = { embedded: false }
     await assert.dispatchCount(domain, 'change', 1, { timeout: 1 })
   })
 

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

@@ -8,8 +8,8 @@ import {
   DataFormat,
   SemanticType,
   type OnDeleteRule,
+  type AssociationSchema,
 } from '../../../src/index.js'
-import { Shapes } from '@api-client/amf-core'
 
 test.group('DomainAssociation.createSchema()', () => {
   test('creates a valid schema with default values', ({ assert }) => {
@@ -58,7 +58,7 @@ test.group('DomainAssociation.createSchema()', () => {
   })
 
   test('creates a schema with provided schema', ({ assert }) => {
-    const schemaDefinition: Shapes.IApiAssociationShape = { linked: false }
+    const schemaDefinition: AssociationSchema = { embedded: false }
     const schema = DomainAssociation.createSchema({ schema: schemaDefinition })
     assert.deepEqual(schema.schema, schemaDefinition)
   })
@@ -88,7 +88,7 @@ test.group('DomainAssociation.createSchema()', () => {
   test('creates a schema with all properties', ({ assert }) => {
     const key = 'test-key'
     const info = { name: 'Test Association', description: 'Test description' }
-    const schemaDefinition: Shapes.IApiAssociationShape = { linked: false }
+    const schemaDefinition: AssociationSchema = { embedded: false }
     const multiple = true
     const required = true
     const bindings: AssociationBinding[] = [{ type: 'web', schema: { hidden: false } }]
@@ -144,7 +144,7 @@ test.group('DomainAssociation.createSchema()', () => {
   })
 
   test('creates a schema with cloned schema', ({ assert }) => {
-    const schemaDefinition: Shapes.IApiAssociationShape = { linked: false }
+    const schemaDefinition: AssociationSchema = { embedded: false }
     const schema = DomainAssociation.createSchema({ schema: schemaDefinition })
     assert.deepEqual(schema.schema, schemaDefinition)
     assert.notStrictEqual(schema.schema, schemaDefinition)
@@ -212,7 +212,7 @@ test.group('DomainAssociation.constructor()', () => {
   test('creates an instance with provided schema', ({ assert }) => {
     const dataDomain = new DataDomain()
     const parentKey = 'test-parent'
-    const schemaDefinition: Shapes.IApiAssociationShape = { linked: false }
+    const schemaDefinition: AssociationSchema = { embedded: false }
     const association = new DomainAssociation(dataDomain, parentKey, { schema: schemaDefinition })
     assert.deepEqual(association.schema, schemaDefinition)
   })
@@ -252,7 +252,7 @@ test.group('DomainAssociation.constructor()', () => {
     const parentKey = 'test-parent'
     const key = 'test-key'
     const info = { name: 'Test Association', description: 'Test description' }
-    const schemaDefinition: Shapes.IApiAssociationShape = { linked: false }
+    const schemaDefinition: AssociationSchema = { embedded: false }
     const multiple = true
     const required = true
     const bindings: AssociationBinding[] = [{ type: 'web', schema: { hidden: false } }]
@@ -316,7 +316,7 @@ test.group('DomainAssociation.constructor()', () => {
   test('creates an instance with cloned schema', ({ assert }) => {
     const dataDomain = new DataDomain()
     const parentKey = 'test-parent'
-    const schemaDefinition: Shapes.IApiAssociationShape = { linked: false }
+    const schemaDefinition: AssociationSchema = { embedded: false }
     const association = new DomainAssociation(dataDomain, parentKey, { schema: schemaDefinition })
     assert.deepEqual(association.schema, schemaDefinition)
     assert.notStrictEqual(association.schema, schemaDefinition)
@@ -390,7 +390,7 @@ test.group('DomainAssociation.toJSON()', () => {
   test('returns a JSON representation with provided schema', ({ assert }) => {
     const dataDomain = new DataDomain()
     const parentKey = 'test-parent'
-    const schemaDefinition: Shapes.IApiAssociationShape = { linked: false }
+    const schemaDefinition: AssociationSchema = { embedded: false }
     const association = new DomainAssociation(dataDomain, parentKey, { schema: schemaDefinition })
     const json = association.toJSON()
     assert.deepEqual(json.schema, schemaDefinition)
@@ -438,7 +438,7 @@ test.group('DomainAssociation.toJSON()', () => {
     const parentKey = 'test-parent'
     const key = 'test-key'
     const info = { name: 'Test Association', description: 'Test description' }
-    const schemaDefinition: Shapes.IApiAssociationShape = { linked: false }
+    const schemaDefinition: AssociationSchema = { embedded: false }
     const multiple = true
     const required = true
     const bindings: AssociationBinding[] = [{ type: 'web', schema: { hidden: false } }]
@@ -527,7 +527,7 @@ test.group('DomainAssociation.toJSON()', () => {
   test('returns a JSON representation with cloned schema', ({ assert }) => {
     const dataDomain = new DataDomain()
     const parentKey = 'test-parent'
-    const schemaDefinition: Shapes.IApiAssociationShape = { linked: false }
+    const schemaDefinition: AssociationSchema = { embedded: false }
     const association = new DomainAssociation(dataDomain, parentKey, { schema: schemaDefinition })
     const json = association.toJSON()
     assert.deepEqual(json.schema, schemaDefinition)
@@ -538,7 +538,7 @@ test.group('DomainAssociation.toJSON()', () => {
     const dataDomain = new DataDomain()
     const parentKey = 'test-parent'
     const association = new DomainAssociation(dataDomain, parentKey)
-    const schemaDefinition: Shapes.IApiAssociationShape = { linked: false }
+    const schemaDefinition: AssociationSchema = { embedded: false }
     association.schema = schemaDefinition
     const json = association.toJSON()
     assert.deepEqual(json.schema, schemaDefinition)
@@ -672,7 +672,7 @@ test.group('DomainAssociation.ensureSchema()', () => {
 
   test('returns the existing schema object if it exists', ({ assert }) => {
     const dataDomain = new DataDomain()
-    const schemaDefinition: Shapes.IApiAssociationShape = { linked: false }
+    const schemaDefinition: AssociationSchema = { embedded: false }
     const association = new DomainAssociation(dataDomain, 'test-parent', { schema: schemaDefinition })
     const originalSchema = association.schema
     const schema = association.ensureSchema()
@@ -682,7 +682,7 @@ test.group('DomainAssociation.ensureSchema()', () => {
 
   test('does not modify the existing schema object', ({ assert }) => {
     const dataDomain = new DataDomain()
-    const schemaDefinition: Shapes.IApiAssociationShape = { linked: false }
+    const schemaDefinition: AssociationSchema = { embedded: false }
     const association = new DomainAssociation(dataDomain, 'test-parent', { schema: schemaDefinition })
     const originalSchema = association.schema
     association.ensureSchema()
@@ -1083,7 +1083,7 @@ test.group('DomainAssociation.duplicate()', () => {
     association.readOnly = true
     association.onDelete = 'cascade'
     association.semantics = [{ id: SemanticType.ResourceOwnerIdentifier }]
-    association.schema = { linked: true, unionType: 'allOf' }
+    association.schema = { embedded: true, unionType: 'allOf' }
     association.bindings = [{ type: 'web', schema: { hidden: true } }]
 
     const duplicate = association.duplicate()
@@ -1095,7 +1095,7 @@ test.group('DomainAssociation.duplicate()', () => {
     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.schema, { embedded: true, unionType: 'allOf' })
     assert.deepEqual(duplicate.bindings, [{ type: 'web', schema: { hidden: true } }])
   })
 
@@ -1107,17 +1107,17 @@ test.group('DomainAssociation.duplicate()', () => {
 
     const association = entity.addAssociation({ targets: [{ key: targetEntity.key }] })
     association.info.name = 'original'
-    association.schema = { linked: false, unionType: 'anyOf' }
+    association.schema = { embedded: false, unionType: 'anyOf' }
     association.bindings = [{ type: 'web', schema: { hidden: false } }]
 
     const duplicate = association.duplicate()
 
     // Modify original schema and bindings
-    association.schema!.linked = true
+    association.schema!.embedded = true
     association.bindings[0].schema = { hidden: true }
 
     // Duplicate should be unaffected
-    assert.equal(duplicate.schema!.linked, false)
+    assert.equal(duplicate.schema!.embedded, false)
     assert.deepEqual(duplicate.bindings[0].schema, { hidden: false })
   })
 

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

@@ -730,7 +730,7 @@ test.group('JSON DomainEntity Generator: associations', (group) => {
 
   test('creates a property from an association', ({ assert }) => {
     e2.addProperty({ type: 'number', key: 'n1', info: { name: 'n1' } })
-    e1.addAssociation({ targets: [{ key: e2.key }], key: 'a1', info: { name: 'a1' } })
+    e1.addAssociation({ targets: [{ key: e2.key }], key: 'a1', info: { name: 'a1' }, schema: { embedded: true } })
 
     const result = e1.toExample(mime) as string
 
@@ -744,8 +744,8 @@ test.group('JSON DomainEntity Generator: associations', (group) => {
     const e3 = d1.addEntity({ key: 'e3', info: { name: 'e3' } })
     e3.addProperty({ type: 'number', key: 'i1', info: { name: 'i1' } })
     e2.addProperty({ type: 'number', key: 'n1', info: { name: 'n1' } })
-    e1.addAssociation({ targets: [{ key: e2.key }], key: 'a1', info: { name: 'a1' } })
-    e2.addAssociation({ targets: [{ key: e3.key }], key: 'a2', info: { name: 'a2' } })
+    e1.addAssociation({ targets: [{ key: e2.key }], key: 'a1', info: { name: 'a1' }, schema: { embedded: true } })
+    e2.addAssociation({ targets: [{ key: e3.key }], key: 'a2', info: { name: 'a2' }, schema: { embedded: true } })
 
     const result = e1.toExample(mime) as string
 
@@ -757,8 +757,8 @@ test.group('JSON DomainEntity Generator: associations', (group) => {
     assert.typeOf(data.a1.a2.i1, 'number', 'has a deep association property')
   })
 
-  test('does not make associations to self (recursive #1)', ({ assert }) => {
-    e1.addAssociation({ targets: [{ key: e1.key }], key: 'a1' })
+  test('does not make associations to self with embedded shape (recursive #1)', ({ assert }) => {
+    e1.addAssociation({ targets: [{ key: e1.key }], schema: { embedded: true } })
     const result = e1.toExample(mime) as string
     assert.equal(result, '{}')
   })
@@ -767,9 +767,24 @@ test.group('JSON DomainEntity Generator: associations', (group) => {
     const e3 = d1.addEntity({ key: 'e3', info: { name: 'e3' } })
     e3.addProperty({ type: 'number', key: 'i1', info: { name: 'i1' } })
     e2.addProperty({ type: 'number', key: 'n1', info: { name: 'n1' } })
-    e1.addAssociation({ targets: [{ key: e2.key }], key: 'a1', info: { name: 'a1' } })
-    e2.addAssociation({ targets: [{ key: e3.key }], key: 'a2', info: { name: 'a2' } })
-    e3.addAssociation({ targets: [{ key: e1.key }], key: 'a3', info: { name: 'a3' } })
+    e1.addAssociation({
+      targets: [{ key: e2.key }],
+      key: 'a1',
+      info: { name: 'a1' },
+      schema: { embedded: true },
+    })
+    e2.addAssociation({
+      targets: [{ key: e3.key }],
+      key: 'a2',
+      info: { name: 'a2' },
+      schema: { embedded: true },
+    })
+    e3.addAssociation({
+      targets: [{ key: e1.key }],
+      key: 'a3',
+      info: { name: 'a3' },
+      schema: { embedded: true },
+    })
 
     const result = e1.toExample(mime) as string
 
@@ -786,7 +801,12 @@ test.group('JSON DomainEntity Generator: associations', (group) => {
     const e3 = d1.addEntity({ key: 'e3', info: { name: 'e3' } })
     e3.addProperty({ type: 'number', key: 'i1', info: { name: 'i1' } })
     e2.addProperty({ type: 'string', key: 's1', info: { name: 's1' } })
-    const a1 = e1.addAssociation({ targets: [{ key: e2.key }], key: 'a1', info: { name: 'a1' } })
+    const a1 = e1.addAssociation({
+      targets: [{ key: e2.key }],
+      key: 'a1',
+      info: { name: 'a1' },
+      schema: { embedded: true },
+    })
     a1.addTarget(e3.key)
 
     const result = e1.toExample(mime) as string
@@ -801,9 +821,14 @@ test.group('JSON DomainEntity Generator: associations', (group) => {
     const e3 = d1.addEntity({ key: 'e3', info: { name: 'e3' } })
     e3.addProperty({ type: 'number', key: 'i1', info: { name: 'i1' } })
     e2.addProperty({ type: 'string', key: 's1', info: { name: 's1' } })
-    const a1 = e1.addAssociation({ targets: [{ key: e2.key }], key: 'a1', info: { name: 'a1' } })
+    const a1 = e1.addAssociation({
+      targets: [{ key: e2.key }],
+      key: 'a1',
+      info: { name: 'a1' },
+      multiple: true,
+      schema: { embedded: true },
+    })
     a1.addTarget(e3.key)
-    a1.multiple = true
 
     const result = e1.toExample(mime) as string
 
@@ -821,9 +846,13 @@ test.group('JSON DomainEntity Generator: associations', (group) => {
     e2.addProperty({ type: 'string', key: 's1', info: { name: 's1' } })
     e3.addProperty({ type: 'number', key: 'i1', info: { name: 'i1' } })
 
-    const a1 = e1.addAssociation({ targets: [{ key: e2.key }], key: 'a1', info: { name: 'a1' } })
+    const a1 = e1.addAssociation({
+      targets: [{ key: e2.key }],
+      key: 'a1',
+      info: { name: 'a1' },
+      schema: { unionType: 'anyOf', embedded: true },
+    })
     a1.addTarget(e3.key)
-    a1.schema = { unionType: 'anyOf' }
 
     const result = e1.toExample(mime) as string
 
@@ -838,9 +867,13 @@ test.group('JSON DomainEntity Generator: associations', (group) => {
     const e3 = d1.addEntity({ key: 'e3', info: { name: 'e3' } })
     e3.addProperty({ type: 'number', key: 'i1', info: { name: 'i1' } })
     e2.addProperty({ type: 'string', key: 's1', info: { name: 's1' } })
-    const a1 = e1.addAssociation({ targets: [{ key: e2.key }], key: 'a1', info: { name: 'a1' } })
+    const a1 = e1.addAssociation({
+      targets: [{ key: e2.key }],
+      key: 'a1',
+      info: { name: 'a1' },
+      schema: { embedded: true, unionType: 'allOf' },
+    })
     a1.addTarget(e3.key)
-    a1.schema = { unionType: 'allOf' }
 
     const result = e1.toExample(mime) as string
 
@@ -857,11 +890,14 @@ test.group('JSON DomainEntity Generator: associations', (group) => {
     e2.addProperty({ type: 'string', key: 's1', info: { name: 's1' } })
     e3.addProperty({ type: 'number', key: 'i1', info: { name: 'i1' } })
 
-    const a1 = e1.addAssociation({ targets: [{ key: e2.key }], key: 'a1', info: { name: 'a1' } })
+    const a1 = e1.addAssociation({
+      targets: [{ key: e2.key }],
+      key: 'a1',
+      info: { name: 'a1' },
+      schema: { embedded: true, unionType: 'oneOf' },
+    })
     a1.addTarget(e3.key)
 
-    a1.schema = { unionType: 'oneOf' }
-
     const result = e1.toExample(mime) as string
 
     assert.typeOf(result, 'string', 'result is a string')
@@ -877,9 +913,13 @@ test.group('JSON DomainEntity Generator: associations', (group) => {
     e2.addProperty({ type: 'string', key: 's1', info: { name: 's1' } })
     e3.addProperty({ type: 'number', key: 'i1', info: { name: 'i1' } })
 
-    const a1 = e1.addAssociation({ targets: [{ key: e2.key }], key: 'a1', info: { name: 'a1' } })
+    const a1 = e1.addAssociation({
+      targets: [{ key: e2.key }],
+      key: 'a1',
+      info: { name: 'a1' },
+      schema: { unionType: 'oneOf', embedded: true },
+    })
     a1.addTarget(e3.key)
-    a1.schema = { unionType: 'oneOf' }
 
     const result = e1.toExample(mime) as string
 
@@ -897,7 +937,12 @@ test.group('JSON DomainEntity Generator: associations', (group) => {
     e3.addProperty({ type: 'number', key: 'n1', info: { name: 'n1' } })
     n2.info.version = '1.0.0'
     n1.registerForeignDomain(n2)
-    e1.addAssociation({ targets: [{ key: e3.key, domain: n2.key }], key: 'a3', info: { name: 'a3' } })
+    e1.addAssociation({
+      targets: [{ key: e3.key, domain: n2.key }],
+      key: 'a3',
+      info: { name: 'a3' },
+      schema: { embedded: true },
+    })
     const result = e1.toExample(mime) as string
     assert.typeOf(result, 'string', 'result is a string')
     const data = JSON.parse(result)
@@ -945,7 +990,7 @@ test.group('JSON DomainEntity Generator: parents', (group) => {
     e2.addParent(e1.key)
     const e3 = d1.addEntity({ key: 'e3', info: { name: 'e3' } })
     e3.addProperty({ type: 'string', key: 'p3', info: { name: 'p3' } })
-    e2.addAssociation({ targets: [{ key: e3.key }], key: 'a1', info: { name: 'a1' } })
+    e2.addAssociation({ targets: [{ key: e3.key }], key: 'a1', info: { name: 'a1' }, schema: { embedded: true } })
 
     const result = e2.toExample(mime) as string
 
@@ -963,7 +1008,7 @@ test.group('JSON DomainEntity Generator: parents', (group) => {
     e2.addParent(e1.key)
     const e3 = d1.addEntity({ key: 'e3', info: { name: 'e3' } })
     e3.addProperty({ type: 'string', key: 'p3', info: { name: 'p3' } })
-    e1.addAssociation({ targets: [{ key: e3.key }], key: 'a1', info: { name: 'a1' } })
+    e1.addAssociation({ targets: [{ key: e3.key }], key: 'a1', info: { name: 'a1' }, schema: { embedded: true } })
 
     const result = e2.toExample(mime) as string
 

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

@@ -1108,7 +1108,12 @@ test.group('XML DomainEntity Generator: associations', (group) => {
 
   test('creates a property from an association', ({ assert }) => {
     e2.addProperty({ type: 'number', key: 'n1', info: { name: 'n1' } })
-    e1.addAssociation({ targets: [{ key: e2.key }], key: 'a1', info: { name: 'a1' } })
+    e1.addAssociation({
+      targets: [{ key: e2.key }],
+      key: 'a1',
+      info: { name: 'a1' },
+      schema: { embedded: true },
+    })
 
     const result = e1.toExample(mime) as string
 
@@ -1131,8 +1136,18 @@ test.group('XML DomainEntity Generator: associations', (group) => {
     const e3 = d1.addEntity({ key: 'e3', info: { name: 'e3' } })
     e3.addProperty({ type: 'number', key: 'i1', info: { name: 'i1' } })
     e2.addProperty({ type: 'number', key: 'n1', info: { name: 'n1' } })
-    e1.addAssociation({ targets: [{ key: e2.key }], key: 'a1', info: { name: 'a1' } })
-    e2.addAssociation({ targets: [{ key: e3.key }], key: 'a2', info: { name: 'a2' } })
+    e1.addAssociation({
+      targets: [{ key: e2.key }],
+      key: 'a1',
+      info: { name: 'a1' },
+      schema: { embedded: true },
+    })
+    e2.addAssociation({
+      targets: [{ key: e3.key }],
+      key: 'a2',
+      info: { name: 'a2' },
+      schema: { embedded: true },
+    })
 
     const result = e1.toExample(mime) as string
 
@@ -1192,7 +1207,12 @@ test.group('XML DomainEntity Generator: associations', (group) => {
     const e3 = d1.addEntity({ key: 'e3', info: { name: 'e3' } })
     e3.addProperty({ type: 'number', key: 'i1', info: { name: 'i1' } })
     e2.addProperty({ type: 'string', key: 's1', info: { name: 's1' } })
-    const a1 = e1.addAssociation({ targets: [{ key: e2.key }], key: 'a1', info: { name: 'a1' } })
+    const a1 = e1.addAssociation({
+      targets: [{ key: e2.key }],
+      key: 'a1',
+      info: { name: 'a1' },
+      schema: { embedded: true },
+    })
     a1.addTarget(e3.key)
 
     const result = e1.toExample(mime) as string
@@ -1233,11 +1253,14 @@ test.group('XML DomainEntity Generator: associations', (group) => {
     e2.addProperty({ type: 'string', key: 's1', info: { name: 's1' } })
     e3.addProperty({ type: 'number', key: 'i1', info: { name: 'i1' } })
 
-    const a1 = e1.addAssociation({ targets: [{ key: e2.key }], key: 'a1', info: { name: 'a1' } })
+    const a1 = e1.addAssociation({
+      targets: [{ key: e2.key }],
+      key: 'a1',
+      info: { name: 'a1' },
+      schema: { embedded: true, unionType: 'anyOf' },
+    })
     a1.addTarget(e3.key)
 
-    a1.schema = { unionType: 'anyOf' }
-
     const result = e1.toExample(mime) as string
     assert.typeOf(result, 'string', 'result is a string')
 
@@ -1374,7 +1397,7 @@ test.group('XML DomainEntity Generator: parents', (group) => {
     e2.addParent(e1.key)
     const e3 = d1.addEntity({ key: 'e3', info: { name: 'e3' } })
     e3.addProperty({ type: 'string', key: 'p3', info: { name: 'p3' } })
-    e2.addAssociation({ targets: [{ key: e3.key }], key: 'a1', info: { name: 'a1' } })
+    e2.addAssociation({ targets: [{ key: e3.key }], key: 'a1', info: { name: 'a1' }, schema: { embedded: true } })
 
     const result = e2.toExample(mime) as string
     assert.typeOf(result, 'string', 'result is a string')
@@ -1406,7 +1429,7 @@ test.group('XML DomainEntity Generator: parents', (group) => {
     e2.addParent(e1.key)
     const e3 = d1.addEntity({ key: 'e3', info: { name: 'e3' } })
     e3.addProperty({ type: 'string', key: 'p3', info: { name: 'p3' } })
-    e1.addAssociation({ targets: [{ key: e3.key }], key: 'a1', info: { name: 'a1' } })
+    e1.addAssociation({ targets: [{ key: e3.key }], key: 'a1', info: { name: 'a1' }, schema: { embedded: true } })
 
     const result = e2.toExample(mime) as string
     assert.typeOf(result, 'string', 'result is a string')