@api-client/core 0.11.2 → 0.11.4

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

@@ -1,5 +1,13 @@
 import { test } from '@japa/runner'
-import { DataEntity, DataModel, DataNamespace, DataNamespaceKind, IDataNamespace, Thing } from '../../../src/index.js'
+import {
+  DataEntity,
+  DataItem,
+  DataModel,
+  DataNamespace,
+  DataNamespaceKind,
+  IDataNamespace,
+  Thing,
+} from '../../../src/index.js'
 
 test.group('constructor() defaults', () => {
   test('sets the kind', ({ assert }) => {
@@ -821,3 +829,377 @@ test.group('computeForeignNamespaceKeys()', () => {
     assert.deepEqual(result, [n2.key])
   })
 })
+
+test.group('findAssociatedEntity()', (group) => {
+  let root: DataNamespace
+  let foreign: DataNamespace
+  let e1: DataEntity
+  let e2: DataEntity
+
+  group.each.setup(() => {
+    root = new DataNamespace()
+    foreign = new DataNamespace()
+    root.addForeign(foreign)
+    const model1 = root.addDataModel('m1')
+    const model2 = foreign.addDataModel('m2')
+    e1 = model1.addEntity('e1')
+    e2 = model2.addEntity('e2')
+  })
+
+  test('finds an entity in the current namespace', ({ assert }) => {
+    const result = root.findAssociatedEntity(e1.key)
+    assert.deepEqual(result, e1)
+  })
+
+  test('finds an entity in a foreign namespace', ({ assert }) => {
+    const result = root.findAssociatedEntity(e2.key, foreign.key)
+    assert.deepEqual(result, e2)
+  })
+
+  test('returns undefined when the entity is not found in the current namespace', ({ assert }) => {
+    const result = root.findAssociatedEntity('non-existent-key')
+    assert.isUndefined(result)
+  })
+
+  test('returns undefined when the entity is not found in a foreign namespace', ({ assert }) => {
+    const result = root.findAssociatedEntity('non-existent-key', foreign.key)
+    assert.isUndefined(result)
+  })
+
+  test('returns undefined when the foreign namespace does not exist', ({ assert }) => {
+    const result = root.findAssociatedEntity(e2.key, 'non-existent-namespace')
+    assert.isUndefined(result)
+  })
+
+  test('returns undefined when no namespace is provided and the entity is in a foreign namespace', ({ assert }) => {
+    const result = root.findAssociatedEntity(e2.key)
+    assert.isUndefined(result)
+  })
+})
+
+test.group('addForeign()', (group) => {
+  let root: DataNamespace
+  let foreign: DataNamespace
+
+  group.each.setup(() => {
+    root = new DataNamespace()
+    foreign = new DataNamespace()
+  })
+
+  test('adds a foreign namespace', ({ assert }) => {
+    root.addForeign(foreign)
+    assert.deepEqual(root.foreign, [foreign])
+  })
+
+  test('does not add the same foreign namespace twice', ({ assert }) => {
+    root.addForeign(foreign)
+    root.addForeign(foreign)
+    assert.deepEqual(root.foreign, [foreign])
+  })
+})
+
+test.group('removeForeign()', (group) => {
+  let root: DataNamespace
+  let foreign: DataNamespace
+  let foreign2: DataNamespace
+
+  group.each.setup(() => {
+    root = new DataNamespace()
+    foreign = new DataNamespace()
+    foreign2 = new DataNamespace()
+    root.addForeign(foreign)
+    root.addForeign(foreign2)
+  })
+
+  test('removes a foreign namespace', ({ assert }) => {
+    root.removeForeign(foreign)
+    assert.deepEqual(root.foreign, [foreign2])
+  })
+
+  test('does nothing when the foreign namespace does not exist', ({ assert }) => {
+    const other = new DataNamespace()
+    root.removeForeign(other)
+    assert.deepEqual(root.foreign, [foreign, foreign2])
+  })
+})
+
+test.group('hasForeignNamespace()', (group) => {
+  let root: DataNamespace
+  let foreign: DataNamespace
+
+  group.each.setup(() => {
+    root = new DataNamespace()
+    foreign = new DataNamespace()
+    root.addForeign(foreign)
+  })
+
+  test('returns true when the foreign namespace exists', ({ assert }) => {
+    const result = root.hasForeignNamespace(foreign.key)
+    assert.isTrue(result)
+  })
+
+  test('returns false when the foreign namespace does not exist', ({ assert }) => {
+    const result = root.hasForeignNamespace('non-existent-key')
+    assert.isFalse(result)
+  })
+})
+
+test.group('listNamespaces()', (group) => {
+  let root: DataNamespace
+  let n1: DataNamespace
+  let n2: DataNamespace
+  let m1: DataModel
+
+  group.each.setup(() => {
+    root = new DataNamespace()
+    n1 = root.addNamespace('n1')
+    n2 = root.addNamespace('n2')
+    m1 = root.addDataModel('m1')
+  })
+
+  test('lists all namespaces', ({ assert }) => {
+    const result = root.listNamespaces()
+    assert.deepEqual(result, [n1, n2])
+  })
+
+  test('lists namespaces in a sub-namespace', ({ assert }) => {
+    const n3 = n1.addNamespace('n3')
+    const result = n1.listNamespaces()
+    assert.deepEqual(result, [n3])
+  })
+
+  test('does not list data models', ({ assert }) => {
+    const result = root.listNamespaces()
+    assert.notDeepInclude(result, m1)
+  })
+})
+
+test.group('listDataModels()', (group) => {
+  let root: DataNamespace
+  let n1: DataNamespace
+  let m1: DataModel
+  let m2: DataModel
+  let e1: DataEntity
+
+  group.each.setup(() => {
+    root = new DataNamespace()
+    n1 = root.addNamespace('n1')
+    m1 = root.addDataModel('m1')
+    m2 = n1.addDataModel('m2')
+    e1 = m2.addEntity('e1')
+  })
+
+  test('lists all data models', ({ assert }) => {
+    const result = root.listDataModels()
+    assert.deepEqual(result, [m1])
+  })
+
+  test('lists data models in a sub-namespace', ({ assert }) => {
+    const m3 = n1.addDataModel('m3')
+    const result = n1.listDataModels()
+    assert.deepEqual(result, [m2, m3])
+  })
+
+  test('does not list entities', ({ assert }) => {
+    const result = root.listDataModels()
+    assert.notDeepInclude(result, e1)
+  })
+})
+
+test.group('getRoot()', (group) => {
+  let root: DataNamespace
+  let n1: DataNamespace
+  let n2: DataNamespace
+
+  group.each.setup(() => {
+    root = new DataNamespace()
+    n1 = root.addNamespace('n1')
+    n2 = n1.addNamespace('n2')
+  })
+
+  test('returns self when called on the root namespace', ({ assert }) => {
+    const result = root.getRoot()
+    assert.deepEqual(result, root)
+  })
+
+  test('returns the root namespace when called on a sub-namespace', ({ assert }) => {
+    const result = n1.getRoot()
+    assert.deepEqual(result, root)
+  })
+
+  test('returns the root namespace when called on a sub-sub-namespace', ({ assert }) => {
+    const result = n2.getRoot()
+    assert.deepEqual(result, root)
+  })
+})
+
+test.group('getParent()', (group) => {
+  let root: DataNamespace
+  let n1: DataNamespace
+  let n2: DataNamespace
+
+  group.each.setup(() => {
+    root = new DataNamespace()
+    n1 = root.addNamespace('n1')
+    n2 = n1.addNamespace('n2')
+  })
+
+  test('returns undefined when called on the root namespace', ({ assert }) => {
+    const result = root.getParent()
+    assert.isUndefined(result)
+  })
+
+  test('returns the parent namespace when called on a sub-namespace', ({ assert }) => {
+    const result = n2.getParent()
+    assert.deepEqual(result, n1)
+  })
+})
+
+test.group('isRoot()', (group) => {
+  let root: DataNamespace
+  let n1: DataNamespace
+
+  group.each.setup(() => {
+    root = new DataNamespace()
+    n1 = root.addNamespace('n1')
+  })
+
+  test('returns true when called on the root namespace', ({ assert }) => {
+    const result = root.isRoot()
+    assert.isTrue(result)
+  })
+
+  test('returns false when called on a sub-namespace', ({ assert }) => {
+    const result = n1.isRoot()
+    assert.isFalse(result)
+  })
+})
+
+test.group('adaptNamespace()', (group) => {
+  let root: DataNamespace
+  let n1: DataNamespace
+  let n2: DataNamespace
+
+  group.each.setup(() => {
+    root = new DataNamespace()
+    n1 = root.addNamespace('n1')
+    n2 = root.addNamespace('n2')
+  })
+
+  test('moves a namespace to a new parent', ({ assert }) => {
+    const n3 = n1.addNamespace('n3')
+    n2.adaptNamespace(n3)
+    assert.deepEqual(n1.items, [], 'removes from the old parent')
+    const item = DataItem.dataNamespace(root, n3.key)
+    assert.deepEqual(n2.items, [item], 'adds to the new parent')
+    assert.deepEqual(root.definitions.namespaces, [n1, n2, n3], 'keeps the namespace in the root definitions')
+  })
+
+  test('moves a namespace to a new index', ({ assert }) => {
+    const n3 = n1.addNamespace('n3')
+    const n4 = n1.addNamespace('n4')
+    const n5 = n2.addNamespace('n5')
+    n2.adaptNamespace(n3, { index: 0 })
+    const item3 = DataItem.dataNamespace(root, n3.key)
+    const item4 = DataItem.dataNamespace(root, n4.key)
+    const item5 = DataItem.dataNamespace(root, n5.key)
+    assert.deepEqual(n1.items, [item4], 'removes from the old parent')
+    assert.deepEqual(n2.items, [item3, item5], 'adds to the new parent')
+    assert.deepEqual(root.definitions.namespaces, [n1, n2, n3, n4, n5], 'keeps the namespace in the root definitions')
+  })
+
+  test('throws when adapting self', ({ assert }) => {
+    assert.throws(() => n1.adaptNamespace(n1), 'Unable to adapt a namespace that is self.')
+  })
+
+  test('throws when adapting a namespace from another root', ({ assert }) => {
+    const otherRoot = new DataNamespace()
+    const otherNs = otherRoot.addNamespace('other')
+    assert.throws(
+      () => n1.adaptNamespace(otherNs),
+      `The namespace ${otherNs.key} is not in the same namespace as this data namespace.`
+    )
+  })
+
+  test('throws when adapting a namespace that is already adapted', ({ assert }) => {
+    const n3 = n1.addNamespace('n3')
+    n2.adaptNamespace(n3)
+    assert.throws(() => n2.adaptNamespace(n3), `The namespace ${n3.key} is already adapted by this data namespace.`)
+  })
+
+  test('throws when index is out of range (minimum)', ({ assert }) => {
+    assert.throws(() => n1.adaptNamespace(n2, { index: -1 }), `The index -1 cannot be below 0.`)
+  })
+
+  test('throws when index is out of range (maximum)', ({ assert }) => {
+    assert.throws(() => n1.adaptNamespace(n2, { index: 1 }), `The index 1 is not valid.`)
+  })
+})
+
+test.group('adaptNamespace() - Circular Dependency', (group) => {
+  let root: DataNamespace
+  let n1: DataNamespace
+  let n2: DataNamespace
+  let n3: DataNamespace
+  let n4: DataNamespace
+
+  // Root
+  // ├── n1
+  // │   ├── n3
+  // │   │   └── n4
+  // └── n2
+
+  group.each.setup(() => {
+    root = new DataNamespace()
+    n1 = root.addNamespace('n1')
+    n2 = root.addNamespace('n2')
+    n3 = n1.addNamespace('n3')
+    n4 = n3.addNamespace('n4')
+  })
+
+  test('throws when adapting a namespace under itself', ({ assert }) => {
+    assert.throws(() => n1.adaptNamespace(n1), 'Unable to adapt a namespace that is self.')
+  })
+
+  test('throws when adapting a namespace under its child', ({ assert }) => {
+    assert.throws(
+      () => n3.adaptNamespace(n1),
+      `Unable to adapt namespace ${n1.key} under itself or one of its children.`
+    )
+  })
+
+  test('throws when adapting a namespace under its grandchild', ({ assert }) => {
+    assert.throws(
+      () => n4.adaptNamespace(n1),
+      `Unable to adapt namespace ${n1.key} under itself or one of its children.`
+    )
+  })
+
+  test('does not throw when adapting a namespace under its sibling', ({ assert }) => {
+    const n5 = n1.addNamespace('n5')
+    assert.doesNotThrow(() => n2.adaptNamespace(n5))
+  })
+
+  test("does not throw when adapting a namespace under its sibling's child", ({ assert }) => {
+    const n5 = n1.addNamespace('n5')
+    const n6 = n5.addNamespace('n6')
+    assert.doesNotThrow(() => n2.adaptNamespace(n6))
+  })
+
+  test("does not throw when adapting a namespace under its sibling's parent", ({ assert }) => {
+    const n5 = n1.addNamespace('n5')
+    // Root (before)
+    // ├── n1
+    // │   ├── n3
+    // │   │   └── n4
+    // │   └── n5
+    // └── n2
+    // Root (after)
+    // └── n1
+    //     ├── n3
+    //     │   └── n4
+    //     └── n5
+    //         └── n2
+    assert.doesNotThrow(() => n5.adaptNamespace(n2))
+  })
+})

package/build/oauth-popup.html

@@ -1,33 +0,0 @@
-<!doctype html>
-<html>
-  <head>
-    <meta charset="utf-8" />
-    <title>Oauth2 callback window</title>
-    <style>
-      *[hidden] {
-        display: none;
-      }
-    </style>
-  </head>
-  <body>
-    <h1>Sending the authorization data to the application</h1>
-    <p id="general-error" hidden>
-      The window wasn't opened as a popup and therefore it can't pass the authorization information.<br />
-      This is an error.
-    </p>
-    <script>
-      const messageTarget = window.opener || window.parent || window.top
-      if (!messageTarget || messageTarget === window || !messageTarget.postMessage) {
-        const elm = document.getElementById('general-error')
-        elm.removeAttribute('hidden')
-      } else {
-        const search = window.location.search.substr(1)
-        if (search) {
-          messageTarget.postMessage(search, '*')
-        } else {
-          messageTarget.postMessage(window.location.hash.substr(1), '*')
-        }
-      }
-    </script>
-  </body>
-</html>