@api-client/core 0.19.28 → 0.19.29

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.28",
+  "version": "0.19.29",
   "license": "UNLICENSED",
   "exports": {
     "./browser.js": {

package/src/modeling/DomainEntity.ts

@@ -351,6 +351,39 @@ export class DomainEntity extends DomainElement {
     }
   }
 
+  /**
+   * Collects a list of all properties that affect this entity,
+   * including all inherited from parents properties as well as
+   * this entity's properties.
+   *
+   * The resulting list already accounts for a property override.
+   * A property overrides another property if it is lower in the
+   * inheritance chain. As such, a property defined on this entity
+   * always overrides previously defined entities.
+   * @returns The iterator over the list of all properties.
+   */
+  withInheritedProperties(): MapIterator<DomainProperty> {
+    const cache = new Map<string, DomainProperty>()
+    const parents = this.listAllParents('up')
+    for (const parent of parents) {
+      for (const prop of parent.properties) {
+        if (!prop.info.name) {
+          continue
+        }
+        // We want to override the previously set property
+        // so the last definition wins.
+        cache.set(prop.info.name, prop)
+      }
+    }
+    for (const prop of this.properties) {
+      if (!prop.info.name) {
+        continue
+      }
+      cache.set(prop.info.name, prop)
+    }
+    return cache.values()
+  }
+
   /**
    * Checks if this entity has any properties.
    *

package/src/modeling/validation/api_model_rules.ts

@@ -454,16 +454,19 @@ export function validateAction(action: Action, parent: ExposedEntity, apiModelKe
   return issues
 }
 
-export function validateExposedEntity(entity: ExposedEntity, apiModel: ApiModel): ApiModelValidationItem[] {
+export function validateExposedEntity(exposure: ExposedEntity, apiModel: ApiModel): ApiModelValidationItem[] {
   const issues: ApiModelValidationItem[] = []
   const context: ApiModelValidationContext = {
     apiModelKey: apiModel.key,
     kind: ExposedEntityKind,
-    key: entity.key,
+    key: exposure.key,
   }
 
+  const entity = exposure.entity ? apiModel.domain?.findEntity(exposure.entity.key, exposure.entity.domain) : undefined
+  const entityName = entity?.info.getLabel() || entity?.key || 'unknown'
+
   // Valid Entity Reference
-  if (!entity.entity || !entity.entity.key) {
+  if (!exposure.entity || !exposure.entity.key) {
     issues.push({
       code: createCode('EXPOSURE', 'MISSING_ENTITY_REF'),
       message: 'This exposed endpoint does not point to a specific data model.',
@@ -471,7 +474,7 @@ export function validateExposedEntity(entity: ExposedEntity, apiModel: ApiModel)
       severity: 'error',
       context: { ...context, property: 'entity' },
     })
-  } else if (apiModel.domain && !apiModel.domain.findEntity(entity.entity.key, entity.entity.domain)) {
+  } else if (!entity) {
     issues.push({
       code: createCode('EXPOSURE', 'INVALID_ENTITY_REF'),
       message: 'This endpoint points to a data model that no longer exists.',
@@ -482,21 +485,21 @@ export function validateExposedEntity(entity: ExposedEntity, apiModel: ApiModel)
   }
 
   // Path Integrity
-  if (entity.hasCollection) {
-    if (!entity.collectionPath) {
+  if (exposure.hasCollection) {
+    if (!exposure.collectionPath) {
       issues.push({
         code: createCode('EXPOSURE', 'MISSING_COLLECTION_PATH'),
-        message: 'When an endpoint exposes a collection, it must define what its base URL path is.',
+        message: `[${entityName}]: When an endpoint exposes a collection, it must define what its base URL path is.`,
         suggestion: 'Add a path (e.g., "/items").',
         severity: 'error',
         context: { ...context, property: 'collectionPath' },
       })
     } else {
-      const parts = entity.collectionPath.split('/').filter(Boolean)
-      if (parts.length !== 1 || !entity.collectionPath.startsWith('/')) {
+      const parts = exposure.collectionPath.split('/').filter(Boolean)
+      if (parts.length !== 1 || !exposure.collectionPath.startsWith('/')) {
         issues.push({
           code: createCode('EXPOSURE', 'INVALID_COLLECTION_PATH'),
-          message: 'The collection URL should start with "/" and have no extra slashes.',
+          message: `[${entityName}]: The collection URL should start with "/" and have no extra slashes.`,
           suggestion: `Ensure the path looks like exactly "/${parts[0] || 'subresource'}".`,
           severity: 'error',
           context: { ...context, property: 'collectionPath' },
@@ -504,41 +507,41 @@ export function validateExposedEntity(entity: ExposedEntity, apiModel: ApiModel)
       }
     }
 
-    if (!entity.resourcePath) {
+    if (!exposure.resourcePath) {
       issues.push({
         code: createCode('EXPOSURE', 'MISSING_RESOURCE_PATH'),
-        message: 'You need an identifier to locate single items.',
+        message: `[${entityName}]: You need an identifier to locate single items.`,
         suggestion: 'Specify the identification parameter format, like "{id}".',
         severity: 'error',
         context: { ...context, property: 'resourcePath' },
       })
-    } else if (entity.collectionPath) {
-      const colRegex = new RegExp(`^${entity.collectionPath}/\\{[a-zA-Z0-9_]+\\}$`)
-      if (!colRegex.test(entity.resourcePath)) {
+    } else if (exposure.collectionPath) {
+      const colRegex = new RegExp(`^${exposure.collectionPath}/\\{[a-zA-Z0-9_]+\\}$`)
+      if (!colRegex.test(exposure.resourcePath)) {
         issues.push({
           code: createCode('EXPOSURE', 'INVALID_RESOURCE_PATH_FORMAT'),
-          message: 'The single item route should match exactly your collection path plus one identifier variable.',
-          suggestion: `Make sure the item path is formatted exactly like "${entity.collectionPath}/{id}".`,
+          message: `[${entityName}]: The single item route should match exactly your collection path plus one identifier variable.`,
+          suggestion: `Make sure the item path is formatted exactly like "${exposure.collectionPath}/{id}".`,
           severity: 'error',
           context: { ...context, property: 'resourcePath' },
         })
       }
     }
   } else {
-    if (!entity.resourcePath) {
+    if (!exposure.resourcePath) {
       issues.push({
         code: createCode('EXPOSURE', 'MISSING_RESOURCE_PATH'),
-        message: 'Endpoints representing a single item must declare their URL route.',
+        message: `[${entityName}]: Exposed entity representing a single item must declare their URL route.`,
         suggestion: 'Set the URL path (such as "/profile").',
         severity: 'error',
         context: { ...context, property: 'resourcePath' },
       })
     } else {
-      const parts = entity.resourcePath.split('/').filter(Boolean)
-      if (parts.length !== 1 || !entity.resourcePath.startsWith('/')) {
+      const parts = exposure.resourcePath.split('/').filter(Boolean)
+      if (parts.length !== 1 || !exposure.resourcePath.startsWith('/')) {
         issues.push({
           code: createCode('EXPOSURE', 'INVALID_RESOURCE_PATH_FORMAT'),
-          message: 'The URL route must only contain one exact part or level.',
+          message: `[${entityName}]: The URL route ${exposure.resourcePath} must only contain one exact part or level.`,
           suggestion: 'Simplify the endpoint URL to a single segment.',
           severity: 'error',
           context: { ...context, property: 'resourcePath' },
@@ -548,13 +551,13 @@ export function validateExposedEntity(entity: ExposedEntity, apiModel: ApiModel)
   }
 
   // Path Collisions
-  if (entity.isRoot) {
-    if (entity.collectionPath) {
-      const collectionCollision = apiModel.findCollectionPathCollision(entity.collectionPath, entity.key)
+  if (exposure.isRoot) {
+    if (exposure.collectionPath) {
+      const collectionCollision = apiModel.findCollectionPathCollision(exposure.collectionPath, exposure.key)
       if (collectionCollision) {
         issues.push({
           code: createCode('EXPOSURE', 'ROOT_COLLECTION_COLLISION'),
-          message: `The route "${entity.collectionPath}" is already used by another view.`,
+          message: `[${entityName}]: The route "${exposure.collectionPath}" is already used by another view.`,
           suggestion: 'Give this resource a different path to avoid conflicts.',
           severity: 'error',
           context: { ...context, property: 'collectionPath' },
@@ -562,12 +565,12 @@ export function validateExposedEntity(entity: ExposedEntity, apiModel: ApiModel)
       }
     }
 
-    if (entity.resourcePath) {
-      const resourceCollision = apiModel.findResourcePathCollision(entity.resourcePath, entity.key)
+    if (exposure.resourcePath) {
+      const resourceCollision = apiModel.findResourcePathCollision(exposure.resourcePath, exposure.key)
       if (resourceCollision) {
         issues.push({
           code: createCode('EXPOSURE', 'ROOT_RESOURCE_COLLISION'),
-          message: `The route "${entity.resourcePath}" is already used by another view.`,
+          message: `[${entityName}]: The route "${exposure.resourcePath}" is already used by another one.`,
           suggestion: 'Give this single-item resource a different path to avoid conflicts.',
           severity: 'error',
           context: { ...context, property: 'resourcePath' },
@@ -577,10 +580,10 @@ export function validateExposedEntity(entity: ExposedEntity, apiModel: ApiModel)
   }
 
   // Minimum Actions
-  if (!entity.actions || entity.actions.length === 0) {
+  if (!exposure.actions || exposure.actions.length === 0) {
     issues.push({
       code: createCode('EXPOSURE', 'MISSING_ACTIONS'),
-      message: 'This exposed view does not let users do anything.',
+      message: `[${entityName}]: This exposed entity does not let users do anything.`,
       suggestion: 'Enable at least one operation like Create, Read, or Update.',
       severity: 'error',
       context: { ...context, property: 'actions' },
@@ -588,8 +591,8 @@ export function validateExposedEntity(entity: ExposedEntity, apiModel: ApiModel)
   } else {
     let hasSearch = false
     let hasList = false
-    for (const action of entity.actions) {
-      issues.push(...validateAction(action, entity, apiModel.key))
+    for (const action of exposure.actions) {
+      issues.push(...validateAction(action, exposure, apiModel.key))
 
       if (SearchAction.isSearchAction(action)) hasSearch = true
       if (ListAction.isListAction(action)) hasList = true
@@ -598,9 +601,9 @@ export function validateExposedEntity(entity: ExposedEntity, apiModel: ApiModel)
       // For a rule to exist, it might be on the action, the exposure, any parent, or the apiModel.
       let hasAuth = false
       if (action.accessRule && action.accessRule.length > 0) hasAuth = true
-      if (!hasAuth && entity.accessRule && entity.accessRule.length > 0) hasAuth = true
+      if (!hasAuth && exposure.accessRule && exposure.accessRule.length > 0) hasAuth = true
 
-      let curr = entity.parent?.key
+      let curr = exposure.parent?.key
       while (curr && !hasAuth) {
         const p = apiModel.exposes.get(curr)
         if (p && p.accessRule && p.accessRule.length > 0) {
@@ -615,21 +618,21 @@ export function validateExposedEntity(entity: ExposedEntity, apiModel: ApiModel)
       if (!hasAuth) {
         issues.push({
           code: createCode('ACTION', 'MISSING_ACCESS_RULES'),
-          message: `The ${action.kind} action has no security rules attached, making it entirely inaccessible or open.`,
+          message: `[${entityName}]: The ${action.kind} action has no security rules attached, making it entirely inaccessible or open.`,
           suggestion: 'Allow specific user roles to access this operation.',
           severity: 'error',
           // using action.kind as the key context equivalent
-          context: { ...context, kind: 'Action', key: action.kind, parentExposedEntityKey: entity.key },
+          context: { ...context, kind: 'Action', key: action.kind, parentExposedEntityKey: exposure.key },
         })
       }
     }
 
     if (hasList || hasSearch) {
-      const contract = entity.paginationContract
+      const contract = exposure.paginationContract
       if (!contract) {
         issues.push({
           code: createCode('EXPOSURE', 'MISSING_PAGINATION_CONTRACT'),
-          message: 'The List or Search action needs a pagination contract.',
+          message: `[${entityName}]: The List or Search action needs a pagination contract.`,
           suggestion: 'Add a pagination contract to the exposed entity.',
           severity: 'error',
           context,
@@ -639,7 +642,7 @@ export function validateExposedEntity(entity: ExposedEntity, apiModel: ApiModel)
           if (!contract.filterableFields || contract.filterableFields.length === 0) {
             issues.push({
               code: createCode('EXPOSURE', 'LIST_MISSING_FILTERS'),
-              message: 'Listing all elements without filters could be overwhelming for large tables.',
+              message: `[${entityName}]: Listing all elements without filters could be overwhelming for large tables.`,
               suggestion: 'Select a few important fields to allow filtering.',
               severity: 'warning',
               context,
@@ -648,7 +651,7 @@ export function validateExposedEntity(entity: ExposedEntity, apiModel: ApiModel)
           if (!contract.sortableFields || contract.sortableFields.length === 0) {
             issues.push({
               code: createCode('EXPOSURE', 'LIST_MISSING_SORTING'),
-              message: 'Listing all elements without sorting could be overwhelming for large tables.',
+              message: `[${entityName}]: Listing all elements without sorting could be overwhelming for large tables.`,
               suggestion: 'Select a few important fields to allow sorting.',
               severity: 'warning',
               context,
@@ -667,7 +670,7 @@ export function validateExposedEntity(entity: ExposedEntity, apiModel: ApiModel)
           if (!all.length) {
             issues.push({
               code: createCode('EXPOSURE', 'SEARCH_MISSING_FIELDS'),
-              message: 'Search action needs to know which fields to look in.',
+              message: `[${entityName}]: Search action needs to know which text fields to look in.`,
               suggestion: 'Select a few important fields to allow searching or full-text search.',
               severity: 'warning',
               context,

package/src/modeling/validation/api_model_validation_rules.md

@@ -3,21 +3,25 @@
 This document outlines the validation rules for the `ApiModel` schema. These rules ensure that an API model is structurally sound, secure, and ready for use or publication.
 
 Validations are evaluated with one of three severity levels:
+
 - **Error**: A blocker that makes the model invalid and must be resolved (e.g., missing required configurations or broken references).
 - **Warning**: A non-blocker, typically indicating missing optional but recommended properties, or non-optimal configurations.
 - **Info**: Informational messages about the model's status or suggestions for improvement.
 
 ## 1. Core Properties
+
 - **`kind`** [Error]: Must be exactly the value defined by `ApiModelKind`.
 - **`key`** [Error]: Must be a defined, non-empty string.
 - **`info.name`** [Error]: The `info` property must be a valid structure with at least a `name` defined.
 - **`info.description`** [Warning]: It is highly recommended to provide a description for the API model.
 
 ## 2. Domain Dependency
+
 - **Domain Attachment** [Error]: The API model must have an attached `DataDomain`.
 - **Domain Versioning** [Error]: The attached Data Domain must have a `version` defined (`domain.info.version`).
 
 ## 3. Security & Access Control
+
 - **Authentication** [Error]: The `authentication` configuration is required.
   - If the strategy is `UsernamePassword`, the `passwordKey` must be defined.
 - **Authorization** [Error]: The `authorization` configuration is required.
@@ -28,9 +32,10 @@ Validations are evaluated with one of three severity levels:
   - **RBAC Role Property**: If the authorization strategy is `RBAC`, the `session.properties` must also map the role property into the session payload.
   - **Transports**: At least one session transport (such as `cookie` or `jwt`) must be configured and marked as `enabled`.
 - **User Entity** [Error]: A designated `user` entity reference is required. This reference must point to a Data Entity that is appropriately annotated with the `User` semantic.
-- **Action Access Rules** [Error]: Each configured operation (Action) must have at least one access rule defined that applies to it. This can be inherited from the API Model level, the Exposed Entity level, any parent Exposed Entity, or explicitly defined on the Action itself. 
+- **Action Access Rules** [Error]: Each configured operation (Action) must have at least one access rule defined that applies to it. This can be inherited from the API Model level, the Exposed Entity level, any parent Exposed Entity, or explicitly defined on the Action itself.
 
 ## 4. Exposures
+
 - **Path Integrity** [Error]:
   - If an exposure `hasCollection` is true, it MUST have a `collectionPath` defined.
   - The `collectionPath` (if present) must contain exactly one segment starting with `/`.
@@ -40,18 +45,20 @@ Validations are evaluated with one of three severity levels:
 - **Exposures Exist** [Warning]: If no entities are exposed, the API model will not generate any endpoints.
 
 ## 5. API Actions
+
 - **Minimum Actions** [Error]: Each exposed entity must have at least one action added to it in the `actions` array.
 - **Rate Limiting** [Warning]: It is recommended to set up rate limiting for exposed entities and individual actions to protect the API.
-- **List Action** [Error/Warning]: 
+- **List Action** [Error/Warning]:
   - **Pagination** [Error]: The `List` action strictly requires a pagination definition (`pagination.kind` must be defined as `offset` or `cursor`).
   - **Filtering/Sorting** [Warning]: It is recommended to define `filterableFields` and `sortableFields`, but it is up to the user.
 - **Search Action** [Error]: The `Search` action requires the user to define at least one indexable field in the `fields` array to perform the search on.
-- **Delete Action** [Error/Info]: 
+- **Delete Action** [Error/Info]:
   - **Strategy** [Error]: The `Delete` action must define a deletion strategy (`soft` or `hard`).
   - **Hard Delete Warning** [Info]: When the `hard` delete strategy is selected, print an info message that there will be no way to restore data.
 - **Update Action** [Error]: The `Update` action must have at least one update method chosen in the `allowedMethods` array (e.g., `PUT` or `PATCH`).
 
 ## 6. Metadata
+
 - **Contact Email** [Error]: If `contact.email` is provided, it MUST be in the format of a valid email address.
 - **Contact URL** [Error]: If `contact.url` is provided, it MUST be in the format of a valid URL.
 - **License URL** [Error]: If `license.url` is provided, it MUST be in the format of a valid URL.

package/src/modeling/validation/semantic_validation.ts

@@ -37,30 +37,89 @@ export class SemanticValidation {
   }
 
   /**
-   * Validates if there is at least one entity with the User semantic.
+   * Validates if there is exactly one entity with the User semantic.
    * This is a recommended semantic for authentication purposes.
    */
   private validateUserEntity(): DomainValidationSchema[] {
     const results: DomainValidationSchema[] = []
-    let hasUserEntity = false
+    let userEntitiesCount = 0
 
     for (const entity of this.domain.listEntities()) {
       if (entity.hasSemantic(SemanticType.User)) {
-        hasUserEntity = true
-        break
+        userEntitiesCount++
+        let hasUsername = false
+        let hasPassword = false
+        let hasRole = false
+        for (const property of entity.withInheritedProperties()) {
+          if (property.hasSemantic(SemanticType.Username)) {
+            hasUsername = true
+          }
+          if (property.hasSemantic(SemanticType.Password)) {
+            hasPassword = true
+          }
+          if (property.hasSemantic(SemanticType.UserRole)) {
+            hasRole = true
+          }
+          if (hasUsername && hasPassword && hasRole) {
+            break
+          }
+        }
+        if (!hasUsername) {
+          results.push({
+            field: 'semantics',
+            rule: 'has_username',
+            message: 'No username property on the User entity found.',
+            help: 'It is recommended to set the "username" property semantic for APIs supporting authentication.',
+            severity: 'warning',
+            key: 'user_semantic',
+            kind: DomainEntityKind,
+          })
+        }
+        if (!hasPassword) {
+          results.push({
+            field: 'semantics',
+            rule: 'has_password',
+            message: 'No password property on the User entity found.',
+            help: 'It is recommended to set the "password" property semantic for APIs supporting authentication.',
+            severity: 'warning',
+            key: 'user_semantic',
+            kind: DomainEntityKind,
+          })
+        }
+        if (!hasRole) {
+          results.push({
+            field: 'semantics',
+            rule: 'has_user_role',
+            message: 'No role property on the User entity found.',
+            help: 'It is recommended to set the "User role" property semantic for APIs supporting authentication.',
+            severity: 'warning',
+            key: 'user_semantic',
+            kind: DomainEntityKind,
+          })
+        }
       }
     }
 
-    if (!hasUserEntity) {
+    if (userEntitiesCount === 0) {
       results.push({
         field: 'semantics',
         rule: 'recommended',
         message: 'No entity with User taxonomy found in the domain.',
-        help: 'It is recommended to have at least one entity with the User taxonomy for authentication purposes.',
+        help: 'It is recommended to have an entity with the User taxonomy for authentication purposes.',
         severity: 'warning',
         key: 'user_semantic',
         kind: DomainEntityKind,
       })
+    } else if (userEntitiesCount > 1) {
+      results.push({
+        field: 'semantics',
+        rule: 'one_user',
+        message: 'There is more than one entity with User taxonomy in the domain.',
+        help: 'There can be only one user in the system. Remove the additional User taxonomies.',
+        severity: 'error',
+        key: 'user_semantic',
+        kind: DomainEntityKind,
+      })
     }
 
     return results

package/src/runtime/http-engine/CoreEngine.ts

@@ -417,10 +417,9 @@ export class CoreEngine extends EventEmitter {
     const port = getPort(this.uri.port, this.uri.protocol)
     const host = this.uri.hostname
     const protocol = this.uri.protocol
-
     const socket = await this.connectionManager.createConnection(host, port, protocol, this.opts)
     const { timeout } = this
-    if (timeout > 0) {
+    if (typeof timeout === 'number' && timeout > 0) {
       socket.setTimeout(timeout)
     }
     this.socket = socket

package/src/runtime/http-engine/connections/DirectConnection.ts

@@ -30,8 +30,7 @@ export class DirectConnection {
     } else {
       socket = await this.createTcpConnection(host, port, logger, stats)
     }
-
-    if (timeout && timeout > 0) {
+    if (typeof timeout === 'number' && timeout > 0) {
       socket.setTimeout(timeout)
     }
 
@@ -54,8 +53,12 @@ export class DirectConnection {
       if (isIp) {
         stats.lookupTime = Date.now()
       }
-
-      const client = net.createConnection(port, host, () => {
+      const { timeout } = this.options
+      const opts: net.NetConnectOpts = { host, port }
+      if (typeof timeout === 'number' && timeout > 0) {
+        opts.timeout = timeout
+      }
+      const client = net.createConnection(opts, () => {
         stats.connectedTime = Date.now()
         logger.debug('HTTP connection established.')
         resolve(client)
@@ -68,6 +71,7 @@ export class DirectConnection {
         })
       }
       client.once('error', (err: Error) => reject(err))
+      client.once('', (err: Error) => reject(err))
     })
   }
 

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

@@ -73,14 +73,20 @@ test.group('DomainImpactAnalysis.validate()', (group) => {
     const p3e1 = entity1.addProperty({ type: 'datetime', info: { name: 'p3e1' } })
     const p4e1 = entity1.addProperty({ type: 'datetime', info: { name: 'p4e1' } })
     const p5e1 = entity1.addProperty({ type: 'boolean', info: { name: 'p5e1' } })
+    const p6e1 = entity1.addProperty({ type: 'string', info: { name: 'role_property' } })
+    const p7e1 = entity1.addProperty({ type: 'string', info: { name: 'pass_property' } })
+    const p8e1 = entity1.addProperty({ type: 'string', info: { name: 'uname_property' } })
 
     entity1.addSemantic({ id: SemanticType.User })
+    p8e1.addSemantic({ id: SemanticType.Username })
+    p7e1.addSemantic({ id: SemanticType.Password })
     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 })
+    p6e1.addSemantic({ id: SemanticType.UserRole })
 
     const report = analysis.validate()
     assert.lengthOf(report, 0)

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

@@ -22,10 +22,13 @@ test.group('SemanticValidation', (group) => {
     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 }) => {
+  test('validate() should not return a warning when a User entity is found with semantic properties', ({ assert }) => {
     const model = domain.addModel({ key: 'model' })
     const entity = model.addEntity({ key: 'user', info: { name: 'User' } })
     entity.addSemantic({ id: SemanticType.User })
+    entity.addProperty({ type: 'string', info: { name: 'username' }, semantics: [{ id: SemanticType.Username }] })
+    entity.addProperty({ type: 'string', info: { name: 'password' }, semantics: [{ id: SemanticType.Password }] })
+    entity.addProperty({ type: 'string', info: { name: 'role' }, semantics: [{ id: SemanticType.UserRole }] })
     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.')

package/tests/unit/runtime/http-engine/core_engine.spec.ts

@@ -268,12 +268,13 @@ test.group('CoreEngine - Error Handling Integration', () => {
 
   test('handles connection errors with proper error types', async ({ assert }) => {
     const request: IHttpRequest = {
-      url: 'http://invalid-hostname-that-does-not-exist-12345.com/api',
+      // Use a local closed port so the failure is deterministic and does not depend on DNS behavior.
+      url: 'http://127.0.0.1:1/api',
       method: 'GET',
     }
     const opts: HttpEngineOptions = {
       logger,
-      timeout: 5000,
+      timeout: 300,
     }
     const engine = new CoreEngine(request, opts)
 
@@ -283,10 +284,12 @@ test.group('CoreEngine - Error Handling Integration', () => {
     } catch (error: unknown) {
       assert.isTrue(error instanceof Error)
       if (error instanceof Error) {
-        assert.include(error.message, 'connect')
+        assert.match(error.message, /connect|econnrefused|refused/i)
       }
     }
-  }).tags(['@core-engine2', '@error-handling', '@connection'])
+  })
+    .tags(['@core-engine2', '@error-handling', '@connection'])
+    .timeout(5000)
 
   test('handles unsupported payload types with proper error types', async ({ assert, httpConfig }) => {
     const request: IHttpRequest = {
@@ -502,9 +505,9 @@ test.group('CoreEngine - Component Isolation Tests', () => {
 
     const authManager = new AuthManager({
       logger,
-      credentials: {
-        username: 'testuser',
-        password: 'testpass',
+      proxyCredentials: {
+        proxyUsername: 'testuser',
+        proxyPassword: 'testpass',
       },
     })