@api-client/core 0.11.11 → 0.12.0

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

@@ -0,0 +1,404 @@
+import { test } from '@japa/runner'
+import { DataDomain, DomainNamespace } from '../../../src/index.js'
+
+test.group('DomainNamespace.addNamespace()', () => {
+  test('adds a namespace to the data domain', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const namespace = dataDomain.addNamespace()
+    const childNamespace = namespace.addNamespace()
+    assert.instanceOf(childNamespace, DomainNamespace)
+    assert.isTrue(dataDomain.graph.hasNode(childNamespace.key))
+    assert.equal(dataDomain.graph.parent(childNamespace.key), namespace.key)
+  })
+
+  test('adds a namespace with default values', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const namespace = dataDomain.addNamespace()
+    const childNamespace = namespace.addNamespace()
+    assert.instanceOf(childNamespace, DomainNamespace)
+    assert.isTrue(dataDomain.graph.hasNode(childNamespace.key))
+    assert.equal(childNamespace.info.name, 'New namespace')
+  })
+
+  test('throws an error if a namespace with the same key already exists', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const namespace = dataDomain.addNamespace()
+    assert.throws(() => {
+      namespace.addNamespace({ key: namespace.key })
+    }, `Trying to add a namespace to ${namespace.key}, but it already exists`)
+  })
+
+  test('notifies change', async ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const namespace = dataDomain.addNamespace()
+    namespace.addNamespace()
+    await assert.dispatches(dataDomain, 'change', { timeout: 20 })
+  })
+
+  test('adds a namespace to the root of the graph', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const namespace = dataDomain.addNamespace()
+    const childNamespace = namespace.addNamespace()
+    assert.instanceOf(childNamespace, DomainNamespace)
+    assert.isTrue(dataDomain.graph.hasNode(childNamespace.key))
+    assert.equal(dataDomain.graph.parent(childNamespace.key), namespace.key)
+  })
+
+  test('adds a namespace to a parent namespace - checks parent-child relationship', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const parentNamespace = dataDomain.addNamespace()
+    const childNamespace = parentNamespace.addNamespace()
+    assert.isTrue(dataDomain.graph.hasParent(childNamespace.key, parentNamespace.key))
+  })
+
+  test('adds a namespace to a parent namespace - checks items list', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const parentNamespace = dataDomain.addNamespace()
+    const childNamespace = parentNamespace.addNamespace()
+    assert.deepInclude([...parentNamespace.listNamespaces()], childNamespace)
+  })
+})
+
+test.group('DomainNamespace.removeNamespace()', () => {
+  test('removes a child namespace', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const namespace = dataDomain.addNamespace()
+    const childNamespace = namespace.addNamespace()
+    namespace.removeNamespace(childNamespace.key)
+    assert.isUndefined(dataDomain.findNamespace(childNamespace.key))
+    assert.isFalse(dataDomain.graph.hasNode(childNamespace.key))
+    assert.deepEqual([...namespace.listNamespaces()], [])
+  })
+
+  test('throws an error if the namespace does not exist', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const namespace = dataDomain.addNamespace()
+    assert.throws(() => {
+      namespace.removeNamespace('non-existent-ns')
+    }, "Trying to remove the non-existent-ns namespace, but it doesn't exist")
+  })
+
+  test('throws an error when deleting not a namespace', ({ assert }) => {
+    const root = new DataDomain()
+    const n1 = root.addNamespace()
+    const m1 = n1.addModel()
+    assert.throws(() => {
+      n1.removeNamespace(m1.key)
+    }, `Trying to remove the ${m1.key} namespace, but it is not a namespace`)
+  })
+
+  test('removes a namespace with children', ({ assert }) => {
+    const root = new DataDomain()
+    const n1 = root.addNamespace()
+    const n2 = n1.addNamespace()
+    const m1 = n2.addModel()
+    n1.removeNamespace(n2.key)
+    assert.isUndefined(root.findNamespace(n2.key))
+    assert.isFalse(root.graph.hasNode(n2.key))
+    assert.isFalse(root.graph.hasNode(m1.key))
+    assert.deepEqual([...n1.listNamespaces()], [])
+  })
+
+  test('removes a namespace with models', ({ assert }) => {
+    const root = new DataDomain()
+    const n1 = root.addNamespace()
+    const n2 = n1.addNamespace()
+    const m1 = n2.addModel()
+    n1.removeNamespace(n2.key)
+    assert.isUndefined(root.findModel(m1.key))
+    assert.isFalse(root.graph.hasNode(m1.key))
+  })
+
+  test('removes a namespace with entities', ({ assert }) => {
+    const root = new DataDomain()
+    const n1 = root.addNamespace()
+    const n2 = n1.addNamespace()
+    const m1 = n2.addModel()
+    const entity = m1.addEntity()
+    n1.removeNamespace(n2.key)
+    assert.isUndefined(root.findEntity(entity.key))
+    assert.isFalse(root.graph.hasNode(entity.key))
+  })
+
+  test('removes a namespace with properties', ({ assert }) => {
+    const root = new DataDomain()
+    const n1 = root.addNamespace()
+    const n2 = n1.addNamespace()
+    const m1 = n2.addModel()
+    const e1 = m1.addEntity()
+    const property = e1.addProperty()
+    n1.removeNamespace(n2.key)
+    assert.isUndefined(root.findProperty(property.key))
+    assert.isFalse(root.graph.hasNode(property.key))
+  })
+
+  test('removes a namespace with associations', ({ assert }) => {
+    const root = new DataDomain()
+    const n1 = root.addNamespace()
+    const n2 = n1.addNamespace()
+    const m1 = n2.addModel()
+    const e1 = m1.addEntity()
+    const a1 = e1.addAssociation()
+    n1.removeNamespace(n2.key)
+    assert.isUndefined(root.findAssociation(a1.key))
+    assert.isFalse(root.graph.hasNode(a1.key))
+  })
+
+  test('removes a namespace with children - checks parent-child relationship', ({ assert }) => {
+    const root = new DataDomain()
+    const n1 = root.addNamespace()
+    const n2 = n1.addNamespace()
+    n1.removeNamespace(n2.key)
+    assert.isFalse(root.graph.hasParent(n2.key, n1.key))
+  })
+
+  test('removes a namespace with children - checks items list', ({ assert }) => {
+    const root = new DataDomain()
+    const n1 = root.addNamespace()
+    const n2 = n1.addNamespace()
+    n1.removeNamespace(n2.key)
+    assert.notDeepInclude([...n1.listNamespaces()], n2)
+  })
+
+  test('removes a namespace with models - checks parent-child relationship', ({ assert }) => {
+    const root = new DataDomain()
+    const n1 = root.addNamespace()
+    const n2 = n1.addNamespace()
+    const m1 = n2.addModel()
+    n1.removeNamespace(n2.key)
+    assert.isFalse(root.graph.hasParent(m1.key, n2.key))
+  })
+
+  test('removes a namespace with models - checks items list', ({ assert }) => {
+    const root = new DataDomain()
+    const n1 = root.addNamespace()
+    const n2 = n1.addNamespace()
+    const m1 = n2.addModel()
+    n1.removeNamespace(n2.key)
+    assert.notDeepInclude([...n2.listModels()], m1)
+  })
+})
+
+test.group('DomainNamespace.attachNamespace()', () => {
+  test('attaches a child namespace', ({ assert }) => {
+    const root = new DataDomain()
+    const n1 = root.addNamespace()
+    const n2 = root.addNamespace()
+    n1.attachNamespace(n2.key)
+    assert.deepInclude([...n1.listNamespaces()], n2)
+  })
+
+  test('throws an error if the namespace does not exist', ({ assert }) => {
+    const root = new DataDomain()
+    const n1 = root.addNamespace()
+    assert.throws(() => {
+      n1.attachNamespace('non-existent-ns')
+    }, "Trying to attach the non-existent-ns namespace, but it doesn't exist")
+  })
+
+  test('attaches a namespace - checks parent-child relationship', ({ assert }) => {
+    const root = new DataDomain()
+    const n1 = root.addNamespace()
+    const n2 = root.addNamespace()
+    n1.attachNamespace(n2.key)
+    assert.isTrue(root.graph.hasParent(n2.key, n1.key))
+  })
+
+  test('attaches a namespace - checks items list', ({ assert }) => {
+    const root = new DataDomain()
+    const n1 = root.addNamespace()
+    const n2 = root.addNamespace()
+    n1.attachNamespace(n2.key)
+    assert.deepInclude([...n1.listNamespaces()], n2)
+  })
+
+  test('attaches a namespace - does notify change', async ({ assert, sleep }) => {
+    const root = new DataDomain()
+    const n1 = root.addNamespace()
+    const n2 = root.addNamespace()
+    // addNamespace dispatches the change event
+    await sleep(0)
+    n1.attachNamespace(n2.key)
+    await assert.dispatches(root, 'change', { timeout: 20 })
+  })
+
+  test('throws an error when attaching not a namespace', ({ assert }) => {
+    const root = new DataDomain()
+    const n1 = root.addNamespace()
+    const m1 = n1.addModel()
+    assert.throws(() => {
+      n1.attachNamespace(m1.key)
+    }, `Trying to attach the ${m1.key} namespace, but it is not a namespace`)
+  })
+
+  test('attaches a namespace and removes it from the previous parent', ({ assert }) => {
+    const root = new DataDomain()
+    const n1 = root.addNamespace()
+    const n2 = n1.addNamespace()
+    const n3 = root.addNamespace()
+    n3.attachNamespace(n2.key)
+    assert.deepEqual(n1.fields, [])
+  })
+
+  test('attaches a namespace from root', ({ assert }) => {
+    const root = new DataDomain()
+    const n1 = root.addNamespace()
+    const n2 = root.addNamespace()
+    n1.attachNamespace(n2.key)
+    assert.deepEqual(n1.fields, [{ key: n2.key, type: 'namespace' }])
+  })
+})
+
+test.group('DomainNamespace.detachNamespace()', () => {
+  test('detaches a child namespace', ({ assert }) => {
+    const root = new DataDomain()
+    const n1 = root.addNamespace()
+    const n2 = n1.addNamespace()
+    n1.detachNamespace(n2.key)
+    assert.ok(root.findNamespace(n2.key))
+    assert.isTrue(root.graph.hasNode(n2.key))
+    assert.deepEqual([...n1.listNamespaces()], [])
+  })
+
+  test('throws an error if the namespace does not exist', ({ assert }) => {
+    const root = new DataDomain()
+    const n1 = root.addNamespace()
+    assert.throws(() => {
+      n1.detachNamespace('non-existent-ns')
+    }, `Trying to detach the non-existent-ns namespace, but it doesn't exist`)
+  })
+
+  test('detaches a namespace - checks parent-child relationship', ({ assert }) => {
+    const root = new DataDomain()
+    const n1 = root.addNamespace()
+    const n2 = n1.addNamespace()
+    n1.detachNamespace(n2.key)
+    assert.isFalse(root.graph.hasParent(n2.key, n1.key))
+  })
+
+  test('detaches a namespace - checks items list', ({ assert }) => {
+    const root = new DataDomain()
+    const n1 = root.addNamespace()
+    const n2 = n1.addNamespace()
+    n1.detachNamespace(n2.key)
+    assert.notDeepInclude([...n1.listNamespaces()], n2)
+  })
+
+  test('detaches a namespace - does not notify change', async ({ assert, sleep }) => {
+    const root = new DataDomain()
+    const n1 = root.addNamespace()
+    const n2 = n1.addNamespace()
+    await sleep(0)
+    await assert.notDispatches(root, 'change', { timeout: 20 })
+    n1.detachNamespace(n2.key)
+  })
+
+  test('throws an error when detaching not a namespace', ({ assert }) => {
+    const root = new DataDomain()
+    const n1 = root.addNamespace()
+    const m1 = n1.addModel()
+    assert.throws(() => {
+      n1.detachNamespace(m1.key)
+    }, `Trying to detach the ${m1.key} namespace, but it is not a namespace`)
+  })
+})
+
+test.group('DomainNamespace.listNamespaces()', () => {
+  test('lists all child namespaces', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const namespace = dataDomain.addNamespace()
+    const childNamespace1 = namespace.addNamespace()
+    const childNamespace2 = namespace.addNamespace()
+    const namespaces = [...namespace.listNamespaces()]
+    assert.lengthOf(namespaces, 2)
+    assert.deepInclude(namespaces, childNamespace1)
+    assert.deepInclude(namespaces, childNamespace2)
+  })
+
+  test('returns an empty array if there are no child namespaces', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const namespace = dataDomain.addNamespace()
+    const namespaces = [...namespace.listNamespaces()]
+    assert.lengthOf(namespaces, 0)
+  })
+
+  test('returns only namespaces', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const namespace = dataDomain.addNamespace()
+    const childNamespace = namespace.addNamespace()
+    namespace.addModel()
+    const namespaces = [...namespace.listNamespaces()]
+    assert.lengthOf(namespaces, 1)
+    assert.deepInclude(namespaces, childNamespace)
+  })
+
+  test('namespaces in the list are of type DomainNamespace', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const namespace = dataDomain.addNamespace()
+    namespace.addNamespace()
+    const namespaces = [...namespace.listNamespaces()]
+    assert.instanceOf(namespaces[0], DomainNamespace)
+  })
+
+  test('lists namespaces in the order they were added', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const namespace = dataDomain.addNamespace()
+    const childNamespace1 = namespace.addNamespace()
+    const childNamespace2 = namespace.addNamespace()
+    const namespaces = [...namespace.listNamespaces()]
+    assert.deepEqual(namespaces, [childNamespace1, childNamespace2])
+  })
+
+  test('lists namespaces when there are no namespaces', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const namespace = dataDomain.addNamespace()
+    const namespaces = [...namespace.listNamespaces()]
+    assert.deepEqual(namespaces, [])
+  })
+
+  test('lists namespaces when there are other domain elements', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const namespace = dataDomain.addNamespace()
+    const childNamespace = namespace.addNamespace()
+    namespace.addModel()
+    const namespaces = [...namespace.listNamespaces()]
+    assert.deepEqual(namespaces, [childNamespace])
+  })
+})
+
+test.group('DomainNamespace.hasNamespaces()', () => {
+  test('returns true if there are child namespaces', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const namespace = dataDomain.addNamespace()
+    namespace.addNamespace()
+    assert.isTrue(namespace.hasNamespaces())
+  })
+
+  test('returns false if there are no child namespaces', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const namespace = dataDomain.addNamespace()
+    assert.isFalse(namespace.hasNamespaces())
+  })
+
+  test('returns false if there are only models', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const namespace = dataDomain.addNamespace()
+    namespace.addModel()
+    assert.isFalse(namespace.hasNamespaces())
+  })
+
+  test('returns true if there are both namespaces and models', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const namespace = dataDomain.addNamespace()
+    namespace.addNamespace()
+    namespace.addModel()
+    assert.isTrue(namespace.hasNamespaces())
+  })
+
+  test('returns false if the namespace has no fields', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const namespace = dataDomain.addNamespace()
+    namespace.fields = []
+    assert.isFalse(namespace.hasNamespaces())
+  })
+})

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

@@ -0,0 +1,140 @@
+import { test } from '@japa/runner'
+import { DataDomain, DomainVersioning } from '../../../src/index.js'
+
+test.group('DomainVersioning', () => {
+  test('should serialize a domain with only local nodes', ({ assert }) => {
+    const root = new DataDomain()
+    const ns1 = root.addNamespace({ key: 'ns1' })
+    const m1 = ns1.addModel({ key: 'm1' })
+    m1.addEntity({ key: 'e1' })
+
+    const serialized = DomainVersioning.serializeForVersionRelease(root)
+
+    assert.lengthOf(serialized.nodes, 3)
+    assert.lengthOf(serialized.edges, 0)
+  })
+
+  test('should include connected foreign nodes', ({ assert }) => {
+    const root = new DataDomain()
+    const ns1 = root.addNamespace({ key: 'ns1' })
+    const m1 = ns1.addModel({ key: 'm1' })
+    const e1 = m1.addEntity({ key: 'e1' })
+
+    const fd = new DataDomain()
+    const fm1 = fd.addModel({ key: 'fm1' })
+    const fe1 = fm1.addEntity({ key: 'fe1' })
+    fd.info.version = '1.0.0'
+    root.registerForeignDomain(fd)
+
+    e1.addAssociation({ domain: fd.key, key: fe1.key }, { key: 'a1' })
+
+    const serialized = DomainVersioning.serializeForVersionRelease(root)
+
+    assert.lengthOf(serialized.nodes, 5)
+    assert.lengthOf(serialized.edges, 2)
+    const foreignNode = serialized.nodes.find((n) => n.v === `${fd.key}:${fe1.key}`)
+    assert.isDefined(foreignNode)
+  })
+
+  test('should exclude unconnected foreign nodes', ({ assert }) => {
+    const root = new DataDomain()
+    const ns1 = root.addNamespace({ key: 'ns1' })
+    ns1.addModel({ key: 'm1' })
+
+    const fd = new DataDomain()
+    const fm1 = fd.addModel({ key: 'fm1' })
+    const fe1 = fm1.addEntity({ key: 'fe1' })
+    fd.info.version = '1.0.0'
+    root.registerForeignDomain(fd)
+
+    const serialized = DomainVersioning.serializeForVersionRelease(root)
+
+    assert.lengthOf(serialized.nodes, 2)
+    assert.lengthOf(serialized.edges, 0)
+    const foreignNode = serialized.nodes.find((n) => n.v === `${fd.key}:${fe1.key}`)
+    assert.isUndefined(foreignNode)
+  })
+
+  test('should handle indirect connections', ({ assert }) => {
+    const root = new DataDomain()
+    const n1 = root.addNamespace({ key: 'n1' })
+    const m1 = n1.addModel({ key: 'm1' })
+    const e1 = m1.addEntity({ key: 'e1' })
+
+    const fd1 = new DataDomain()
+    const fm1 = fd1.addModel({ key: 'fm1' })
+    const fe1 = fm1.addEntity({ key: 'fe1' })
+    const fe2 = fm1.addEntity({ key: 'fe2' }) // This should be included
+    fe1.addAssociation({ key: fe2.key }, { key: 'a1' })
+    fd1.info.version = '1.0.0'
+    root.registerForeignDomain(fd1)
+
+    e1.addAssociation({ domain: fd1.key, key: fe1.key }, { key: 'a2' })
+
+    const serialized = DomainVersioning.serializeForVersionRelease(root)
+
+    assert.lengthOf(serialized.nodes, 7)
+    assert.lengthOf(serialized.edges, 4)
+    const foreignNode1 = serialized.nodes.find((n) => n.v === `${fd1.key}:${fe1.key}`)
+    assert.isDefined(foreignNode1)
+    const foreignNode2 = serialized.nodes.find((n) => n.v === `${fd1.key}:${fe2.key}`)
+    assert.isDefined(foreignNode2)
+  })
+
+  test('should serialize nested dependencies', ({ assert }) => {
+    const root = new DataDomain()
+    root.key = 'root'
+    const n1 = root.addNamespace({ key: 'n1' }) // serialized
+    const m1 = n1.addModel({ key: 'm1' }) // serialized
+    const e1 = m1.addEntity({ key: 'e1' }) // serialized
+
+    const fd1 = new DataDomain()
+    fd1.key = 'fd1'
+    const fm1 = fd1.addModel({ key: 'fm1' }) // not serialized
+    const fe1 = fm1.addEntity({ key: 'fe1' }) // serialized
+    fd1.info.version = '1.0.0'
+
+    const fd2 = new DataDomain()
+    fd2.key = 'fd2'
+    fd2.registerForeignDomain(fd1)
+    const fm2 = fd2.addModel({ key: 'fm2' }) // not serialized
+    const fe2 = fm2.addEntity({ key: 'fe2' }) // serialized
+    const fa1 = fe2.addAssociation({ domain: fd1.key, key: fe1.key }, { key: 'a1' })
+    fd2.info.version = '1.0.0'
+    root.registerForeignDomain(fd2) // serialized
+
+    const a2 = e1.addAssociation({ domain: fd2.key, key: fe2.key }, { key: 'a2' }) // serialized
+
+    const serialized = DomainVersioning.serializeForVersionRelease(root)
+
+    assert.lengthOf(serialized.nodes, 7)
+    assert.lengthOf(serialized.edges, 4)
+    const sa1 = serialized.edges.find((e) => e.v === e1.key && e.w === a2.key)
+    assert.isDefined(sa1)
+    assert.deepEqual(sa1!.value, { type: 'association' })
+    const sa2 = serialized.edges.find((e) => e.v === a2.key && e.w === `${fd2.key}:${fe2.key}`)
+    assert.isDefined(sa2)
+    assert.deepEqual(sa2!.value, { type: 'association', domain: fd2.key, foreign: true })
+    const sa3 = serialized.edges.find((e) => e.v === `${fd2.key}:${fe2.key}` && e.w === `${fd2.key}:${fa1.key}`)
+    assert.isDefined(sa3)
+    assert.deepEqual(sa3!.value, { type: 'association', domain: fd2.key, foreign: true })
+    const sa4 = serialized.edges.find(
+      (e) => e.v === `${fd2.key}:${fa1.key}` && e.w === `${fd2.key}:${fd1.key}:${fe1.key}`
+    )
+    assert.isDefined(sa4)
+    assert.deepEqual(sa4!.value, { type: 'association', domain: fd1.key, foreign: true })
+    const sfe1 = serialized.nodes.find((n) => n.v === `${fd2.key}:${fd1.key}:${fe1.key}`)
+    assert.isDefined(sfe1)
+    const sfe2 = serialized.nodes.find((n) => n.v === `${fd2.key}:${fe2.key}`)
+    assert.isDefined(sfe2)
+    const sfa1 = serialized.nodes.find((n) => n.v === `${fd2.key}:${fa1.key}`)
+    assert.isDefined(sfa1)
+  })
+
+  test('should serialize an empty graph', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const serialized = DomainVersioning.serializeForVersionRelease(dataDomain)
+    assert.lengthOf(serialized.nodes, 0)
+    assert.lengthOf(serialized.edges, 0)
+  })
+})

package/tests/unit/{amf → modeling/legacy}/amf_shape_generator.spec.ts

@@ -1,8 +1,8 @@
 import { test } from '@japa/runner'
-import { DataProperty } from '../../../src/modeling/DataProperty.js'
-import { DataEntity } from '../../../src/modeling/DataEntity.js'
-import { DataNamespace } from '../../../src/modeling/DataNamespace.js'
-import { DataModel } from '../../../src/modeling/DataModel.js'
+import { DataProperty } from '../../../../src/modeling/legacy/DataProperty.js'
+import { DataEntity } from '../../../../src/modeling/legacy/DataEntity.js'
+import { DataNamespace } from '../../../../src/modeling/legacy/DataNamespace.js'
+import { DataModel } from '../../../../src/modeling/legacy/DataModel.js'
 import {
   IApiArrayShape,
   IApiDataExample,
@@ -13,7 +13,7 @@ import {
   IApiUnionShape,
   IApiXmlSerializer,
   IShapeUnion,
-} from '../../../src/amf/definitions/Shapes.js'
+} from '../../../../src/amf/definitions/Shapes.js'
 import {
   IAmfAnyTypes,
   IAmfArrayTypes,
@@ -23,11 +23,11 @@ import {
   IAmfPropertyTypes,
   IAmfScalarTypes,
   IAmfUnionTypes,
-} from '../../../src/amf/AmfTypes.js'
-import { AmfNamespace } from '../../../src/amf/definitions/Namespace.js'
-import { AmfShapeGenerator } from '../../../src/amf/AmfShapeGenerator.js'
-import { DataAssociation } from '../../../src/modeling/DataAssociation.js'
-import type { PropertyWebBindings } from '../../../src/index.js'
+} from '../../../../src/amf/AmfTypes.js'
+import { AmfNamespace } from '../../../../src/amf/definitions/Namespace.js'
+import { AmfShapeGenerator } from '../../../../src/amf/AmfShapeGenerator.js'
+import { DataAssociation } from '../../../../src/modeling/legacy/DataAssociation.js'
+import type { PropertyWebBindings } from '../../../../src/index.js'
 
 test.group('entity()', (group) => {
   let root: DataNamespace
@@ -708,7 +708,7 @@ test.group('property() / default value functions', (group) => {
     assert.match(value.value as string, /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$/)
   })
 
-  test('returns novalue for unsupported function', ({ assert }) => {
+  test('returns noValue for unsupported function', ({ assert }) => {
     p1.schema = { defaultValue: { value: 'unsupported', type: 'function' } }
     const generator = new AmfShapeGenerator()
     const result = generator.property(p1)

package/tests/unit/modeling/{data_association.spec.ts → legacy/data_association.spec.ts}

@@ -1,14 +1,6 @@
 import { test } from '@japa/runner'
-import {
-  DataNamespace,
-  DataModel,
-  DataAssociation,
-  IDataAssociation,
-  DataAssociationKind,
-  DataEntity,
-  Thing,
-  ValidationError,
-} from '../../../src/index.js'
+import { DataAssociationKind, Thing, ValidationError } from '../../../../src/index.js'
+import { DataNamespace, DataModel, DataAssociation, IDataAssociation, DataEntity } from '../../../../src/legacy.js'
 
 test.group('constructor() with defaults', (g) => {
   let root: DataNamespace
@@ -29,7 +21,7 @@ test.group('constructor() with defaults', (g) => {
 
   test('sets the default "info"', ({ assert }) => {
     const assoc = new DataAssociation(root)
-    assert.typeOf(assoc.info, 'object')
+    assert.typeOf(assoc.info, 'EventTarget')
     assert.equal(assoc.info.name, 'Unnamed association')
   })
 

package/tests/unit/modeling/{data_entity.spec.ts → legacy/data_entity.spec.ts}

@@ -1,19 +1,21 @@
 import { test } from '@japa/runner'
 import {
-  DataNamespace,
-  DataEntity,
   DataEntityKind,
-  DataProperty,
-  IDataEntity,
   Thing,
-  DataModel,
-  DataAssociation,
   ValidationError,
   RemovePropertyException,
   RemoveAssociationException,
   RemoveEntityException,
   ForeignAssociationException,
-} from '../../../src/index.js'
+} from '../../../../src/index.js'
+import {
+  DataNamespace,
+  DataEntity,
+  DataProperty,
+  IDataEntity,
+  DataModel,
+  DataAssociation,
+} from '../../../../src/legacy.js'
 
 test.group('constructor() with defaults', (group) => {
   let root: DataNamespace
@@ -34,7 +36,7 @@ test.group('constructor() with defaults', (group) => {
 
   test('sets the default "info"', ({ assert }) => {
     const assoc = new DataEntity(root)
-    assert.typeOf(assoc.info, 'object')
+    assert.typeOf(assoc.info, 'EventTarget')
     assert.equal(assoc.info.name, '')
   })
 

package/tests/unit/modeling/{data_entity_generator_json.spec.ts → legacy/data_entity_generator_json.spec.ts}

@@ -1,6 +1,6 @@
 /* eslint-disable max-len */
 import { test } from '@japa/runner'
-import { DataNamespace, DataEntity, DataModel, DataProperty } from '../../../src/index.js'
+import { DataNamespace, DataEntity, DataModel, DataProperty } from '../../../../src/legacy.js'
 
 // const rfc2616Re =
 //   /^(Mon|Tue|Wed|Thu|Fri|Sat|Sun), ([0-3][0-9]) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) ([0-9]{4}) ([01][0-9]|2[0-3])(:[0-5][0-9]){2} GMT$/

package/tests/unit/modeling/{data_entity_generator_xml.spec.ts → legacy/data_entity_generator_xml.spec.ts}

@@ -1,6 +1,6 @@
 import { test } from '@japa/runner'
 import { JSDOM } from 'jsdom'
-import { DataNamespace, DataEntity, DataModel, DataProperty } from '../../../src/index.js'
+import { DataNamespace, DataEntity, DataModel, DataProperty } from '../../../../src/legacy.js'
 
 const rfc3339Re = /^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}\.[0-9]{3}Z$/
 const dateRe = /^[0-9]{4}-[0-9]{2}-[0-9]{2}$/