@api-client/core 0.17.7 → 0.18.1

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.1",
   "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)
+    }
+  }
+}

package/src/mocking/lib/ret.ts

@@ -0,0 +1,279 @@
+// Regular Expression Tokenizer
+// https://github.com/fent/ret.js
+
+export enum types {
+  ROOT = 0,
+  GROUP = 1,
+  POSITION = 2,
+  SET = 3,
+  RANGE = 4,
+  REPETITION = 5,
+  REFERENCE = 6,
+  CHAR = 7,
+}
+
+export interface Token {
+  type: types
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  [key: string]: any
+}
+const wordBoundary = (): Token => ({ type: types.POSITION, value: 'b' })
+const nonWordBoundary = (): Token => ({ type: types.POSITION, value: 'B' })
+const begin = (): Token => ({ type: types.POSITION, value: '^' })
+const end = (): Token => ({ type: types.POSITION, value: '$' })
+
+const ints = (): Token[] => [{ type: types.RANGE, from: 48, to: 57 }]
+const words = (): Token[] => [
+  { type: types.CHAR, value: 95 },
+  { type: types.RANGE, from: 97, to: 122 },
+  { type: types.RANGE, from: 65, to: 90 },
+  ...ints(),
+]
+const whitespace = (): Token[] => [
+  { type: types.CHAR, value: 9 },
+  { type: types.CHAR, value: 10 },
+  { type: types.CHAR, value: 11 },
+  { type: types.CHAR, value: 12 },
+  { type: types.CHAR, value: 13 },
+  { type: types.CHAR, value: 32 },
+  { type: types.CHAR, value: 160 },
+  { type: types.CHAR, value: 5760 },
+  { type: types.CHAR, value: 6158 },
+  { type: types.CHAR, value: 8192 },
+  { type: types.CHAR, value: 8193 },
+  { type: types.CHAR, value: 8194 },
+  { type: types.CHAR, value: 8195 },
+  { type: types.CHAR, value: 8196 },
+  { type: types.CHAR, value: 8197 },
+  { type: types.CHAR, value: 8198 },
+  { type: types.CHAR, value: 8199 },
+  { type: types.CHAR, value: 8200 },
+  { type: types.CHAR, value: 8201 },
+  { type: types.CHAR, value: 8202 },
+  { type: types.CHAR, value: 8232 },
+  { type: types.CHAR, value: 8233 },
+  { type: types.CHAR, value: 8239 },
+  { type: types.CHAR, value: 8287 },
+  { type: types.CHAR, value: 12288 },
+  { type: types.CHAR, value: 65279 },
+]
+const notanychar = (): Token[] => [
+  { type: types.CHAR, value: 10 },
+  { type: types.CHAR, value: 13 },
+  { type: types.CHAR, value: 8232 },
+  { type: types.CHAR, value: 8233 },
+]
+
+const words_ = (): Token => ({ type: types.SET, set: words(), not: false })
+const notWords = (): Token => ({ type: types.SET, set: words(), not: true })
+const ints_ = (): Token => ({ type: types.SET, set: ints(), not: false })
+const notInts = (): Token => ({ type: types.SET, set: ints(), not: true })
+const whitespace_ = (): Token => ({ type: types.SET, set: whitespace(), not: false })
+const notWhitespace = (): Token => ({ type: types.SET, set: whitespace(), not: true })
+const anyChar = (): Token => ({ type: types.SET, set: notanychar(), not: true })
+
+const specialChars: Record<string, number> = {
+  '0': 0,
+  't': 9,
+  'n': 10,
+  'v': 11,
+  'f': 12,
+  'r': 13,
+}
+
+const strToChars = (str: string): string => {
+  const chars = /(\[\\b\])|(\\)?\\(?:u([A-F0-9]{4})|x([A-F0-9]{2})|(0?[0-7]{2})|c([@A-Z[\\\]^?])|([0tnvfr]))/g
+  return str.replace(chars, (match, b, s, uh, xh, o, c, sp) => {
+    if (s) return match
+    const code = b
+      ? 8
+      : uh
+        ? parseInt(uh, 16)
+        : xh
+          ? parseInt(xh, 16)
+          : o
+            ? parseInt(o, 8)
+            : c
+              ? '@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^ ?'.indexOf(c)
+              : specialChars[sp]
+    let ch = String.fromCharCode(code)
+    if (/[[{}^$.|?*+()]/.test(ch)) {
+      ch = `\\${ch}`
+    }
+    return ch
+  })
+}
+
+const tokenizeClass = (str: string, regexpStr: string): [Token[], number] => {
+  const tokens: Token[] = []
+  const classTokens = /\\(?:(w)|(d)|(s)|(W)|(D)|(S))|((?:(?:\\)(.)|([^\]\\]))-(?:\\)?([^\]]))|(\])|(?:\\)?(.)/g
+  let match
+  let char
+  while ((match = classTokens.exec(str)) !== null) {
+    if (match[1]) {
+      tokens.push(words_())
+    } else if (match[2]) {
+      tokens.push(ints_())
+    } else if (match[3]) {
+      tokens.push(whitespace_())
+    } else if (match[4]) {
+      tokens.push(notWords())
+    } else if (match[5]) {
+      tokens.push(notInts())
+    } else if (match[6]) {
+      tokens.push(notWhitespace())
+    } else if (match[7]) {
+      tokens.push({
+        type: types.RANGE,
+        from: (match[8] || match[9]).charCodeAt(0),
+        to: match[10].charCodeAt(0),
+      })
+    } else if ((char = match[12])) {
+      tokens.push({ type: types.CHAR, value: char.charCodeAt(0) })
+    } else {
+      return [tokens, classTokens.lastIndex]
+    }
+  }
+  throw new SyntaxError(`Invalid regular expression: /${regexpStr}/: Unterminated character class`)
+}
+
+const error = (regexpStr: string, msg: string): never => {
+  throw new SyntaxError(`Invalid regular expression: /${regexpStr}/: ${msg}`)
+}
+
+export const ret = (regexpStr: string): Token => {
+  let i = 0
+  const root: Token = { type: types.ROOT, stack: [] }
+  let p: Token = root
+  let stack: Token[] = root.stack
+  const groupStack: Token[] = []
+
+  const repeatErr = (i: number) => error(regexpStr, `Nothing to repeat at column ${i - 1}`)
+  const chars = strToChars(regexpStr)
+
+  while (i < chars.length) {
+    let c = chars[i++]
+    switch (c) {
+      case '\\':
+        c = chars[i++]
+        switch (c) {
+          case 'b':
+            stack.push(wordBoundary())
+            break
+          case 'B':
+            stack.push(nonWordBoundary())
+            break
+          case 'w':
+            stack.push(words_())
+            break
+          case 'W':
+            stack.push(notWords())
+            break
+          case 'd':
+            stack.push(ints_())
+            break
+          case 'D':
+            stack.push(notInts())
+            break
+          case 's':
+            stack.push(whitespace_())
+            break
+          case 'S':
+            stack.push(notWhitespace())
+            break
+          default:
+            if (/\d/.test(c)) {
+              stack.push({ type: types.REFERENCE, value: parseInt(c, 10) })
+            } else {
+              stack.push({ type: types.CHAR, value: c.charCodeAt(0) })
+            }
+        }
+        break
+      case '^':
+        stack.push(begin())
+        break
+      case '$':
+        stack.push(end())
+        break
+      case '[': {
+        let not = false
+        if (chars[i] === '^') {
+          not = true
+          i++
+        }
+        const [set, lastIndex] = tokenizeClass(chars.slice(i), regexpStr)
+        i += lastIndex
+        stack.push({ type: types.SET, set, not })
+        break
+      }
+      case '.':
+        stack.push(anyChar())
+        break
+      case '(': {
+        const group: Token = { type: types.GROUP, stack: [], remember: true }
+        if (chars[i] === '?') {
+          c = chars[i + 1]
+          i += 2
+          if (c === '=') {
+            group.followedBy = true
+          } else if (c === '!') {
+            group.notFollowedBy = true
+          } else if (c !== ':') {
+            error(regexpStr, `Invalid group, character '${c}' after '?' at column ${i - 1}`)
+          }
+          group.remember = false
+        }
+        stack.push(group)
+        groupStack.push(p)
+        p = group
+        stack = group.stack
+        break
+      }
+      case ')':
+        if (groupStack.length === 0) error(regexpStr, `Unmatched ) at column ${i - 1}`)
+        p = groupStack.pop() as Token
+        stack = p.options ? p.options[p.options.length - 1] : p.stack
+        break
+      case '|':
+        if (!p.options) {
+          p.options = [p.stack]
+          delete p.stack
+        }
+        {
+          const newStack: Token[] = []
+          p.options.push(newStack)
+          stack = newStack
+        }
+        break
+      case '{': {
+        const repetition = /^(\d+)(,(\d+)?)?\}/.exec(chars.slice(i))
+        if (repetition) {
+          if (stack.length === 0) repeatErr(i)
+          const min = parseInt(repetition[1], 10)
+          const max = repetition[2] ? (repetition[3] ? parseInt(repetition[3], 10) : Infinity) : min
+          i += repetition[0].length
+          stack.push({ type: types.REPETITION, min, max, value: stack.pop() })
+        } else {
+          stack.push({ type: types.CHAR, value: 123 })
+        }
+        break
+      }
+      case '?':
+        if (stack.length === 0) repeatErr(i)
+        stack.push({ type: types.REPETITION, min: 0, max: 1, value: stack.pop() })
+        break
+      case '+':
+        if (stack.length === 0) repeatErr(i)
+        stack.push({ type: types.REPETITION, min: 1, max: Infinity, value: stack.pop() })
+        break
+      case '*':
+        if (stack.length === 0) repeatErr(i)
+        stack.push({ type: types.REPETITION, min: 0, max: Infinity, value: stack.pop() })
+        break
+      default:
+        stack.push({ type: types.CHAR, value: c.charCodeAt(0) })
+    }
+  }
+  if (groupStack.length !== 0) error(regexpStr, 'Unterminated group')
+  return root
+}