@api-client/core 0.14.9 → 0.15.0

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

@@ -12,7 +12,6 @@ import {
   DomainEntity,
   DomainProperty,
   DomainAssociation,
-  DataDomainKind,
 } from '../../../src/index.js'
 
 test.group('DomainImpactAnalysis', (group) => {
@@ -450,112 +449,3 @@ 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/domain_validation.spec.ts

@@ -0,0 +1,94 @@
+import { test } from '@japa/runner'
+import { DomainValidation } from '../../../src/modeling/DomainValidation.js'
+import { DataDomain, DataDomainKind } from '../../../src/index.js'
+import { SemanticType } from '../../../src/modeling/Semantics.js'
+
+test.group('DomainImpactAnalysis.validate()', (group) => {
+  let domain: DataDomain
+  let analysis: DomainValidation
+
+  group.each.setup(() => {
+    domain = new DataDomain()
+    analysis = new DomainValidation(domain)
+  })
+
+  test('validate() should return an empty report when the domain is empty', ({ assert }) => {
+    const report = analysis.validate()
+    assert.deepEqual(report, {
+      key: '',
+      kind: DataDomainKind,
+      impact: [],
+      canProceed: true,
+    })
+  })
+
+  test('validate() should return validation errors for entities', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    model.addEntity({ key: 'entity', info: { name: 'Invalid-Name' } }) // Invalid name
+
+    const report = analysis.validate()
+    assert.lengthOf(report.impact, 8)
+    // we test specific rules in the validation tests
+  })
+
+  test('validate() should return validation errors for properties', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity = model.addEntity({ key: 'entity', info: { name: 'entity' } })
+    entity.addProperty({ key: 'invalid-property', type: 'string', info: { name: 'invalid-property' } })
+
+    const report = analysis.validate()
+    assert.lengthOf(report.impact, 6)
+    // we test specific rules in the validation tests
+  })
+
+  test('validate() 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' } })
+    entity1.addAssociation({ key: entity2.key }, { info: { name: 'Invalid-Name' } })
+
+    const report = analysis.validate()
+    assert.lengthOf(report.impact, 12)
+    // we test specific rules in the validation tests
+  })
+
+  test('validate() 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.validate()
+    assert.lengthOf(report.impact, 16)
+    // we test specific rules in the validation tests
+  })
+
+  test('validate() 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' } })
+    const p3e2 = entity2.addProperty({ key: 'p3', type: 'number', info: { name: 'property3' } })
+    entity2.addProperty({ key: 'p4', type: 'string', primary: true, info: { name: 'property4' } })
+    const p5e2 = entity2.addProperty({ key: 'p5', type: 'number', info: { name: 'property5' } })
+    const p6e2 = entity2.addProperty({ key: 'p6', type: 'number', info: { name: 'property6' } })
+    entity1.addAssociation({ key: entity2.key }, { info: { name: 'name' } })
+    const p3e1 = entity1.addProperty({ type: 'number', info: { name: 'p3e1' } })
+    const p4e1 = entity1.addProperty({ type: 'number', info: { name: 'p4e1' } })
+    const p5e1 = entity1.addProperty({ type: 'boolean', info: { name: 'p5e1' } })
+
+    entity1.addSemantic({ id: SemanticType.User })
+    p3e2.addSemantic({ id: SemanticType.CreatedTimestamp })
+    p5e2.addSemantic({ id: SemanticType.UpdatedTimestamp })
+    p6e2.addSemantic({ id: SemanticType.DeletedTimestamp })
+    p3e1.addSemantic({ id: SemanticType.CreatedTimestamp })
+    p4e1.addSemantic({ id: SemanticType.UpdatedTimestamp })
+    p5e1.addSemantic({ id: SemanticType.DeletedFlag })
+
+    const report = analysis.validate()
+    assert.lengthOf(report.impact, 0)
+    assert.equal(report.canProceed, true)
+  })
+})

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

@@ -0,0 +1,91 @@
+import { test } from '@japa/runner'
+import { DataDomain } from '../../../../src/modeling/DataDomain.js'
+import { SemanticValidation } from '../../../../src/modeling/validation/semantic_validation.js'
+import { SemanticType } from '../../../../src/modeling/Semantics.js'
+
+test.group('SemanticValidation', (group) => {
+  let domain: DataDomain
+  let validation: SemanticValidation
+
+  group.each.setup(() => {
+    domain = new DataDomain()
+    validation = new SemanticValidation(domain)
+  })
+
+  test('validate() should return a warning when no User entity is found', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    model.addEntity({ key: 'entity', info: { name: 'Entity' } })
+    const results = validation.validate()
+    assert.lengthOf(results, 4) // Warning for User + 2 info for timestamps + info for soft delete
+    assert.equal(results[0].rule, 'recommended')
+    assert.equal(results[0].severity, 'warning')
+    assert.equal(results[0].message, 'No entity with User taxonomy found in the domain.')
+  })
+
+  test('validate() should not return a warning when a User entity is found', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity = model.addEntity({ key: 'user', info: { name: 'User' } })
+    entity.addSemantic({ id: SemanticType.User })
+    const results = validation.validate()
+    assert.lengthOf(results, 3) // Only info for timestamps (2) and soft delete
+    assert.notEqual(results[0].message, 'No entity with User taxonomy found in the domain.')
+  })
+
+  test('validate() should return info when an entity has no timestamp taxonomy', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    model.addEntity({ key: 'entity', info: { name: 'Entity' } })
+    const results = validation.validate()
+    assert.lengthOf(results, 4)
+    const timestampResults = results.filter(
+      (r) => r.message.includes('CreatedTimestamp') || r.message.includes('UpdatedTimestamp')
+    )
+    assert.lengthOf(timestampResults, 2)
+    assert.equal(timestampResults[0].severity, 'info')
+    assert.equal(timestampResults[1].severity, 'info')
+  })
+
+  test('validate() should not return info when an entity has timestamp taxonomy', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity = model.addEntity({ key: 'entity', info: { name: 'Entity' } })
+    const createdProperty = entity.addProperty({
+      key: 'created_at',
+      type: 'datetime',
+      info: { name: 'created_at' },
+    })
+    const updatedProperty = entity.addProperty({
+      key: 'updated_at',
+      type: 'datetime',
+      info: { name: 'updated_at' },
+    })
+    createdProperty.addSemantic({ id: SemanticType.CreatedTimestamp })
+    updatedProperty.addSemantic({ id: SemanticType.UpdatedTimestamp })
+    const results = validation.validate()
+    const timestampResults = results.filter(
+      (r) => r.message.includes('CreatedTimestamp') || r.message.includes('UpdatedTimestamp')
+    )
+    assert.lengthOf(timestampResults, 0)
+  })
+
+  test('validate() should return info when an entity has no soft delete taxonomy', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    model.addEntity({ key: 'entity', info: { name: 'Entity' } })
+    const results = validation.validate()
+    const softDeleteResults = results.filter((r) => r.message.includes('soft delete taxonomy'))
+    assert.lengthOf(softDeleteResults, 1)
+    assert.equal(softDeleteResults[0].severity, 'info')
+  })
+
+  test('validate() should not return info when an entity has soft delete taxonomy', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity = model.addEntity({ key: 'entity', info: { name: 'Entity' } })
+    const deletedProperty = entity.addProperty({
+      key: 'deleted_at',
+      type: 'datetime',
+      info: { name: 'deleted_at' },
+    })
+    deletedProperty.addSemantic({ id: SemanticType.DeletedTimestamp })
+    const results = validation.validate()
+    const softDeleteResults = results.filter((r) => r.message.includes('soft delete taxonomy'))
+    assert.lengthOf(softDeleteResults, 0)
+  })
+})