falcor/lib/get/onMissing.js

A JavaScript library for efficient data fetching.

module.exports = function onMissing(model, path, depth,
                                    outerResults, requestedPath,
                                    optimizedPath, optimizedLength) {
    var pathSlice;
    if (!outerResults.requestedMissingPaths) {
        outerResults.requestedMissingPaths = [];
        outerResults.optimizedMissingPaths = [];
    }

    if (depth < path.length) {
        // If part of path has not been traversed, we need to ensure that there
        // are no empty paths (range(1, 0) or empyt array)
        var isEmpty = false;
        for (var i = depth; i < path.length && !isEmpty; ++i) {
            if (isEmptyAtom(path[i])) {
                return;
            }
        }

        pathSlice = path.slice(depth);
    } else {
        pathSlice = [];
    }

    concatAndInsertMissing(model, pathSlice, depth, requestedPath,
                           optimizedPath, optimizedLength, outerResults);
};

function concatAndInsertMissing(model, remainingPath, depth, requestedPath,
                                optimizedPath, optimizedLength, results) {
    var requested = requestedPath.slice(0, depth);
    Array.prototype.push.apply(requested, remainingPath);
    results.requestedMissingPaths[results.requestedMissingPaths.length] = requested;

    var optimized = optimizedPath.slice(0, optimizedLength);
    Array.prototype.push.apply(optimized, remainingPath);
    results.optimizedMissingPaths[results.optimizedMissingPaths.length] = optimized;
}

function isEmptyAtom(atom) {
    if (atom === null || typeof atom !== "object") {
        return false;
    }

    var isArray = Array.isArray(atom);
    if (isArray && atom.length) {
        return false;
    }

    // Empty array
    else if (isArray) {
        return true;
    }

    var from = atom.from;
    var to = atom.to;
    if (from === undefined || from <= to) {
        return false;
    }

    return true;
}