@api-client/core 0.16.1 → 0.17.1

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

@@ -2,10 +2,13 @@ import { test } from '@japa/runner'
 import {
   SemanticType,
   SemanticScope,
+  SemanticCategory,
   isEntitySemantic,
   isPropertySemantic,
   isAssociationSemantic,
   DataSemantics,
+  getSemanticsByCategory,
+  getSemanticsByCategoryType,
   type EntitySemantic,
   type PropertySemantic,
   type AssociationSemantic,
@@ -45,18 +48,21 @@ test.group('Semantics', () => {
       displayName: 'User Entity',
       description: 'Test',
       scope: SemanticScope.Entity,
+      category: SemanticCategory.Identity,
     }
     const propertySemantic: PropertySemantic = {
       id: SemanticType.CreatedTimestamp,
       displayName: 'Creation Timestamp',
       description: 'Test',
       scope: SemanticScope.Property,
+      category: SemanticCategory.Lifecycle,
     }
     const associationSemantic: AssociationSemantic = {
       id: SemanticType.ResourceOwnerIdentifier,
       displayName: 'Resource Owner Identifier',
       description: 'Test',
       scope: SemanticScope.Association,
+      category: SemanticCategory.Identity,
     }
 
     assert.isTrue(isEntitySemantic(entitySemantic))
@@ -70,18 +76,21 @@ test.group('Semantics', () => {
       displayName: 'User Entity',
       description: 'Test',
       scope: SemanticScope.Entity,
+      category: SemanticCategory.Identity,
     }
     const propertySemantic: PropertySemantic = {
       id: SemanticType.CreatedTimestamp,
       displayName: 'Creation Timestamp',
       description: 'Test',
       scope: SemanticScope.Property,
+      category: SemanticCategory.Lifecycle,
     }
     const associationSemantic: AssociationSemantic = {
       id: SemanticType.ResourceOwnerIdentifier,
       displayName: 'Resource Owner Identifier',
       description: 'Test',
       scope: SemanticScope.Association,
+      category: SemanticCategory.Identity,
     }
 
     assert.isFalse(isPropertySemantic(entitySemantic))
@@ -95,18 +104,21 @@ test.group('Semantics', () => {
       displayName: 'User Entity',
       description: 'Test',
       scope: SemanticScope.Entity,
+      category: SemanticCategory.Identity,
     }
     const propertySemantic: PropertySemantic = {
       id: SemanticType.CreatedTimestamp,
       displayName: 'Creation Timestamp',
       description: 'Test',
       scope: SemanticScope.Property,
+      category: SemanticCategory.Lifecycle,
     }
     const associationSemantic: AssociationSemantic = {
       id: SemanticType.ResourceOwnerIdentifier,
       displayName: 'Resource Owner Identifier',
       description: 'Test',
       scope: SemanticScope.Association,
+      category: SemanticCategory.Identity,
     }
 
     assert.isFalse(isAssociationSemantic(entitySemantic))
@@ -128,6 +140,11 @@ test.group('Semantics', () => {
       assert.isNotEmpty(semantic.description, `description for ${type} should not be empty`)
 
       assert.oneOf(semantic.scope, Object.values(SemanticScope), `scope for ${type} should be a valid SemanticScope`)
+      assert.oneOf(
+        semantic.category,
+        Object.values(SemanticCategory),
+        `category for ${type} should be a valid SemanticCategory`
+      )
 
       if (isPropertySemantic(semantic)) {
         if (semantic.applicableDataTypes) {
@@ -142,15 +159,18 @@ test.group('Semantics', () => {
     // Specific checks for some semantics
     const userSemantic = DataSemantics[SemanticType.User]
     assert.equal(userSemantic.scope, SemanticScope.Entity)
+    assert.equal(userSemantic.category, SemanticCategory.Identity)
 
     const createdTimestampSemantic = DataSemantics[SemanticType.CreatedTimestamp]
     assert.equal(createdTimestampSemantic.scope, SemanticScope.Property)
+    assert.equal(createdTimestampSemantic.category, SemanticCategory.Lifecycle)
     if (isPropertySemantic(createdTimestampSemantic)) {
       assert.deepEqual(createdTimestampSemantic.applicableDataTypes, ['datetime'])
     }
 
     const resourceOwnerSemantic = DataSemantics[SemanticType.ResourceOwnerIdentifier]
     assert.equal(resourceOwnerSemantic.scope, SemanticScope.Association)
+    assert.equal(resourceOwnerSemantic.category, SemanticCategory.Identity)
   })
 
   test('GeospatialCoordinates semantic should have correct definition', ({ assert }) => {
@@ -193,6 +213,58 @@ test.group('Semantics', () => {
     const description = geospatialSemantic.description
 
     // Check that the description mentions key features
-    assert.equal(description, 'Annotates a field that holds geospatial coordinate data (latitude/longitude).')
+    assert.equal(description, 'Location coordinates')
+  })
+
+  test('getSemanticsByCategory should group semantics correctly', ({ assert }) => {
+    const semanticsByCategory = getSemanticsByCategory()
+
+    // Check that all categories are present
+    const expectedCategories = Object.values(SemanticCategory)
+    expectedCategories.forEach((category) => {
+      assert.isDefined(semanticsByCategory[category], `Category ${category} should be present`)
+      assert.isArray(semanticsByCategory[category], `Category ${category} should be an array`)
+    })
+
+    // Check that User semantic is in Identity category
+    const identitySemantics = semanticsByCategory[SemanticCategory.Identity]
+    const userSemantic = identitySemantics.find((s) => s.id === SemanticType.User)
+    assert.isDefined(userSemantic, 'User semantic should be in Identity category')
+
+    // Check that CreatedTimestamp is in Lifecycle category
+    const lifecycleSemantics = semanticsByCategory[SemanticCategory.Lifecycle]
+    const createdTimestampSemantic = lifecycleSemantics.find((s) => s.id === SemanticType.CreatedTimestamp)
+    assert.isDefined(createdTimestampSemantic, 'CreatedTimestamp semantic should be in Lifecycle category')
+
+    // Check that Title is in Content category
+    const contentSemantics = semanticsByCategory[SemanticCategory.Content]
+    const titleSemantic = contentSemantics.find((s) => s.id === SemanticType.Title)
+    assert.isDefined(titleSemantic, 'Title semantic should be in Content category')
+
+    // Verify all semantics are categorized (total count should match)
+    const totalSemantics = Object.values(semanticsByCategory).flat().length
+    const allSemantics = Object.values(DataSemantics).length
+    assert.equal(totalSemantics, allSemantics, 'All semantics should be categorized')
+  })
+
+  test('getSemanticsByCategoryType should filter semantics by category', ({ assert }) => {
+    const identitySemantics = getSemanticsByCategoryType(SemanticCategory.Identity)
+
+    // All returned semantics should be in Identity category
+    identitySemantics.forEach((semantic) => {
+      assert.equal(semantic.category, SemanticCategory.Identity, 'All semantics should be in Identity category')
+    })
+
+    // Should include User semantic
+    const userSemantic = identitySemantics.find((s) => s.id === SemanticType.User)
+    assert.isDefined(userSemantic, 'Should include User semantic')
+
+    // Should include Password semantic
+    const passwordSemantic = identitySemantics.find((s) => s.id === SemanticType.Password)
+    assert.isDefined(passwordSemantic, 'Should include Password semantic')
+
+    // Test empty result for a category with no semantics (if any)
+    const locationSemantics = getSemanticsByCategoryType(SemanticCategory.Location)
+    assert.isArray(locationSemantics, 'Should return an array even if empty')
   })
 })