@api-client/core 0.18.17 → 0.18.19

package/data/models/example-generator-api.json

@@ -42068,10 +42068,10 @@
 "@id": "#194"
 },
 {
-"@id": "#200"
+"@id": "#197"
 },
 {
-"@id": "#197"
+"@id": "#200"
 },
 {
 "@id": "#203"
@@ -43478,7 +43478,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "class: '3'\ndescription: '150 - 300'\nnumberOfFte: 5500\nnumberOfEmployees: 5232\n",
+"doc:raw": "code: '5'\ndescription: 'Limited company'\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -43499,7 +43499,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "code: '5'\ndescription: 'Limited company'\n",
+"doc:raw": "class: '3'\ndescription: '150 - 300'\nnumberOfFte: 5500\nnumberOfEmployees: 5232\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -44766,12 +44766,12 @@
 {
 "@id": "#199/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#199",
-"sourcemaps:value": "[(1,0)-(5,0)]"
+"sourcemaps:value": "[(1,0)-(3,0)]"
 },
 {
 "@id": "#202/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#202",
-"sourcemaps:value": "[(1,0)-(3,0)]"
+"sourcemaps:value": "[(1,0)-(5,0)]"
 },
 {
 "@id": "#205/source-map/lexical/element_0",

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.18.17",
+  "version": "0.18.19",
   "license": "Apache-2.0",
   "exports": {
     "./browser.js": {
@@ -57,6 +57,7 @@
     "#authorization/*": "./src/authorization/*",
     "#cookies/*": "./src/cookies/*",
     "#data/*": "./src/data/*",
+    "#decorators/*": "./src/decorators/*",
     "#events/*": "./src/events/*",
     "#lib/*": "./src/lib/*",
     "#mocking/*": "./src/mocking/*",

package/src/{modeling → decorators}/observed.ts

@@ -73,10 +73,10 @@ export function toRaw<T extends object = object>(source: object, target: T): T |
  * - As a class property decorator
  * - As a class setter decorator
  *
- * The property class either has to have a `root` property
+ * The property class either has to have the `domain` property
  * or a `notifyChange` method. The decorator will call the
  * `notifyChange` method if it exists. Otherwise, it will
- * call the `notifyChange` method of the root domain.
+ * call the `notifyChange` method of the root domain (the `domain` property).
  */
 export function observed(config: ObserveConfig = {}): PropertyDecorator {
   return <C extends DomainInstance, V>(
@@ -138,7 +138,7 @@ export function observed(config: ObserveConfig = {}): PropertyDecorator {
             map = {}
             Reflect.set(this, reactiveSymbol, map)
           }
-          if (map[context.name] === context.name) {
+          if (map[context.name] === value) {
             return
           }
           const notify = () => {
@@ -196,7 +196,7 @@ export function observed(config: ObserveConfig = {}): PropertyDecorator {
  * property itself.
  */
 export function retargetChange() {
-  return <C extends DomainInstance, V extends EventTarget>(
+  return <C extends DomainInstance, V extends EventTarget | undefined>(
     target: StandardPropertyTarget<C, V>,
     context: StandardPropertyContext<C, V>
   ): any => {
@@ -215,7 +215,7 @@ export function retargetChange() {
             map = {}
             Reflect.set(this, reactiveSymbol, map)
           }
-          if (map[context.name] === context.name) {
+          if (map[context.name] === value) {
             return
           }
           const oldValue = map[context.name]

package/src/modeling/ApiModel.ts

@@ -14,7 +14,7 @@ import type {
 } from './types.js'
 import { DataDomain } from './DataDomain.js'
 import { DependentModel, type DependentModelSchema, type DomainDependency } from './DependentModel.js'
-import { observed, toRaw } from './observed.js'
+import { observed, toRaw } from '../decorators/observed.js'
 
 /**
  * Contact information for the exposed API.

package/src/modeling/DataDomain.ts

@@ -15,6 +15,9 @@ import type {
   DomainGraphEdge,
   DomainGraphNodeType,
   SerializedGraph,
+  DomainSearchCriteria,
+  DomainSearchResult,
+  SearchableNodeType,
 } from './types.js'
 import { type DomainNamespaceSchema, DomainNamespace, type NamespaceOrderedItem } from './DomainNamespace.js'
 import { type DomainModelSchema, DomainModel } from './DomainModel.js'
@@ -1361,4 +1364,145 @@ export class DataDomain extends DependentModel {
         throw new Error(`Unknown kind ${kind} for the object ${key}`)
     }
   }
+
+  /**
+   * Searches domain nodes by text content and/or node type.
+   *
+   * This function traverses the graph and filters nodes based on the provided search criteria.
+   * It can search through name, displayName, and description fields of domain objects,
+   * and optionally filter by specific node types.
+   *
+   * @param criteria Search criteria including query string/regex and filtering options.
+   * @returns An array of search results containing matching nodes and metadata.
+   *
+   * @example
+   * ```typescript
+   * // Search for nodes containing "user" in any text field
+   * const results = dataDomain.search({ query: 'user' });
+   *
+   * // Search for entities only
+   * const entityResults = dataDomain.search({
+   *   nodeTypes: [DomainEntityKind]
+   * });
+   *
+   * // Search for "user" in entities and properties with case-sensitive matching
+   * const specificResults = dataDomain.search({
+   *   query: 'User',
+   *   nodeTypes: [DomainEntityKind, DomainPropertyKind],
+   *   caseSensitive: true
+   * });
+   *
+   * // Search using regex pattern
+   * const regexResults = dataDomain.search({
+   *   query: /^user/i
+   * });
+   * ```
+   */
+  search(criteria: DomainSearchCriteria = {}): DomainSearchResult[] {
+    const { query, nodeTypes, includeForeignDomains = false, caseSensitive = false } = criteria
+
+    const results: DomainSearchResult[] = []
+
+    // If no criteria provided, return all nodes
+    const shouldReturnAll = !query && (!nodeTypes || nodeTypes.length === 0)
+
+    // Helper function to check if a node matches the type filter
+    const matchesNodeType = (nodeKind: string): boolean => {
+      if (!nodeTypes || nodeTypes.length === 0) {
+        return true
+      }
+      return nodeTypes.includes(nodeKind as SearchableNodeType)
+    }
+
+    // Helper function to check if text matches the query
+    const matchesQuery = (text: string | undefined): boolean => {
+      if (!text || !query) {
+        return !query // If no query, consider it a match
+      }
+
+      if (query instanceof RegExp) {
+        return query.test(text)
+      }
+
+      // String query
+      const searchText = caseSensitive ? text : text.toLowerCase()
+      const searchQuery = caseSensitive ? query : query.toLowerCase()
+      return searchText.includes(searchQuery)
+    }
+
+    // Helper function to get matched fields for a node
+    const getMatchedFields = (node: DomainGraphNodeType): ('name' | 'displayName' | 'description')[] => {
+      if (!query) {
+        return [] // No query means no specific field matching
+      }
+
+      const matched: ('name' | 'displayName' | 'description')[] = []
+      const { info } = node
+
+      if (matchesQuery(info.name)) {
+        matched.push('name')
+      }
+      if (matchesQuery(info.displayName)) {
+        matched.push('displayName')
+      }
+      if (matchesQuery(info.description)) {
+        matched.push('description')
+      }
+
+      return matched
+    }
+
+    // Helper function to determine if a node key belongs to a foreign domain
+    const isForeignNode = (nodeKey: string): boolean => {
+      return nodeKey.includes(':')
+    }
+
+    // Iterate through all nodes in the graph
+    for (const nodeKey of this.graph.nodes()) {
+      const node = this.graph.node(nodeKey) as DomainGraphNodeType
+
+      // Skip if node doesn't exist or doesn't have required properties
+      if (!node || !node.info) {
+        continue
+      }
+
+      const isForeign = isForeignNode(nodeKey)
+
+      // Skip foreign nodes if not requested
+      if (isForeign && !includeForeignDomains) {
+        continue
+      }
+
+      // Check node type filter
+      if (!matchesNodeType(node.kind)) {
+        continue
+      }
+
+      // If returning all nodes (no specific criteria), add the node
+      if (shouldReturnAll) {
+        results.push({
+          node,
+          matchedFields: [],
+          key: nodeKey,
+          isForeign,
+        })
+        continue
+      }
+
+      // Check text query match
+      const matchedFields = getMatchedFields(node)
+      const hasTextMatch = !query || matchedFields.length > 0
+
+      if (hasTextMatch) {
+        results.push({
+          node,
+          matchedFields,
+          key: nodeKey,
+          isForeign,
+        })
+      }
+    }
+
+    return results
+  }
 }

package/src/modeling/DomainAssociation.ts

@@ -3,7 +3,7 @@ import { DomainAssociationKind } from '../models/kinds.js'
 import { DomainElement, type DomainElementSchema } from './DomainElement.js'
 import { nanoid } from '../nanoid.js'
 import { type IThing, Thing } from '../models/Thing.js'
-import { observed, retargetChange, toRaw } from './observed.js'
+import { observed, retargetChange, toRaw } from '../decorators/observed.js'
 import type { DomainEntity } from './DomainEntity.js'
 import type { IApiAssociationShape, IApiPropertyShape } from '../amf/definitions/Shapes.js'
 import type { AssociationBinding, AssociationBindings, AssociationWebBindings } from './Bindings.js'
@@ -591,4 +591,54 @@ export class DomainAssociation extends DomainElement {
   hasSemantic(semanticId: SemanticType): boolean {
     return this.semantics.some((s) => s.id === semanticId)
   }
+
+  /**
+   * Creates a duplicate of this association.
+   * It places the duplicate on the parent entity right after the original association.
+   *
+   * @returns A new `DomainAssociation` instance that is a duplicate of this one.
+   */
+  duplicate(): DomainAssociation {
+    const parent = this.getParentInstance()
+    if (!parent) {
+      throw new Error(`Cannot duplicate association ${this.key} as it has no parent entity.`)
+    }
+    const originalIndex = parent.fields.findIndex((f) => f.key === this.key)
+    if (originalIndex === -1) {
+      throw new Error(`Cannot duplicate association ${this.key} as it does not exist on the parent entity fields list.`)
+    }
+    const baseName = this.info.name || 'field'
+    const newName = parent.generateUniqueName(baseName)
+
+    // Making a copy and restoring it through the `addAssociation()` method
+    // scales better than copying it manually.
+    const copy = this.toJSON() as Partial<DomainAssociationSchema>
+
+    // Delete properties that should not be copied
+    delete copy.key
+    delete copy.targets
+
+    // Set the new name for the duplicated association
+    if (copy.info) {
+      copy.info.name = newName
+    } else {
+      copy.info = { name: newName }
+    }
+
+    const result = parent.addAssociation({}, copy)
+
+    // Copy the target entities
+    for (const target of this.targets) {
+      result.addTarget(target.key, target.domain)
+    }
+
+    // Move the duplicate to be right after the original
+    const fromIndex = parent.fields.length - 1
+    const duplicateField = parent.fields[fromIndex]
+    parent.fields.splice(fromIndex, 1)
+    parent.fields.splice(originalIndex + 1, 0, duplicateField)
+
+    this.domain.notifyChange()
+    return result
+  }
 }

package/src/modeling/DomainEntity.ts

@@ -3,7 +3,7 @@ import { DomainAssociationKind, DomainEntityKind, DomainPropertyKind } from '../
 import { DomainElement, type DomainElementSchema } from './DomainElement.js'
 import { nanoid } from '../nanoid.js'
 import { type IThing, Thing } from '../models/Thing.js'
-import { observed, retargetChange, toRaw } from './observed.js'
+import { observed, retargetChange, toRaw } from '../decorators/observed.js'
 import type { IShapeUnion } from '../amf/definitions/Shapes.js'
 import { DomainProperty, type DomainPropertySchema } from './DomainProperty.js'
 import { RemovePropertyException } from '../exceptions/remove_property_exception.js'
@@ -880,4 +880,27 @@ export class DomainEntity extends DomainElement {
   hasSemantic(semanticId: SemanticType): boolean {
     return this.semantics.some((s) => s.id === semanticId)
   }
+
+  /**
+   * Generates a unique name by appending a number to the base name.
+   * @param baseName The base name to make unique.
+   * @returns A unique name within the current entity.
+   */
+  generateUniqueName(baseName: string): string {
+    const existingNames = new Set<string>()
+    for (const field of this.listFields()) {
+      if (field.info.name) {
+        existingNames.add(field.info.name)
+      }
+    }
+
+    let counter = 2
+    let newName = `${baseName}_copy`
+    while (existingNames.has(newName)) {
+      newName = `${baseName}_copy_${counter}`
+      counter++
+    }
+
+    return newName
+  }
 }

package/src/modeling/DomainModel.ts

@@ -3,7 +3,7 @@ import { DomainEntityKind, DomainModelKind } from '../models/kinds.js'
 import { DomainElement, DomainElementSchema } from './DomainElement.js'
 import { nanoid } from '../nanoid.js'
 import { type IThing, Thing } from '../models/Thing.js'
-import { observed, retargetChange } from './observed.js'
+import { observed, retargetChange } from '../decorators/observed.js'
 import type { DomainNamespace } from './DomainNamespace.js'
 import type { FileBreadcrumb } from '../models/store/File.js'
 import { DomainEntity, type DomainEntitySchema } from './DomainEntity.js'

package/src/modeling/DomainNamespace.ts

@@ -3,7 +3,7 @@ import { DomainModelKind, DomainNamespaceKind } from '../models/kinds.js'
 import { DomainElement, DomainElementSchema } from './DomainElement.js'
 import { nanoid } from '../nanoid.js'
 import { IThing, Thing } from '../models/Thing.js'
-import { observed, retargetChange } from './observed.js'
+import { observed, retargetChange } from '../decorators/observed.js'
 import { DomainModel, DomainModelSchema } from './DomainModel.js'
 import { RemoveNamespaceException } from '../exceptions/remove_namespace_exception.js'
 import { RemoveModelException } from '../exceptions/remove_model_exception.js'

package/src/modeling/DomainProperty.ts

@@ -3,7 +3,7 @@ import { DomainPropertyKind } from '../models/kinds.js'
 import { DomainElement, type DomainElementSchema } from './DomainElement.js'
 import { nanoid } from '../nanoid.js'
 import { type IThing, Thing } from '../models/Thing.js'
-import { observed, retargetChange, toRaw } from './observed.js'
+import { observed, retargetChange, toRaw } from '../decorators/observed.js'
 import {
   type BinaryFormat,
   BinaryFormats,
@@ -44,6 +44,11 @@ export interface DomainPropertySchema extends DomainElementSchema {
    * Whether this property describes a primary key of the entity.
    */
   primary?: boolean
+  /**
+   * Whether this property describes a unique property of the entity.
+   * This is used to generate unique constraints in the database.
+   */
+  unique?: boolean
   /**
    * Whether this property describes an indexed property of the entity.
    */
@@ -158,6 +163,12 @@ export class DomainProperty extends DomainElement {
    */
   @observed() accessor primary: boolean | undefined
 
+  /**
+   * Whether this property describes a unique property of the entity.
+   * This is used to generate unique constraints in the database.
+   */
+  @observed() accessor unique: boolean | undefined
+
   /**
    * Whether this property describes an indexed property of the entity.
    */
@@ -230,6 +241,7 @@ export class DomainProperty extends DomainElement {
       type = DomainPropertyList.string,
       index,
       primary,
+      unique,
       readOnly,
       writeOnly,
       tags,
@@ -262,6 +274,9 @@ export class DomainProperty extends DomainElement {
     if (typeof primary === 'boolean') {
       result.primary = primary
     }
+    if (typeof unique === 'boolean') {
+      result.unique = unique
+    }
     if (typeof readOnly === 'boolean') {
       result.readOnly = readOnly
     }
@@ -339,6 +354,11 @@ export class DomainProperty extends DomainElement {
     } else {
       this.primary = undefined
     }
+    if (typeof init.unique === 'boolean') {
+      this.unique = init.unique
+    } else {
+      this.unique = undefined
+    }
     if (typeof init.readOnly === 'boolean') {
       this.readOnly = init.readOnly
     } else {
@@ -405,6 +425,9 @@ export class DomainProperty extends DomainElement {
     if (typeof this.primary === 'boolean') {
       result.primary = this.primary
     }
+    if (typeof this.unique === 'boolean') {
+      result.unique = this.unique
+    }
     if (typeof this.multiple === 'boolean') {
       result.multiple = this.multiple
     }
@@ -617,4 +640,46 @@ export class DomainProperty extends DomainElement {
   hasSemantic(semanticId: SemanticType): boolean {
     return this.semantics.some((s) => s.id === semanticId)
   }
+
+  /**
+   * Creates a duplicate of this domain property on the parent entity.
+   * It places the duplicate on the parent entity right after the original property.
+   */
+  duplicate(): DomainProperty {
+    const parent = this.getParentInstance()
+    if (!parent) {
+      throw new Error(`Cannot duplicate property ${this.key} as it has no parent entity.`)
+    }
+    const originalIndex = parent.fields.findIndex((f) => f.key === this.key)
+    if (originalIndex === -1) {
+      throw new Error(`Cannot duplicate property ${this.key} as it does not exist on the parent entity fields list.`)
+    }
+    const baseName = this.info.name || 'field'
+    const newName = parent.generateUniqueName(baseName)
+
+    // Making a copy and restoring it through the `addProperty()` method
+    // scales better than copying it manually.
+    const copy = this.toJSON() as Partial<DomainPropertySchema>
+
+    // Delete properties that should not be copied
+    delete copy.key
+    delete copy.primary // Don't duplicate the primary key
+
+    // Set the new name for the duplicated property
+    if (copy.info) {
+      copy.info.name = newName
+    } else {
+      copy.info = { name: newName }
+    }
+    const result = parent.addProperty(copy)
+
+    // Move the duplicate to be right after the original
+    const fromIndex = parent.fields.length - 1
+    const duplicateField = parent.fields[fromIndex]
+    parent.fields.splice(fromIndex, 1)
+    parent.fields.splice(originalIndex + 1, 0, duplicateField)
+
+    this.domain.notifyChange()
+    return result
+  }
 }

package/src/modeling/DomainSerialization.ts

@@ -200,10 +200,8 @@ function validateGraphConsistency(g: DataDomainGraph, domainKey: string): void {
       })
 
       if (targetEdges.length === 0) {
-        validationErrors.push(
-          `Association "${association.info.name}" (${nodeId}) has no target entities. ` +
-            `Associations must reference at least one target entity.`
-        )
+        // This is general warning message, do not an error.
+        // We can serialize and deserialize associations without targets.
       }
 
       // Validate that all target entities exist

package/src/modeling/definitions/SKU.ts

@@ -152,6 +152,8 @@ export const SKU_PRESETS = {
     caseMode: 'uppercase',
     prefix: 'PROD-',
     enforceUniqueness: true,
+    validateReservedWords: true,
+    reservedValues: ['ADMIN', 'TEST', 'NULL', 'DEFAULT'],
   }),
 
   /**