@api-client/core 0.11.11 → 0.12.1

package/src/modeling/{DataProperty.ts → legacy/DataProperty.ts}

@@ -1,11 +1,11 @@
 import { Json } from '@api-client/json'
-import { IThing, Thing } from '../models/Thing.js'
-import v4 from '../lib/uuid.js'
+import { IThing, Thing } from '../../models/Thing.js'
+import { nanoid } from 'nanoid'
 import { DataNamespace } from './DataNamespace.js'
-import { IApiPropertyShape } from '../amf/definitions/Shapes.js'
-import { AmfShapeGenerator } from '../amf/AmfShapeGenerator.js'
-import { PropertyBinding, PropertyBindings, PropertyWebBindings } from './Bindings.js'
-import { DataPropertyKind } from '../models/kinds.js'
+import { IApiPropertyShape } from '../../amf/definitions/Shapes.js'
+import { AmfShapeGenerator } from '../../amf/AmfShapeGenerator.js'
+import { PropertyBinding, PropertyBindings, PropertyWebBindings } from '../Bindings.js'
+import { DataPropertyKind } from '../../models/kinds.js'
 import {
   type BinaryFormat,
   BinaryFormats,
@@ -17,11 +17,12 @@ import {
   DataPropertyTypes,
   type NumberFormat,
   NumberFormats,
-} from './DataFormat.js'
+} from '../DataFormat.js'
 import type { DataEntity } from './DataEntity.js'
 
 /**
  * Describes the default value set on a property schema.
+ * @deprecated
  */
 export interface SchemaDefaultValue {
   /**
@@ -41,6 +42,7 @@ export interface SchemaDefaultValue {
 /**
  * A general schema definition for a property.
  * This is propagated to all bindings (when they support these properties).
+ * @deprecated
  */
 export interface DataPropertySchema {
   /**
@@ -109,6 +111,9 @@ export interface DataPropertySchema {
   examples?: string[]
 }
 
+/**
+ * @deprecated
+ */
 export interface IDataProperty {
   kind: typeof DataPropertyKind
   /**
@@ -180,6 +185,9 @@ export interface IDataProperty {
   bindings?: PropertyBinding[]
 }
 
+/**
+ * @deprecated
+ */
 export class DataProperty {
   kind = DataPropertyKind
 
@@ -296,7 +304,7 @@ export class DataProperty {
     } else {
       init = {
         kind: DataPropertyKind,
-        key: v4(),
+        key: nanoid(),
         info: Thing.fromName('').toJSON(),
         type: 'string',
       }
@@ -310,7 +318,7 @@ export class DataProperty {
     }
     const {
       info,
-      key = v4(),
+      key = nanoid(),
       kind = DataPropertyKind,
       multiple,
       required,

package/src/modeling/observed.ts

@@ -0,0 +1,267 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const reactiveSymbol = Symbol('reactive')
+const proxySymbol = Symbol('proxy')
+
+interface DomainInstance {
+  domain?: { notifyChange(): void }
+  notifyChange?: () => void
+}
+
+export interface PropertyDecorator {
+  // accessor decorator signature
+  <C extends DomainInstance, V>(
+    target: ClassAccessorDecoratorTarget<C, V>,
+    context: ClassAccessorDecoratorContext<C, V>
+  ): ClassAccessorDecoratorResult<C, V>
+  // setter decorator signature
+  <C extends DomainInstance, V>(
+    target: (value: V) => void,
+    context: ClassSetterDecoratorContext<C, V>
+  ): (this: C, value: V) => void
+}
+
+type StandardPropertyContext<C, V> = ClassAccessorDecoratorContext<C, V> | ClassSetterDecoratorContext<C, V>
+type StandardPropertyTarget<C, V> = ClassAccessorDecoratorTarget<C, V> | ((value: V) => void)
+
+export interface ObserveConfig {
+  /**
+   * To be used when observing an object and not a primitive.
+   * It creates a proxy that observes changes in the object.
+   */
+  deep?: boolean
+}
+
+/**
+ * Reads the raw value of the object, that is, not proxied object.
+ * @param source The source object that contains the object
+ * @param target The target object set on the source object
+ * @returns The not proxied object or undefined
+ */
+export function toRaw<T extends object = object>(source: object, target: T): T | undefined {
+  const proxies = Reflect.get(source, proxySymbol) as Map<object, object>
+  if (!proxies) {
+    return undefined
+  }
+  for (const [key, value] of proxies.entries()) {
+    if (value === target) {
+      return key as T
+    }
+  }
+}
+
+/**
+ * Turns a class property or a setter into an observed property
+ * that notifies the root domain when changed.
+ *
+ * A property has to be declared with the `accessor` type to be
+ * observed.
+ *
+ * ```typescript
+ * @observed() accessor name: string | undefined
+ *
+ * @observed()
+ * set height(value: number) {
+ *   this.#height = value
+ * }
+ *
+ * get height(): number {
+ *   return this.#height
+ * }
+ * ```
+ *
+ * The decorator can be used in the following ways:
+ * - As a class property decorator
+ * - As a class setter decorator
+ *
+ * The property class either has to have a `root` 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.
+ */
+export function observed(config: ObserveConfig = {}): PropertyDecorator {
+  return <C extends DomainInstance, V>(
+    target: StandardPropertyTarget<C, V>,
+    context: StandardPropertyContext<C, V>
+  ): any => {
+    const { kind } = context
+    const { deep } = config
+
+    function createDeepProxy(this: DomainInstance, obj: unknown, notifyChange: () => void): any {
+      if (typeof obj !== 'object' || obj === null) {
+        return obj
+      }
+      // instead of using the target object to store the proxy info, we
+      // reflect the proxy info to the object itself. This way we can
+      // keep the stored values clean, which helps with testing (deep equal would include symbols)
+      // Keys are original objects, values are proxies
+      let proxies = Reflect.get(this, proxySymbol) as Map<object, object>
+      if (!proxies) {
+        proxies = new Map()
+        Reflect.set(this, proxySymbol, proxies)
+      }
+
+      if (proxies.has(obj)) {
+        return obj
+      }
+
+      // eslint-disable-next-line @typescript-eslint/no-this-alias
+      const targetObject = this
+
+      const proxy = new Proxy(obj, {
+        get(target, prop) {
+          const value = Reflect.get(target, prop)
+          return createDeepProxy.bind(targetObject)(value, notifyChange)
+        },
+        set(target, prop, value) {
+          const oldValue = Reflect.get(target, prop)
+          if (oldValue !== value) {
+            Reflect.set(target, prop, value)
+            notifyChange()
+          }
+          return true
+        },
+        deleteProperty(target, prop) {
+          Reflect.deleteProperty(target, prop)
+          notifyChange()
+          return true
+        },
+      })
+      proxies.set(obj, proxy)
+      return proxy
+    }
+
+    if (kind === 'accessor') {
+      return {
+        set(this: DomainInstance, value: V): void {
+          let map = Reflect.get(this, reactiveSymbol)
+          if (!map) {
+            map = {}
+            Reflect.set(this, reactiveSymbol, map)
+          }
+          if (map[context.name] === context.name) {
+            return
+          }
+          const notify = () => {
+            if (this.domain) {
+              this.domain.notifyChange()
+            } else if (this.notifyChange) {
+              this.notifyChange()
+            }
+          }
+          if (deep) {
+            value = createDeepProxy.bind(this)(value, notify)
+          }
+          if (value === undefined) {
+            // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+            delete map[context.name]
+          } else {
+            map[context.name] = value
+          }
+          notify()
+        },
+
+        get(): V {
+          const map = Reflect.get(this, reactiveSymbol) || {}
+          return map[context.name]
+        },
+      }
+    } else if (kind === 'setter') {
+      const { name } = context
+      return function (this: DomainInstance, value: V): void {
+        const oldValue = this[name as keyof DomainInstance]
+        if (value === oldValue) {
+          return
+        }
+        const notify = () => {
+          if (this.domain) {
+            this.domain.notifyChange()
+          } else if (this.notifyChange) {
+            this.notifyChange()
+          }
+        }
+        ;(target as (value: V) => void).call(this, value)
+        notify()
+      }
+    }
+    throw new Error(`Unsupported decorator location: ${kind}`)
+  }
+}
+
+/**
+ * A decorator that can be used to retarget the change event
+ * of a property to the root domain.
+ *
+ * This decorator should not be used with the `observed` decorator.
+ * It does the same thing. It will notify about a change to the
+ * property itself.
+ */
+export function retargetChange() {
+  return <C extends DomainInstance, V extends EventTarget>(
+    target: StandardPropertyTarget<C, V>,
+    context: StandardPropertyContext<C, V>
+  ): any => {
+    const { kind } = context
+    function observer(this: DomainInstance) {
+      if (this.domain) {
+        this.domain.notifyChange()
+      }
+    }
+    let binding: ((this: DomainInstance) => void) | undefined
+    if (kind === 'accessor') {
+      return {
+        set(this: DomainInstance, value: V): void {
+          let map = Reflect.get(this, reactiveSymbol)
+          if (!map) {
+            map = {}
+            Reflect.set(this, reactiveSymbol, map)
+          }
+          if (map[context.name] === context.name) {
+            return
+          }
+          const oldValue = map[context.name]
+          if (oldValue === value) {
+            return
+          }
+          if (value === undefined) {
+            // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+            delete map[context.name]
+          } else {
+            map[context.name] = value
+          }
+          if (oldValue && binding) {
+            oldValue.removeEventListener('change', binding)
+          }
+          if (value) {
+            binding = observer.bind(this)
+            value.addEventListener('change', binding)
+          }
+          if (this.domain) {
+            this.domain.notifyChange()
+          }
+        },
+
+        get(): V {
+          const map = Reflect.get(this, reactiveSymbol) || {}
+          return map[context.name]
+        },
+      }
+    } else if (kind === 'setter') {
+      const { name } = context
+      return function (this: DomainInstance, value: V): void {
+        const oldValue = this[name as keyof DomainInstance] as unknown as V
+        if (value === oldValue) {
+          return
+        }
+        ;(target as (value: V) => void).call(this, value)
+        if (oldValue && binding) {
+          oldValue.removeEventListener('change', binding)
+        }
+        if (value) {
+          binding = observer.bind(this)
+          value.addEventListener('change', binding)
+        }
+      }
+    }
+    throw new Error(`Unsupported decorator location: ${kind}`)
+  }
+}

package/src/modeling/types.ts

@@ -1,6 +1,13 @@
+import type { Graph, GraphJson } from '@api-client/graph'
+import type { DomainAssociation } from './DomainAssociation.js'
+import type { DomainEntity } from './DomainEntity.js'
+import type { DomainModel } from './DomainModel.js'
+import type { DomainNamespace } from './DomainNamespace.js'
+import type { DomainProperty } from './DomainProperty.js'
+
 export interface DataDomainRemoveOptions {
   /**
-   * When true, the object will be forcebly removed.
+   * When true, the object will be forcibly removed.
    * The resolution defined in the `ImpactResolution` class will be applied.
    *
    * For example, when removing an entity that is a parent to another entity, it will
@@ -11,3 +18,169 @@ export interface DataDomainRemoveOptions {
    */
   force?: boolean
 }
+
+export interface AssociationAddOptions {
+  /**
+   * When set, it is the the association target's origin data domain.
+   * The key of the target data domain where this target entity is defined.
+   * Only used when `key` is specified.
+   */
+  domain?: string
+  /**
+   * The key of the association target, if known.
+   * If the target of the association is not specified, and the association has no other targets,
+   * the association is ignored in the namespace while processing.
+   */
+  key?: string
+}
+
+export interface DomainGraphEdge {
+  /**
+   * Indicates that the edge is to or from a foreign domain.
+   */
+  foreign?: boolean
+  /**
+   * The key of the foreign domain. Always set with the `foreign` property.
+   */
+  domain?: string
+  /**
+   * The type of the edge.
+   * - `association` The edge is to an association object.
+   *   - When coming **from** an entiry (the `v` property), that entity owns the association.
+   *   - When coming **to** an entity (the `w` property), that entity is the target of the association.
+   *     An association can have multiple targets.
+   * - `property` The edge is to a property object. Can only be created between an entity and a property.
+   *   - The **from** (`v`) is the entity.
+   *   - The **to** (`w`) is the property.
+   * - `parent` The edge is to a parent object.
+   *   - The **from** (`v`) is the child entity.
+   *   - The **to** (`w`) is the parent entity.
+   */
+  type: 'association' | 'property' | 'parent'
+}
+
+export type DomainGraphNodeType = DomainNamespace | DomainModel | DomainEntity | DomainProperty | DomainAssociation
+
+/**
+ * An interface that describes the data domain dependency.
+ */
+export interface ForeignDomainDependency {
+  /**
+   * The system registered key of the foreign domain.
+   */
+  key: string
+  /**
+   * The version of the foreign domain used in this domain.
+   */
+  version: string
+}
+
+export interface AssociationTarget {
+  /**
+   * The key of the target entity.
+   */
+  key: string
+  /**
+   * The key of the target data domain.
+   * This is only set when the target is in a different data domain.
+   */
+  domain?: string
+}
+
+/**
+ * Describes the default value set on a property schema.
+ */
+export interface SchemaDefaultValue {
+  /**
+   * The type of the default value.
+   *
+   * - `literal` The `value` should be used as-is.
+   * - `function` The value represents the name of the function to be used.
+   */
+  type: 'literal' | 'function'
+  /**
+   * The actual value type depends on the `type`.
+   * It is always a string and it has to be casted to the property's data type.
+   */
+  value: string
+}
+
+/**
+ * A general schema definition for a property.
+ * This is propagated to all bindings (when they support these properties).
+ */
+export interface PropertySchema {
+  /**
+   * The minimum value of the property.
+   *
+   * By default it is inclusive value. Use the `exclusiveMinimum` property to make it exclusive.
+   *
+   * Used with:
+   * - string
+   * - number
+   * - date
+   * - time
+   * - datetime
+   */
+  minimum?: number
+  /**
+   * The maximum value of the property.
+   *
+   * By default it is inclusive value. Use the `exclusiveMaximum` property to make it exclusive.
+   *
+   * Used with:
+   * - string
+   * - number
+   * - date
+   * - time
+   * - datetime
+   */
+  maximum?: number
+  /**
+   * When set, the minimum value is exclusive.
+   *
+   * - When `false`: value ≥ minimum.
+   * - When `true`: value > minimum.
+   */
+  exclusiveMinimum?: boolean
+  /**
+   * When set, the exclusiveMaximum value is exclusive.
+   *
+   * - When `false`: value ≤ maximum.
+   * - When `true`: value < minimum.
+   */
+  exclusiveMaximum?: boolean
+  /**
+   * The multiplier value for a number scalar.
+   *
+   * Examples:
+   * - if `1` then every integer is allowed
+   * - if `2` than every even number is allowed
+   * - if `0.5` than every number dividable by `0.5` is allowed
+   */
+  multipleOf?: number
+  /**
+   * The enum values for the property.
+   * They are always encoded as strings. The actual type is defined in the `dataType` property.
+   */
+  enum?: string[]
+  /**
+   * The default value for the property.
+   * This is always encoded as a string. The actual type is defined in the `dataType` property.
+   */
+  defaultValue?: SchemaDefaultValue
+  /**
+   * The example values for the property.
+   * They are always encoded as strings. The actual type is defined in the `dataType` property.
+   */
+  examples?: string[]
+}
+
+/**
+ * The shortcut type for the data domain graph.
+ */
+export type DataDomainGraph = Graph<unknown, DomainGraphNodeType, DomainGraphEdge>
+/**
+ * The serialized version of the data domain graph.
+ */
+export type SerializedGraph = GraphJson<unknown, object, DomainGraphEdge>

package/src/models/AuthorizationData.ts

@@ -1,4 +1,4 @@
-import v4 from '../lib/uuid.js'
+import { nanoid } from 'nanoid'
 
 export interface IAuthorizationData {
   key: string
@@ -30,7 +30,7 @@ export class AuthorizationData {
       init = input
     } else {
       init = {
-        key: v4(),
+        key: nanoid(),
       }
     }
     this.new(init)
@@ -42,7 +42,7 @@ export class AuthorizationData {
    * Note, this throws an error when the provider is not an API Client provider object.
    */
   new(init: IAuthorizationData): void {
-    const { username, password, domain, key = v4() } = init
+    const { username, password, domain, key = nanoid() } = init
     this.username = username
     this.password = password
     this.domain = domain

package/src/models/CertificateFile.ts

@@ -1,4 +1,4 @@
-import v4 from '../lib/uuid.js'
+import { nanoid } from 'nanoid'
 import { Certificate, ICertificate } from './ClientCertificate.js'
 import { CertificateFileKind } from './kinds.js'
 import { IFile, File } from './store/File.js'
@@ -48,7 +48,7 @@ export class CertificateFile extends File {
     } else {
       init = {
         kind: CertificateFileKind,
-        key: v4(),
+        key: nanoid(),
         organization: '',
         info: Thing.fromName('').toJSON(),
         parents: [],

package/src/models/ClientCertificate.ts

@@ -1,5 +1,5 @@
 import { base64ToBuffer, bufferToBase64 } from '../lib/Buffer.js'
-import v4 from '../lib/uuid.js'
+import { nanoid } from 'nanoid'
 import {
   Certificate as LegacyCertificate,
   ARCCertificateIndex,
@@ -177,7 +177,7 @@ export class Certificate {
       certKey: {
         data: key,
       },
-      key: v4(),
+      key: nanoid(),
       name,
       type: 'pem',
       created: Date.now(),
@@ -201,7 +201,7 @@ export class Certificate {
       cert: {
         data: cert,
       },
-      key: v4(),
+      key: nanoid(),
       name,
       type: 'p12',
       created: Date.now(),
@@ -220,7 +220,7 @@ export class Certificate {
    *              to its original format.
    */
   static fromLegacy(index: ARCCertificateIndex, cert: RequestCertificate): Certificate {
-    const { name = '', type, created = Date.now(), _id = v4() } = index
+    const { name = '', type, created = Date.now(), _id = nanoid() } = index
     if (type === 'pem') {
       const data = Array.isArray(cert.cert) ? cert.cert[0] : cert.cert
       const key = Array.isArray(cert.key) ? cert.key[0] : (cert.key as LegacyCertificate)
@@ -253,7 +253,7 @@ export class Certificate {
   }
 
   constructor(certificate: HttpCertificate) {
-    const { type, cert, key = v4(), name = '', created = Date.now() } = certificate
+    const { type, cert, key = nanoid(), name = '', created = Date.now() } = certificate
     this.key = key
     this.name = name
     this.type = type

package/src/models/Environment.ts

@@ -1,7 +1,7 @@
 import { Property, IProperty } from './Property.js'
 import { Server, IServer } from './Server.js'
 import { IThing, Thing } from './Thing.js'
-import v4 from '../lib/uuid.js'
+import { nanoid } from 'nanoid'
 import { ARCVariable } from './legacy/models/Variable.js'
 import { IRequestAuthorization, RequestAuthorization } from './RequestAuthorization.js'
 
@@ -91,7 +91,7 @@ export class Environment {
    * @param name The name to set.
    */
   static fromName(name: string): Environment {
-    const key = v4()
+    const key = nanoid()
     const info = Thing.fromName(name)
     const definition = new Environment({
       key,
@@ -103,7 +103,7 @@ export class Environment {
   }
 
   static fromLegacyVariables(name: string, variables: ARCVariable[]): Environment {
-    const key = v4()
+    const key = nanoid()
     const info = Thing.fromName(name)
     const definition = new Environment({
       key,
@@ -132,7 +132,7 @@ export class Environment {
     } else {
       init = {
         kind: Kind,
-        key: v4(),
+        key: nanoid(),
         info: Thing.fromName('').toJSON(),
         variables: [],
       }
@@ -149,7 +149,7 @@ export class Environment {
     if (!Environment.isEnvironment(init)) {
       throw new Error(`Not an environment.`)
     }
-    const { key = v4(), variables, info, server, encapsulated = false, authorization } = init
+    const { key = nanoid(), variables, info, server, encapsulated = false, authorization } = init
     this.kind = Kind
     this.key = key
     this.encapsulated = encapsulated
@@ -262,7 +262,7 @@ export class Environment {
   clone(opts: IEnvironmentCloneOptions = {}): Environment {
     const copy = new Environment(this.toJSON())
     if (!opts.withoutRevalidate) {
-      copy.key = v4()
+      copy.key = nanoid()
     }
     return copy
   }

package/src/models/Folder.ts

@@ -1,5 +1,5 @@
 import { IFile, File } from './store/File.js'
-import v4 from '../lib/uuid.js'
+import { nanoid } from 'nanoid'
 import { Thing } from './Thing.js'
 import { FolderKind } from './kinds.js'
 
@@ -39,7 +39,7 @@ export class Folder extends File {
     } else {
       init = {
         kind: FolderKind,
-        key: v4(),
+        key: nanoid(),
         organization: '',
         info: Thing.fromName('').toJSON(),
         parents: [],