@mojaloop/ml-testing-toolkit-shared-lib 14.0.5 → 14.2.0

package/.grype.yaml

@@ -0,0 +1,13 @@
+disabled: true
+ignore:
+
+# Set output format defaults
+output:
+  - "table"
+  - "json"
+
+# Modify your CircleCI job to check critical count
+search:
+  scope: "squashed"
+quiet: false
+check-for-app-update: false

package/.nvmrc

@@ -1 +1 @@
-22.15.0
+22.15.1

package/CHANGELOG.md

@@ -1,4 +1,18 @@
 # Changelog: [mojaloop/als-consent-oracle](https://github.com/mojaloop/als-consent-oracle)
+## [14.2.0](https://github.com/mojaloop/ml-testing-toolkit-shared-lib/compare/v14.1.0...v14.2.0) (2025-07-15)
+
+
+### Features
+
+* fix vuls and update deps ([#24](https://github.com/mojaloop/ml-testing-toolkit-shared-lib/issues/24)) ([0f8a020](https://github.com/mojaloop/ml-testing-toolkit-shared-lib/commit/0f8a0202058b5ba6cd855ba987f22b384911403a))
+
+## [14.1.0](https://github.com/mojaloop/ml-testing-toolkit-shared-lib/compare/v14.0.5...v14.1.0) (2025-06-03)
+
+
+### Features
+
+* bump up the node version to v22.15.1 ([#23](https://github.com/mojaloop/ml-testing-toolkit-shared-lib/issues/23)) ([ccd59bd](https://github.com/mojaloop/ml-testing-toolkit-shared-lib/commit/ccd59bdc348ab1b9bce1cb2ee69f6553fb7021a5))
+
 ### [14.0.5](https://github.com/mojaloop/ml-testing-toolkit-shared-lib/compare/v14.0.4...v14.0.5) (2025-05-16)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mojaloop/ml-testing-toolkit-shared-lib",
-  "version": "14.0.5",
+  "version": "14.2.0",
   "description": "Shared library for ml-testing-toolkit re-usable functions",
   "main": "src/index.js",
   "contributors": [
@@ -20,7 +20,9 @@
   "homepage": "https://github.com/mojaloop/ml-testing-toolkit-shared-lib#readme",
   "pre-commit": [
     "lint",
-    "dep:check"
+    "dep:check",
+    "audit:check",
+    "test"
   ],
   "scripts": {
     "start": "node src/index.js",
@@ -30,35 +32,35 @@
     "lint:fix": "npm run standard:fix",
     "test": "npm run test:unit",
     "test:unit": "jest --testMatch '**/test/unit/**/*.test.js'",
+    "test:xunit": "npm run test:unit",
     "test:int": "jest --reporters=default --reporters=jest-junit --testMatch '**/test/integration/**/*.test.js'",
     "test:coverage": "jest --coverage --coverageThreshold='{}' --testMatch '**/test/unit/**/*.test.js'",
     "test:coverage-check": "jest --coverage --testMatch '**/test/unit/**/*.test.js'",
     "test:junit": "jest --reporters=default --reporters=jest-junit --testMatch '**/test/unit/**/*.test.js'",
-    "test:integration": "./test/integration-runner.sh ",
+    "test:integration": "echo 'No integration tests defined'",
+    "test:functional": "echo 'No functional tests defined'",
     "cover": "npx nyc --all report --reporter=lcov npm run test",
     "audit:check": "npx audit-ci --config ./audit-ci.jsonc",
     "audit:fix": "npm audit fix",
     "dep:check": "npx ncu -e 2",
     "dep:update": "npx ncu -u",
-    "prepare": "husky || true",
     "release": "npx standard-version --no-verify --releaseCommitMessageFormat 'chore(release): {{currentTag}} [skip ci]'",
     "snapshot": "npx standard-version --no-verify --skip.changelog --prerelease snapshot --releaseCommitMessageFormat 'chore(snapshot): {{currentTag}}'"
   },
   "dependencies": {
-    "@faker-js/faker": "^9.8.0",
-    "@stoplight/json-schema-sampler": "0.3.0",
+    "@apidevtools/json-schema-ref-parser": "14.1.0",
+    "@faker-js/faker": "9.9.0",
     "ajv": "8.17.1",
-    "json-schema-ref-parser": "9.0.9",
+    "json-schema-faker": "0.5.9",
     "lodash": "4.17.21",
     "node-dir": "0.1.17"
   },
   "devDependencies": {
     "@commitlint/cli": "^19.8.1",
     "@commitlint/config-conventional": "^19.8.1",
-    "@types/jest": "29.5.14",
+    "@types/jest": "30.0.0",
     "audit-ci": "^7.1.0",
-    "husky": "^9.1.7",
-    "jest": "29.7.0",
+    "jest": "30.0.4",
     "jest-junit": "16.0.0",
     "npm-check-updates": "18.0.1",
     "pre-commit": "^1.2.2",
@@ -70,7 +72,8 @@
     "cross-spawn": "7.0.6",
     "glob": "9.3.5",
     "rimraf": "5.0.10",
-    "@babel/helpers": "7.26.10"
+    "@babel/helpers": "7.26.10",
+    "brace-expansion": "1.1.12"
   },
   "standard-version": {
     "scripts": {

package/src/lib/openApiMockGenerator.js

@@ -32,203 +32,18 @@ const _ = require('lodash')
 // const jref = require('json-ref-lite')
 // const yaml = require('js-yaml')
 const { faker } = require('@faker-js/faker')
-const JSONSchemaSampler = require('@stoplight/json-schema-sampler')
-const $RefParser = require('json-schema-ref-parser')
+const jsf = require('json-schema-faker')
+const $RefParser = require('@apidevtools/json-schema-ref-parser')
 const Ajv = require('ajv')
 
-// Configure the sampler options to match original jsf behavior
-const samplerOptions = {
-  skipNonRequired: false,
-  quiet: true,
-  maxSampleDepth: 5,
-  maxItems: 2,
-  ignoreMissingRefs: true,
-  formatHandlers: {
-    byte: () => Buffer.alloc(faker.lorem.sentence(12)).toString('base64'),
-    date: () => faker.date.anytime().toISOString().split('T')[0],
-    'date-time': () => faker.date.anytime().toISOString(),
-    email: () => faker.internet.email(),
-    uri: () => faker.internet.url(),
-    uuid: () => faker.string.uuid(),
-    phone: () => faker.phone.number('+###########'),
-    'geo-latitude': () => {
-      const val = faker.location.latitude().toFixed(4)
-      return (parseFloat(val) >= 0 ? '+' : '') + val
-    },
-    'geo-longitude': () => {
-      const val = faker.location.longitude().toFixed(4)
-      return (parseFloat(val) >= 0 ? '+' : '') + val
-    },
-    'fsp-id': () => generateFspId(),
-    currency: () => faker.helpers.arrayElement(['USD', 'EUR', 'GBP', 'JPY', 'AUD', 'CAD', 'CHF', 'CNY', 'INR', 'BRL']),
-    'sub-scenario': () => faker.helpers.fromRegExp(/^[A-Z_]{1,32}$/),
-    name: () => `${faker.person.firstName()} ${faker.person.lastName()}`,
-    'complex-name': () => ({
-      firstName: faker.person.firstName(),
-      middleName: faker.helpers.maybe(() => faker.person.middleName(), { probability: 0.3 }),
-      lastName: faker.person.lastName()
-    }),
-    'party-identifier': () => faker.phone.number('##########'),
-    amount: () => faker.number.float({ min: 0.01, max: 1000, precision: 0.01 }).toFixed(2),
-    'transaction-scenario': () => faker.helpers.arrayElement(['DEPOSIT', 'WITHDRAWAL', 'TRANSFER', 'PAYMENT', 'REFUND']),
-    'transaction-initiator': () => faker.helpers.arrayElement(['PAYER', 'PAYEE']),
-    'transaction-initiator-type': () => faker.helpers.arrayElement(['CONSUMER', 'AGENT', 'BUSINESS', 'DEVICE']),
-    'transfer-state': () => faker.helpers.arrayElement(['RECEIVED', 'RESERVED', 'COMMITTED', 'ABORTED'])
-  },
-  typeHandlers: {
-    string: (schema) => {
-      const key = (schema.key || '').toLowerCase()
-      const parentKey = (schema.parentKey || '').toLowerCase()
-
-      // Handle patterns
-      if (schema.pattern) {
-        if (schema.pattern === 'Created|Closed') {
-          return faker.helpers.arrayElement(['Created', 'Closed'])
-        }
-        if (schema.pattern === 'PERSONAL_ID|BUSINESS_ID') {
-          return faker.helpers.arrayElement(['PERSONAL_ID', 'BUSINESS_ID'])
-        }
-        if (schema.pattern === '123') {
-          return '123'
-        }
-        if (schema.pattern === '^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$') {
-          return faker.internet.email()
-        }
-        if (schema.pattern === '^[A-Z0-9]{1,32}$') {
-          return generateFspId()
-        }
-        if (schema.pattern === '^\\d{10,15}$') {
-          // Always generate a string of 10-15 digits
-          return generateDigitsPhoneNumber(faker.number.int({ min: 10, max: 15 }))
-        }
-      }
-
-      // Handle Content-Length
-      if (key === 'content-length' || key === 'contentlength') {
-        return '123'
-      }
-
-      // Handle state, reason, status
-      if (key === 'state' || key === 'reason' || key === 'status') {
-        return faker.helpers.arrayElement(['Created', 'Closed'])
-      }
-
-      // Handle partyIdType
-      if (key === 'partyidtype' || (parentKey === 'partyidinfo' && key === 'partyidtype')) {
-        return faker.helpers.arrayElement(['PERSONAL_ID', 'BUSINESS_ID'])
-      }
-
-      // Handle transferState
-      if (key === 'transferstate') {
-        return faker.helpers.arrayElement(['RECEIVED', 'RESERVED', 'COMMITTED', 'ABORTED'])
-      }
-
-      // Handle FSP ID fields (fspid, payerfsp, payeefsp)
-      if (key === 'fspid' || key === 'payerfsp' || key === 'payeefsp' || (parentKey === 'partyidinfo' && key === 'fspid')) {
-        return generateFspId()
-      }
-
-      // Handle currency
-      if (key === 'currency' || (parentKey === 'amount' && key === 'currency')) {
-        const currency = faker.helpers.arrayElement(['USD', 'EUR', 'GBP', 'JPY', 'AUD', 'CAD', 'CHF', 'CNY', 'INR', 'BRL'])
-        if (schema.parentKey === 'amount') {
-          schema._currency = currency
-        }
-        return currency
-      }
-
-      // Handle amount (including nested amount.amount)
-      if (key === 'amount') {
-        return faker.number.float({ min: 0.01, max: 1000, precision: 0.01 }).toFixed(2)
-      }
-
-      // Handle partyIdentifier (digits only)
-      if (key === 'partyidentifier' || (parentKey === 'partyidinfo' && key === 'partyidentifier')) {
-        return generateDigitsPhoneNumber(faker.number.int({ min: 10, max: 15 }))
-      }
-
-      // Handle geo coordinates
-      if (key === 'latitude') {
-        const val = faker.location.latitude().toFixed(4)
-        return (parseFloat(val) >= 0 ? '+' : '') + val
-      }
-      if (key === 'longitude') {
-        const val = faker.location.longitude().toFixed(4)
-        return (parseFloat(val) >= 0 ? '+' : '') + val
-      }
-
-      // Handle UUIDs for IDs
-      if (key === 'bulkquoteid' || key === 'bulktransferid' || key === 'quoteid' || key === 'transferid' || key === 'id') {
-        return faker.string.uuid()
-      }
+jsf.format('byte', () => Buffer.alloc(faker.lorem.sentence({ min: 12, max: 12 })).toString('base64'))
 
-      // Handle scenario, initiator, initiatorType
-      if (key === 'scenario' || (parentKey === 'transactiontype' && key === 'scenario')) {
-        return faker.helpers.arrayElement(['DEPOSIT', 'WITHDRAWAL', 'TRANSFER', 'PAYMENT', 'REFUND'])
-      }
-      if (key === 'initiator' || (parentKey === 'transactiontype' && key === 'initiator')) {
-        return faker.helpers.arrayElement(['PAYER', 'PAYEE'])
-      }
-      if (key === 'initiatortype' || (parentKey === 'transactiontype' && key === 'initiatortype')) {
-        return faker.helpers.arrayElement(['CONSUMER', 'AGENT', 'BUSINESS', 'DEVICE'])
-      }
-
-      // Handle firstName and lastName fields (single name, capitalized, strictly alphabetic)
-      if (key === 'firstname') {
-        let first
-        do {
-          first = faker.person.firstName()
-          first = `${first.charAt(0).toUpperCase()}${first.slice(1)}`
-        } while (!/^[A-Z][a-z]+$/.test(first))
-        return first
-      }
-      if (key === 'lastname') {
-        let last
-        do {
-          last = faker.person.lastName()
-          last = `${last.charAt(0).toUpperCase()}${last.slice(1)}`
-        } while (!/^[A-Z][a-z]+$/.test(last))
-        return last
-      }
-
-      // Handle name field (full name)
-      if (key === 'name') {
-        const first = faker.person.firstName()
-        const last = faker.person.lastName()
-        return `${first.charAt(0).toUpperCase()}${first.slice(1)} ${last.charAt(0).toUpperCase()}${last.slice(1)}`
-      }
-
-      // Handle complexName (string) to always return a full name (Firstname Lastname)
-      if (key === 'complexname' && schema.type === 'string') {
-        const first = faker.person.firstName()
-        const last = faker.person.lastName()
-        return `${first.charAt(0).toUpperCase()}${first.slice(1)} ${last.charAt(0).toUpperCase()}${last.slice(1)}`
-      }
-
-      // For any other key ending with 'name' (but not 'name', 'firstname', 'lastname', or 'complexname'), generate a single capitalized name.
-      if (/name$/i.test(key) && key !== 'name' && key !== 'firstname' && key !== 'lastname' && key !== 'complexname') {
-        const single = faker.person.firstName()
-        return `${single.charAt(0).toUpperCase()}${single.slice(1)}`
-      }
-
-      // Fallback to customTypeHandler for any other string field
-      const custom = customTypeHandler(schema)
-      if (custom !== undefined) return custom
-
-      // Default fallback
-      return faker.lorem.sentence()
-    },
-    number: (schema) => {
-      const key = (schema.key || '').toLowerCase()
-      if (key === 'amount' || /amount$/i.test(key)) {
-        return faker.number.float({ min: 0.01, max: 1000, precision: 0.01 }).toFixed(2)
-      }
-      return faker.number.float({ min: 1, max: 1000, precision: 0.01 })
-    },
-    integer: () => faker.number.int({ min: 1, max: 1000 }),
-    boolean: () => faker.datatype.boolean()
-  }
-}
+jsf.option({
+  alwaysFakeOptionals: true,
+  ignoreMissingRefs: true,
+  maxItems: 2
+})
+jsf.extend('faker', () => require('@faker-js/faker').faker)
 
 const ajv = new Ajv({
   strict: false,
@@ -322,574 +137,124 @@ const findRequestSchema = (r) => {
   return _.find(content).schema
 }
 
-// Helper function to match field names
-function matchesField (key, ...names) {
-  if (!key) return false
-  const keyLower = key.toLowerCase()
-  return names.some(name => keyLower === name.toLowerCase() || keyLower.endsWith(name.toLowerCase()))
-}
-
-// Fix date-time format handler to always generate a valid ISO string with milliseconds
-const customFormatHandlers = {
-  name: () => {
-    const firstNames = ['John', 'Jane', 'Michael', 'Sarah', 'David', 'Emma']
-    const lastNames = ['Smith', 'Johnson', 'Williams', 'Brown', 'Jones', 'Garcia']
-    return `${firstNames[Math.floor(Math.random() * firstNames.length)]} ${lastNames[Math.floor(Math.random() * lastNames.length)]}`
-  },
-  amount: () => {
-    return (Math.random() * 1000).toFixed(2)
-  },
-  phone: () => {
-    return Math.floor(Math.random() * 9000000000 + 1000000000).toString()
-  },
-  'geo-latitude': () => {
-    const val = (Math.random() * 180 - 90).toFixed(4)
-    return (val >= 0 ? '+' : '') + val
-  },
-  'geo-longitude': () => {
-    const val = (Math.random() * 360 - 180).toFixed(4)
-    return (val >= 0 ? '+' : '') + val
-  },
-  uuid: () => {
-    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
-      const r = Math.random() * 16 | 0
-      const v = c === 'x' ? r : (r & 0x3 | 0x8)
-      return v.toString(16)
-    })
-  },
-  'date-time': () => {
-    // Always use toISOString() which includes milliseconds
-    return new Date().toISOString()
-  }
-}
-
-// Custom type handler for the sampler
-const customTypeHandler = (schema) => {
-  if (!schema || typeof schema !== 'object') return undefined
-
-  const key = schema.key || ''
-
-  // Always handle state, reason, status fields
-  if (matchesField(key, 'state', 'status', 'reason')) {
-    return ['Created', 'Closed'][Math.floor(Math.random() * 2)]
-  }
-
-  // Always handle party ID type fields
-  if (matchesField(key, 'partyIdType', 'idType')) {
-    return ['PERSONAL_ID', 'BUSINESS_ID'][Math.floor(Math.random() * 2)]
-  }
-
-  // Always handle content length
-  if (matchesField(key, 'contentLength', 'content-length')) {
-    return '123'
-  }
-
-  // Handle email fields
-  if (matchesField(key, 'email', 'emailAddress')) {
-    const domains = ['example.com', 'test.com', 'domain.com']
-    const name = Math.random().toString(36).substring(2, 8)
-    return `${name}@${domains[Math.floor(Math.random() * domains.length)]}`
-  }
-
-  // Handle date-time fields
-  if (matchesField(key, 'expiration', 'dateTime', 'datetime', 'timestamp')) {
-    return customFormatHandlers['date-time']()
-  }
-
-  // Handle date fields
-  if (matchesField(key, 'dateOfBirth', 'date')) {
-    const date = new Date()
-    return date.toISOString().split('T')[0]
-  }
-
-  // Use format handlers for other fields
-  if (schema.format && customFormatHandlers[schema.format]) {
-    return customFormatHandlers[schema.format]()
-  }
-
-  return undefined
-}
-
-// Preprocess schema to inject default values for known fields
-function preprocessSchema (schema, parentKey = null) {
-  if (!schema || typeof schema !== 'object') return schema
-
-  const processed = JSON.parse(JSON.stringify(schema))
-  processed.parentKey = parentKey
-
-  // Process properties recursively
-  if (processed.properties) {
-    Object.keys(processed.properties).forEach(key => {
-      processed.properties[key] = preprocessSchema(processed.properties[key], key)
-    })
-  }
-
-  // Process items for arrays
-  if (processed.items) {
-    processed.items = preprocessSchema(processed.items, parentKey)
-  }
-
-  // Handle specific field types
-  if (processed.type === 'string') {
-    const key = processed.key || ''
-    // Handle state and reason fields
-    if (matchesField(key, 'state', 'status', 'reason')) {
-      processed.format = 'transaction-state'
-      return processed
-    }
-    // Handle party ID type fields
-    if (matchesField(key, 'partyIdType', 'idType')) {
-      processed.format = 'party-id-type'
-      return processed
-    }
-    // Handle FSP ID fields
-    if (matchesField(key, 'fspId', 'fspid')) {
-      processed.format = 'fsp-id'
-      return processed
-    }
-    // Handle currency fields
-    if (matchesField(key, 'currency')) {
-      processed.format = 'currency'
-      return processed
-    }
-    // Handle date-time fields
-    if (matchesField(key, 'expiration', 'datetime', 'timestamp')) {
-      processed.format = 'date-time'
-      return processed
-    }
-    // Handle date fields
-    if (matchesField(key, 'dateOfBirth', 'date')) {
-      processed.format = 'date'
-      return processed
-    }
-    // Handle party identifier fields
-    if (matchesField(key, 'partyIdentifier')) {
-      processed.format = 'party-identifier'
-      return processed
-    }
-    // Handle transaction type fields
-    if (matchesField(key, 'scenario')) {
-      processed.format = 'transaction-scenario'
-      return processed
-    }
-    if (matchesField(key, 'initiator')) {
-      processed.format = 'transaction-initiator'
-      return processed
-    }
-    if (matchesField(key, 'initiatorType')) {
-      processed.format = 'transaction-initiator-type'
-      return processed
-    }
-    // Handle transfer state fields
-    if (matchesField(key, 'transferState')) {
-      processed.format = 'transfer-state'
-      return processed
-    }
-    // Handle subScenario fields
-    if (matchesField(key, 'subScenario')) {
-      processed.format = 'sub-scenario'
-      return processed
-    }
-    // Handle complex name fields
-    if (matchesField(key, 'complexName')) {
-      processed.type = 'object'
-      processed.properties = {
-        firstName: { type: 'string', format: 'name' },
-        middleName: { type: 'string', format: 'name' },
-        lastName: { type: 'string', format: 'name' }
-      }
-      return processed
-    }
-    // Handle bulk operation IDs
-    if (matchesField(key, 'bulkQuoteId', 'bulkTransferId', 'quoteId', 'transferId', 'id')) {
-      processed.format = 'uuid'
-      return processed
-    }
-  }
-  return processed
-}
+const generateMockResponseBody = async (method, name, data, jsfRefs) => {
+  const responseSchema = findResponseSchema(data.responses)
+  // Create a new copy of object without copying by references
+  const newResponseSchema = JSON.parse(JSON.stringify(responseSchema))
 
-const processRefs = (schema, jsfRefs) => {
-  if (!jsfRefs || !jsfRefs.length) {
-    // Preprocess schema even if no jsfRefs
-    return preprocessSchema(schema)
+  if (!newResponseSchema) {
+    return {}
   }
-
-  const newSchema = JSON.parse(JSON.stringify(schema))
-
-  // Process each reference
   jsfRefs.forEach(ref => {
-    // Convert the reference ID to a valid JSON pointer path
-    const path = ref.id.split('.').map(part => {
-      // Escape special characters in JSON pointer
-      return part.replace(/~/g, '~0').replace(/\//g, '~1')
-    }).join('/')
+    const convertedId = ref.id.replace(/\.(?!items)/g, '.properties.')
 
-    // Helper function to process a schema object
-    const processSchemaObject = (targetObject) => {
-      if (!targetObject) return
+    const targetObject = _.get(newResponseSchema.type === 'array' ? newResponseSchema.items.properties : newResponseSchema.properties, convertedId)
 
-      // Preserve the original type and properties
+    if (targetObject) {
+      targetObject.$ref = ref.id
       if (ref.pattern) {
-        // For pattern-based fields, ensure we have a string type
-        targetObject.type = 'string'
-        targetObject.enum = ['Created', 'Closed'] // Use enum instead of pattern
-        delete targetObject.pattern
-        delete targetObject.format
-      } else if (ref.id === 'Content-Length') {
-        // Special handling for Content-Length
-        targetObject.type = 'string'
-        targetObject.enum = ['123']
-        delete targetObject.pattern
-        delete targetObject.format
-      } else if (ref.id === 'partyIdType') {
-        // Special handling for partyIdType
-        targetObject.type = 'string'
-        targetObject.enum = ['PERSONAL_ID', 'BUSINESS_ID']
         delete targetObject.pattern
-        delete targetObject.format
+        delete targetObject.enum
       }
     }
-
-    // Handle array items
-    if (newSchema.type === 'array' && newSchema.items) {
-      if (newSchema.items.properties) {
-        const targetObject = _.get(newSchema.items.properties, path)
-        processSchemaObject(targetObject)
-      }
-    }
-
-    // Handle object properties
-    if (newSchema.properties) {
-      const targetObject = _.get(newSchema.properties, path)
-      processSchemaObject(targetObject)
-    }
-
-    // Handle nested objects
-    const processNestedObjects = (obj) => {
-      if (!obj || typeof obj !== 'object') return
-
-      if (obj.properties) {
-        Object.keys(obj.properties).forEach(key => {
-          if (key === ref.id) {
-            processSchemaObject(obj.properties[key])
-          } else {
-            processNestedObjects(obj.properties[key])
-          }
-        })
-      }
-
-      if (obj.items) {
-        processNestedObjects(obj.items)
-      }
-    }
-
-    processNestedObjects(newSchema)
   })
 
-  // Preprocess the schema after handling refs
-  return preprocessSchema(newSchema)
-}
-
-// Helper to generate a digits-only phone number of length 10-15
-function generateDigitsPhoneNumber (length = 12) {
-  let num = ''
-  while (num.length < length) {
-    num += faker.number.int({ min: 0, max: 9 }).toString()
-  }
-  return num.slice(0, length)
-}
-
-// Helper to generate a random uppercase alphanumeric string of length 1-32
-function generateFspId () {
-  const length = faker.number.int({ min: 1, max: 32 })
-  let result = ''
-  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
-  for (let i = 0; i < length; i++) {
-    result += chars.charAt(faker.number.int({ min: 0, max: chars.length - 1 }))
-  }
-  return result
-}
-
-// Deep schema walk to generate mock data
-function deepSchemaWalk (schema, key = null, jsfRefs = [], parentKey = null) {
-  if (!schema || typeof schema !== 'object') return undefined
-
-  // Add parent key context
-  schema.parentKey = parentKey
-
-  // Handle arrays
-  if (schema.type === 'array') {
-    const maxItems = schema.maxItems || 2
-    const minItems = schema.minItems || 0
-    let count = Math.min(maxItems, Math.max(minItems, 1))
-
-    // For bulk operations, ensure at least one item
-    if (parentKey === 'individualQuotes' || parentKey === 'individualTransfers') {
-      count = Math.max(1, count)
-    }
-
-    const items = []
-    for (let i = 0; i < count; i++) {
-      const item = deepSchemaWalk(schema.items, null, jsfRefs, key)
-      if (item !== undefined) {
-        items.push(item)
-      }
-    }
-    return items
-  }
-
-  // Handle objects
-  if (schema.type === 'object' || schema.properties) {
-    const result = {}
-    const properties = schema.properties || {}
-    const required = schema.required || []
-
-    // Always process required fields
-    for (const propKey of required) {
-      const propSchema = properties[propKey]
-      const value = deepSchemaWalk(propSchema, propKey, jsfRefs, propKey)
-      if (value !== undefined) {
-        result[propKey] = value
-      }
-    }
-
-    // Process optional fields based on skipNonRequired setting
-    if (!samplerOptions.skipNonRequired) {
-      for (const propKey in properties) {
-        if (!required.includes(propKey)) {
-          const propSchema = properties[propKey]
-          const value = deepSchemaWalk(propSchema, propKey, jsfRefs, propKey)
-          if (value !== undefined) {
-            result[propKey] = value
-          }
-        }
-      }
-    }
-
-    // Handle currency matching for fees
-    if (result.amount && result.amount.currency && result.fees) {
-      result.fees.currency = result.amount.currency
-    }
-
-    return result
-  }
-
-  // Handle primitive types
-  if (schema.type) {
-    const typeHandler = samplerOptions.typeHandlers[schema.type]
-    if (typeHandler) {
-      return typeHandler({ ...schema, key, parentKey })
+  const fakedResponse = {}
+  fakedResponse.body = await jsf.resolve(newResponseSchema, jsfRefs)
+  for (const key in data.responses) {
+    fakedResponse.status = key
+    if (key >= 200 && key <= 299) {
+      break
     }
   }
-
-  return undefined
+  return fakedResponse
 }
 
-// Modify postProcessMock to use deepSchemaWalk
-function postProcessMock (obj, schema, key = null, jsfRefs = []) {
-  // If schema is missing, try to infer type from obj
-  if (!schema || typeof schema !== 'object') {
-    if (obj === 'string' && key) {
-      const fake = customTypeHandler({ key, type: 'string' })
-      return fake !== undefined ? fake : 'string'
-    }
-    return obj
-  }
-
-  // Use deepSchemaWalk to generate a complete mock object
-  const generated = deepSchemaWalk(schema, key, jsfRefs)
-
-  // If deepSchemaWalk generated something, use it
-  if (generated !== undefined && typeof generated === 'object' && !Array.isArray(generated)) {
-    // Add missing top-level fields if required by tests
-    // 1. state, reason, partyIdType
-    if (schema.properties) {
-      if (schema.properties.state && generated.state === undefined) {
-        generated.state = faker.helpers.arrayElement(['Created', 'Closed'])
-      }
-      if (schema.properties.reason && generated.reason === undefined) {
-        generated.reason = faker.helpers.arrayElement(['Created', 'Closed'])
-      }
-      if (schema.properties.partyIdType && generated.partyIdType === undefined) {
-        generated.partyIdType = faker.helpers.arrayElement(['PERSONAL_ID', 'BUSINESS_ID'])
-      }
-      if (schema.properties.transferState && generated.transferState === undefined) {
-        generated.transferState = faker.helpers.arrayElement(['RECEIVED', 'RESERVED', 'COMMITTED', 'ABORTED'])
-      }
-      if (schema.properties.bulkQuoteId && generated.bulkQuoteId === undefined) {
-        generated.bulkQuoteId = faker.string.uuid()
-      }
-      if (schema.properties.bulkTransferId && generated.bulkTransferId === undefined) {
-        generated.bulkTransferId = faker.string.uuid()
-      }
-      if (schema.properties.subScenario && generated.subScenario === undefined) {
-        generated.subScenario = faker.helpers.fromRegExp(/^[A-Z_]{1,32}$/)
-      }
-    }
-    // Patch for nested FSP ID and name fields
-    function patchNested (obj) {
-      if (!obj || typeof obj !== 'object') return
-      for (const k in obj) {
-        if (k.toLowerCase() === 'fspid' && (typeof obj[k] !== 'string' || !/^[A-Z0-9]{1,32}$/.test(obj[k]))) {
-          obj[k] = generateFspId()
-        }
-        // Only apply full name fallback to 'name' field, not firstName, lastName, or complexName
-        if (
-          k.toLowerCase() === 'name' &&
-          (typeof obj[k] !== 'string' || !/^[A-Z][a-z]+ [A-Z][a-z]+$/.test(obj[k]))
-        ) {
-          const first = faker.person.firstName()
-          const last = faker.person.lastName()
-          obj[k] = `${first.charAt(0).toUpperCase()}${first.slice(1)} ${last.charAt(0).toUpperCase()}${last.slice(1)}`
-        }
-        if (typeof obj[k] === 'object') patchNested(obj[k])
-      }
-    }
-    patchNested(generated)
-    return generated
-  }
-
-  // Fallback to original object if deepSchemaWalk didn't generate anything
-  if (typeof obj === 'object' && !Array.isArray(obj)) {
-    const result = {}
-    for (const k in obj) {
-      if (schema.properties && schema.properties[k]) {
-        result[k] = postProcessMock(obj[k], schema.properties[k], k, jsfRefs)
-      } else {
-        result[k] = obj[k]
-      }
-    }
-    return result
-  }
-
-  return obj
-}
-
-// Update generateMockOperation to pass jsfRefs to postProcessMock
 const generateMockOperation = async (method, name, data, jsfRefs) => {
-  if (!data || !data.requestBody) {
-    return {}
-  }
-
   const requestSchema = findRequestSchema(data.requestBody)
-  if (!requestSchema) {
-    return {}
-  }
-
-  try {
-    const processedSchema = processRefs(requestSchema, jsfRefs)
-    let sampled = JSONSchemaSampler.sample(processedSchema, samplerOptions)
-    sampled = postProcessMock(sampled, processedSchema, null, jsfRefs)
-    return sampled
-  } catch (error) {
-    console.error(`Error generating mock operation for ${method} ${name}:`, error)
-    return {}
-  }
-}
-
-// Update other generateMock functions similarly
-const generateMockResponseBody = async (method, name, data, jsfRefs) => {
-  if (OpenApiRequestGenerator._testForceError === 'generateMockResponseBody') throw new Error('Forced error for test')
-  if (!data || !data.responses) {
-    return {}
-  }
-
-  const responseSchema = findResponseSchema(data.responses)
-  if (!responseSchema) {
-    return {}
-  }
-
-  try {
-    const processedSchema = processRefs(responseSchema, jsfRefs)
-    const fakedResponse = {}
-    let sampled = JSONSchemaSampler.sample(processedSchema, samplerOptions)
-    sampled = postProcessMock(sampled, processedSchema, null, jsfRefs)
-    fakedResponse.body = sampled
-
-    for (const key in data.responses) {
-      fakedResponse.status = key
-      if (key >= 200 && key <= 299) {
-        break
+  // Create a new copy of object without copying by references
+  const newRequestSchema = JSON.parse(JSON.stringify(requestSchema))
+  jsfRefs.forEach(ref => {
+    const convertedId = ref.id.replace(/\./g, '.properties.')
+    const targetObject = _.get(newRequestSchema.properties, convertedId)
+    if (targetObject) {
+      targetObject.$ref = ref.id
+      if (ref.pattern) {
+        delete targetObject.pattern
+        delete targetObject.enum
       }
     }
-    return fakedResponse
-  } catch (error) {
-    console.error(`Error generating mock response for ${method} ${name}:`, error)
-    return {}
-  }
+  })
+
+  const fakedResponse = await jsf.resolve(newRequestSchema, jsfRefs)
+
+  return fakedResponse
 }
 
 const generateMockHeaders = async (method, name, data, jsfRefs) => {
-  if (OpenApiRequestGenerator._testForceError === 'generateMockHeaders') throw new Error('Forced error for test')
-  if (!data || !Array.isArray(data.parameters)) {
-    return {}
-  }
-  const properties = {}
+  const headers = {}
   data.parameters.forEach(param => {
     if (param.in === 'header') {
-      properties[param.name] = (param.schema && param.schema.type) ? { type: param.schema.type } : {}
+      headers[param.name] = (param.schema && param.schema.type) ? { type: param.schema.type } : {}
+    }
+  })
+  jsfRefs.forEach(ref => {
+    if (headers[ref.id]) {
+      headers[ref.id] = { $ref: ref.id }
     }
   })
 
-  if (Object.keys(properties).length === 0) {
+  if (Object.keys(headers).length === 0) {
     return {}
   }
 
-  const schema = { type: 'object', properties }
-  const processedSchema = processRefs(schema, jsfRefs)
-  let sampled = JSONSchemaSampler.sample(processedSchema, samplerOptions)
-  sampled = postProcessMock(sampled, processedSchema, null, jsfRefs)
-  if (sampled === null) sampled = {}
-  return sampled
+  const fakedResponse = await jsf.resolve(headers, jsfRefs)
+
+  return fakedResponse
 }
 
 const generateMockQueryParams = async (method, name, data, jsfRefs) => {
-  if (OpenApiRequestGenerator._testForceError === 'generateMockQueryParams') throw new Error('Forced error for test')
-  if (!data || !Array.isArray(data.parameters)) {
-    return {}
-  }
-  const properties = {}
+  const queryParams = {}
   data.parameters.forEach(param => {
     if (param.in === 'query') {
-      properties[param.name] = (param.schema) ? { ...param.schema } : {}
+      queryParams[param.name] = (param.schema) ? { ...param.schema } : {}
+    }
+  })
+  jsfRefs.forEach(ref => {
+    if (queryParams[ref.id]) {
+      queryParams[ref.id] = { $ref: ref.id }
     }
   })
 
-  if (Object.keys(properties).length === 0) {
+  if (Object.keys(queryParams).length === 0) {
     return {}
   }
 
-  const schema = { type: 'object', properties }
-  const processedSchema = processRefs(schema, jsfRefs)
-  let sampled = JSONSchemaSampler.sample(processedSchema, samplerOptions)
-  sampled = postProcessMock(sampled, processedSchema, null, jsfRefs)
-  if (sampled === null) sampled = {}
-  return sampled
+  const fakedResponse = await jsf.resolve(queryParams, jsfRefs)
+
+  return fakedResponse
 }
 
 const generateMockPathParams = async (method, name, data, jsfRefs) => {
-  if (OpenApiRequestGenerator._testForceError === 'generateMockPathParams') throw new Error('Forced error for test')
-  if (!data || !Array.isArray(data.parameters)) {
-    return {}
-  }
-  const properties = {}
+  const pathParams = {}
   data.parameters.forEach(param => {
     if (param.in === 'path') {
-      properties[param.name] = (param.schema) ? { ...param.schema } : {}
+      pathParams[param.name] = (param.schema) ? { ...param.schema } : {}
+    }
+  })
+  jsfRefs.forEach(ref => {
+    if (pathParams[ref.id]) {
+      pathParams[ref.id] = { $ref: ref.id }
     }
   })
 
-  if (Object.keys(properties).length === 0) {
+  if (Object.keys(pathParams).length === 0) {
     return {}
   }
 
-  const schema = { type: 'object', properties }
-  const processedSchema = processRefs(schema, jsfRefs)
-  let sampled = JSONSchemaSampler.sample(processedSchema, samplerOptions)
-  sampled = postProcessMock(sampled, processedSchema, null, jsfRefs)
-  if (sampled === null) sampled = {}
-  return sampled
+  const fakedResponse = await jsf.resolve(pathParams, jsfRefs)
+
+  return fakedResponse
 }
 
 class OpenApiRequestGenerator {
@@ -898,105 +263,44 @@ class OpenApiRequestGenerator {
   }
 
   async load (schemaPath) {
-    try {
-      this.schema = await loadYamlFile(schemaPath)
-    } catch (error) {
-      console.error('Error loading schema:', error)
-      this.schema = {}
-    }
+    this.schema = await loadYamlFile(schemaPath)
   }
 
   async generateRequestBody (path, httpMethod, jsfRefs = []) {
-    try {
-      const pathValue = this.schema.paths?.[path]
-      if (!pathValue) {
-        return {}
-      }
-      const operation = pathValue[httpMethod]
-      if (!operation) {
-        return {}
-      }
-      const id = operation.operationId || operation.summary
-      return generateMockOperation(httpMethod, id, operation, jsfRefs)
-    } catch (error) {
-      console.error(`Error generating request body for ${path} ${httpMethod}:`, error)
-      return {}
-    }
+    const pathValue = this.schema.paths[path]
+    const operation = pathValue[httpMethod]
+    const id = operation.operationId || operation.summary
+    return generateMockOperation(httpMethod, id, operation, jsfRefs)
   }
 
   async generateRequestHeaders (path, httpMethod, jsfRefs = []) {
-    try {
-      const pathValue = this.schema.paths?.[path]
-      if (!pathValue) {
-        return {}
-      }
-      const operation = pathValue[httpMethod]
-      if (!operation) {
-        return {}
-      }
-      const id = operation.operationId || operation.summary
-      return generateMockHeaders(httpMethod, id, operation, jsfRefs)
-    } catch (error) {
-      console.error(`Error generating request headers for ${path} ${httpMethod}:`, error)
-      return {}
-    }
+    const pathValue = this.schema.paths[path]
+    const operation = pathValue[httpMethod]
+    const id = operation.operationId || operation.summary
+    return generateMockHeaders(httpMethod, id, operation, jsfRefs)
   }
 
   async generateRequestQueryParams (path, httpMethod, jsfRefs = []) {
-    try {
-      const pathValue = this.schema.paths?.[path]
-      if (!pathValue) {
-        return {}
-      }
-      const operation = pathValue[httpMethod]
-      if (!operation) {
-        return {}
-      }
-      const id = operation.operationId || operation.summary
-      return generateMockQueryParams(httpMethod, id, operation, jsfRefs)
-    } catch (error) {
-      console.error(`Error generating query params for ${path} ${httpMethod}:`, error)
-      return {}
-    }
+    const pathValue = this.schema.paths[path]
+    const operation = pathValue[httpMethod]
+    const id = operation.operationId || operation.summary
+    return generateMockQueryParams(httpMethod, id, operation, jsfRefs)
   }
 
   async generateRequestPathParams (path, httpMethod, jsfRefs = []) {
-    try {
-      const pathValue = this.schema.paths?.[path]
-      if (!pathValue) {
-        return {}
-      }
-      const operation = pathValue[httpMethod]
-      if (!operation) {
-        return {}
-      }
-      const id = operation.operationId || operation.summary
-      return generateMockPathParams(httpMethod, id, operation, jsfRefs)
-    } catch (error) {
-      console.error(`Error generating path params for ${path} ${httpMethod}:`, error)
-      return {}
-    }
+    const pathValue = this.schema.paths[path]
+    const operation = pathValue[httpMethod]
+    const id = operation.operationId || operation.summary
+    return generateMockPathParams(httpMethod, id, operation, jsfRefs)
   }
 
   async generateResponseBody (path, httpMethod, jsfRefs = []) {
-    try {
-      const pathValue = this.schema.paths?.[path]
-      if (!pathValue) {
-        return {}
-      }
-      const operation = pathValue[httpMethod]
-      if (!operation) {
-        return {}
-      }
-      const id = operation.operationId || operation.summary
-      return generateMockResponseBody(httpMethod, id, operation, jsfRefs)
-    } catch (error) {
-      console.error(`Error generating response body for ${path} ${httpMethod}:`, error)
-      return {}
-    }
+    const pathValue = this.schema.paths[path]
+    const operation = pathValue[httpMethod]
+    const id = operation.operationId || operation.summary
+
+    return generateMockResponseBody(httpMethod, id, operation, jsfRefs)
   }
 }
 
-OpenApiRequestGenerator._testForceError = null
-
 module.exports = OpenApiRequestGenerator

package/.husky/commit-msg

@@ -1,4 +0,0 @@
-#!/usr/bin/env sh
-. "$(dirname -- "$0")/_/husky.sh"
-
-npx commitlint --edit $1

package/.husky/post-commit

@@ -1,4 +0,0 @@
-#!/usr/bin/env sh
-. "$(dirname -- "$0")/_/husky.sh"
-
-git update-index --again

package/.husky/pre-commit

@@ -1 +0,0 @@
-npm run lint; npm run dep:check; npm run test:unit