@api-client/core 0.19.11 → 0.19.12

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@api-client/core",
   "description": "The API Client's core client library. Works in NodeJS and in a ES enabled browser.",
-  "version": "0.19.11",
+  "version": "0.19.12",
   "license": "UNLICENSED",
   "exports": {
     "./browser.js": {

package/src/modeling/ApiValidation.ts

@@ -0,0 +1,86 @@
+import { ApiModel } from './ApiModel.js'
+import { ApiModelValidationItem } from './types.js'
+import { ApiModelKind } from '../models/kinds.js'
+import {
+  validateApiModelInfo,
+  validateApiModelDependency,
+  validateApiModelSecurity,
+  validateApiModelMetadata,
+  validateExposedEntity,
+} from './validation/api_model_rules.js'
+
+/**
+ * ApiValidation performs comprehensive validation on an API model.
+ *
+ * This class orchestrates validation across all API model elements including
+ * info, security, exposures, and actions. It ensures that the API model is
+ * well-formed and follows established conventions before it can be published.
+ */
+export class ApiValidation {
+  report: ApiModelValidationItem[] = []
+  #infoCount = 0
+  #warningCount = 0
+  #errorCount = 0
+  #counted = false
+
+  get infoCount(): number {
+    if (!this.#counted) {
+      this.computeIssueCounters()
+    }
+    return this.#infoCount
+  }
+
+  get warningCount(): number {
+    if (!this.#counted) {
+      this.computeIssueCounters()
+    }
+    return this.#warningCount
+  }
+
+  get errorCount(): number {
+    if (!this.#counted) {
+      this.computeIssueCounters()
+    }
+    return this.#errorCount
+  }
+
+  constructor(protected model: ApiModel) {}
+
+  /**
+   * Performs comprehensive validation on the entire API model.
+   *
+   * @returns A comprehensive validation report with all issues found
+   */
+  validate(): ApiModelValidationItem[] {
+    this.#counted = false
+    this.report = []
+
+    this.report.push(...validateApiModelInfo(this.model))
+    this.report.push(...validateApiModelDependency(this.model))
+    this.report.push(...validateApiModelSecurity(this.model))
+    this.report.push(...validateApiModelMetadata(this.model))
+
+    if (!this.model.exposes || this.model.exposes.size === 0) {
+      this.report.push({
+        code: 'API_NO_EXPOSURES',
+        message: 'Your API currently has no exposed data for external clients to request.',
+        suggestion: 'Expose a data model so apps can communicate with it.',
+        severity: 'warning',
+        context: { apiModelKey: this.model.key, kind: ApiModelKind, key: this.model.key, property: 'exposes' },
+      })
+    } else {
+      for (const exposure of this.model.exposes.values()) {
+        this.report.push(...validateExposedEntity(exposure, this.model))
+      }
+    }
+
+    return this.report
+  }
+
+  computeIssueCounters(): void {
+    this.#infoCount = this.report.filter((validation) => validation.severity === 'info').length
+    this.#warningCount = this.report.filter((validation) => validation.severity === 'warning').length
+    this.#errorCount = this.report.filter((validation) => validation.severity === 'error').length
+    this.#counted = true
+  }
+}

package/src/modeling/DomainValidation.ts

@@ -1,9 +1,8 @@
-import { DataDomainKind } from '../models/kinds.js'
 import { DataDomain } from './DataDomain.js'
-import type { DomainImpactReport } from './types.js'
 import { AssociationValidation } from './validation/association_validation.js'
 import { EntityValidation } from './validation/entity_validation.js'
 import { PropertyValidation } from './validation/property_validation.js'
+import { DomainValidationSchema } from './validation/rules.js'
 import { SemanticValidation } from './validation/semantic_validation.js'
 
 /**
@@ -76,12 +75,35 @@ import { SemanticValidation } from './validation/semantic_validation.js'
  * @see {@link SemanticValidation} for detailed semantic validation rules
  */
 export class DomainValidation {
-  private root: DataDomain
+  report: DomainValidationSchema[] = []
+  #infoCount = 0
+  #warningCount = 0
+  #errorCount = 0
+  #counted = false
 
-  constructor(root: DataDomain) {
-    this.root = root
+  get infoCount(): number {
+    if (!this.#counted) {
+      this.computeIssueCounters()
+    }
+    return this.#infoCount
+  }
+
+  get warningCount(): number {
+    if (!this.#counted) {
+      this.computeIssueCounters()
+    }
+    return this.#warningCount
+  }
+
+  get errorCount(): number {
+    if (!this.#counted) {
+      this.computeIssueCounters()
+    }
+    return this.#errorCount
   }
 
+  constructor(protected domain: DataDomain) {}
+
   /**
    * Performs comprehensive validation on the entire data domain.
    *
@@ -91,93 +113,54 @@ export class DomainValidation {
    *
    * @returns A comprehensive validation report with all issues found
    */
-  validate(): DomainImpactReport {
-    const result: DomainImpactReport = {
-      key: '',
-      kind: DataDomainKind,
-      impact: [],
-      canProceed: true,
-    }
-    const entityValidator = new EntityValidation(this.root)
-    const propertyValidator = new PropertyValidation(this.root)
-    const associationValidator = new AssociationValidation(this.root)
-    const semanticValidator = new SemanticValidation(this.root)
+  validate(): DomainValidationSchema[] {
+    this.#counted = false
+    this.report = []
+    const entityValidator = new EntityValidation(this.domain)
+    const propertyValidator = new PropertyValidation(this.domain)
+    const associationValidator = new AssociationValidation(this.domain)
+    const semanticValidator = new SemanticValidation(this.domain)
 
     let hasEntities = false
-    // Validate entities, properties, and associations
-    for (const entity of this.root.listEntities()) {
-      if (entity.domain.key !== this.root.key) {
+    for (const entity of this.domain.listEntities()) {
+      if (entity.domain.key !== this.domain.key) {
         // we don't need to validate foreign entities
         continue
       }
       hasEntities = true
-      const report = entityValidator.validate(entity)
-      for (const item of report) {
-        const blocking = item.severity === 'error'
-        result.canProceed = result.canProceed && !blocking
-        result.impact.push({
-          key: item.key,
-          kind: item.kind,
-          type: 'publish',
-          impact: item.message,
-          resolution: item.help,
-          severity: item.severity,
-          parent: item.parent,
-        })
-      }
+      const entities = entityValidator.validate(entity)
+      this.report.push(...entities)
       for (const property of entity.properties) {
-        const report = propertyValidator.validate(property)
-        for (const item of report) {
-          const blocking = item.severity === 'error'
-          result.canProceed = result.canProceed && !blocking
-          result.impact.push({
-            key: item.key,
-            kind: item.kind,
-            type: 'publish',
-            impact: item.message,
-            resolution: item.help,
-            severity: item.severity,
-            parent: item.parent,
-          })
+        if (property.domain.key !== this.domain.key) {
+          // we don't need to validate foreign properties
+          continue
         }
+        const properties = propertyValidator.validate(property)
+        this.report.push(...properties)
       }
       for (const association of entity.associations) {
-        const report = associationValidator.validate(association)
-        for (const item of report) {
-          const blocking = item.severity === 'error'
-          result.canProceed = result.canProceed && !blocking
-          result.impact.push({
-            key: item.key,
-            kind: item.kind,
-            type: 'publish',
-            impact: item.message,
-            resolution: item.help,
-            severity: item.severity,
-            parent: item.parent,
-          })
+        if (association.domain.key !== this.domain.key) {
+          // we don't need to validate foreign properties
+          continue
         }
+        const associations = associationValidator.validate(association)
+        this.report.push(...associations)
       }
     }
     if (!hasEntities) {
       // no entities, no need to validate anything else
-      return result
+      return this.report
     }
     // Validate semantics
     const semanticReport = semanticValidator.validate()
-    for (const item of semanticReport) {
-      const blocking = item.severity === 'error'
-      result.canProceed = result.canProceed && !blocking
-      result.impact.push({
-        key: item.key,
-        kind: item.kind,
-        type: 'publish',
-        impact: item.message,
-        resolution: item.help,
-        severity: item.severity,
-        parent: item.parent,
-      })
-    }
+    this.report.push(...semanticReport)
+    return this.report
+  }
 
-    return result
+  computeIssueCounters(): void {
+    this.#infoCount = this.report.filter((validation) => validation.severity === 'info').length
+    this.#warningCount = this.report.filter((validation) => validation.severity === 'warning').length
+    this.#errorCount = this.report.filter((validation) => validation.severity === 'error').length
+    this.#counted = true
   }
 }

package/src/modeling/validation/api_model_rules.ts

@@ -6,7 +6,7 @@ import { DeleteAction } from '../actions/DeleteAction.js'
 import { UpdateAction } from '../actions/UpdateAction.js'
 import { SearchAction } from '../actions/SearchAction.js'
 import type { RolesBasedAccessControl, UsernamePasswordConfiguration } from '../types.js'
-import type { ApiModelValidationItem, ApiModelValidationResult, ApiModelValidationContext } from '../types.js'
+import type { ApiModelValidationItem, ApiModelValidationContext } from '../types.js'
 import { ApiModelKind, ExposedEntityKind } from '../../models/kinds.js'
 import { SemanticType } from '../Semantics.js'
 
@@ -608,33 +608,3 @@ export function validateExposedEntity(entity: ExposedEntity, apiModel: ApiModel)
 
   return issues
 }
-
-export function validateApiModel(model: ApiModel): ApiModelValidationResult {
-  const issues: ApiModelValidationItem[] = []
-
-  issues.push(...validateApiModelInfo(model))
-  issues.push(...validateApiModelDependency(model))
-  issues.push(...validateApiModelSecurity(model))
-  issues.push(...validateApiModelMetadata(model))
-
-  if (!model.exposes || model.exposes.size === 0) {
-    issues.push({
-      code: createCode('API', 'NO_EXPOSURES'),
-      message: 'Your API currently has no exposed data for external clients to request.',
-      suggestion: 'Expose a data model so apps can communicate with it.',
-      severity: 'warning',
-      context: { apiModelKey: model.key, kind: ApiModelKind, key: model.key, property: 'exposes' },
-    })
-  } else {
-    for (const exposure of model.exposes.values()) {
-      issues.push(...validateExposedEntity(exposure, model))
-    }
-  }
-
-  const hasErrors = issues.some((i) => i.severity === 'error')
-
-  return {
-    isValid: !hasErrors,
-    issues,
-  }
-}

package/src/modeling/validation/association_validation.ts

@@ -2,7 +2,7 @@ import { DomainAssociationKind } from '../../models/kinds.js'
 import type { DataDomain } from '../DataDomain.js'
 import type { DomainAssociation } from '../DomainAssociation.js'
 import type { DomainEntity } from '../DomainEntity.js'
-import { type DomainValidation, validatePropertyName } from './rules.js'
+import { type DomainValidationSchema, validatePropertyName } from './rules.js'
 
 /**
  * AssociationValidation is a class that performs validation on associations in a data domain.
@@ -16,8 +16,8 @@ export class AssociationValidation {
    * @param target The target association to validate. Can be a string with
    *               the association key or a DomainAssociation object.
    */
-  validate(target: string | DomainAssociation): DomainValidation[] {
-    const results: DomainValidation[] = []
+  validate(target: string | DomainAssociation): DomainValidationSchema[] {
+    const results: DomainValidationSchema[] = []
     let association: DomainAssociation | undefined
     if (typeof target === 'string') {
       association = this.domain.findAssociation(target)
@@ -58,7 +58,7 @@ export class AssociationValidation {
    *   - (recommendation) Column names should be in lower case.
    * @param association The association to validate
    */
-  validateName(association: DomainAssociation): DomainValidation[] {
+  validateName(association: DomainAssociation): DomainValidationSchema[] {
     return validatePropertyName(association)
   }
 
@@ -66,8 +66,8 @@ export class AssociationValidation {
    * Validates the association targets.
    * @param association The association to validate
    */
-  validateTargets(association: DomainAssociation): DomainValidation[] {
-    const results: DomainValidation[] = []
+  validateTargets(association: DomainAssociation): DomainValidationSchema[] {
+    const results: DomainValidationSchema[] = []
     const label = association.info.getLabel()
     const parentEntity = association.getParentInstance() as DomainEntity
     if (!association.targets.length) {

package/src/modeling/validation/entity_validation.ts

@@ -2,7 +2,7 @@ import { DomainEntityKind } from '../../models/kinds.js'
 import type { DataDomain } from '../DataDomain.js'
 import type { DomainEntity } from '../DomainEntity.js'
 import { ReservedKeywords } from './postgresql.js'
-import type { DomainValidation } from './rules.js'
+import type { DomainValidationSchema } from './rules.js'
 
 /**
  * EntityValidation is a class that performs validation on entities in a data domain.
@@ -20,8 +20,8 @@ export class EntityValidation {
    * @param target The target entity to validate. Can be a string with
    *               the entity key or a DomainEntity object.
    */
-  validate(target: string | DomainEntity): DomainValidation[] {
-    const results: DomainValidation[] = []
+  validate(target: string | DomainEntity): DomainValidationSchema[] {
+    const results: DomainValidationSchema[] = []
     let entity: DomainEntity | undefined
     if (typeof target === 'string') {
       entity = this.domain.findEntity(target)
@@ -57,8 +57,8 @@ export class EntityValidation {
    * Validates the entity primary key.
    * @param entity The entity to validate
    */
-  validatePrimaryKey(entity: DomainEntity): DomainValidation[] {
-    const results: DomainValidation[] = []
+  validatePrimaryKey(entity: DomainEntity): DomainValidationSchema[] {
+    const results: DomainValidationSchema[] = []
     const primary = entity.primaryKey()
     if (!primary) {
       const message = `The "${entity.info.getLabel()}" entity has no identifier.`
@@ -124,8 +124,8 @@ export class EntityValidation {
    * Checks if the entity has the minimum required properties.
    * @param entity The entity to validate
    */
-  minimumRequiredProperties(entity: DomainEntity): DomainValidation[] {
-    const results: DomainValidation[] = []
+  minimumRequiredProperties(entity: DomainEntity): DomainValidationSchema[] {
+    const results: DomainValidationSchema[] = []
 
     // Check if entity has properties or associations through entire inheritance chain
     const hasProperties = this.hasPropertiesInherited(entity)
@@ -161,8 +161,8 @@ export class EntityValidation {
    *   - Should not be a reserved word (for example: "IN", "SELECT", "FROM", etc.).
    * @param entity The entity to validate
    */
-  validateName(entity: DomainEntity): DomainValidation[] {
-    const results: DomainValidation[] = []
+  validateName(entity: DomainEntity): DomainValidationSchema[] {
+    const results: DomainValidationSchema[] = []
     const label = entity.info.getLabel()
     if (!entity.info.name) {
       const message = `The "${label}" entity has no name.`
@@ -252,8 +252,8 @@ export class EntityValidation {
    * Checks if the entity name is unique in the data domain.
    * @param entity The entity to validate
    */
-  uniqueName(entity: DomainEntity): DomainValidation[] {
-    const results: DomainValidation[] = []
+  uniqueName(entity: DomainEntity): DomainValidationSchema[] {
+    const results: DomainValidationSchema[] = []
     const name = entity.info.name?.toLowerCase()
     if (!name) {
       return results

package/src/modeling/validation/property_validation.ts

@@ -1,7 +1,7 @@
 import { DomainPropertyKind } from '../../models/kinds.js'
 import type { DataDomain } from '../DataDomain.js'
 import type { DomainProperty } from '../DomainProperty.js'
-import { type DomainValidation, validatePropertyName } from './rules.js'
+import { type DomainValidationSchema, validatePropertyName } from './rules.js'
 
 export class PropertyValidation {
   constructor(protected domain: DataDomain) {}
@@ -12,8 +12,8 @@ export class PropertyValidation {
    * @param target The target property to validate. Can be a string with
    *               the property key or a DomainProperty object.
    */
-  validate(target: string | DomainProperty): DomainValidation[] {
-    const results: DomainValidation[] = []
+  validate(target: string | DomainProperty): DomainValidationSchema[] {
+    const results: DomainValidationSchema[] = []
     let property: DomainProperty | undefined
     if (typeof target === 'string') {
       property = this.domain.findProperty(target)
@@ -52,7 +52,7 @@ export class PropertyValidation {
    *   - (recommendation) Column names should be in lower case.
    * @param property The property to validate
    */
-  validateName(property: DomainProperty): DomainValidation[] {
+  validateName(property: DomainProperty): DomainValidationSchema[] {
     return validatePropertyName(property)
   }
 }

package/src/modeling/validation/rules.ts

@@ -12,7 +12,10 @@ import { DomainPropertyKind } from '../../models/kinds.js'
  * - `type` -> unused
  * - `relationship` -> unused
  */
-export interface DomainValidation extends Omit<DomainImpactItem, 'type' | 'impact' | 'relationship' | 'resolution'> {
+export interface DomainValidationSchema extends Omit<
+  DomainImpactItem,
+  'type' | 'impact' | 'relationship' | 'resolution'
+> {
   /**
    * The field that did not pass validation.
    */
@@ -55,8 +58,8 @@ export interface DomainValidation extends Omit<DomainImpactItem, 'type' | 'impac
  *
  * @param property The property to validate
  */
-export function validatePropertyName(property: DomainProperty | DomainAssociation): DomainValidation[] {
-  const results: DomainValidation[] = []
+export function validatePropertyName(property: DomainProperty | DomainAssociation): DomainValidationSchema[] {
+  const results: DomainValidationSchema[] = []
   const label = property.info.getLabel()
   const parentEntity = property.getParentInstance() as DomainEntity
   const type = property.kind === DomainPropertyKind ? 'property' : 'association'

package/src/modeling/validation/semantic_validation.ts

@@ -1,7 +1,7 @@
 import { DomainEntityKind } from '../../models/kinds.js'
 import type { DataDomain } from '../DataDomain.js'
 import { DataSemantics, isPropertySemantic, SemanticType } from '../Semantics.js'
-import type { DomainValidation } from './rules.js'
+import type { DomainValidationSchema } from './rules.js'
 
 /**
  * SemanticValidation is a class that performs validation on semantics in a data domain.
@@ -14,8 +14,8 @@ export class SemanticValidation {
    * Performs all the semantic validation rules on the domain.
    * @returns The list of validation messages.
    */
-  validate(): DomainValidation[] {
-    const results: DomainValidation[] = []
+  validate(): DomainValidationSchema[] {
+    const results: DomainValidationSchema[] = []
 
     // Check for User entity semantic
     const hasUserEntity = this.validateUserEntity()
@@ -40,8 +40,8 @@ export class SemanticValidation {
    * Validates if there is at least one entity with the User semantic.
    * This is a recommended semantic for authentication purposes.
    */
-  private validateUserEntity(): DomainValidation[] {
-    const results: DomainValidation[] = []
+  private validateUserEntity(): DomainValidationSchema[] {
+    const results: DomainValidationSchema[] = []
     let hasUserEntity = false
 
     for (const entity of this.domain.listEntities()) {
@@ -70,8 +70,8 @@ export class SemanticValidation {
    * Validates if entities have the recommended timestamp semantics.
    * This includes CreatedTimestamp and UpdatedTimestamp.
    */
-  private validateTimestampSemantics(): DomainValidation[] {
-    const results: DomainValidation[] = []
+  private validateTimestampSemantics(): DomainValidationSchema[] {
+    const results: DomainValidationSchema[] = []
 
     for (const entity of this.domain.listEntities()) {
       let hasCreatedTimestamp = false
@@ -118,8 +118,8 @@ export class SemanticValidation {
    * Validates if entities have the recommended soft delete semantics.
    * This includes either DeletedTimestamp or DeletedFlag.
    */
-  private validateSoftDeleteSemantics(): DomainValidation[] {
-    const results: DomainValidation[] = []
+  private validateSoftDeleteSemantics(): DomainValidationSchema[] {
+    const results: DomainValidationSchema[] = []
 
     for (const entity of this.domain.listEntities()) {
       let hasSoftDelete = false
@@ -150,8 +150,8 @@ export class SemanticValidation {
   /**
    * Validates if property semantics are applied to properties with compatible data types.
    */
-  private validatePropertySemanticsDataTypes(): DomainValidation[] {
-    const results: DomainValidation[] = []
+  private validatePropertySemanticsDataTypes(): DomainValidationSchema[] {
+    const results: DomainValidationSchema[] = []
 
     for (const entity of this.domain.listEntities()) {
       for (const property of entity.listProperties()) {

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

@@ -1,6 +1,6 @@
 import { test } from '@japa/runner'
 import { DomainValidation } from '../../../src/modeling/DomainValidation.js'
-import { DataDomain, DataDomainKind } from '../../../src/index.js'
+import { DataDomain } from '../../../src/index.js'
 import { SemanticType } from '../../../src/modeling/Semantics.js'
 
 test.group('DomainImpactAnalysis.validate()', (group) => {
@@ -14,12 +14,7 @@ test.group('DomainImpactAnalysis.validate()', (group) => {
 
   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,
-    })
+    assert.deepEqual(report, [])
   })
 
   test('validate() should return validation errors for entities', ({ assert }) => {
@@ -27,7 +22,7 @@ test.group('DomainImpactAnalysis.validate()', (group) => {
     model.addEntity({ key: 'entity', info: { name: 'Invalid-Name' } }) // Invalid name
 
     const report = analysis.validate()
-    assert.lengthOf(report.impact, 8)
+    assert.lengthOf(report, 8)
     // we test specific rules in the validation tests
   })
 
@@ -37,7 +32,7 @@ test.group('DomainImpactAnalysis.validate()', (group) => {
     entity.addProperty({ key: 'invalid-property', type: 'string', info: { name: 'invalid-property' } })
 
     const report = analysis.validate()
-    assert.lengthOf(report.impact, 6)
+    assert.lengthOf(report, 6)
     // we test specific rules in the validation tests
   })
 
@@ -48,7 +43,7 @@ test.group('DomainImpactAnalysis.validate()', (group) => {
     entity1.addAssociation({ targets: [{ key: entity2.key }], info: { name: 'Invalid-Name' } })
 
     const report = analysis.validate()
-    assert.lengthOf(report.impact, 12)
+    assert.lengthOf(report, 12)
     // we test specific rules in the validation tests
   })
 
@@ -60,7 +55,7 @@ test.group('DomainImpactAnalysis.validate()', (group) => {
     entity1.addAssociation({ targets: [{ key: entity2.key }], info: { name: 'Invalid-Name' } })
 
     const report = analysis.validate()
-    assert.lengthOf(report.impact, 16)
+    assert.lengthOf(report, 16)
     // we test specific rules in the validation tests
   })
 
@@ -88,7 +83,6 @@ test.group('DomainImpactAnalysis.validate()', (group) => {
     p5e1.addSemantic({ id: SemanticType.DeletedFlag })
 
     const report = analysis.validate()
-    assert.lengthOf(report.impact, 0)
-    assert.equal(report.canProceed, true)
+    assert.lengthOf(report, 0)
   })
 })

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

@@ -9,8 +9,8 @@ import {
   validateApiModelMetadata,
   validateExposedEntity,
   validateAction,
-  validateApiModel,
 } from '../../../../src/modeling/validation/api_model_rules.js'
+import { ApiValidation } from '../../../../src/modeling/ApiValidation.js'
 import { ExposedEntity } from '../../../../src/modeling/ExposedEntity.js'
 import { ListAction } from '../../../../src/modeling/actions/ListAction.js'
 import { DeleteAction } from '../../../../src/modeling/actions/DeleteAction.js'
@@ -305,9 +305,10 @@ test.group('ApiModel Validation', () => {
       },
       domain
     )
-    const result = validateApiModel(model)
-    assert.isTrue(result.isValid)
-    assert.isEmpty(result.issues.filter((i) => i.severity === 'error'))
+    const validator = new ApiValidation(model)
+    const report = validator.validate()
+    assert.equal(validator.errorCount, 0)
+    assert.isEmpty(report.filter((i) => i.severity === 'error'))
   })
 
   test('validateApiModel - fails on multiple errors', ({ assert }) => {
@@ -315,10 +316,11 @@ test.group('ApiModel Validation', () => {
       info: { name: '' },
     })
     // Now it's missing name, missing domain, missing security context, missing contact.
-    const result = validateApiModel(model)
-    assert.isFalse(result.isValid)
-    assert.isTrue(result.issues.some((i) => i.code === 'API_MISSING_NAME'))
-    assert.isTrue(result.issues.some((i) => i.code === 'API_MISSING_DOMAIN'))
-    assert.isTrue(result.issues.some((i) => i.code === 'API_MISSING_AUTHENTICATION'))
+    const validator = new ApiValidation(model)
+    const report = validator.validate()
+    assert.isAbove(validator.errorCount, 0)
+    assert.isTrue(report.some((i) => i.code === 'API_MISSING_NAME'))
+    assert.isTrue(report.some((i) => i.code === 'API_MISSING_DOMAIN'))
+    assert.isTrue(report.some((i) => i.code === 'API_MISSING_AUTHENTICATION'))
   })
 })