@api-client/core 0.17.7 → 0.18.0

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

@@ -42071,13 +42071,13 @@
 "@id": "#197"
 },
 {
-"@id": "#200"
+"@id": "#206"
 },
 {
-"@id": "#203"
+"@id": "#200"
 },
 {
-"@id": "#206"
+"@id": "#203"
 },
 {
 "@id": "#209"
@@ -43499,7 +43499,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "class: '3'\ndescription: '150 - 300'\nnumberOfFte: 5500\nnumberOfEmployees: 5232\n",
+"doc:raw": "code: 'J'\ndescription: 'Information and communication'\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -43520,7 +43520,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "code: 'J'\ndescription: 'Information and communication'\n",
+"doc:raw": "code: '7487'\ndescription: 'Financial and insurance activities'\ntype: \"PRIMARY\"\nclassificationCode: 'BE_NACEBEL2008'\nactivityGroupCode: 'ABCDE'\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -43541,7 +43541,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "code: '7487'\ndescription: 'Financial and insurance activities'\ntype: \"PRIMARY\"\nclassificationCode: 'BE_NACEBEL2008'\nactivityGroupCode: 'ABCDE'\n",
+"doc:raw": "class: '3'\ndescription: '150 - 300'\nnumberOfFte: 5500\nnumberOfEmployees: 5232\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -44771,17 +44771,17 @@
 {
 "@id": "#202/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#202",
-"sourcemaps:value": "[(1,0)-(5,0)]"
+"sourcemaps:value": "[(1,0)-(3,0)]"
 },
 {
 "@id": "#205/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#205",
-"sourcemaps:value": "[(1,0)-(3,0)]"
+"sourcemaps:value": "[(1,0)-(6,0)]"
 },
 {
 "@id": "#208/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#208",
-"sourcemaps:value": "[(1,0)-(6,0)]"
+"sourcemaps:value": "[(1,0)-(5,0)]"
 },
 {
 "@id": "#223/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.17.7",
+  "version": "0.18.0",
   "license": "Apache-2.0",
   "exports": {
     "./browser.js": {

package/src/amf/ApiSchemaGenerator.ts

@@ -1,5 +1,5 @@
 import { AmfNamespace as ns } from './definitions/Namespace.js'
-import { IApiAnyShape, IApiDataExample, IShapeUnion } from './definitions/Shapes.js'
+import { IApiAnyShape, IApiDataExample, IApiPropertyShape, IShapeUnion } from './definitions/Shapes.js'
 import { ShapeBase, IShapeRenderOptions } from './shape/ShapeBase.js'
 import { ShapeJsonSchemaGenerator } from './shape/ShapeJsonSchemaGenerator.js'
 import { ShapeXmlSchemaGenerator } from './shape/ShapeXmlSchemaGenerator.js'
@@ -69,7 +69,7 @@ export class ApiSchemaGenerator {
    *
    * @param shape The Shape definition
    */
-  generate(shape: IShapeUnion): string | number | boolean | null | undefined {
+  generate(shape: IShapeUnion | IApiPropertyShape<IShapeUnion>): string | number | boolean | null | undefined {
     const { generator } = this
     if (!generator) {
       return undefined

package/src/amf/ApiSchemaValues.ts

@@ -16,6 +16,7 @@ import {
   IShapeUnion,
 } from './definitions/Shapes.js'
 import type { ILoremWordInit, ITypeHashInit, ITypeNumberInit } from '@pawel-up/data-mock/types.js'
+import { RandExp } from '../mocking/RandExp.js'
 
 export interface IApiSchemaReadOptions {
   /**
@@ -275,7 +276,13 @@ export class ApiSchemaValues {
   }
 
   static generateStringValue(schema: IApiScalarShape): string {
-    const { minLength, maxLength, name = '', format } = schema
+    const { minLength, maxLength, name = '', format, pattern } = schema
+    if (pattern) {
+      // if the pattern is set we generate a random string that matches the pattern.
+      // Note, this is not a full regex support, just a simple one.
+      const randExp = new RandExp(pattern, undefined, { max: 10 })
+      return randExp.gen()
+    }
     const lowerName = name.toLowerCase()
     // we employ some heuristics to generate content based on the property name.
     if (lowerName === 'description') {

package/src/amf/shape/ShapeBase.ts

@@ -138,7 +138,7 @@ export abstract class ShapeBase {
    * @param schema The Shape definition
    * @returns The generated example
    */
-  abstract generate(schema: IShapeUnion): string | number | boolean | null | undefined
+  abstract generate(schema: IShapeUnion | IApiPropertyShape<IShapeUnion>): string | number | boolean | null | undefined
 
   /**
    * Serializes generated values into the final mime type related form.

package/src/amf/shape/ShapeJsonSchemaGenerator.ts

@@ -20,8 +20,13 @@ export class ShapeJsonSchemaGenerator extends ShapeBase {
    *
    * @param schema The Shape definition
    */
-  generate(schema: IShapeUnion): string | number | boolean | null | undefined {
-    const result = this.toObject(schema)
+  generate(schema: IShapeUnion | IApiPropertyShape<IShapeUnion>): string | number | boolean | null | undefined {
+    let result: string | number | boolean | object | object[] | null | undefined
+    if (schema.types.includes(ns.w3.shacl.PropertyShape)) {
+      result = this._propertyShapeObject(schema as IApiPropertyShape<IShapeUnion>)
+    } else {
+      result = this.toObject(schema as IShapeUnion)
+    }
     if (result !== null && typeof result === 'object') {
       return this.serialize(result)
     }

package/src/amf/shape/ShapeXmlSchemaGenerator.ts

@@ -55,9 +55,14 @@ export class ShapeXmlSchemaGenerator extends ShapeBase {
    *
    * @param schema The Shape definition
    */
-  generate(schema: IShapeUnion): string | undefined {
-    const value = this.processNode(schema, {}, true)
-    return value
+  generate(schema: IShapeUnion | IApiPropertyShape<IShapeUnion>): string | undefined {
+    let result: string | undefined
+    if (schema.types.includes(ns.w3.shacl.PropertyShape)) {
+      result = this._propertyShapeObject(schema as IApiPropertyShape<IShapeUnion>)
+    } else {
+      result = this.processNode(schema as IShapeUnion, {}, true)
+    }
+    return result
   }
 
   /**

package/src/mocking/RandExp.ts

@@ -0,0 +1,335 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * randexp v0.4.6
+ * Create random strings that match a given regular expression.
+ *
+ * Copyright (C) 2017 by fent (https://github.com/fent)
+ * MIT License
+ */
+
+import { ret, Token, types } from './lib/ret.js'
+
+class DRange {
+  low: number
+  high: number
+  length: number
+
+  constructor(low: number, high: number) {
+    this.low = low
+    this.high = high
+    this.length = 1 + high - low
+  }
+
+  overlaps(range: DRange): boolean {
+    return !(this.high < range.low || this.low > range.high)
+  }
+
+  touches(range: DRange): boolean {
+    return !(this.high + 1 < range.low || this.low - 1 > range.high)
+  }
+
+  add(range: DRange): DRange | null {
+    if (this.touches(range)) {
+      return new DRange(Math.min(this.low, range.low), Math.max(this.high, range.high))
+    }
+    return null
+  }
+
+  subtract(range: DRange): DRange[] {
+    if (!this.overlaps(range)) {
+      return [this.clone()]
+    }
+    if (range.low <= this.low && range.high >= this.high) {
+      return []
+    }
+    if (range.low > this.low && range.high < this.high) {
+      return [new DRange(this.low, range.low - 1), new DRange(range.high + 1, this.high)]
+    }
+    if (range.low <= this.low) {
+      return [new DRange(range.high + 1, this.high)]
+    }
+    // if (range.high >= this.high)
+    return [new DRange(this.low, range.low - 1)]
+  }
+
+  toString(): string {
+    return this.low === this.high ? String(this.low) : `${this.low}-${this.high}`
+  }
+
+  clone(): DRange {
+    return new DRange(this.low, this.high)
+  }
+}
+
+class DiscontinuousRange {
+  ranges: DRange[] = []
+  length = 0
+
+  constructor(low?: number | DiscontinuousRange, high?: number) {
+    if (low !== undefined) {
+      this.add(low, high)
+    }
+  }
+
+  private _setLength(): void {
+    this.length = this.ranges.reduce((sum, range) => sum + range.length, 0)
+  }
+
+  add(low: number | DiscontinuousRange | DRange, high?: number): this {
+    const addRange = (range: DRange) => {
+      const newRanges: DRange[] = []
+      let i = 0
+      while (i < this.ranges.length && !range.touches(this.ranges[i])) {
+        newRanges.push(this.ranges[i].clone())
+        i++
+      }
+      while (i < this.ranges.length && range.touches(this.ranges[i])) {
+        range = range.add(this.ranges[i]) as DRange
+        i++
+      }
+      newRanges.push(range)
+      while (i < this.ranges.length) {
+        newRanges.push(this.ranges[i].clone())
+        i++
+      }
+      this.ranges = newRanges
+      this._setLength()
+    }
+
+    if (low instanceof DiscontinuousRange) {
+      low.ranges.forEach(addRange)
+    } else if (low instanceof DRange) {
+      addRange(low)
+    } else {
+      if (high === undefined) high = low
+      addRange(new DRange(low, high))
+    }
+    return this
+  }
+
+  subtract(low: number | DiscontinuousRange | DRange, high?: number): this {
+    const subtractRange = (range: DRange) => {
+      const newRanges: DRange[] = []
+      let i = 0
+      while (i < this.ranges.length && !range.overlaps(this.ranges[i])) {
+        newRanges.push(this.ranges[i].clone())
+        i++
+      }
+      while (i < this.ranges.length && range.overlaps(this.ranges[i])) {
+        newRanges.push(...this.ranges[i].subtract(range))
+        i++
+      }
+      while (i < this.ranges.length) {
+        newRanges.push(this.ranges[i].clone())
+        i++
+      }
+      this.ranges = newRanges
+      this._setLength()
+    }
+
+    if (low instanceof DiscontinuousRange) {
+      low.ranges.forEach(subtractRange)
+    } else if (low instanceof DRange) {
+      subtractRange(low)
+    } else {
+      if (high === undefined) high = low
+      subtractRange(new DRange(low, high))
+    }
+    return this
+  }
+
+  index(i: number): number | null {
+    let j = 0
+    while (j < this.ranges.length && this.ranges[j].length <= i) {
+      i -= this.ranges[j].length
+      j++
+    }
+    if (j >= this.ranges.length) {
+      return null
+    }
+    return this.ranges[j].low + i
+  }
+
+  toString(): string {
+    return `[ ${this.ranges.join(', ')} ]`
+  }
+
+  clone(): DiscontinuousRange {
+    return new DiscontinuousRange(this)
+  }
+}
+
+export interface RandExpOptions {
+  max?: number
+  defaultRange?: DiscontinuousRange
+  randInt?: (min: number, max: number) => number
+}
+
+export class RandExp {
+  max = 10 // Reduced from 100 to 10 for more reasonable string lengths
+  defaultRange: DiscontinuousRange = new DiscontinuousRange(32, 126)
+  randInt: (min: number, max: number) => number = (min, max) => {
+    return min + Math.floor(Math.random() * (max - min + 1))
+  }
+
+  private tokens: Token
+  private ignoreCase: boolean
+  private multiline: boolean
+
+  constructor(regexp: RegExp | string, flags?: string, options?: RandExpOptions) {
+    this.defaultRange = this.defaultRange.clone()
+
+    // Apply options if provided
+    if (options) {
+      if (typeof options.max === 'number') {
+        this.max = options.max
+      }
+      if (options.defaultRange instanceof DiscontinuousRange) {
+        this.defaultRange = options.defaultRange
+      }
+      if (typeof options.randInt === 'function') {
+        this.randInt = options.randInt
+      }
+    }
+
+    if (regexp instanceof RegExp) {
+      this.ignoreCase = regexp.ignoreCase
+      this.multiline = regexp.multiline
+      this._setDefaults(regexp)
+      regexp = regexp.source
+    } else if (typeof regexp === 'string') {
+      this.ignoreCase = flags?.includes('i') ?? false
+      this.multiline = flags?.includes('m') ?? false
+    } else {
+      throw new Error('Expected a regexp or string')
+    }
+    this.tokens = ret(regexp)
+  }
+
+  private _setDefaults(regexp: any): void {
+    if (typeof regexp.max === 'number') {
+      this.max = regexp.max
+    }
+    if (regexp.defaultRange instanceof DiscontinuousRange) {
+      this.defaultRange = regexp.defaultRange
+    }
+    if (typeof regexp.randInt === 'function') {
+      this.randInt = regexp.randInt
+    }
+  }
+
+  gen(): string {
+    return this._gen(this.tokens, [])
+  }
+
+  private _gen(token: Token, groups: (string | null)[]): string {
+    let stack, str, i, l
+
+    switch (token.type) {
+      case types.ROOT:
+      case types.GROUP:
+        if (token.followedBy || token.notFollowedBy) return ''
+
+        if (token.remember && token.groupNumber === undefined) {
+          token.groupNumber = groups.push(null) - 1
+        }
+
+        stack = token.options ? this._choice(token.options) : token.stack
+        str = ''
+        for (i = 0, l = stack.length; i < l; i++) {
+          str += this._gen(stack[i], groups)
+        }
+
+        if (token.remember) {
+          groups[token.groupNumber] = str
+        }
+        return str
+
+      case types.POSITION:
+        return ''
+
+      case types.SET: {
+        const set = this._processSet(token)
+        if (!set.length) return ''
+        return String.fromCharCode(this._choice(set) as number)
+      }
+      case types.REPETITION: {
+        const n = this.randInt(token.min, token.max === Infinity ? token.min + this.max : token.max)
+        str = ''
+        for (i = 0; i < n; i++) {
+          str += this._gen(token.value, groups)
+        }
+        return str
+      }
+      case types.REFERENCE:
+        return groups[token.value - 1] || ''
+
+      case types.CHAR: {
+        const code = this.ignoreCase && this._coin() ? RandExp._toCaseInverse(token.value) : token.value
+        return String.fromCharCode(code)
+      }
+    }
+    return ''
+  }
+
+  private _processSet(token: Token): DiscontinuousRange {
+    if (token.type === types.CHAR) {
+      return new DiscontinuousRange(token.value)
+    }
+    if (token.type === types.RANGE) {
+      return new DiscontinuousRange(token.from, token.to)
+    }
+
+    const dr = new DiscontinuousRange()
+    for (const char of token.set) {
+      const sub = this._processSet(char)
+      dr.add(sub)
+      if (this.ignoreCase) {
+        for (let j = 0; j < sub.length; j++) {
+          const charCode = sub.index(j) as number
+          const otherCase = RandExp._toCaseInverse(charCode)
+          if (charCode !== otherCase) {
+            dr.add(otherCase)
+          }
+        }
+      }
+    }
+
+    return token.not ? this.defaultRange.clone().subtract(dr) : dr
+  }
+
+  private static _toCaseInverse(code: number): number {
+    if (code >= 97 && code <= 122) return code - 32
+    if (code >= 65 && code <= 90) return code + 32
+    return code
+  }
+
+  private _coin(): boolean {
+    return this.randInt(0, 1) === 0
+  }
+
+  private _choice(choices: any[] | DiscontinuousRange): any {
+    if (choices instanceof DiscontinuousRange) {
+      return choices.index(this.randInt(0, choices.length - 1))
+    }
+    return choices[this.randInt(0, choices.length - 1)]
+  }
+
+  static randexp(regexp: RegExp | string, flags?: string, options?: RandExpOptions): string {
+    let randexpInstance
+    if ((regexp as any)._randexp === undefined) {
+      randexpInstance = new RandExp(regexp, flags, options)
+      ;(regexp as any)._randexp = randexpInstance
+    } else {
+      randexpInstance = (regexp as any)._randexp
+    }
+    randexpInstance._setDefaults(regexp)
+    return randexpInstance.gen()
+  }
+
+  static sugar(): void {
+    ;(RegExp.prototype as any).gen = function () {
+      return RandExp.randexp(this)
+    }
+  }
+}