json-schema-defaults ile node.js üstünde .json uzantılı şemaları dinamik yüklemek

Tüm kodunu en aşağıya yapıştırdım ama ekelediğim yeri biraz anlatmış olayım:

var getRemoteRef = function (_uri, definitions) {
// loadschema ileride async olarak şema yüklemelerini sağlamak için kullanacağım için şimdiden hazır edeyim dedim.
    var loadSchema = function (uri, callback) {
        var request = require('request');
        request(uri, function (err, res, body) {
            console.log(body); // Bu gelen şemayı doğrulamaya göndermeden önce JSON'a çevirmelisiniz.

            if (err || res.statusCode >= 400)
                callback(err || new Error('Loading error: ' + res.statusCode));
            else {
                callback(null, JSON.parse(body));
            }
        });
    };

    // node uygulamasının hangi fiziksel klasörde olduğunu buluyorum
    var appRoot = require('app-root-path'),
        // dosya yolunun schema'lı halini oluşturuyorum
        indexOfSchema = _uri.indexOf('/schema/');

    // .json dosyasının tam yolunu bulduktan sonra 
    var filePath = appRoot + "/node/" + _uri.substr(indexOfSchema);
    console.log("Path: " + filePath);

    // reuqire ile çekiyoruz
    var result = require(filePath);

    if (!isObject(result)) {
        return result;
    }
    return cloneJSON(result);
}

(function (root, factory) {

    'use strict';

    if (typeof require === 'function' && typeof exports === 'object' && typeof module === 'object') {
        // CommonJS
        module.exports = factory();
    } else if (typeof define === 'function' && define.amd) {
        // AMD
        define('json-schema-defaults', [], function () {
            return factory();
        });
    } else {
        // global with noConflict
        var jsonSchemaDefaults = root.jsonSchemaDefaults;
        root.jsonSchemaDefaults = factory();
        root.jsonSchemaDefaults.noConflict = function () {
            var defaults = root.jsonSchemaDefaults;
            root.jsonSchemaDefaults = jsonSchemaDefaults;
            return defaults;
        };
    }

}(this, function () {

    'use strict';

    var ajv = null;

    /**
     * check whether item is plain object
     * @param {*} item
     * @return {Boolean}
     */
    var isObject = function (item) {
        return typeof item === 'object' && item !== null && item.toString() === {}.toString();
    };

    /**
     * deep JSON object clone
     *
     * @param {Object} source
     * @return {Object}
     */
    var cloneJSON = function (source) {
        return JSON.parse(JSON.stringify(source));
    };

    /**
     * returns a result of deep merge of two objects
     *
     * @param {Object} target
     * @param {Object} source
     * @return {Object}
     */
    var merge = function (target, source) {
        target = cloneJSON(target);

        for (var key in source) {
            if (source.hasOwnProperty(key)) {
                if (isObject(target[key]) && isObject(source[key])) {
                    target[key] = merge(target[key], source[key]);
                } else {
                    target[key] = source[key];
                }
            }
        }
        return target;
    };

    /**
     * merge list of objects from allOf properties
     * if some of objects contains $ref field extracts this reference and merge it
     *
     * @param {Array} allOfList
     * @param {Object} definitions
     * @return {Object}
     */
    var mergeAllOf = function (allOfList, definitions) {
        var length = allOfList.length,
            index = -1,
            result = {};

        while (++index < length) {
            var item = allOfList[index];

            item = (typeof item.$ref !== 'undefined') ? getLocalRef(item.$ref, definitions) : item;

            result = merge(result, item);
        }

        return result;
    };

    /**
     * get object by reference. works only with local references that points on
     * definitions object
     *
     * @param {String} path
     * @param {Object} definitions
     * @return {Object}
     */
    var getLocalRef = function (path, definitions) {
        path = path.replace(/^#\/definitions\//, '').split('/');

        var find = function (path, root) {
            var key = path.shift();
            if (!root[key]) {
                return {};
            } else if (!path.length) {
                return root[key];
            } else {
                return find(path, root[key]);
            }
        };

        var result = find(path, definitions);

        if (!isObject(result)) {
            return result;
        }
        return cloneJSON(result);
    };


    var getRemoteRef = function (_uri, definitions) {
        var loadSchema = function (uri, callback) {
            var request = require('request');
            request(uri, function (err, res, body) {
                console.log(body); // Bu gelen şemayı doğrulamaya göndermeden önce JSON'a çevirmelisiniz.

                if (err || res.statusCode >= 400)
                    callback(err || new Error('Loading error: ' + res.statusCode));
                else {
                    callback(null, JSON.parse(body));
                }
            });
        };

        var Path = require('path'),
            appRoot = require('app-root-path'),
            indexOfSchema = _uri.indexOf('/schema/');

        var filePath = appRoot + "/node/" + _uri.substr(indexOfSchema);
        console.log("Path: " + filePath);
        var result = require(filePath);
        if (!isObject(result)) {
            return result;
        }
        return cloneJSON(result);
    }


    /**
     * returns a object that built with default values from json schema
     *
     * @param {Object} schema
     * @param {Object} definitions
     * @return {Object}
     */
    var defaults = function (schema, definitions) {
        console.log("schema: " + JSON.stringify(schema, null, ' '));
        console.log("definitions: " + JSON.stringify(definitions));
        if (typeof schema['default'] !== 'undefined') {

            return schema['default'];

        }
        else if (typeof schema.allOf !== 'undefined') {

            var mergedItem = mergeAllOf(schema.allOf, definitions);
            console.log("MergedItem: " + JSON.stringify(mergedItem));
            return defaults(mergedItem, definitions);

        }
        else if (typeof schema.$ref !== 'undefined') {
            console.log("Reference name: " + schema.$ref);
            var reference;
            if (schema.$ref.indexOf("http") == 0) {
                reference = getRemoteRef(schema.$ref, definitions);
                //reference= getRemoteRef("http://localhost:3000/schema/providers/login/test.json", definitions);
            } else {
                reference = getLocalRef(schema.$ref, definitions);
            }

            console.log("Refernce: " + JSON.stringify(reference));
            return defaults(reference, definitions);

        }
        else if (schema.type === 'object') {

            if (!schema.properties) {
                return {};
            }

            for (var key in schema.properties) {
                if (schema.properties.hasOwnProperty(key)) {
                    schema.properties[key] = defaults(schema.properties[key], definitions);

                    if (typeof schema.properties[key] === 'undefined') {
                        delete schema.properties[key];
                    }
                }
            }

            return schema.properties;

        }
        else if (schema.type === 'array') {

            if (!schema.items) {
                return [];
            }
            return [defaults(schema.items, definitions)];

        }
        else if (schema.type && typeof(schema.type) === 'object') {

            console.log("Reference name: " + schema.type.$ref);
            var reference = getLocalRef(schema.$ref, definitions);
            console.log("Refernce: " + JSON.stringify(reference));
            return defaults(reference, definitions);

            if (!schema.items) {
                return [];
            }
            return [defaults(schema.items, definitions)];

        }

    };

    /**
     * main function
     *
     * @param {Object} schema
     * @param {Object|undefined} definitions
     * @return {Object}
     */
    return function (schema, definitions, _ajv) {
        ajv = _ajv;

        if (definitions && Array.isArray(definitions)) {
            var defs = {};
            definitions.forEach(function (_definition) {
                defs = merge(_definition, schema.definitions);
            });
            definitions = defs;
        }

        if (typeof definitions === 'undefined') {
            definitions = schema.definitions || {};
        }
        else if (isObject(schema.definitions)) {
            definitions = merge(definitions, schema.definitions);
        }

        return defaults(cloneJSON(schema), definitions);
    };

}));