@api-client/core 0.18.53 → 0.18.55

package/src/modeling/templates/verticals/business-services/financial-services-domain.ts

@@ -25,6 +25,8 @@
 
 import { DataDomain } from '../../../DataDomain.js'
 import { SemanticType } from '../../../Semantics.js'
+import { createCountrySemantic, DEFAULT_COUNTRY_CONFIG } from '../../../definitions/Country.js'
+import { createPostalCodeSemantic, DEFAULT_POSTAL_CODE_CONFIG } from '../../../definitions/PostalCode.js'
 import {
   addIdField,
   addNameField,
@@ -262,24 +264,35 @@ export default function createFinancialServicesDomain(options: CreateTemplateOpt
     info: { name: 'address', displayName: 'Address', description: 'Customer residential address' },
     type: 'string',
     required: true,
+    semantics: [{ id: SemanticType.StreetAddress }],
   })
 
   customerProfileEntity.addProperty({
     info: { name: 'city', displayName: 'City', description: 'Customer city' },
     type: 'string',
     required: true,
+    semantics: [{ id: SemanticType.City }],
   })
 
   customerProfileEntity.addProperty({
-    info: { name: 'state', displayName: 'State', description: 'Customer state' },
+    info: { name: 'state', displayName: 'State/Province', description: 'State or province' },
     type: 'string',
     required: true,
+    semantics: [{ id: SemanticType.Region }],
   })
 
   customerProfileEntity.addProperty({
-    info: { name: 'zip_code', displayName: 'ZIP Code', description: 'Customer ZIP code' },
+    info: { name: 'postal_code', displayName: 'ZIP/Postal Code', description: 'ZIP or postal code' },
     type: 'string',
     required: true,
+    semantics: [createPostalCodeSemantic(DEFAULT_POSTAL_CODE_CONFIG)],
+  })
+
+  customerProfileEntity.addProperty({
+    info: { name: 'country', displayName: 'Country', description: 'Country name' },
+    type: 'string',
+    required: true,
+    semantics: [createCountrySemantic(DEFAULT_COUNTRY_CONFIG)],
   })
 
   customerProfileEntity.addProperty({

package/tests/unit/modeling/helpers/intellisense.spec.ts

@@ -32,8 +32,17 @@ import {
   addUnitPriceField,
   addCurrencyAmountField,
   addRecommendedFields,
+  addDisplayNameField,
+  addRoleField,
+  addCountryField,
+  addPostalCodeField,
+  addStreetAddressField,
+  addCityField,
+  addRegionField,
 } from '../../../../src/modeling/helpers/Intelisense.js'
 import { SemanticType } from '../../../../src/modeling/Semantics.js'
+import { createCountrySemantic } from '../../../../src/modeling/definitions/Country.js'
+import { createPostalCodeSemantic } from '../../../../src/modeling/definitions/PostalCode.js'
 
 function createTestEntity(): DomainEntity {
   const domain = new DataDomain({ key: 'test-domain', info: { name: 'Test Domain' } })
@@ -259,6 +268,46 @@ test.group('addAutoField()', () => {
     assert.equal(field.type, 'number')
     assert.isTrue(field.required)
   })
+
+  test('adds street address field when autoField is "street-address"', ({ assert }) => {
+    const entity = createTestEntity()
+    const field = addAutoField(entity, 'street-address') as DomainProperty
+    assert.instanceOf(field, DomainProperty)
+    assert.equal(field.info.name, 'street_address')
+    assert.isTrue(field.hasSemantic(SemanticType.StreetAddress))
+  })
+
+  test('adds city field when autoField is "city"', ({ assert }) => {
+    const entity = createTestEntity()
+    const field = addAutoField(entity, 'city') as DomainProperty
+    assert.instanceOf(field, DomainProperty)
+    assert.equal(field.info.name, 'city')
+    assert.isTrue(field.hasSemantic(SemanticType.City))
+  })
+
+  test('adds postal code field when autoField is "postal-code"', ({ assert }) => {
+    const entity = createTestEntity()
+    const field = addAutoField(entity, 'postal-code') as DomainProperty
+    assert.instanceOf(field, DomainProperty)
+    assert.equal(field.info.name, 'postal_code')
+    assert.isTrue(field.hasSemantic(SemanticType.PostalCode))
+  })
+
+  test('adds country field when autoField is "country"', ({ assert }) => {
+    const entity = createTestEntity()
+    const field = addAutoField(entity, 'country') as DomainProperty
+    assert.instanceOf(field, DomainProperty)
+    assert.equal(field.info.name, 'country')
+    assert.isTrue(field.hasSemantic(SemanticType.Country))
+  })
+
+  test('adds region field when autoField is "region"', ({ assert }) => {
+    const entity = createTestEntity()
+    const field = addAutoField(entity, 'region') as DomainProperty
+    assert.instanceOf(field, DomainProperty)
+    assert.equal(field.info.name, 'region')
+    assert.isTrue(field.hasSemantic(SemanticType.Region))
+  })
 })
 
 test.group('addIdField()', () => {
@@ -402,6 +451,33 @@ test.group('addNameField()', () => {
   })
 })
 
+test.group('addDisplayNameField()', () => {
+  test('creates new display name field when none exists', ({ assert }) => {
+    const entity = createTestEntity()
+    const field = addDisplayNameField(entity) as DomainProperty
+    assert.instanceOf(field, DomainProperty)
+    assert.equal(field.info.name, 'display-name')
+    assert.equal(field.info.displayName, 'Display Name')
+    assert.equal(field.type, 'string')
+    assert.isTrue(field.semantics.length > 0)
+  })
+
+  test('returns existing display name field when one exists', ({ assert }) => {
+    const entity = createTestEntity()
+    const firstField = addDisplayNameField(entity) as DomainProperty
+    const secondField = addDisplayNameField(entity) as DomainProperty
+    assert.equal(firstField, secondField)
+    assert.lengthOf([...entity.properties], 1)
+  })
+
+  test('adds semantic annotation', ({ assert }) => {
+    const entity = createTestEntity()
+    const field = addDisplayNameField(entity) as DomainProperty
+    const hasSemantic = field.hasSemantic(SemanticType.Name)
+    assert.isTrue(hasSemantic)
+  })
+})
+
 test.group('addDescriptionField()', () => {
   test('creates new description field when none exists', ({ assert }) => {
     const entity = createTestEntity()
@@ -568,6 +644,36 @@ test.group('addDeletedAtField()', () => {
   })
 })
 
+test.group('addRoleField()', () => {
+  test('creates new role field when none exists', ({ assert }) => {
+    const entity = createTestEntity()
+    const field = addRoleField(entity)
+    assert.instanceOf(field, DomainProperty)
+    assert.equal(field.info.name, 'role')
+    assert.equal(field.info.displayName, 'Role')
+    assert.equal(field.type, 'string')
+    assert.isTrue(field.index)
+    assert.deepEqual(field.schema?.defaultValue, { type: 'literal', value: 'user' })
+    assert.deepEqual(field.schema?.enum, ['user', 'admin'])
+    assert.isTrue(field.hasSemantic(SemanticType.UserRole))
+  })
+
+  test('returns existing role field when one exists', ({ assert }) => {
+    const entity = createTestEntity()
+    const firstField = addRoleField(entity)
+    const secondField = addRoleField(entity)
+    assert.equal(firstField, secondField)
+    assert.lengthOf([...entity.properties], 1)
+  })
+
+  test('merges custom info with defaults', ({ assert }) => {
+    const entity = createTestEntity()
+    const field = addRoleField(entity, { description: 'User role' })
+    assert.equal(field.info.name, 'role')
+    assert.equal(field.info.description, 'User role')
+  })
+})
+
 test.group('addIsDeletedField()', () => {
   test('creates new is deleted field when none exists', ({ assert }) => {
     const entity = createTestEntity()
@@ -969,3 +1075,165 @@ test.group('addRecommendedFields()', () => {
     assert.isAtLeast([...entity.properties].length, initialFieldCount + 1)
   })
 })
+
+test.group('addCountryField()', () => {
+  test('creates new country field when none exists', ({ assert }) => {
+    const entity = createTestEntity()
+    const field = addCountryField(entity) as DomainProperty
+    assert.instanceOf(field, DomainProperty)
+    assert.equal(field.info.name, 'country')
+    assert.equal(field.type, 'string')
+    assert.isTrue(field.required)
+    assert.isTrue(field.index)
+    assert.isTrue(field.semantics.length > 0)
+  })
+
+  test('returns existing country field when one exists', ({ assert }) => {
+    const entity = createTestEntity()
+    const existingField = entity.addProperty({
+      info: { name: 'country', displayName: 'Country' },
+      type: 'string',
+      semantics: [createCountrySemantic()],
+    })
+    const field = addCountryField(entity)
+    assert.equal(field, existingField)
+  })
+
+  test('merges custom info with defaults', ({ assert }) => {
+    const entity = createTestEntity()
+    const field = addCountryField(entity, { description: 'Country code' }) as DomainProperty
+    assert.equal(field.info.name, 'country')
+    assert.equal(field.info.displayName, 'Country')
+    assert.equal(field.info.description, 'Country code')
+  })
+})
+
+test.group('addPostalCodeField()', () => {
+  test('creates new postal code field when none exists', ({ assert }) => {
+    const entity = createTestEntity()
+    const field = addPostalCodeField(entity) as DomainProperty
+    assert.instanceOf(field, DomainProperty)
+    assert.equal(field.info.name, 'postal_code')
+    assert.equal(field.info.displayName, 'Postal Code')
+    assert.equal(field.type, 'string')
+    assert.isTrue(field.required)
+    assert.isTrue(field.index)
+    assert.isTrue(field.semantics.length > 0)
+  })
+
+  test('returns existing postal code field when one exists', ({ assert }) => {
+    const entity = createTestEntity()
+    const existingField = entity.addProperty({
+      info: { name: 'postal_code', displayName: 'Postal Code' },
+      type: 'string',
+      semantics: [createPostalCodeSemantic()],
+    })
+    const field = addPostalCodeField(entity)
+    assert.equal(field, existingField)
+  })
+
+  test('merges custom info with defaults', ({ assert }) => {
+    const entity = createTestEntity()
+    const field = addPostalCodeField(entity, { description: 'ZIP code' }) as DomainProperty
+    assert.equal(field.info.name, 'postal_code')
+    assert.equal(field.info.displayName, 'Postal Code')
+    assert.equal(field.info.description, 'ZIP code')
+  })
+})
+
+test.group('addStreetAddressField()', () => {
+  test('creates new street address field when none exists', ({ assert }) => {
+    const entity = createTestEntity()
+    const field = addStreetAddressField(entity) as DomainProperty
+    assert.instanceOf(field, DomainProperty)
+    assert.equal(field.info.name, 'street_address')
+    assert.equal(field.info.displayName, 'Street Address')
+    assert.equal(field.type, 'string')
+    assert.isTrue(field.required)
+    assert.isTrue(field.semantics.length > 0)
+  })
+
+  test('returns existing street address field when one exists', ({ assert }) => {
+    const entity = createTestEntity()
+    const existingField = entity.addProperty({
+      info: { name: 'street_address', displayName: 'Street Address' },
+      type: 'string',
+      semantics: [{ id: SemanticType.StreetAddress }],
+    })
+    const field = addStreetAddressField(entity)
+    assert.equal(field, existingField)
+  })
+
+  test('merges custom info with defaults', ({ assert }) => {
+    const entity = createTestEntity()
+    const field = addStreetAddressField(entity, { description: 'Street address XXX' }) as DomainProperty
+    assert.equal(field.info.name, 'street_address')
+    assert.equal(field.info.displayName, 'Street Address')
+    assert.equal(field.info.description, 'Street address XXX')
+  })
+})
+
+test.group('addCityField()', () => {
+  test('creates new city field when none exists', ({ assert }) => {
+    const entity = createTestEntity()
+    const field = addCityField(entity) as DomainProperty
+    assert.instanceOf(field, DomainProperty)
+    assert.equal(field.info.name, 'city')
+    assert.equal(field.info.displayName, 'City')
+    assert.equal(field.type, 'string')
+    assert.isTrue(field.required)
+    assert.isTrue(field.index)
+    assert.isTrue(field.semantics.length > 0)
+  })
+
+  test('returns existing city field when one exists', ({ assert }) => {
+    const entity = createTestEntity()
+    const existingField = entity.addProperty({
+      info: { name: 'city', displayName: 'City' },
+      type: 'string',
+      semantics: [{ id: SemanticType.City }],
+    })
+    const field = addCityField(entity)
+    assert.equal(field, existingField)
+  })
+
+  test('merges custom info with defaults', ({ assert }) => {
+    const entity = createTestEntity()
+    const field = addCityField(entity, { description: 'City XXX' }) as DomainProperty
+    assert.equal(field.info.name, 'city')
+    assert.equal(field.info.displayName, 'City')
+    assert.equal(field.info.description, 'City XXX')
+  })
+})
+
+test.group('addRegionField()', () => {
+  test('creates new region field when none exists', ({ assert }) => {
+    const entity = createTestEntity()
+    const field = addRegionField(entity) as DomainProperty
+    assert.instanceOf(field, DomainProperty)
+    assert.equal(field.info.name, 'region')
+    assert.equal(field.info.displayName, 'Region')
+    assert.equal(field.type, 'string')
+    assert.isTrue(field.index)
+    assert.isTrue(field.semantics.length > 0)
+  })
+
+  test('returns existing region field when one exists', ({ assert }) => {
+    const entity = createTestEntity()
+    const existingField = entity.addProperty({
+      info: { name: 'region', displayName: 'Region' },
+      type: 'string',
+      semantics: [{ id: SemanticType.Region }],
+    })
+    const field = addRegionField(entity)
+    assert.equal(field, existingField)
+  })
+
+  test('merges custom info with defaults', ({ assert }) => {
+    const entity = createTestEntity()
+    const field = addRegionField(entity, { description: 'Region XXX' }) as DomainProperty
+    assert.equal(field.info.name, 'region')
+    assert.equal(field.info.displayName, 'Region')
+    assert.equal(field.info.description, 'Region XXX')
+  })
+})