@api-client/core 0.14.10 → 0.15.0

package/tests/unit/events/telemetry.spec.ts

@@ -0,0 +1,224 @@
+import { test } from '@japa/runner'
+import sinon from 'sinon'
+import { EventTypes } from '../../../src/events/EventTypes.js'
+import { Events } from '../../../src/events/Events.js'
+import { ensureUnique } from './EventsTestHelpers.js'
+import './events_polyfills.js'
+
+test.group('Events > Telemetry > EventTypes.Telemetry', () => {
+  test('has the namespace', ({ assert }) => {
+    assert.typeOf(EventTypes.Telemetry, 'object')
+  })
+
+  test('has "{prop}" property')
+    .with([
+      { prop: 'view', value: 'telemetryscreenview' },
+      { prop: 'event', value: 'telemetryevent' },
+      { prop: 'exception', value: 'telemetryexception' },
+      { prop: 'social', value: 'telemetrysocial' },
+      { prop: 'timing', value: 'telemetrytiming' },
+    ])
+    .run(({ assert }, { prop, value }) => {
+      // @ts-expect-error Used in testing
+      assert.equal(EventTypes.Telemetry[prop], value)
+    })
+
+  test('has unique events for the namespace', () => {
+    ensureUnique('EventTypes.Telemetry', EventTypes.Telemetry)
+  })
+})
+
+test.group('Events > Telemetry > Events.Telemetry > view()', () => {
+  const screenName = 'test-screen'
+
+  test('dispatches the event', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Telemetry.view, spy)
+    Events.Telemetry.view(screenName)
+    globalThis.removeEventListener(EventTypes.Telemetry.view, spy)
+    assert.isTrue(spy.calledOnce)
+  })
+
+  test('the event has screen name on the detail', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Telemetry.view, spy)
+    Events.Telemetry.view(screenName)
+    globalThis.removeEventListener(EventTypes.Telemetry.view, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.equal(e.detail.screenName, screenName)
+  })
+
+  test('the event has the custom configuration', async ({ assert }) => {
+    const spy = sinon.spy()
+    const custom = {
+      customMetrics: [{ index: 1, value: 1 }],
+      customDimensions: [{ index: 1, value: 'test' }],
+    }
+    globalThis.addEventListener(EventTypes.Telemetry.view, spy)
+    Events.Telemetry.view(screenName, undefined, custom)
+    globalThis.removeEventListener(EventTypes.Telemetry.view, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.deepEqual(e.detail.customMetrics, custom.customMetrics, 'has customMetrics')
+    assert.deepEqual(e.detail.customDimensions, custom.customDimensions, 'has customDimensions')
+  })
+})
+
+test.group('Events > Telemetry > Events.Telemetry > event()', () => {
+  const init = {
+    category: 'e-cat',
+    action: 'e-act',
+    label: 'e-label',
+    value: 1,
+  }
+
+  test('dispatches the event', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Telemetry.event, spy)
+    Events.Telemetry.event(init)
+    globalThis.removeEventListener(EventTypes.Telemetry.event, spy)
+    assert.isTrue(spy.calledOnce)
+  })
+
+  test('the event has the detail object', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Telemetry.event, spy)
+    Events.Telemetry.event(init)
+    globalThis.removeEventListener(EventTypes.Telemetry.event, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.deepEqual(e.detail, init)
+  })
+})
+
+test.group('Events > Telemetry > Events.Telemetry > exception()', () => {
+  const description = 'event-exception'
+  const fatal = true
+
+  test('dispatches the event', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Telemetry.exception, spy)
+    Events.Telemetry.exception(description)
+    globalThis.removeEventListener(EventTypes.Telemetry.exception, spy)
+    assert.isTrue(spy.calledOnce)
+  })
+
+  test('the event has the description', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Telemetry.exception, spy)
+    Events.Telemetry.exception(description)
+    globalThis.removeEventListener(EventTypes.Telemetry.exception, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.equal(e.detail.description, description)
+  })
+
+  test('the event has the fatal', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Telemetry.exception, spy)
+    Events.Telemetry.exception(description, fatal)
+    globalThis.removeEventListener(EventTypes.Telemetry.exception, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.equal(e.detail.fatal, fatal)
+  })
+
+  test('the event has custom configuration', async ({ assert }) => {
+    const spy = sinon.spy()
+    const custom = {
+      customMetrics: [{ index: 1, value: 1 }],
+      customDimensions: [{ index: 1, value: 'test' }],
+    }
+    globalThis.addEventListener(EventTypes.Telemetry.exception, spy)
+    Events.Telemetry.exception(description, fatal, undefined, custom)
+    globalThis.removeEventListener(EventTypes.Telemetry.exception, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.deepEqual(e.detail.customMetrics, custom.customMetrics, 'has customMetrics')
+    assert.deepEqual(e.detail.customDimensions, custom.customDimensions, 'has customDimensions')
+  })
+})
+
+test.group('Events > Telemetry > Events.Telemetry > social()', () => {
+  const init = {
+    network: 'e-network',
+    action: 'e-action',
+    target: 'e-target',
+  }
+
+  test('dispatches the event', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Telemetry.social, spy)
+    Events.Telemetry.social(init.network, init.action, init.target)
+    globalThis.removeEventListener(EventTypes.Telemetry.social, spy)
+    assert.isTrue(spy.calledOnce)
+  })
+
+  test('the event has the detail object', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Telemetry.social, spy)
+    Events.Telemetry.social(init.network, init.action, init.target)
+    globalThis.removeEventListener(EventTypes.Telemetry.social, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.deepEqual(e.detail, init)
+  })
+
+  test('the event has custom configuration', async ({ assert }) => {
+    const spy = sinon.spy()
+    const custom = {
+      customMetrics: [{ index: 1, value: 1 }],
+      customDimensions: [{ index: 1, value: 'test' }],
+    }
+    globalThis.addEventListener(EventTypes.Telemetry.social, spy)
+    Events.Telemetry.social(init.network, init.action, init.target, undefined, custom)
+    globalThis.removeEventListener(EventTypes.Telemetry.social, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.deepEqual(e.detail.customMetrics, custom.customMetrics, 'has customMetrics')
+    assert.deepEqual(e.detail.customDimensions, custom.customDimensions, 'has customDimensions')
+  })
+})
+
+test.group('Events > Telemetry > Events.Telemetry > timing()', () => {
+  const init = {
+    category: 'e-category',
+    variable: 'e-variable',
+    value: 100,
+    label: 'e-label',
+  }
+
+  test('dispatches the event', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Telemetry.timing, spy)
+    Events.Telemetry.timing(init.category, init.variable, init.value, init.label)
+    globalThis.removeEventListener(EventTypes.Telemetry.timing, spy)
+    assert.isTrue(spy.calledOnce)
+  })
+
+  test('the event has the detail object', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Telemetry.timing, spy)
+    Events.Telemetry.timing(init.category, init.variable, init.value, init.label)
+    globalThis.removeEventListener(EventTypes.Telemetry.timing, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.deepEqual(e.detail, init)
+  })
+
+  test('the event has custom configuration', async ({ assert }) => {
+    const spy = sinon.spy()
+    const custom = {
+      customMetrics: [{ index: 1, value: 1 }],
+      customDimensions: [{ index: 1, value: 'test' }],
+    }
+    globalThis.addEventListener(EventTypes.Telemetry.timing, spy)
+    Events.Telemetry.timing(init.category, init.variable, init.value, init.label, undefined, custom)
+    globalThis.removeEventListener(EventTypes.Telemetry.timing, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.deepEqual(e.detail.customMetrics, custom.customMetrics, 'has customMetrics')
+    assert.deepEqual(e.detail.customDimensions, custom.customDimensions, 'has customDimensions')
+  })
+})
+
+test.group('Events > Telemetry > Events.Telemetry > State', () => {
+  test('set()', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Telemetry.State.set, spy)
+    Events.Telemetry.State.set()
+    globalThis.removeEventListener(EventTypes.Telemetry.State.set, spy)
+    assert.isTrue(spy.calledOnce)
+  })
+})

package/tests/unit/events/transport.spec.ts

@@ -0,0 +1,139 @@
+import { test } from '@japa/runner'
+import sinon from 'sinon'
+import { EventTypes } from '../../../src/events/EventTypes.js'
+import { Events } from '../../../src/events/Events.js'
+import { ensureUnique } from './EventsTestHelpers.js'
+import { IHttpRequest, HttpRequest, Kind as HttpRequestKind } from '../../../src/models/HttpRequest.js'
+import { Kind as HttpProjectKind } from '../../../src/models/HttpProject.js'
+import { IHttpRequestDetail } from '../../../src/events/transport/TransportEvents.js'
+import { IRequestProxyInit } from '../../../src/proxy/RequestProxy.js'
+import { ContextEventDetailWithResult } from '../../../src/events/BaseEvents.js'
+import { IHttpProjectProxyInit, IHttpProjectStoreProxyInit } from '../../../src/proxy/HttpProjectProxy.js'
+import './events_polyfills.js'
+
+test.group('Events > Transport > EventTypes.Transport.Core', () => {
+  test('has "{prop}" property')
+    .with([
+      ['request', 'transportcorerequest'],
+      ['httpProject', 'transportcorehttpproject'],
+    ])
+    .run(({ assert }, [prop, value]) => {
+      // @ts-expect-error Used in testing
+      assert.equal(EventTypes.Transport.Core[prop], value)
+    })
+
+  test('has unique events for the namespace', () => {
+    ensureUnique('EventTypes.Transport.Core', EventTypes.Transport.Core)
+  })
+})
+
+test.group('Events > Transport > EventTypes.Transport.Http', () => {
+  test('has "{prop}" property')
+    .with([['send', 'httptransportsend']])
+    .run(({ assert }, [prop, value]) => {
+      // @ts-expect-error Used in testing
+      assert.equal(EventTypes.Transport.Http[prop], value)
+    })
+
+  test('has unique events for the namespace', () => {
+    ensureUnique('EventTypes.Transport.Http', EventTypes.Transport.Http)
+  })
+})
+
+test.group('Events > Transport > EventTypes.Transport.Ws', () => {
+  test('has "{prop}" property')
+    .with([
+      ['connect', 'wstransportconnect'],
+      ['disconnect', 'wstransportdisconnect'],
+      ['send', 'wstransportsend'],
+    ])
+    .run(({ assert }, [prop, value]) => {
+      // @ts-expect-error Used in testing
+      assert.equal(EventTypes.Transport.Ws[prop], value)
+    })
+
+  test('has unique events for the namespace', () => {
+    ensureUnique('EventTypes.Transport.Ws', EventTypes.Transport.Ws)
+  })
+})
+
+test.group('Events > Transport > Events.Transport.Core > request()', () => {
+  const init: IRequestProxyInit = {
+    kind: HttpRequestKind,
+    request: new HttpRequest().toJSON(),
+  }
+
+  test('dispatches the event', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Transport.Core.request, spy)
+    await Events.Transport.Core.request(init)
+    globalThis.removeEventListener(EventTypes.Transport.Core.request, spy)
+    assert.isTrue(spy.calledOnce)
+  })
+
+  test('has the detail object', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Transport.Core.request, spy)
+    await Events.Transport.Core.request(init)
+    globalThis.removeEventListener(EventTypes.Transport.Core.request, spy)
+    const e = spy.args[0][0] as CustomEvent<ContextEventDetailWithResult<IRequestProxyInit>>
+    assert.deepEqual(e.detail, { ...init, result: undefined })
+  })
+})
+
+test.group('Events > Transport > Events.Transport.Core > httpProject()', () => {
+  const init: IHttpProjectStoreProxyInit = {
+    kind: HttpProjectKind,
+    pid: 'test-id',
+    options: { parallel: true },
+    organization: 'test-organization',
+  }
+
+  test('dispatches the event', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Transport.Core.httpProject, spy)
+    await Events.Transport.Core.httpProject(init)
+    globalThis.removeEventListener(EventTypes.Transport.Core.httpProject, spy)
+    assert.isTrue(spy.calledOnce)
+  })
+
+  test('has the detail object', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Transport.Core.httpProject, spy)
+    await Events.Transport.Core.httpProject(init)
+    globalThis.removeEventListener(EventTypes.Transport.Core.httpProject, spy)
+    const e = spy.args[0][0] as CustomEvent<ContextEventDetailWithResult<IHttpProjectProxyInit>>
+    assert.deepEqual(e.detail, { ...init, result: undefined })
+  })
+})
+
+test.group('Events > Transport > Events.Transport.Http > send()', () => {
+  const request: IHttpRequest = new HttpRequest().toJSON()
+  const init: RequestInit = { method: 'POST' }
+
+  test('dispatches the event', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Transport.Http.send, spy)
+    await Events.Transport.Http.send(request)
+    globalThis.removeEventListener(EventTypes.Transport.Http.send, spy)
+    assert.isTrue(spy.calledOnce)
+  })
+
+  test('has the request on the detail', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Transport.Http.send, spy)
+    await Events.Transport.Http.send(request)
+    globalThis.removeEventListener(EventTypes.Transport.Http.send, spy)
+    const e = spy.args[0][0] as CustomEvent<IHttpRequestDetail>
+    assert.equal(e.detail.request, request)
+  })
+
+  test('has the optional init on the detail', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Transport.Http.send, spy)
+    await Events.Transport.Http.send(request, init)
+    globalThis.removeEventListener(EventTypes.Transport.Http.send, spy)
+    const e = spy.args[0][0] as CustomEvent<IHttpRequestDetail>
+    assert.deepEqual(e.detail.init, init)
+  })
+})

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)
+  })
+})