@api-client/core 0.18.18 → 0.18.19

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.18",
+  "version": "0.18.19",
   "license": "Apache-2.0",
   "exports": {
     "./browser.js": {

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/DomainProperty.ts

@@ -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
     }

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'],
   }),
 
   /**