liborm/lib/entity.js

ORM that use the legacy libsqlite

"use strict";

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.Entity = undefined;

var _char = require("hjs-core/lib/char");

var char = _interopRequireWildcard(_char);

var _type2 = require("hjs-core/lib/type");

var type = _interopRequireWildcard(_type2);

var _helper = require("libsqlite/lib/helper");

var _model = require("./model");

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

/** @babel */
var ENTITIES = {};

var GENERATED = false;

var Entity = exports.Entity = {
    generate: function generate() {
        if (!GENERATED) {
            var tables = _helper.TableInfo.getTables();
            for (var tableName in tables) {
                if (tables.hasOwnProperty(tableName)) {
                    var table = tables[tableName];
                    if (!ENTITIES[tableName]) {
                        var _type = this.generateCtr(tableName);
                        var proto = this.generateProto(_type, table);
                        proto = this.generateMembers(table, proto);
                        ENTITIES[tableName] = this.generateClass(table, proto);
                    }
                }
            }
            GENERATED = true;
        }
    },
    generateCtr: function generateCtr(name) {
        var ctrName = char.camelify(name);
        var F = new Function("return function " + ctrName + "(){" + ctrName + ".superclass.call(this); }");
        return F();
    },
    generateField: function generateField(name, proto) {
        proto[name] = null;
        return proto;
    },
    generateGetter: function generateGetter(name, proto) {
        var methodName = char.asCamelifyGetMethod(name);
        var M = new Function("return function " + methodName + "(){ return this." + name + "; }");
        proto[methodName] = M();
        return proto;
    },
    generateClass: function generateClass(table, proto) {
        var C = type.Class.extend(proto);
        C.table = table;
        return C;
    },
    generateMembers: function generateMembers(table, proto) {
        var columns = table.getColumnNames();
        var len = columns.length;
        while (len--) {
            var field = columns[len];
            if (field === _helper.BaseColumns._ID) {
                continue;
            }
            proto = this.generateField(field, proto);
            proto = this.generateGetter(field, proto);
            proto = this.generateSetter(field, proto);
        }
        return proto;
    },
    generateProto: function generateProto(type, table) {
        return {
            extends: _model.SQLiteModel,
            constructor: type,
            getTable: function getTable() {
                return this.constructor.table;
            },
            getTableName: function getTableName() {
                return this.getTable().getTableName();
            }
        };
    },
    generateSetter: function generateSetter(name, proto) {
        var methodName = char.asCamelifySetMethod(name);
        var M = new Function("return function " + methodName + "(value){ this." + name + " = value; }");
        proto[methodName] = M();
        return proto;
    },
    getTableClass: function getTableClass(table) {
        var type = ENTITIES[table];
        if (type) {
            return type;
        }
        return null;
    },
    getTableInstance: function getTableInstance(table) {
        var type = this.getTableClass(table);
        if (type) {
            return new type();
        }
        return null;
    },
    isGenerated: function isGenerated() {
        return GENERATED;
    }
};