unmock-core/dist/generator.js

[][npmjs] [](https://circleci.com/gh/unmock/unmock-js) [](h

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const json_schema_faker_1 = __importDefault(require("json-schema-faker"));
const lodash_1 = require("lodash");
const service_1 = require("./service");
const interfaces_1 = require("./service/interfaces");
const parser_1 = require("./service/parser");
const serviceStore_1 = require("./service/serviceStore");
function firstOrRandomOrUndefined(arr) {
    return arr.length === 0
        ? undefined
        : arr.length === 1
            ? arr[0]
            : arr[Math.floor(Math.random() * arr.length)];
}
function responseCreatorFactory({ serviceDefLoader, }) {
    const serviceDefs = serviceDefLoader.loadSync();
    const parser = new parser_1.ServiceParser();
    const services = serviceDefs.map(serviceDef => parser.parse(serviceDef));
    const serviceStore = new serviceStore_1.ServiceStore(services);
    const stateStore = service_1.stateStoreFactory(serviceStore);
    return {
        stateStore,
        createResponse: (sreq) => generateMockFromTemplate(serviceStore.match(sreq)),
    };
}
exports.responseCreatorFactory = responseCreatorFactory;
const normalizeHeaders = (headers) => headers === undefined
    ? undefined
    : Object.keys(headers).reduce((acc, h) => (Object.assign({}, acc, { [h]: headers[h].schema })), {});
const setupJSFUnmockProperties = () => {
};
const getStateForOperation = (operation, state) => {
    const responses = operation.responses;
    const operationCodes = Object.keys(responses);
    if (state === undefined || Object.keys(state).length === 0) {
        return undefined;
    }
    const possibleResponseCodes = Object.keys(state).filter((code) => operationCodes.includes(code));
    const statusCode = firstOrRandomOrUndefined(possibleResponseCodes);
    if (statusCode === undefined) {
        return undefined;
    }
    const operationResponse = responses[statusCode];
    if (operationResponse === undefined ||
        interfaces_1.isReference(operationResponse) ||
        operationResponse.content === undefined) {
        return undefined;
    }
    const operationContent = operationResponse.content;
    const mediaTypes = Object.keys(state[statusCode]).filter((type) => Object.keys(operationContent).includes(type));
    const mediaType = firstOrRandomOrUndefined(mediaTypes);
    if (mediaType === undefined) {
        return undefined;
    }
    const requestedState = state[statusCode][mediaType];
    const matchedOperation = operationContent[mediaType].schema;
    return {
        $code: statusCode,
        template: lodash_1.defaultsDeep(requestedState, matchedOperation),
        headers: operationResponse.headers,
    };
};
const tryCatch = (value, f) => {
    try {
        return f(value);
    }
    catch (_a) {
        return value;
    }
};
const chooseResponseFromOperation = (operation) => {
    const responses = operation.responses;
    const chosenCode = firstOrRandomOrUndefined(Object.keys(responses));
    if (chosenCode === undefined) {
        throw new Error("Not sure what went wrong");
    }
    const response = responses[chosenCode];
    if (response === undefined ||
        interfaces_1.isReference(response) ||
        response.content === undefined) {
        throw new Error("Not sure what went wrong");
    }
    const content = response.content;
    const chosenMediaType = firstOrRandomOrUndefined(Object.keys(content));
    if (chosenMediaType === undefined) {
        throw new Error("Not sure what went wrong");
    }
    const schema = content[chosenMediaType].schema;
    if (schema === undefined || interfaces_1.isReference(schema)) {
        throw new Error("Missing schema for a response!");
    }
    return {
        $code: chosenCode,
        template: schema,
        headers: response.headers,
    };
};
const generateMockFromTemplate = (matchedService) => {
    if (matchedService === undefined) {
        return undefined;
    }
    const { operation, state } = matchedService;
    const { template, $code, headers } = getStateForOperation(operation, state) ||
        chooseResponseFromOperation(operation);
    setupJSFUnmockProperties();
    if (template.required === undefined) {
        json_schema_faker_1.default.option("alwaysFakeOptionals", true);
    }
    const resolvedTemplate = json_schema_faker_1.default.generate(template);
    json_schema_faker_1.default.reset();
    const body = JSON.stringify(tryCatch(resolvedTemplate, json_schema_faker_1.default.generate));
    json_schema_faker_1.default.option("useDefaultValue", true);
    const resHeaders = json_schema_faker_1.default.generate(normalizeHeaders(headers));
    json_schema_faker_1.default.reset();
    return {
        body,
        headers: resHeaders,
        statusCode: +$code || 200,
    };
};
//# sourceMappingURL=generator.js.map