@api-client/core 0.14.0 → 0.14.1

package/src/modeling/DomainProperty.ts

@@ -16,12 +16,13 @@ import {
   type NumberFormat,
   NumberFormats,
 } from './DataFormat.js'
+import { ShapeGenerator } from './amf/ShapeGenerator.js'
 import type { PropertyBinding, PropertyBindings, PropertyWebBindings } from './Bindings.js'
 import type { ModelValidationOptions } from '../models/types.js'
 import type { DomainEntity } from './DomainEntity.js'
 import type { IApiPropertyShape } from '../amf/definitions/Shapes.js'
-import { ShapeGenerator } from './amf/ShapeGenerator.js'
-import { PropertySchema } from './types.js'
+import type { PropertySchema } from './types.js'
+import { DataSemantics, isPropertySemantic, type SemanticType, type AppliedDataSemantic } from './Semantics.js'
 
 export interface DomainPropertySchema extends DomainElementSchema {
   kind: typeof DomainPropertyKind
@@ -62,11 +63,11 @@ export interface DomainPropertySchema extends DomainElementSchema {
    */
   tags?: string[]
   /**
-   * For future use.
-   *
-   * The keys of the taxonomy items associated with the property.
+   * The semantics applied to this property.
+   * This is a list of applied semantics that can be used to
+   * describe the property in more detail.
    */
-  taxonomy?: string[]
+  semantics?: AppliedDataSemantic[]
   /**
    * The data type for this property.
    * Note, not all schemas support the same type. For example, defining `sint32`
@@ -106,21 +107,21 @@ export interface DomainPropertySchema extends DomainElementSchema {
  * -   **Bindings:** Allows defining how the property is
  *     represented in different formats (e.g., web APIs,
  *     protocol buffers).
- * -   **Metadata:** Supports metadata such as tags, taxonomy,
+ * -   **Metadata:** Supports metadata such as tags, semantics,
  *     read-only/write-only status, and deprecation.
  * -   **Schema:** Allows defining a general schema for the
  *     property, which is propagated to all bindings.
  *
  * **Usage:**
  *
- * Use the `DataEntity.addProperty` method to add a new property to an
+ * Use the `DomainEntity.addProperty` method to add a new property to an
  * entity. The property can be created using the constructor, but it
  * won't be added to the graph until you call the `addProperty` method.
  *
  * **Example:**
  *
  * ```typescript
- * const entity = dataModel.addEntity({ key: 'user' });
+ * const entity = domainModel.addEntity({ key: 'user' });
  * const property = entity.addProperty({
  *   key: 'name',
  *   type: 'string',
@@ -185,11 +186,9 @@ export class DomainProperty extends DomainElement {
   @observed({ deep: true }) accessor tags: string[] = []
 
   /**
-   * Reserved for future use.
-   *
-   * The keys of the taxonomy items associated with the property.
+   * Semantics applied to this property.
    */
-  @observed({ deep: true }) accessor taxonomy: string[] = []
+  @observed({ deep: true }) accessor semantics: AppliedDataSemantic[] = []
 
   /**
    * The data type for this property.
@@ -232,7 +231,7 @@ export class DomainProperty extends DomainElement {
       readOnly,
       writeOnly,
       tags,
-      taxonomy,
+      semantics,
       deprecated,
       schema,
       bindings,
@@ -273,8 +272,8 @@ export class DomainProperty extends DomainElement {
     if (Array.isArray(tags)) {
       result.tags = [...tags]
     }
-    if (Array.isArray(taxonomy)) {
-      result.taxonomy = [...taxonomy]
+    if (Array.isArray(semantics)) {
+      result.semantics = [...semantics]
     }
     if (schema) {
       result.schema = structuredClone(schema)
@@ -353,10 +352,10 @@ export class DomainProperty extends DomainElement {
     } else {
       this.tags = []
     }
-    if (Array.isArray(init.taxonomy)) {
-      this.taxonomy = [...init.taxonomy]
+    if (Array.isArray(init.semantics)) {
+      this.semantics = [...init.semantics]
     } else {
-      this.taxonomy = []
+      this.semantics = []
     }
     if (init.schema) {
       this.schema = structuredClone(init.schema)
@@ -419,8 +418,8 @@ export class DomainProperty extends DomainElement {
     if (Array.isArray(this.tags) && this.tags.length) {
       result.tags = [...this.tags]
     }
-    if (Array.isArray(this.taxonomy) && this.taxonomy.length) {
-      result.taxonomy = [...this.taxonomy]
+    if (Array.isArray(this.semantics) && this.semantics.length) {
+      result.semantics = toRaw(this, this.semantics)?.map((i) => structuredClone(i))
     }
     if (this.schema) {
       result.schema = structuredClone(toRaw(this, this.schema))
@@ -545,4 +544,44 @@ export class DomainProperty extends DomainElement {
     const serializer = new ShapeGenerator()
     return serializer.property(this)
   }
+
+  /**
+   * Adds or updates a semantic to the property.
+   * @param semantic The semantic to add to the property.
+   * @throws Error if the semantic is not an property semantic.
+   */
+  addSemantic(semantic: AppliedDataSemantic): void {
+    const sem = DataSemantics[semantic.id]
+    if (!isPropertySemantic(sem)) {
+      throw new Error(`Invalid semantic type: ${semantic.id}. Expected a property semantic.`)
+    }
+    const index = this.semantics.findIndex((s) => s.id === semantic.id)
+    if (index >= 0) {
+      this.semantics[index] = semantic
+    } else {
+      this.semantics.push(semantic)
+    }
+    this.domain.notifyChange()
+  }
+
+  /**
+   * Removes a semantic from the property.
+   * @param semanticId The ID of the semantic to remove.
+   */
+  removeSemantic(semanticId: SemanticType): void {
+    const index = this.semantics.findIndex((s) => s.id === semanticId)
+    if (index >= 0) {
+      this.semantics.splice(index, 1)
+      this.domain.notifyChange()
+    }
+  }
+
+  /**
+   * Checks if the property has a specific semantic.
+   * @param semanticId The ID of the semantic to check.
+   * @returns True if the semantic is present, false otherwise.
+   */
+  hasSemantic(semanticId: SemanticType): boolean {
+    return this.semantics.some((s) => s.id === semanticId)
+  }
 }

package/src/modeling/Semantics.ts

@@ -0,0 +1,178 @@
+import type { DomainPropertyType } from './DataFormat.js'
+
+/**
+ * Defines the names for all available data semantics.
+ * Using a string enum makes it easy to add or remove semantics in a single place.
+ */
+export enum SemanticType {
+  // Entity-Level Semantics
+  /**
+   * Designates a Data Entity that represents users of the system.
+   */
+  User = 'https://apinow.app/semantics/entities/#User',
+
+  // Property-Level Semantics
+  CreatedTimestamp = 'https://apinow.app/semantics/properties/#CreatedTimestamp',
+  UpdatedTimestamp = 'https://apinow.app/semantics/properties/#UpdatedTimestamp',
+  DeletedTimestamp = 'https://apinow.app/semantics/properties/#DeletedTimestamp',
+  DeletedFlag = 'https://apinow.app/semantics/properties/#DeletedFlag',
+  PublicUniqueName = 'https://apinow.app/semantics/properties/#PublicUniqueName',
+  // Association-Level Semantics
+  ResourceOwnerIdentifier = 'https://apinow.app/semantics/associations/#ResourceOwnerIdentifier',
+}
+
+/**
+ * Defines the scope at which a semantic can be applied.
+ */
+export enum SemanticScope {
+  Entity = 'Entity',
+  Property = 'Property',
+  Association = 'Association',
+}
+
+/**
+ * A base interface for all Data Semantics, containing common properties.
+ * A semantic is an annotation applied to a Data Entity, Property, or Association
+ * to provide additional context or constraints.
+ * This interface is extended by more specific semantic types.
+ */
+interface BaseDataSemantic {
+  /**
+   * A unique identifier for the semantic definition.
+   */
+  id: SemanticType
+  /**
+   * A human-readable name for the semantic.
+   */
+  displayName: string
+  /**
+   * A description of the semantic's purpose and impact.
+   */
+  description: string
+  /**
+   * Specifies whether the semantic applies to an Entity, Property, or Association.
+   */
+  scope: SemanticScope
+}
+
+/**
+ * Represents a semantic that can be applied to an entire Data Entity.
+ */
+export interface EntitySemantic extends BaseDataSemantic {
+  scope: SemanticScope.Entity
+}
+
+/**
+ * Represents a semantic that can be applied to a single property.
+ */
+export interface PropertySemantic extends BaseDataSemantic {
+  scope: SemanticScope.Property
+  /**
+   * Optional array of data types this semantic can be applied to.
+   * Enforces constraints, e.g., DeletedTimestamp on a DateTime property.
+   */
+  applicableDataTypes?: DomainPropertyType[]
+}
+
+/**
+ * Represents a semantic that can be applied to an association between entities.
+ */
+export interface AssociationSemantic extends BaseDataSemantic {
+  scope: SemanticScope.Association
+}
+
+/**
+ * A type guard to check if a semantic is an EntitySemantic.
+ */
+export const isEntitySemantic = (semantic: DataSemantic): semantic is EntitySemantic =>
+  semantic.scope === SemanticScope.Entity
+
+/**
+ * A type guard to check if a semantic is a PropertySemantic.
+ */
+export const isPropertySemantic = (semantic: DataSemantic): semantic is PropertySemantic =>
+  semantic.scope === SemanticScope.Property
+
+/**
+ * A type guard to check if a semantic is a AssociationSemantic.
+ */
+export const isAssociationSemantic = (semantic: DataSemantic): semantic is AssociationSemantic =>
+  semantic.scope === SemanticScope.Association
+
+/**
+ * Union type for any kind of data semantic
+ */
+export type DataSemantic = EntitySemantic | PropertySemantic | AssociationSemantic
+
+/**
+ * A map to store the definitions of all available data semantics.
+ * This acts as a central registry for the application.
+ */
+export const DataSemantics: Record<SemanticType, DataSemantic> = {
+  // Entity-Level Definitions
+  [SemanticType.User]: {
+    id: SemanticType.User,
+    displayName: 'User Entity',
+    scope: SemanticScope.Entity,
+    description: 'Designates an entity that represents system users, crucial for authentication and authorization.',
+  },
+
+  // Property-Level Definitions
+  [SemanticType.CreatedTimestamp]: {
+    id: SemanticType.CreatedTimestamp,
+    displayName: 'Creation Timestamp',
+    scope: SemanticScope.Property,
+    description: "Marks a field as the one that contains the object's creation timestamp.",
+    applicableDataTypes: ['datetime'],
+  },
+  [SemanticType.UpdatedTimestamp]: {
+    id: SemanticType.UpdatedTimestamp,
+    displayName: 'Update Timestamp',
+    scope: SemanticScope.Property,
+    description: "Marks a field as the field that contains object's last modification timestamp.",
+    applicableDataTypes: ['datetime'],
+  },
+  [SemanticType.DeletedTimestamp]: {
+    id: SemanticType.DeletedTimestamp,
+    displayName: 'Soft Delete Timestamp',
+    scope: SemanticScope.Property,
+    description: "Marks a field as the field that contains object's deletion timestamp.",
+    applicableDataTypes: ['datetime'],
+  },
+  [SemanticType.DeletedFlag]: {
+    id: SemanticType.DeletedFlag,
+    displayName: 'Soft Delete Flag',
+    scope: SemanticScope.Property,
+    description: 'A boolean property that marks the object as deleted without physically removing it.',
+    applicableDataTypes: ['boolean'],
+  },
+  [SemanticType.ResourceOwnerIdentifier]: {
+    id: SemanticType.ResourceOwnerIdentifier,
+    displayName: 'Resource Owner Identifier',
+    scope: SemanticScope.Association,
+    description: 'Links a resource to a "User" entity instance, indicating ownership for access control.',
+  },
+  [SemanticType.PublicUniqueName]: {
+    id: SemanticType.PublicUniqueName,
+    displayName: 'Public Unique Name (Slug)',
+    scope: SemanticScope.Property,
+    description: 'A user-friendly, unique public identifier for a resource, often used in URLs.',
+    applicableDataTypes: ['string'],
+  },
+}
+
+/**
+ * Represents the application of a data semantic to a specific
+ * entity or property within a user's data model.
+ */
+export interface AppliedDataSemantic {
+  /**
+   * The unique identifier of the semantic being applied.
+   */
+  id: SemanticType
+
+  /**
+   * Optional configuration or values specific to this application.
+   */
+  config?: Record<string, unknown>
+}

package/src/modeling/graph.md

@@ -4,20 +4,20 @@
 
 ```plain
 DataDomain (Root container)
-  ├── DataNamespace (logical grouping)
-  │   └── DataModel
-  │       └── DataEntity
+  ├── DomainNamespace (logical grouping)
+  │   └── DomainModel
+  │       └── DomainEntity
   │           ├── Property (name, type, ...)
   │           ├── Association (name, cardinality, target Entity)
-  │           └── ParentEntity (reference to another DataEntity)
-  ├── DataModel
-  │   └── DataEntity
+  │           └── ParentEntity (reference to another DomainEntity)
+  ├── DomainModel
+  │   └── DomainEntity
   │       ├── Property
   │       ├── Association
   │       └── ParentEntity
-  └── ForeignDataNamespace (immutable, imported from another DataDomain)
-      └── DataModel
-          └── DataEntity
+  └── ForeignDomainNamespace (immutable, imported from another DataDomain)
+      └── DomainModel
+          └── DomainEntity
               ├── Property
               ├── Association
               └── ParentEntity
@@ -31,11 +31,11 @@ Here's a breakdown of how each element is represented in the graph:
 
 **Nodes:**
 
-* **Namespace:** Represents a `DataNamespace`. It's a container for models and other namespaces.
-* **Model:** Represents a `DataModel`. It's a container for entities.
-* **Entity:** Represents a `DataEntity`. It's the fundamental building block, defining a specific type of data.
-* **Property:** Represents a `DataProperty`. It's an attribute of an entity.
-* **Association:** Represents a `DataAssociation`. It defines a relationship between entities.
+* **Namespace:** Represents a `DomainNamespace`. It's a container for models and other namespaces.
+* **Model:** Represents a `DomainModel`. It's a container for entities.
+* **Entity:** Represents a `DomainEntity`. It's the fundamental building block, defining a specific type of data.
+* **Property:** Represents a `DomainProperty`. It's an attribute of an entity.
+* **Association:** Represents a `DomainAssociation`. It defines a relationship between entities.
 
 **Edges:**
 

package/src/modeling/readme.md

@@ -4,53 +4,53 @@
 
 At the heart of this data modeling system are the following fundamental concepts.
 
-### DataNamespace
+### DomainNamespace
 
 This is the top-level container, representing a logical grouping of data. Think of it as a "domain" or a "schema" in a database. It can contain:
 
-- `DataModels`: Logical groupings of entities.
+- `DomainModels`: Logical groupings of entities.
 - `DataEntities`: The basic building blocks, representing individual data structures.
 - `DataProperties`: Attributes of entities (e.g., name, age, address).
-- `DataAssociations`: Relationships between entities (e.g., a user has an address).
+- `DomainAssociations`: Relationships between entities (e.g., a user has an address).
 - `Sub-namespaces`: Namespaces can be nested within each other, creating a hierarchical structure.
 - `Foreign Namespaces`: References to external namespaces, enabling the use of entities defined elsewhere.
 - `Tags`: Common tags for the entire namespace.
 
-### DataModel
+### DomainModel
 
-A logical grouping of `DataEntity` instances. It represents a specific data structure, like a "Product" or "User" model. A `DataModel` can contain multiple `DataEntity` instances.
+A logical grouping of `DomainEntity` instances. It represents a specific data structure, like a "Product" or "User" model. A `DomainModel` can contain multiple `DomainEntity` instances.
 
-### DataEntity
+### DomainEntity
 
 The fundamental building block of the data model. It represents a specific type of data, like a "User," "Product," or "Address."
 
-- `Properties`: DataProperty instances that describe the attributes of the entity.
-- `Associations`: DataAssociation instances that define relationships to other entities.
+- `Properties`: DomainProperty instances that describe the attributes of the entity.
+- `Associations`: DomainAssociation instances that define relationships to other entities.
 - `Parents`: An entity can inherit from other entities, creating a hierarchy.
 - `Fields`: Ordered list of properties and associations.
 - `Tags`: Optional tags for the UI.
-- `Taxonomy`: Reserved for future use.
+- `Semantics`: A system of predefined, meaningful labels or classifications that can be applied to Data Entities or their individual properties.
 - `Deprecated`: Whether the entity is deprecated.
 - `Schema`: The schema allowing to translate the model into a specific format (like JSON, RAML, XML, etc.)
 
-### DataProperty
+### DomainProperty
 
-Represents an attribute of a `DataEntity`. It has a name, a data type (e.g., string, number, boolean), and optional constraints (e.g., required, multiple, min/max values).
+Represents an attribute of a `DomainEntity`. It has a name, a data type (e.g., string, number, boolean), and optional constraints (e.g., required, multiple, min/max values).
 
 - `Type`: The data type of the property.
 - `Schema`: The general schema definition of this property.
 - `Bindings`: The list of bindings for this property.
 - `Tags`: Optional tags for the UI.
-- `Taxonomy`: Reserved for future use.
+- `Semantics`: A system of predefined, meaningful labels or classifications that can be applied to Data Entities or their individual properties.
 - `Deprecated`: Whether the property is deprecated.
 - `Primary`: Whether this property describes a primary key of the entity.
 - `Index`: Whether this property describes an indexed property of the entity.
 - `ReadOnly`: Whether the property is read only in the schema.
 - `WriteOnly`: Whether the property is write only in the schema.
 
-### DataAssociation
+### DomainAssociation
 
-Defines a relationship between `DataEntity` instances. It specifies the target entities and the nature of the relationship (e.g., one-to-one, one-to-many).
+Defines a relationship between `DomainEntity` instances. It specifies the target entities and the nature of the relationship (e.g., one-to-one, one-to-many).
 
 - `Targets`: The list of target entities.
 - `Multiple`: Whether the association allows multiple target entities.
@@ -67,24 +67,24 @@ Defines a translation from a data model to a specific format (like JSON, RAML, X
 
 Here's how these components work together to structure a data domain:
 
-1. **Root Namespace**: You start with a `DataNamespace`, which acts as the root of your data domain. This namespace is the top-level container for all other elements.
+1. **Root Namespace**: You start with a `DomainNamespace`, which acts as the root of your data domain. This namespace is the top-level container for all other elements.
 
 1. **Sub-namespaces (Optional)**: You can create sub-namespaces within the root namespace to further organize your data. This is useful for large domains with many entities and relationships.
 
-1. **Data Models**: Within a namespace (or sub-namespace), you define `DataModel` instances. Each `DataModel` represents a specific area of your domain. For example, you might have a "User Management" `DataModel`, a "Product Catalog" `DataModel`, and an "Order Processing" `DataModel`.
+1. **Data Models**: Within a namespace (or sub-namespace), you define `DomainModel` instances. Each `DomainModel` represents a specific area of your domain. For example, you might have a "User Management" `DomainModel`, a "Product Catalog" `DomainModel`, and an "Order Processing" `DomainModel`.
 
-1. **Data Entities**: Inside each `DataModel`, you define `DataEntity` instances. These are the core data structures. For example, in the "User Management" `DataModel`, you might have `DataEntity` instances for "User," "Role," and "Permission."
+1. **Data Entities**: Inside each `DomainModel`, you define `DomainEntity` instances. These are the core data structures. For example, in the "User Management" `DomainModel`, you might have `DomainEntity` instances for "User," "Role," and "Permission."
 
-1. **Data Properties**: Each `DataEntity` has `DataProperty` instances that describe its attributes. For example, the "User" `DataEntity` might have `DataProperty` instances for "firstName" (string), "lastName" (string), "email" (string), "age" (number), etc.
+1. **Data Properties**: Each `DomainEntity` has `DomainProperty` instances that describe its attributes. For example, the "User" `DomainEntity` might have `DomainProperty` instances for "firstName" (string), "lastName" (string), "email" (string), "age" (number), etc.
 
-1. **Data Associations**: You use `DataAssociation` instances to define relationships between `DataEntity` instances. For example:
+1. **Data Associations**: You use `DomainAssociation` instances to define relationships between `DomainEntity` instances. For example:
 
    - A "User" has an "Address" (one-to-one).
    - A "User" has multiple "Roles" (one-to-many).
    - A "Product" belongs to a "Category" (many-to-one).
    - An "Order" contains multiple "Order Items" (one-to-many).
 
-1. **Inheritance**: `DataEntity` instances can inherit from other `DataEntity` instances using the parents property. This allows you to create a hierarchy of entities and reuse common properties and associations.
+1. **Inheritance**: `DomainEntity` instances can inherit from other `DomainEntity` instances using the parents property. This allows you to create a hierarchy of entities and reuse common properties and associations.
 
 1. **Foreign Namespaces**: You can reference entities from other namespaces using the foreign property of the root namespace. This allows you to reuse data structures defined elsewhere.
 
@@ -109,18 +109,18 @@ Let's imagine a simple e-commerce domain:
         - **Data Association**: `address` (references `Address` entity)
       - **Data Entity**: `Address`
         - **Data Properties**: `street` (string), `city` (string), `zipCode` (string), `country` (string)
-  - **Foreign Namespace**: `Taxonomy` (defined elsewhere)
-    - **Data Model**: `Taxonomy`
-      - **Data Entity**: `TaxonomyItem`
+  - **Foreign Namespace**: `Semantics` (defined elsewhere)
+    - **Data Model**: `Semantics`
+      - **Data Entity**: `SemanticsItem`
 
 ### Key Relationships
 
-- **Namespace-Model**: A `DataNamespace` contains `DataModel` instances.
-- **Model-Entity**: A `DataModel` contains `DataEntity` instances.
-- **Entity-Property**: A `DataEntity` has `DataProperty` instances.
-- **Entity-Association**: A `DataEntity` has `DataAssociation` instances.
-- **Entity-Parent**: A `DataEntity` can have `DataEntity` instances as parents.
-- **Namespace-Foreign**: A `DataNamespace` can have references to `DataNamespace` instances.
+- **Namespace-Model**: A `DomainNamespace` contains `DomainModel` instances.
+- **Model-Entity**: A `DomainModel` contains `DomainEntity` instances.
+- **Entity-Property**: A `DomainEntity` has `DomainProperty` instances.
+- **Entity-Association**: A `DomainEntity` has `DomainAssociation` instances.
+- **Entity-Parent**: A `DomainEntity` can have `DomainEntity` instances as parents.
+- **Namespace-Foreign**: A `DomainNamespace` can have references to `DomainNamespace` instances.
 
 ## Summary
 

package/src/models/kinds.ts

@@ -20,28 +20,3 @@ export const DataCatalogKind = 'Core#DataCatalog'
 export const DataCatalogVersionKind = 'Core#DataCatalogVersion'
 export const OrganizationKind = 'Core#Organization'
 export const InvitationKind = 'Core#Invitation'
-
-/**
- * @deprecated Not used anymore.
- */
-export const DataFileKind = 'Core#DataFile'
-/**
- * @deprecated Not used anymore.
- */
-export const DataNamespaceKind = 'Data#DataNamespace'
-/**
- * @deprecated Not used anymore.
- */
-export const DataModelKind = 'Data#DataModel'
-/**
- * @deprecated Not used anymore.
- */
-export const DataEntityKind = 'Data#DataEntity'
-/**
- * @deprecated Not used anymore.
- */
-export const DataAssociationKind = 'Data#DataAssociation'
-/**
- * @deprecated Not used anymore.
- */
-export const DataPropertyKind = 'Data#DataProperty'

package/src/models/store/data_catalog.ts

@@ -23,7 +23,7 @@ export interface PublishedDataDomain {
    */
   version: string
   /**
-   * Key of the referenced `DataNamespace` document.
+   * Key of the referenced `DomainNamespace` document.
    * Essentially this is a document id.
    */
   fid: string

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

@@ -1,5 +1,6 @@
 import { test } from '@japa/runner'
 import { DataDomain, DataFormat } from '../../../src/index.js'
+import { SemanticType } from '../../../src/modeling/Semantics.js'
 
 test.group('DataDomain change observers', () => {
   test('does not notifies a change when initializing a domain', async ({ assert }) => {
@@ -276,24 +277,24 @@ test.group('DomainEntity change observers', () => {
     await assert.dispatchCount(domain, 'change', 1, { timeout: 1 })
   })
 
-  test('notifies a change when adding a taxonomy', async ({ assert, sleep }) => {
+  test('notifies a change when adding a semantics', async ({ assert, sleep }) => {
     const domain = new DataDomain()
     const n1 = domain.addNamespace()
     const m1 = n1.addModel()
     const e1 = m1.addEntity()
     await sleep(1)
-    e1.taxonomy.push('test')
+    e1.semantics.push({ id: SemanticType.User })
     await assert.dispatchCount(domain, 'change', 1, { timeout: 1 })
   })
 
-  test('notifies a change when removing a taxonomy', async ({ assert, sleep }) => {
+  test('notifies a change when removing a semantics', async ({ assert, sleep }) => {
     const domain = new DataDomain()
     const n1 = domain.addNamespace()
     const m1 = n1.addModel()
     const e1 = m1.addEntity()
-    e1.taxonomy.push('test')
+    e1.semantics.push({ id: SemanticType.User })
     await sleep(1)
-    e1.taxonomy.pop()
+    e1.semantics.pop()
     await assert.dispatchCount(domain, 'change', 1, { timeout: 1 })
   })
 
@@ -508,26 +509,26 @@ test.group('DomainProperty change observers', () => {
     await assert.dispatchCount(domain, 'change', 1, { timeout: 1 })
   })
 
-  test('notifies a change when adding a taxonomy', async ({ assert, sleep }) => {
+  test('notifies a change when adding a semantics', async ({ assert, sleep }) => {
     const domain = new DataDomain()
     const n1 = domain.addNamespace()
     const m1 = n1.addModel()
     const e1 = m1.addEntity()
     const p1 = e1.addProperty()
     await sleep(1)
-    p1.taxonomy.push('test')
+    p1.semantics.push({ id: SemanticType.CreatedTimestamp })
     await assert.dispatchCount(domain, 'change', 1, { timeout: 1 })
   })
 
-  test('notifies a change when removing a taxonomy', async ({ assert, sleep }) => {
+  test('notifies a change when removing a semantics', async ({ assert, sleep }) => {
     const domain = new DataDomain()
     const n1 = domain.addNamespace()
     const m1 = n1.addModel()
     const e1 = m1.addEntity()
     const p1 = e1.addProperty()
-    p1.taxonomy.push('test')
+    p1.semantics.push({ id: SemanticType.CreatedTimestamp })
     await sleep(1)
-    p1.taxonomy.pop()
+    p1.semantics.pop()
     await assert.dispatchCount(domain, 'change', 1, { timeout: 1 })
   })