@api-client/core 0.12.1 → 0.12.3

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

@@ -12,6 +12,7 @@ import {
   DomainEntity,
   DomainProperty,
   DomainAssociation,
+  DataDomainKind,
 } from '../../../src/index.js'
 
 test.group('DomainImpactAnalysis', (group) => {
@@ -89,28 +90,28 @@ test.group('DomainImpactAnalysis', (group) => {
     assert.equal(n1r.kind, DomainNamespaceKind)
     assert.equal(n1r.type, 'delete')
     assert.equal(n1r.impact, `The n1 namespace will be deleted.`)
-    assert.isFalse(n1r.blocking)
+    assert.equal(n1r.severity, 'info')
 
     assert.ok(n2r)
     assert.equal(n2r.key, n2.key)
     assert.equal(n2r.kind, DomainNamespaceKind)
     assert.equal(n2r.type, 'delete')
     assert.equal(n2r.impact, `The n2 namespace will be deleted.`)
-    assert.isFalse(n2r.blocking)
+    assert.equal(n2r.severity, 'info')
 
     assert.ok(m3r)
     assert.equal(m3r.key, m3.key)
     assert.equal(m3r.kind, DomainModelKind)
     assert.equal(m3r.type, 'delete')
     assert.equal(m3r.impact, `The m3 data model will be deleted.`)
-    assert.isFalse(m3r.blocking)
+    assert.equal(m3r.severity, 'info')
 
     assert.ok(e3r)
     assert.equal(e3r.key, e3.key)
     assert.equal(e3r.kind, DomainEntityKind)
     assert.equal(e3r.type, 'delete')
     assert.equal(e3r.impact, `The e3 entity will be deleted.`)
-    assert.isFalse(e3r.blocking)
+    assert.equal(e3r.severity, 'info')
 
     assert.ok(e4r)
     assert.equal(e4r.key, e4.key)
@@ -118,7 +119,7 @@ test.group('DomainImpactAnalysis', (group) => {
     assert.equal(e4r.type, 'delete')
     assert.equal(e4r.impact, `The "e4" entity will become an orphan because it is a child of the "e3" entity.`)
     assert.equal(e4r.resolution, `The "e3" entity will be removed as the parent of the "e4" entity.`)
-    assert.isTrue(e4r.blocking)
+    assert.equal(e4r.severity, 'error')
     assert.equal(e4r.relationship, 'child')
 
     assert.ok(m2r)
@@ -126,14 +127,14 @@ test.group('DomainImpactAnalysis', (group) => {
     assert.equal(m2r.kind, DomainModelKind)
     assert.equal(m2r.type, 'delete')
     assert.equal(m2r.impact, `The m2 data model will be deleted.`)
-    assert.isFalse(m2r.blocking)
+    assert.equal(m2r.severity, 'info')
 
     assert.ok(e2r)
     assert.equal(e2r.key, e2.key)
     assert.equal(e2r.kind, DomainEntityKind)
     assert.equal(e2r.type, 'delete')
     assert.equal(e2r.impact, `The e2 entity will be deleted.`)
-    assert.isFalse(e2r.blocking)
+    assert.equal(e2r.severity, 'info')
 
     assert.ok(a1r)
     assert.equal(a1r.key, a1.key)
@@ -141,7 +142,7 @@ test.group('DomainImpactAnalysis', (group) => {
     assert.equal(a1r.type, 'delete')
     assert.equal(a1r.impact, `The a1 association will be broken because it has a target to e2.`)
     assert.equal(a1r.resolution, `The a1 association will be removed from e2.`)
-    assert.isTrue(a1r.blocking)
+    assert.equal(a1r.severity, 'error')
   })
 
   test('returns a report for deleting a data model', ({ assert }) => {
@@ -164,28 +165,28 @@ test.group('DomainImpactAnalysis', (group) => {
     assert.equal(m1r.kind, DomainModelKind)
     assert.equal(m1r.type, 'delete')
     assert.equal(m1r.impact, `The m1 data model will be deleted.`)
-    assert.isFalse(m1r.blocking)
+    assert.equal(m1r.severity, 'info')
 
     assert.ok(e1r)
     assert.equal(e1r.key, e1.key)
     assert.equal(e1r.kind, DomainEntityKind)
     assert.equal(e1r.type, 'delete')
     assert.equal(e1r.impact, `The e1 entity will be deleted.`)
-    assert.isFalse(e1r.blocking)
+    assert.equal(e1r.severity, 'info')
 
     assert.ok(p1r)
     assert.equal(p1r.key, p1.key)
     assert.equal(p1r.kind, DomainPropertyKind)
     assert.equal(p1r.type, 'delete')
     assert.equal(p1r.impact, `The p1 property will be deleted.`)
-    assert.isFalse(p1r.blocking)
+    assert.equal(p1r.severity, 'info')
 
     assert.ok(a1r)
     assert.equal(a1r.key, a1.key)
     assert.equal(a1r.kind, DomainAssociationKind)
     assert.equal(a1r.type, 'delete')
     assert.equal(a1r.impact, `The a1 association will be deleted.`)
-    assert.isFalse(a1r.blocking)
+    assert.equal(a1r.severity, 'info')
 
     assert.ok(e3r)
     assert.equal(e3r.key, e3.key)
@@ -193,7 +194,7 @@ test.group('DomainImpactAnalysis', (group) => {
     assert.equal(e3r.type, 'delete')
     assert.equal(e3r.impact, `The "e3" entity will become an orphan because it is a child of the "e1" entity.`)
     assert.equal(e3r.resolution, `The "e1" entity will be removed as the parent of the "e3" entity.`)
-    assert.isTrue(e3r.blocking)
+    assert.equal(e3r.severity, 'error')
     assert.equal(e3r.relationship, 'child')
   })
 
@@ -216,21 +217,21 @@ test.group('DomainImpactAnalysis', (group) => {
     assert.equal(e1r.kind, DomainEntityKind)
     assert.equal(e1r.type, 'delete')
     assert.equal(e1r.impact, `The e1 entity will be deleted.`)
-    assert.isFalse(e1r.blocking)
+    assert.equal(e1r.severity, 'info')
 
     assert.ok(p1r)
     assert.equal(p1r.key, p1.key)
     assert.equal(p1r.kind, DomainPropertyKind)
     assert.equal(p1r.type, 'delete')
     assert.equal(p1r.impact, `The p1 property will be deleted.`)
-    assert.isFalse(p1r.blocking)
+    assert.equal(p1r.severity, 'info')
 
     assert.ok(a1r)
     assert.equal(a1r.key, a1.key)
     assert.equal(a1r.kind, DomainAssociationKind)
     assert.equal(a1r.type, 'delete')
     assert.equal(a1r.impact, `The a1 association will be deleted.`)
-    assert.isFalse(a1r.blocking)
+    assert.equal(a1r.severity, 'info')
 
     assert.ok(e3r)
     assert.equal(e3r.key, e3.key)
@@ -238,7 +239,7 @@ test.group('DomainImpactAnalysis', (group) => {
     assert.equal(e3r.type, 'delete')
     assert.equal(e3r.impact, `The "e3" entity will become an orphan because it is a child of the "e1" entity.`)
     assert.equal(e3r.resolution, `The "e1" entity will be removed as the parent of the "e3" entity.`)
-    assert.isTrue(e3r.blocking)
+    assert.equal(e3r.severity, 'error')
     assert.equal(e3r.relationship, 'child')
   })
 
@@ -259,7 +260,7 @@ test.group('DomainImpactAnalysis', (group) => {
     assert.equal(p1r.kind, DomainPropertyKind)
     assert.equal(p1r.type, 'delete')
     assert.equal(p1r.impact, `The p1 property will be deleted.`)
-    assert.isFalse(p1r.blocking)
+    assert.equal(p1r.severity, 'info')
   })
 
   test('returns a report for deleting an association', ({ assert }) => {
@@ -279,7 +280,7 @@ test.group('DomainImpactAnalysis', (group) => {
     assert.equal(a1r.kind, DomainAssociationKind)
     assert.equal(a1r.type, 'delete')
     assert.equal(a1r.impact, `The a1 association will be deleted.`)
-    assert.isFalse(a1r.blocking)
+    assert.equal(a1r.severity, 'info')
   })
 
   test('handles circular dependencies', ({ assert }) => {
@@ -300,7 +301,7 @@ test.group('DomainImpactAnalysis', (group) => {
     assert.equal(e3r.kind, DomainEntityKind)
     assert.equal(e3r.type, 'delete')
     assert.equal(e3r.impact, `The e3 entity will be deleted.`)
-    assert.isFalse(e3r.blocking)
+    assert.equal(e3r.severity, 'info')
 
     assert.ok(e2r)
     assert.equal(e2r.key, e2.key)
@@ -308,7 +309,7 @@ test.group('DomainImpactAnalysis', (group) => {
     assert.equal(e2r.type, 'delete')
     assert.equal(e2r.impact, `The "e2" entity will become an orphan because it is a child of the "e3" entity.`)
     assert.equal(e2r.resolution, `The "e3" entity will be removed as the parent of the "e2" entity.`)
-    assert.isTrue(e2r.blocking)
+    assert.equal(e2r.severity, 'error')
     assert.equal(e2r.relationship, 'child')
 
     assert.ok(e4r)
@@ -317,7 +318,7 @@ test.group('DomainImpactAnalysis', (group) => {
     assert.equal(e4r.type, 'delete')
     assert.equal(e4r.impact, `The "e4" entity will become an orphan because it is a child of the "e3" entity.`)
     assert.equal(e4r.resolution, `The "e3" entity will be removed as the parent of the "e4" entity.`)
-    assert.isTrue(e4r.blocking)
+    assert.equal(e4r.severity, 'error')
     assert.equal(e4r.relationship, 'child')
   })
 
@@ -330,7 +331,6 @@ test.group('DomainImpactAnalysis', (group) => {
     a1.addTarget(fe1)
 
     const report = analyzer.deleteAnalysis(e1.key, DomainEntityKind)
-    // console.log(JSON.stringify(report.impact, null, 2))
     assert.equal(report.key, e1.key)
     assert.equal(report.kind, DomainEntityKind)
     assert.isFalse(report.canProceed, 'operation should not be able to proceed')
@@ -348,21 +348,21 @@ test.group('DomainImpactAnalysis', (group) => {
     assert.equal(e1r.kind, DomainEntityKind)
     assert.equal(e1r.type, 'delete')
     assert.equal(e1r.impact, `The e1 entity will be deleted.`)
-    assert.isFalse(e1r.blocking)
+    assert.equal(e1r.severity, 'info')
 
     assert.ok(p1r)
     assert.equal(p1r.key, p1.key)
     assert.equal(p1r.kind, DomainPropertyKind)
     assert.equal(p1r.type, 'delete')
     assert.equal(p1r.impact, `The p1 property will be deleted.`)
-    assert.isFalse(p1r.blocking)
+    assert.equal(p1r.severity, 'info')
 
     assert.ok(a1r)
     assert.equal(a1r.key, a1.key)
     assert.equal(a1r.kind, DomainAssociationKind)
     assert.equal(a1r.type, 'delete')
     assert.equal(a1r.impact, `The a1 association will be deleted.`)
-    assert.isFalse(a1r.blocking)
+    assert.equal(a1r.severity, 'info')
 
     assert.ok(e3r)
     assert.equal(e3r.key, e3.key)
@@ -370,7 +370,7 @@ test.group('DomainImpactAnalysis', (group) => {
     assert.equal(e3r.type, 'delete')
     assert.equal(e3r.impact, `The "e3" entity will become an orphan because it is a child of the "e1" entity.`)
     assert.equal(e3r.resolution, `The "e1" entity will be removed as the parent of the "e3" entity.`)
-    assert.isTrue(e3r.blocking)
+    assert.equal(e3r.severity, 'error')
     assert.equal(e3r.relationship, 'child')
   })
 
@@ -401,7 +401,7 @@ test.group('DomainImpactAnalysis', (group) => {
       `The "e1" entity will become an orphan because its parent "fe1" is in the foreign namespace "${f1.key}".`
     )
     assert.equal(e1r.resolution, `The "fe1" entity will be removed as the parent of the "e1" entity.`)
-    assert.isTrue(e1r.blocking)
+    assert.equal(e1r.severity, 'error')
     assert.equal(e1r.relationship, 'child')
   })
 
@@ -432,7 +432,7 @@ test.group('DomainImpactAnalysis', (group) => {
       `The "a1" association from "e1" will be broken because it targets "fe1" in the foreign namespace "${f1.key}".`
     )
     assert.equal(a1r.resolution, `The "a1" association will be removed from "e1".`)
-    assert.isTrue(a1r.blocking)
+    assert.equal(a1r.severity, 'error')
   })
 
   test('removeForeignNamespaceAnalysis() handles no foreign entities', ({ assert }) => {
@@ -450,3 +450,112 @@ test.group('DomainImpactAnalysis', (group) => {
     assert.lengthOf(report.impact, 0, 'has all items')
   })
 })
+
+test.group('DomainImpactAnalysis.publishAnalysis()', (group) => {
+  let domain: DataDomain
+  let analysis: DomainImpactAnalysis
+
+  group.each.setup(() => {
+    domain = new DataDomain()
+    analysis = new DomainImpactAnalysis(domain)
+  })
+
+  test('publishAnalysis() should return an empty report when the domain is empty', ({ assert }) => {
+    const report = analysis.publishAnalysis()
+    assert.deepEqual(report, {
+      key: '',
+      kind: DataDomainKind,
+      impact: [],
+      canProceed: true,
+    })
+  })
+
+  test('publishAnalysis() should return validation errors for entities', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity = model.addEntity({ key: 'entity', info: { name: 'Invalid-Name' } }) // Invalid name
+
+    const report = analysis.publishAnalysis()
+    // no key
+    // no properties
+    // invalid name
+    // name is not a snake case
+    assert.lengthOf(report.impact, 4)
+    assert.equal(report.impact[0].key, 'entity')
+    assert.equal(report.impact[0].kind, entity.kind)
+    assert.equal(report.impact[0].type, 'publish')
+    assert.equal(report.impact[0].severity, 'error')
+    assert.equal(report.canProceed, false)
+  })
+
+  test('publishAnalysis() should return validation errors for properties', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity = model.addEntity({ key: 'entity', info: { name: 'entity' } })
+    const property = entity.addProperty({ key: 'invalid-property', type: 'string', info: { name: 'invalid-property' } })
+
+    const report = analysis.publishAnalysis()
+    // no key (entity)
+    // invalid name (property)
+    assert.lengthOf(report.impact, 2)
+    assert.equal(report.impact[1].key, property.key)
+    assert.equal(report.impact[1].kind, property.kind)
+    assert.equal(report.impact[1].type, 'publish')
+    assert.equal(report.impact[1].severity, 'error')
+    assert.equal(report.canProceed, false)
+  })
+
+  test('publishAnalysis() should return validation errors for associations', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity1 = model.addEntity({ key: 'entity1', info: { name: 'entity1' } })
+    const entity2 = model.addEntity({ key: 'entity2', info: { name: 'entity2' } })
+    const association = entity1.addAssociation({ key: entity2.key }, { info: { name: 'Invalid-Name' } })
+
+    const report = analysis.publishAnalysis()
+    // no key (entity1)
+    // invalid name (association)
+    // snake case (association)
+    // no key (entity2)
+    // no properties (entity2)
+    assert.lengthOf(report.impact, 5)
+    assert.equal(report.impact[1].key, association.key)
+    assert.equal(report.impact[1].kind, association.kind)
+    assert.equal(report.impact[1].type, 'publish')
+    assert.equal(report.impact[1].severity, 'error')
+    assert.equal(report.canProceed, false)
+  })
+
+  test('publishAnalysis() should return multiple validation errors', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity1 = model.addEntity({ key: 'invalid-entity', info: { name: 'Invalid-Entity' } })
+    entity1.addProperty({ key: 'invalid-property', type: 'string', info: { name: 'Invalid-Property' } })
+    const entity2 = model.addEntity({ key: 'entity2', info: { name: 'entity2' } })
+    entity1.addAssociation({ key: entity2.key }, { info: { name: 'Invalid-Name' } })
+
+    const report = analysis.publishAnalysis()
+    // entity1 - no key
+    // entity1 - invalid name
+    // entity1 - snake case
+    // property - invalid name
+    // property - snake case
+    // association - invalid name
+    // association - snake case
+    // entity2 - no key
+    // entity2 - no properties
+    assert.lengthOf(report.impact, 9)
+    assert.equal(report.canProceed, false)
+  })
+
+  test('publishAnalysis() should return no errors for a valid domain', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity1 = model.addEntity({ key: 'entity1', info: { name: 'entity1' } })
+    entity1.addProperty({ key: 'p1', type: 'string', info: { name: 'property1' } })
+    entity1.addProperty({ key: 'p2', type: 'string', primary: true, info: { name: 'property2' } })
+    const entity2 = model.addEntity({ key: 'entity2', info: { name: 'entity2' } })
+    entity2.addProperty({ key: 'p3', type: 'number', info: { name: 'property3' } })
+    entity2.addProperty({ key: 'p4', type: 'string', primary: true, info: { name: 'property4' } })
+    entity1.addAssociation({ key: entity2.key }, { info: { name: 'name' } })
+
+    const report = analysis.publishAnalysis()
+    assert.lengthOf(report.impact, 0)
+    assert.equal(report.canProceed, true)
+  })
+})

package/tests/unit/modeling/validation/association_validation.spec.ts

@@ -0,0 +1,157 @@
+import { test } from '@japa/runner'
+import { DataDomain, AssociationValidation } from '../../../../src/index.js'
+
+test.group('AssociationValidation', (group) => {
+  let domain: DataDomain
+  let validation: AssociationValidation
+
+  group.each.setup(() => {
+    domain = new DataDomain()
+    validation = new AssociationValidation(domain)
+  })
+
+  test('validate() should return an error when the association does not exist', ({ assert }) => {
+    const results = validation.validate('nonExistentAssociation')
+    assert.lengthOf(results, 1)
+    assert.equal(results[0].rule, 'exists')
+    assert.equal(results[0].severity, 'error')
+  })
+
+  test('validate() should call other validation methods', ({ assert, sinon }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity1 = model.addEntity({ key: 'entity1', info: { name: 'Entity1' } })
+    const entity2 = model.addEntity({ key: 'entity2', info: { name: 'Entity2' } })
+    const association = entity1.addAssociation(
+      { key: entity2.key },
+      {
+        key: 'association',
+        info: { name: 'Association' },
+      }
+    )
+    const validateNameSpy = sinon.spy(validation, 'validateName')
+    const validateTargetsSpy = sinon.spy(validation, 'validateTargets')
+
+    validation.validate(association)
+
+    assert.calledWith(validateNameSpy, association)
+    assert.calledWith(validateTargetsSpy, association)
+    sinon.restore()
+  })
+
+  test('validateName() should return an error when the association has no name', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity1 = model.addEntity({ key: 'entity1', info: { name: 'Entity1' } })
+    const entity2 = model.addEntity({ key: 'entity2', info: { name: 'Entity2' } })
+    const association = entity1.addAssociation(
+      { key: entity2.key },
+      {
+        key: 'association',
+        info: { name: 'association' },
+      }
+    )
+    association.info.name = undefined
+    const results = validation.validateName(association)
+    assert.lengthOf(results, 1)
+    assert.equal(results[0].rule, 'required')
+    assert.equal(results[0].severity, 'error')
+  })
+
+  test('validateName() should return an error when the association name starts with a number', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity1 = model.addEntity({ key: 'entity1', info: { name: 'Entity1' } })
+    const entity2 = model.addEntity({ key: 'entity2', info: { name: 'Entity2' } })
+    const association = entity1.addAssociation(
+      { key: entity2.key },
+      {
+        key: '1association',
+        info: { name: '1association' },
+      }
+    )
+    const results = validation.validateName(association)
+    assert.lengthOf(results, 1)
+    assert.equal(results[0].rule, 'format')
+    assert.equal(results[0].severity, 'error')
+  })
+
+  test('validateName() should return an error when the association name contains invalid characters', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity1 = model.addEntity({ key: 'entity1', info: { name: 'Entity1' } })
+    const entity2 = model.addEntity({ key: 'entity2', info: { name: 'Entity2' } })
+    const association = entity1.addAssociation(
+      { key: entity2.key },
+      {
+        key: 'invalid-association!',
+        info: { name: 'invalid-association!' },
+      }
+    )
+    const results = validation.validateName(association)
+    assert.lengthOf(results, 1)
+    assert.equal(results[0].rule, 'format')
+    assert.equal(results[0].severity, 'error')
+  })
+
+  test('validateName() should return an error when the association name is too short', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity1 = model.addEntity({ key: 'entity1', info: { name: 'Entity1' } })
+    const entity2 = model.addEntity({ key: 'entity2', info: { name: 'Entity2' } })
+    const association = entity1.addAssociation(
+      { key: entity2.key },
+      {
+        key: 'a',
+        info: { name: 'a' },
+      }
+    )
+    const results = validation.validateName(association)
+    assert.lengthOf(results, 1)
+    assert.equal(results[0].rule, 'length')
+    assert.equal(results[0].severity, 'error')
+  })
+
+  test('validateName() should return an error when the association name is too long', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity1 = model.addEntity({ key: 'entity1', info: { name: 'Entity1' } })
+    const entity2 = model.addEntity({ key: 'entity2', info: { name: 'Entity2' } })
+    const association = entity1.addAssociation(
+      { key: entity2.key },
+      {
+        key: 'a'.repeat(60),
+        info: { name: 'a'.repeat(60) },
+      }
+    )
+    const results = validation.validateName(association)
+    assert.lengthOf(results, 1)
+    assert.equal(results[0].rule, 'length')
+    assert.equal(results[0].severity, 'error')
+  })
+
+  test('validateName() should return no errors when the association name is valid', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity1 = model.addEntity({ key: 'entity1', info: { name: 'Entity1' } })
+    const entity2 = model.addEntity({ key: 'entity2', info: { name: 'Entity2' } })
+    const association = entity1.addAssociation(
+      { key: entity2.key },
+      {
+        key: 'valid_association123',
+        info: { name: 'valid_association123' },
+      }
+    )
+    const results = validation.validateName(association)
+    assert.lengthOf(results, 0)
+  })
+
+  test('validateEntities() should return an error when the target entity does not exist', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity1 = model.addEntity({ key: 'entity1', info: { name: 'Entity1' } })
+    const association = entity1.addAssociation(
+      {},
+      {
+        key: 'association',
+        info: { name: 'association' },
+      }
+    )
+    const results = validation.validateTargets(association)
+    assert.lengthOf(results, 1)
+    assert.equal(results[0].rule, 'required')
+    assert.equal(results[0].severity, 'error')
+  })
+})