How to use the json-schema-faker function in json-schema-faker

return (root, args, context, info) => {
        const random = seedrandom(RANDOM_SEED);
        jsf.format('uuid', generateUUID(random));
        jsf.format('uniqueId', generateUUID(random));
        jsf.option({ random });
        const fake = jsf(operation.schema);
        // console.log(`CALLING API: ${operation.path}\n\n${JSON.stringify(fake, null, 2)}`);
        return fake;
    }
};

/* This script generates mock data for local development.
   This way you don't have to point to an actual API,
   but you can enjoy realistic, but randomized data,
   and rapid page loads due to local, static data.
 */

/* eslint-disable no-console */

import jsf from 'json-schema-faker';
import {schema} from './mockDataSchema';
import fs from 'fs';
import chalk from 'chalk';

const json = JSON.stringify(jsf(schema));

fs.writeFile("./src/api/db.json", json, function (err) {
  if (err) {
    return console.log(chalk.red(err));
  } else {
    console.log(chalk.green("Mock data generated."));
  }
});

item.format !== 'sequence' &&
                    !item.faker &&
                    !item['x-faker']
                ) {
                    item['x-faker'] = 'company.bsNoun'
                }
                result += jsf(item)
            }
            return result
        })

        if (constraintSet.default) {
            constraintSet.enum = [ constraintSet.default ]
        }

        let generated = jsf(constraintSet)
        return generated
    }

function createMessageBodyAssetFromJsonSchema(minim, jsonSchema) {
  const Asset = minim.getElementClass('asset');
  const messageBody = jsonSchemaFaker(jsonSchema)

  const schemaAsset = new Asset(JSON.stringify(messageBody, null, 2));
  schemaAsset.classes.push('messageBody');
  schemaAsset.attributes.set('contentType', 'application/json');

  return schemaAsset;
}

export function schema(request, response) {
  let request_schema = request ? joi_to_json_schema(request) : {};
  let response_schema = response ? joi_to_json_schema(response) : {};
  return {
    schema:{
      request: request_schema,
      response: response_schema
    },
    example:{
      request: !_.isEmpty(request_schema) ? jsf(request_schema) : {},
      response: !_.isEmpty(response_schema) ? jsf(response_schema) : {}
    }
  }
}

let schema = {
            $$schema: schemaDict[mainKey]
        }

        delete schemaDict[mainKey]
        let schemas = this._materializeSchemas(schemaDict)


        Object.assign(schema, schemas)

        if (this.predict) {
            schema = this._guessFormats(schema)
        }

        let generated = (jsf(schema) || {}).$$schema

        let result
        if (typeof generated === 'object') {
            result = JSON.stringify(generated, null, '  ')
        }
        else {
            result = generated
        }
        return result
    }

export function schema(request, response) {
  let request_schema = request ? joi_to_json_schema(request) : {};
  let response_schema = response ? joi_to_json_schema(response) : {};
  return {
    schema:{
      request: request_schema,
      response: response_schema
    },
    example:{
      request: !_.isEmpty(request_schema) ? jsf(request_schema) : {},
      response: !_.isEmpty(response_schema) ? jsf(response_schema) : {}
    }
  }
}

export const generateObjects = ({ objectConfiguration, quantity = 10 }) => {
  const businessObjects = [];
  for (let i = 0; i < quantity; i++) {
    const object = jsfaker(objectConfiguration.schema);
    object[objectIdProp] = `${objectConfiguration.alias || 'object'}-${i}`;
    businessObjects.push(object);
  }
  return businessObjects
}