JSDoc Reference

// Borrowed from helma-ng
// Hack till real logger will be available
var log = {
    debug: function(message) { print('filestore | debug | ' + message); },
    error: function(message) { print('filestore | error | ' + message); }
}
var file = require("file");
var JSON = require("json");
//var dir = require("dir");

var Functional = require("./functional");
var bindArguments = Functional.bindArguments;
var bindThisObject = Function.bindThisObject;

var TEXT = 0;
var REFERENCE = 10;
var COLLECTION = 20;
var LIST = 21;

function Text() { return {id: TEXT} };
function Reference(type) {
    if (!type) throw new Error("Missing type argument in Reference()");
    return {id: REFERENCE, type: type};
};
function Collection(type, options) {
    if (!type) throw new Error("Missing type argument in Collection()");
    return { id: COLLECTION, type: type, options: options };
};
function List(type, options) {
    if (!type) throw new Error("Missing type argument in List()");
    return { id: LIST, type: type, options: options };
};
/**
 * File Store class
 * @class
 * @param path the database directory
 */
function Store(path) {

    // the class registry
    var typeRegistry = {};

    // map of type to current id tip
    var idMap = {};

    /**
     * @param constructor a plain JavaScript constructor
     * @param fields container of fields defined for this object type
     */
    this.registerType = function(constructor, fields) {
        if (typeof constructor != "function") {
           throw new Error("registerType() called with non-function argument: " + constructor);
        }
        if (typeof constructor.name != "string") {
           throw new Error("constructor must not be an anonymous function");
        }

        var typeName = constructor.name;

        // install filter, all, and get methods on constructor
        constructor.list = bindArguments(list, typeName);
        constructor.all = bindArguments(getAll, typeName);
        constructor.get = bindArguments(get, typeName);
        constructor.store = this;
        // add class to registry
        typeRegistry[typeName] = constructor;

        function getter(name, def) {
            if (def.id == REFERENCE) {
                var key = this.properties[name];
                if (isKey(key)) {
                    return get(key._type, key._id);
                }
            } else if (def.id == LIST) {
                if (def.options) {
                    return def.type.list(def.options, this);
                } else {
                    return def.type.all();
                }
            }
            return this.properties[name];
        }

        function setter(name, definition, value) {
            if (value == null) {
                delete this.properties[name];
            } else {
                this.properties[name] = value;
            }
        }

        var proto = constructor.prototype;

        for (var [key, field] in fields) {
            proto.__defineSetter__(key, bindArguments(setter, key, field));
            proto.__defineGetter__(key, bindArguments(getter, key, field));
        }

        proto.__defineGetter__("_type", function() { return typeName });

        proto.getKey = function() {
            if (!(typeof this._id == "string")) {
                throw new Error("getKey() called on non-persistent object");
            }
            return {_id: this._id, _type: this._type};
        }

        proto.save = function(txn) {
            save(txn, this);
        };

        proto.remove = function(txn) {
            remove(txn, this);
        };

        proto.toString = function() {
            return typeName + this.properties.toSource();
        };

        proto.equals = function(obj) {
            return this === obj || obj &&
                                   this._type === obj._type &&
                                   this._id == obj._id;
        }
/*  Jack uses Rhino 1.7 release 3 PRERELEASE 2009 04 05
    Which doesn't supports iterators / generators
        proto.__iterator__ = function(namesOnly) {
            for (var i in this.properties) {
                yield namesOnly ? i : [i, this[i]];
            }
            throw StopIteration;
        }
*/
    }

    this.getRegisteredType = function(name) {
        return typeRegistry[name];
    }

    var list = function(type, options, thisObj) {
        var array = getAll(type);
        if (options) {
            // first filter out the the items we're not interested in
            var filter = options.filter;
            if (typeof filter == "function") {
                array = array.filter(filter, thisObj);
            }
            // then put them into order
            var [orderBy, ascDesc] = [options.orderBy, options.order == "desc" ? -1 : 1];
            if (options.orderBy) {
                array = array.sort(function(o1, o2) {
                    var [p1, p2] = [o1[orderBy], o2[orderBy]];
                    if (p1 < p2) return -1 * ascDesc;
                    if (p1 > p2) return  1 * ascDesc;
                    return 0;
                })
            }
            // finally apply pagination/slicing
            var [start, max] = [parseInt(options.start, 10), parseInt(options.max, 10)];
            if (isFinite(start) || isFinite(max)) {
                var start = start || 0;
                array = array.slice(start, start + max || array.length);
            }
        }
        return array;
    };

    var getAll = function(type) {
        var dir = base.join(type);
        if (!file.exists(dir) || !file.isDirectory(dir)) { return []; }
        var entries = file.list(dir);
        var list = [];

        for each (var entry in entries) {
            // dont check if the files are hidden or not
            if (!file.isFile(dir.join(entry))) continue;
            list.push(persister.retrieve(type, dir.join(entry)));
        }
        return list;
    };

    var get = this.get = function(type, id) {
        var dir = base.join(type);
        var path = dir.join(id);

        if (!file.exists(path)) return null;
        else if (!file.isFile(path)) throw new Error("Is not a regular file: " + path);
        return persister.retrieve(type, path);
    }

    var save = function(txn, obj) {
        var wrapTransaction = !txn;
        if (wrapTransaction) txn = new Transaction();
        for (var i in obj.properties) {
            var v = obj.properties[i];
            if (isStorable(v)) {
                if (isTransientStorable(v)) {
                    v.save(txn);
                }
                obj.properties[i] = v.getKey();
            }
        }
        var [type, id] = [obj._type, obj._id];
        var dir = base.join(type);
        if (!file.exists(dir)) {
            try {
                file.mkdirs(dir);
            } catch(e) {
                throw new Error("Can't create directory for type " + type + " : " + dir);
            }
        }
        if (id == undefined) obj._id = id = persister.generateId(type, dir);

        var path = dir.join(id);
        var tempPath = base.join(type + id + "..tmp");

        persister.store(obj.properties, tempPath);

        if (file.exists(path) && !file.isWritable(path))
            throw new Error("No write permission for " + path);

        txn.updateResource({ path: path, tempPath: tempPath });

        if (wrapTransaction) txn.commit();
    };

    var remove = function(txn, obj) {
        var wrapTransaction = !txn;
        if (wrapTransaction) txn = Transaction();
        for (var i in obj) {
            var v = obj[i];
            if (isPersistentStorable(v)) {
                // cascading delete (just to show it works)
                v.remove(txn);
            }
        }
        var [type, id] = [obj._type, obj._id];
        if (!type) throw new Error("type not defined in object " + obj);
        if (!id) throw new Error("id not defined in object " + obj);

        var path = base.join(type).join(id);
        txn.deleteResource({ path: path });

        if (wrapTransaction) txn.commit();
    };

    // the persister
    var persister = {
        store: function(object, path) {
            log.debug("Storing object: " + object.toSource());
            file.write(path, JSON.encode(object), {append: true});
        },
        retrieve: function(type, path) {
            var content = file.read(path);
            // File read is not a string ??
            var properties = JSON.decode(content.toString());
            var ctor = typeRegistry[type];
            if (!ctor) throw new Error("constructor not registered for type " + type);
            var obj = new ctor(properties);
            obj._id = file.basename(path);
            return obj;
        },

        generateId: function(type, dir) {
            var id = idMap[type] || 1;
            var path = dir.join(id.toString(36));
            while(file.exists(path)) {
                id += 1;
                path = dir.join(id.toString(36));
            }

            idMap[type] = id + 1;
            return file.basename(path);
        }
    };

    var base = new file.Path(path).absolute();
    log.debug("Set up new store: " + base);
};

var isKey = function(value) {
    return value
            && !value.getKey
            && typeof value._id == 'string';
}

var isStorable = function(value) {
    return value && typeof value.getKey == 'function';
}

var isPersistentStorable = function(value) {
    return isStorable(value)
            && typeof value._id == 'string';
}

var isTransientStorable = function(value) {
    return isStorable(value)
            && typeof value._id == 'undefined';
}

function Transaction() {
    var updateList = [];
    var deleteList = [];

    this.deleteResource = function(res) {
        deleteList.push(res);
    };

    this.updateResource = function(res) {
        updateList.push(res);
    };

    this.commit = function() {
        for each (var res in updateList) {
            // because of a Java/Windows quirk, we have to delete
            // the existing file before trying to overwrite it
            if (file.exists(res.path)) file.remove(res.path);
            // move temporary file to permanent name
            try {
                // Think it's stupid to convert them to strings
                // Need to report about this bug
                file.move(res.tempPath.valueOf(), res.path.valueOf());
                // success - delete tmp file
                try { file.remove(res.tempPath); } catch(e) {}
            } catch (e) {
                // error - leave tmp file and print a message
                log.error("Couldn't move file, committed version is in " + res.tempPath);
            }
        }

        for each (var res in deleteList) try { file.remove(res); } catch(e) {}

        updateList = [];
        deleteList = [];
    };

    this.abort = function() {
        for each (var res in updateList) file.remove(res.tempPath);
    };
};

exports.Reference = Reference;
exports.Text = Text;
exports.Collection = Collection;
exports.List = List;
exports.Store = Store;
exports.Transaction = Transaction;
Classes

Files
