@api-client/core 0.18.23 → 0.18.25

package/src/modeling/definitions/Password.ts

@@ -147,9 +147,7 @@ export const DEFAULT_PASSWORD_CONFIG: PasswordConfig = {
   requireNumbers: true,
   requireUppercase: true,
   requireLowercase: true,
-  encryptionAlgorithm: PasswordEncryptionAlgorithm.Bcrypt,
-  saltRounds: 12,
-  maxAge: undefined,
+  minLength: 8,
   preventReuse: false,
   preventReuseCount: 5,
   allowCommonPasswords: false,

package/src/modeling/helpers/Intelisense.ts

@@ -4,12 +4,12 @@ import type { DomainProperty } from '../DomainProperty.js'
 import type { DomainAssociation } from '../DomainAssociation.js'
 import type { IThing } from '../../models/Thing.js'
 import { SemanticType } from '../Semantics.js'
-import { createEmailSemantic } from '../definitions/Email.js'
-import { createPasswordSemantic } from '../definitions/Password.js'
+import { createEmailSemantic, DEFAULT_EMAIL_CONFIG } from '../definitions/Email.js'
+import { createPasswordSemantic, DEFAULT_PASSWORD_CONFIG } from '../definitions/Password.js'
 import { createPhoneSemantic } from '../definitions/Phone.js'
 import { createPublicUniqueNameSemantic, DEFAULT_PUBLIC_UNIQUE_NAME_CONFIG } from '../definitions/PublicUniqueName.js'
 import { createDescriptionSemantic } from '../definitions/Description.js'
-import { createCurrencySemantic } from '../definitions/Currency.js'
+import { CURRENCY_PRESETS } from '../definitions/Currency.js'
 import { createStatusSemantic } from '../definitions/Status.js'
 import { SKU_PRESETS } from '../definitions/SKU.js'
 
@@ -131,13 +131,8 @@ export function addEmailField(entity: DomainEntity, info: Partial<IThing> = {}):
     type: 'string',
     required: true,
     index: true,
-    semantics: [
-      createEmailSemantic({
-        requireVerification: true,
-        verificationMethod: 'email',
-      }),
-    ],
   })
+  prop.addSemantic(createEmailSemantic(DEFAULT_EMAIL_CONFIG))
   return prop
 }
 
@@ -158,16 +153,8 @@ export function addPasswordField(entity: DomainEntity, info: Partial<IThing> = {
     info: { name: 'password', displayName: 'Password', ...info },
     type: 'string',
     required: true,
-    semantics: [
-      createPasswordSemantic({
-        requireSpecialChars: true,
-        requireNumbers: true,
-        requireUppercase: true,
-        requireLowercase: true,
-        minLength: 8,
-      }),
-    ],
   })
+  prop.addSemantic(createPasswordSemantic(DEFAULT_PASSWORD_CONFIG))
   return prop
 }
 
@@ -235,8 +222,8 @@ export function addDescriptionField(entity: DomainEntity, info: Partial<IThing>
   const prop = entity.addProperty({
     info: { name: 'description', displayName: 'Description', ...info },
     type: 'string',
-    semantics: [createDescriptionSemantic()],
   })
+  prop.addSemantic(createDescriptionSemantic())
   return prop
 }
 
@@ -603,15 +590,15 @@ export function addPhoneField(entity: DomainEntity, info: Partial<IThing> = {}):
     info: { name: 'phone', displayName: 'Phone Number', ...info },
     type: 'string',
     index: true,
-    semantics: [
-      createPhoneSemantic({
-        format: 'international',
-        requireCountryCode: true,
-        requireVerification: true,
-        verificationMethod: 'sms',
-      }),
-    ],
   })
+  prop.addSemantic(
+    createPhoneSemantic({
+      format: 'international',
+      requireCountryCode: true,
+      requireVerification: true,
+      verificationMethod: 'sms',
+    })
+  )
   return prop
 }
 
@@ -640,8 +627,8 @@ export function addAvatarUrlField(entity: DomainEntity, info: Partial<IThing> =
   const prop = entity.addProperty({
     info: { name: 'avatar_url', displayName: 'Avatar URL', ...info },
     type: 'string',
-    semantics: [{ id: SemanticType.ImageURL }],
   })
+  prop.addSemantic({ id: SemanticType.ImageURL })
   return prop
 }
 
@@ -676,8 +663,8 @@ export function addPublicUniqueNameField(entity: DomainEntity, info: Partial<ITh
     index: true,
     required: true,
     unique: true,
-    semantics: [createPublicUniqueNameSemantic(DEFAULT_PUBLIC_UNIQUE_NAME_CONFIG)],
   })
+  prop.addSemantic(createPublicUniqueNameSemantic(DEFAULT_PUBLIC_UNIQUE_NAME_CONFIG))
   return prop
 }
 
@@ -707,8 +694,8 @@ export function addSkuField(entity: DomainEntity, info: Partial<IThing> = {}): D
     type: 'string',
     required: true,
     unique: true,
-    semantics: [{ ...SKU_PRESETS.PRODUCT_STANDARD }],
   })
+  prop.addSemantic({ ...SKU_PRESETS.PRODUCT_STANDARD })
   return prop
 }
 
@@ -748,16 +735,8 @@ export function addPriceField(entity: DomainEntity, info: Partial<IThing> = {}):
         },
       },
     ],
-    semantics: [
-      createCurrencySemantic({
-        storageFormat: 'integer_cents',
-        defaultCurrency: 'USD',
-        decimalPlaces: 2,
-        allowNegative: false,
-        validateCurrencyCode: true,
-      }),
-    ],
   })
+  prop.addSemantic({ ...CURRENCY_PRESETS.USD_CENTS })
   return prop
 }
 
@@ -843,7 +822,9 @@ export function addImagesField(entity: DomainEntity, info: Partial<IThing> = {})
     info: { name: 'images', displayName: 'Images', ...info },
     type: 'string',
     multiple: true,
-    semantics: [{ id: SemanticType.ImageURL }],
+  })
+  prop.addSemantic({
+    id: SemanticType.ImageURL,
   })
   return prop
 }
@@ -880,7 +861,6 @@ export function addCustomStatusField(
     info: { name: 'status', displayName: 'Status', ...info },
     type: 'string',
     required: true,
-    semantics: [createStatusSemantic()],
     schema: {
       enum: enumValues,
       defaultValue: {
@@ -889,6 +869,7 @@ export function addCustomStatusField(
       },
     },
   })
+  prop.addSemantic(createStatusSemantic())
   return prop
 }
 
@@ -1008,15 +989,8 @@ export function addUnitPriceField(entity: DomainEntity, info: Partial<IThing> =
     info: { name: 'unitPrice', displayName: 'Unit Price', ...info },
     type: 'number',
     required: true,
-    semantics: [
-      createCurrencySemantic({
-        storageFormat: 'integer_cents',
-        defaultCurrency: 'USD',
-        decimalPlaces: 2,
-        allowNegative: false,
-      }),
-    ],
   })
+  prop.addSemantic({ ...CURRENCY_PRESETS.USD_CENTS })
   return prop
 }
 
@@ -1029,7 +1003,7 @@ export function addCurrencyAmountField(
   displayName: string,
   info: Partial<IThing> = {}
 ): DomainProperty {
-  return entity.addProperty({
+  const prop = entity.addProperty({
     info: {
       name: fieldName,
       displayName,
@@ -1037,15 +1011,9 @@ export function addCurrencyAmountField(
     },
     type: 'number',
     required: true,
-    semantics: [
-      createCurrencySemantic({
-        storageFormat: 'integer_cents',
-        defaultCurrency: 'USD',
-        decimalPlaces: 2,
-        allowNegative: false,
-      }),
-    ],
   })
+  prop.addSemantic({ ...CURRENCY_PRESETS.USD_CENTS })
+  return prop
 }
 
 /**

package/src/modeling/helpers/database.ts

@@ -1,4 +1,4 @@
-import { snakeCase } from '@pawel-up/jexl/string.js'
+import { SNAKE_CASE } from '@pawel-up/jexl/string.js'
 import DOMPurify from '../../lib/dom_purify.js'
 
 export function sanitizeInput(input: string): string {
@@ -20,7 +20,7 @@ export function toDatabaseColumnName(inputName: string, defaultName = 'untitled_
   let name = sanitizeInput(inputName)
 
   // 2. Convert to lowercase
-  name = snakeCase(name)
+  name = SNAKE_CASE(name)
 
   // 3. Replace spaces and multiple hyphens/underscores with a single underscore
   name = name.replace(/[\s-]+/g, '_')

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

@@ -549,7 +549,7 @@ export default function createEcommerceDomain(options: CreateTemplateOptions = {
         allowNegative: false,
       }),
       createCalculatedSemantic({
-        formula: '{{unitPrice}} * {{quantity}}',
+        formula: `{{${cartUnitPrice.key}}} * {{${cartItemQuantity.key}}}`,
         dependencies: [cartUnitPrice.key, cartItemQuantity.key],
         recalculateOnUpdate: true,
       }),
@@ -637,7 +637,7 @@ export default function createEcommerceDomain(options: CreateTemplateOptions = {
         allowNegative: false,
       }),
       createCalculatedSemantic({
-        formula: '{{subtotal}} + {{taxAmount}} + {{shippingAmount}}',
+        formula: `{{${subtotal.key}}} + {{${taxAmount.key}}} + {{${shippingAmount.key}}}`,
         dependencies: [subtotal.key, taxAmount.key, shippingAmount.key],
         recalculateOnUpdate: true,
       }),
@@ -711,7 +711,7 @@ export default function createEcommerceDomain(options: CreateTemplateOptions = {
         allowNegative: false,
       }),
       createCalculatedSemantic({
-        formula: '{{quantity}} * {{unitPrice}}',
+        formula: `{{${quantity.key}}} * {{${unitPrice.key}}}`,
         dependencies: [quantity.key, unitPrice.key],
         recalculateOnUpdate: true,
       }),

package/src/modeling/templates/verticals/technology-media/blog-domain.ts

@@ -251,7 +251,7 @@ export default function createBlogDomain(options: CreateTemplateOptions = {}): D
     semantics: [{ id: SemanticType.Summary }],
   })
 
-  postEntity.addProperty({
+  const postContent = postEntity.addProperty({
     info: { name: 'content', displayName: 'Content', description: 'Full content of the post in HTML or Markdown' },
     type: 'string',
     required: true,
@@ -310,8 +310,8 @@ export default function createBlogDomain(options: CreateTemplateOptions = {}): D
     readOnly: true,
     semantics: [
       createCalculatedSemantic({
-        formula: 'CEILING(LENGTH(REPLACE({{content}}, " ", "")) / 250)',
-        dependencies: [],
+        formula: `CEIL(LENGTH(REPLACE({{${postContent.key}}}, " ", "")) / 250)`,
+        dependencies: [postContent.key],
         recalculateOnUpdate: true,
       }),
     ],
@@ -323,8 +323,8 @@ export default function createBlogDomain(options: CreateTemplateOptions = {}): D
     readOnly: true,
     semantics: [
       createCalculatedSemantic({
-        formula: 'LENGTH({{content}}) - LENGTH(REPLACE({{content}}, " ", "")) + 1',
-        dependencies: [],
+        formula: `LENGTH({{${postContent.key}}}) - LENGTH(REPLACE({{${postContent.key}}}, " ", "")) + 1`,
+        dependencies: [postContent.key],
         recalculateOnUpdate: true,
       }),
     ],

package/tests/unit/modeling/definitions/email.spec.ts

@@ -18,7 +18,6 @@ test.group('Email Semantic Configuration', () => {
     const config: EmailConfig = {
       allowedDomains: ['example.com'],
       requireVerification: true,
-      verificationMethod: 'email',
     }
     const semantic = createEmailSemantic(config)
     assert.equal(semantic.id, SemanticType.Email)

package/tests/unit/modeling/definitions/password.spec.ts

@@ -77,8 +77,6 @@ test.group('Password Semantic Configuration', () => {
     assert.equal(DEFAULT_PASSWORD_CONFIG.requireNumbers, true)
     assert.equal(DEFAULT_PASSWORD_CONFIG.requireUppercase, true)
     assert.equal(DEFAULT_PASSWORD_CONFIG.requireLowercase, true)
-    assert.equal(DEFAULT_PASSWORD_CONFIG.encryptionAlgorithm, PasswordEncryptionAlgorithm.Bcrypt)
-    assert.equal(DEFAULT_PASSWORD_CONFIG.saltRounds, 12)
     assert.equal(DEFAULT_PASSWORD_CONFIG.maxAge, undefined)
     assert.equal(DEFAULT_PASSWORD_CONFIG.preventReuse, false)
     assert.equal(DEFAULT_PASSWORD_CONFIG.preventReuseCount, 5)

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

@@ -141,6 +141,101 @@ test.group('DomainEntity.addParent()', () => {
     assert.isTrue(dataDomain.graph.hasEdge(entity2.key, entity1.key))
     assert.deepEqual(dataDomain.graph.edge(entity2.key, entity1.key), { type: 'parent' })
   })
+
+  test('adds a foreign domain parent to the entity', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const foreignDomain = new DataDomain({ key: 'external-domain' })
+    const model = dataDomain.addModel()
+    const entity = model.addEntity({ key: 'child-entity' })
+    const foreignModel = foreignDomain.addModel()
+    const foreignEntity = foreignModel.addEntity({ key: 'parent-entity' })
+    const foreignKey = `${foreignDomain.key}:${foreignEntity.key}`
+
+    // Register foreign domain and add foreign parent
+    foreignDomain.info.version = '1.0.0'
+    dataDomain.registerForeignDomain(foreignDomain)
+    entity.addParent('parent-entity', 'external-domain')
+
+    // Verify it was added correctly
+    assert.isTrue(dataDomain.graph.hasEdge(entity.key, foreignKey))
+    assert.deepEqual(dataDomain.graph.edge(entity.key, foreignKey), {
+      type: 'parent',
+      domain: 'external-domain',
+      foreign: true,
+    })
+    const parents = [...entity.listParents()]
+    assert.lengthOf(parents, 1)
+    assert.deepEqual(parents[0], foreignEntity)
+  })
+
+  test('throws an error if foreign domain parent does not exist', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const foreignDomain = new DataDomain({ key: 'external-domain' })
+    const model = dataDomain.addModel()
+    const entity = model.addEntity({ key: 'child-entity' })
+
+    // Register foreign domain without the parent entity
+    foreignDomain.info.version = '1.0.0'
+    dataDomain.registerForeignDomain(foreignDomain)
+
+    assert.throws(() => {
+      entity.addParent('non-existent-parent', 'external-domain')
+    }, 'Entity with key "non-existent-parent" not found in domain "external-domain"')
+  })
+
+  test('throws an error if foreign domain is not registered', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity({ key: 'child-entity' })
+
+    assert.throws(() => {
+      entity.addParent('parent-entity', 'non-existent-domain')
+    }, 'Foreign domain non-existent-domain not found')
+  })
+
+  test('can add both local and foreign parents', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const foreignDomain = new DataDomain({ key: 'external-domain' })
+    const model = dataDomain.addModel()
+    const localParent = model.addEntity({ key: 'local-parent' })
+    const entity = model.addEntity({ key: 'child-entity' })
+    const foreignModel = foreignDomain.addModel()
+    const foreignEntity = foreignModel.addEntity({ key: 'foreign-parent' })
+    const foreignKey = `${foreignDomain.key}:${foreignEntity.key}`
+
+    // Register foreign domain and add both parents
+    foreignDomain.info.version = '1.0.0'
+    dataDomain.registerForeignDomain(foreignDomain)
+    entity.addParent(localParent.key)
+    entity.addParent('foreign-parent', 'external-domain')
+
+    // Verify both parents were added
+    assert.isTrue(dataDomain.graph.hasEdge(entity.key, localParent.key))
+    assert.isTrue(dataDomain.graph.hasEdge(entity.key, foreignKey))
+
+    const parents = [...entity.listParents()]
+    assert.lengthOf(parents, 2)
+    assert.deepInclude(parents, localParent)
+    assert.deepInclude(parents, foreignEntity)
+  })
+
+  test('throws an error if trying to add the same foreign parent twice', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const foreignDomain = new DataDomain({ key: 'external-domain' })
+    const model = dataDomain.addModel()
+    const entity = model.addEntity({ key: 'child-entity' })
+    const foreignModel = foreignDomain.addModel()
+    foreignModel.addEntity({ key: 'parent-entity' })
+
+    // Register foreign domain and add foreign parent
+    foreignDomain.info.version = '1.0.0'
+    dataDomain.registerForeignDomain(foreignDomain)
+    entity.addParent('parent-entity', 'external-domain')
+
+    assert.throws(() => {
+      entity.addParent('parent-entity', 'external-domain')
+    }, 'Parent parent-entity already exists')
+  })
 })
 
 test.group('DomainEntity.removeParent()', () => {
@@ -164,6 +259,121 @@ test.group('DomainEntity.removeParent()', () => {
     }, `Trying to remove a parent non-existent-entity from ${entity.key}, but it doesn't exist`)
   })
 
+  test('throws an error if foreign domain parent does not exist', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity({ key: 'child-entity' })
+    assert.throws(() => {
+      entity.removeParent('non-existent-entity', 'external-domain')
+    }, `Foreign domain external-domain not found`)
+  })
+
+  test('throws an error if edge exists but is not a parent relationship', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity1 = model.addEntity({ key: 'entity1' })
+    const entity2 = model.addEntity({ key: 'entity2' })
+    // Create a non-parent edge
+    dataDomain.graph.setEdge(entity2.key, entity1.key, { type: 'association' })
+    assert.throws(() => {
+      entity2.removeParent(entity1.key)
+    }, `Edge between ${entity2.key} and entity1 exists but is not a parent relationship`)
+  })
+
+  test('throws an error if foreign domain edge exists but is not a parent relationship', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const foreignDomain = new DataDomain({ key: 'external-domain' })
+    const model = dataDomain.addModel()
+    const entity = model.addEntity({ key: 'child-entity' })
+    const foreignModel = foreignDomain.addModel()
+    const foreignEntity = foreignModel.addEntity({ key: 'parent-entity' })
+
+    // Register foreign domain and create a non-parent edge
+    foreignDomain.info.version = '1.0.0'
+    dataDomain.registerForeignDomain(foreignDomain)
+    const foreignKey = `${foreignDomain.key}:${foreignEntity.key}`
+    dataDomain.graph.setEdge(entity.key, foreignKey, { type: 'association' })
+
+    assert.throws(() => {
+      entity.removeParent('parent-entity', 'external-domain')
+    }, `Edge between child-entity and parent-entity in domain "external-domain" exists but is not a parent relationship`)
+  })
+
+  test('removes a foreign domain parent from the entity', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const foreignDomain = new DataDomain({ key: 'external-domain' })
+    const model = dataDomain.addModel()
+    const entity = model.addEntity({ key: 'child-entity' })
+    const foreignModel = foreignDomain.addModel()
+    const foreignEntity = foreignModel.addEntity({ key: 'parent-entity' })
+    const foreignKey = `${foreignDomain.key}:${foreignEntity.key}`
+
+    // Register foreign domain and add foreign parent
+    foreignDomain.info.version = '1.0.0'
+    dataDomain.registerForeignDomain(foreignDomain)
+    entity.addParent('parent-entity', 'external-domain')
+
+    // Verify it was added
+    assert.isTrue(dataDomain.graph.hasEdge(entity.key, foreignKey))
+    assert.deepEqual(dataDomain.graph.edge(entity.key, foreignKey), {
+      type: 'parent',
+      domain: 'external-domain',
+      foreign: true,
+    })
+
+    // Remove the foreign parent
+    entity.removeParent('parent-entity', 'external-domain')
+    assert.isFalse(dataDomain.graph.hasEdge(entity.key, foreignKey))
+  })
+
+  test('removes local parent while keeping foreign parent', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const foreignDomain = new DataDomain({ key: 'external-domain' })
+    const model = dataDomain.addModel()
+    const localParent = model.addEntity({ key: 'local-parent' })
+    const entity = model.addEntity({ key: 'child-entity' })
+    const foreignModel = foreignDomain.addModel()
+    const foreignEntity = foreignModel.addEntity({ key: 'foreign-parent' })
+    const foreignKey = `${foreignDomain.key}:${foreignEntity.key}`
+
+    // Register foreign domain and add both parents
+    foreignDomain.info.version = '1.0.0'
+    dataDomain.registerForeignDomain(foreignDomain)
+    entity.addParent(localParent.key)
+    entity.addParent('foreign-parent', 'external-domain')
+
+    // Remove only the local parent
+    entity.removeParent(localParent.key)
+
+    // Verify local parent is removed but foreign remains
+    assert.isFalse(dataDomain.graph.hasEdge(entity.key, localParent.key))
+    assert.isTrue(dataDomain.graph.hasEdge(entity.key, foreignKey))
+  })
+
+  test('removes foreign parent while keeping local parent', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const foreignDomain = new DataDomain({ key: 'external-domain' })
+    const model = dataDomain.addModel()
+    const localParent = model.addEntity({ key: 'local-parent' })
+    const entity = model.addEntity({ key: 'child-entity' })
+    const foreignModel = foreignDomain.addModel()
+    const foreignEntity = foreignModel.addEntity({ key: 'foreign-parent' })
+    const foreignKey = `${foreignDomain.key}:${foreignEntity.key}`
+
+    // Register foreign domain and add both parents
+    foreignDomain.info.version = '1.0.0'
+    dataDomain.registerForeignDomain(foreignDomain)
+    entity.addParent(localParent.key)
+    entity.addParent('foreign-parent', 'external-domain')
+
+    // Remove only the foreign parent
+    entity.removeParent('foreign-parent', 'external-domain')
+
+    // Verify foreign parent is removed but local remains
+    assert.isTrue(dataDomain.graph.hasEdge(entity.key, localParent.key))
+    assert.isFalse(dataDomain.graph.hasEdge(entity.key, foreignKey))
+  })
+
   test('notifies change', async ({ assert }) => {
     const dataDomain = new DataDomain()
     const model = dataDomain.addModel()
@@ -174,6 +384,22 @@ test.group('DomainEntity.removeParent()', () => {
     await assert.dispatches(dataDomain, 'change', { timeout: 20 })
   })
 
+  test('notifies change when removing foreign domain parent', async ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const foreignDomain = new DataDomain({ key: 'external-domain' })
+    const model = dataDomain.addModel()
+    const entity = model.addEntity({ key: 'child-entity' })
+    const foreignModel = foreignDomain.addModel()
+    foreignModel.addEntity({ key: 'parent-entity' })
+
+    // Register foreign domain and add foreign parent
+    foreignDomain.info.version = '1.0.0'
+    dataDomain.registerForeignDomain(foreignDomain)
+    entity.addParent('parent-entity', 'external-domain')
+    entity.removeParent('parent-entity', 'external-domain')
+    await assert.dispatches(dataDomain, 'change', { timeout: 20 })
+  })
+
   test('removes the graph edge', ({ assert }) => {
     const dataDomain = new DataDomain()
     const model = dataDomain.addModel()
@@ -183,6 +409,23 @@ test.group('DomainEntity.removeParent()', () => {
     entity2.removeParent(entity1.key)
     assert.isFalse(dataDomain.graph.hasEdge(entity2.key, entity1.key))
   })
+
+  test('removes the foreign domain graph edge', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const foreignDomain = new DataDomain({ key: 'external-domain' })
+    const model = dataDomain.addModel()
+    const entity = model.addEntity({ key: 'child-entity' })
+    const foreignModel = foreignDomain.addModel()
+    foreignModel.addEntity({ key: 'parent-entity' })
+    const foreignKey = `${foreignDomain.key}:parent-entity`
+
+    // Register foreign domain and add foreign parent
+    foreignDomain.info.version = '1.0.0'
+    dataDomain.registerForeignDomain(foreignDomain)
+    entity.addParent('parent-entity', 'external-domain')
+    entity.removeParent('parent-entity', 'external-domain')
+    assert.isFalse(dataDomain.graph.hasEdge(entity.key, foreignKey))
+  })
 })
 
 test.group('DomainEntity.hasCircularParent()', () => {

package/tests/unit/modeling/semantic-configs.spec.ts

@@ -266,7 +266,6 @@ test.group('Semantic Configurations', () => {
     const config: EmailConfig = {
       allowedDomains: ['example.com'],
       requireVerification: true,
-      verificationMethod: 'email',
     }
     const semantic = createEmailSemantic(config)
     assert.equal(semantic.id, SemanticType.Email)