@iguazu/core/lib/repository.js

"use strict";
var __assign = (this && this.__assign) || Object.assign || function(t) {
    for (var s, i = 1, n = arguments.length; i < n; i++) {
        s = arguments[i];
        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
            t[p] = s[p];
    }
    return t;
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __generator = (this && this.__generator) || function (thisArg, body) {
    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
    function verb(n) { return function (v) { return step([n, v]); }; }
    function step(op) {
        if (f) throw new TypeError("Generator is already executing.");
        while (_) try {
            if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t;
            if (y = 0, t) op = [0, t.value];
            switch (op[0]) {
                case 0: case 1: t = op; break;
                case 4: _.label++; return { value: op[1], done: false };
                case 5: _.label++; y = op[1]; op = [0]; continue;
                case 7: op = _.ops.pop(); _.trys.pop(); continue;
                default:
                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                    if (t[2]) _.ops.pop();
                    _.trys.pop(); continue;
            }
            op = body.call(thisArg, _);
        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
    }
};
Object.defineProperty(exports, "__esModule", { value: true });
var Boom = require("boom");
var Bookshelf = require("bookshelf");
var Knex = require("knex");
var Path = require("path");
var dotenv = require("dotenv");
var pg = require("pg");
var controller_1 = require("./controller");
var event_bus_1 = require("./event-bus");
var Observable_1 = require("rxjs/Observable");
require("rxjs/add/operator/finally");
dotenv.config();
pg.types.setTypeParser(20, "text", parseInt);
var env = process.env.NODE_ENV || "development";
var rootPath = Path.resolve(process.cwd());
var knexfilePath = Path.join(rootPath, "./knexfile");
var knexfile = require(knexfilePath);
var knex = Knex(knexfile[env]);
exports.bookshelf = Bookshelf(knex);
exports.bookshelf.plugin("registry");
exports.bookshelf.plugin("visibility");
exports.tableModelMap = {};
function getDependencies(model) {
    var dependencies = [];
    if (!model || !model.relations) {
        return;
    }
    var relations = Object.values(model.relations).slice();
    while (relations.length) {
        var relation = relations.pop();
        var tableName = void 0;
        if (relation.head &&
            typeof relation.head === "function" &&
            relation.head().relatedData) {
            tableName = relation.head().relatedData.targetTableName;
            if (relation.head().relations) {
                console.log(relation.head().relations);
                Object.values(relation.head().relations).forEach(function (i) {
                    return relations.push(i);
                });
            }
        }
        else if (relation.relatedData && relation.relatedData.targetTableName) {
            tableName = relation.relatedData.targetTableName;
            if (relation.relations) {
                console.log(relation.relations);
                Object.values(relation.relations).forEach(function (i) { return relations.push(i); });
            }
        }
        console.log(relations);
        console.log(tableName);
        console.log(exports.tableModelMap[tableName]);
        if (!dependencies.includes(exports.tableModelMap[tableName])) {
            dependencies.push(exports.tableModelMap[tableName]);
        }
    }
    return dependencies;
}
function getCollectionDependencies(data) {
    return getDependencies(data.head());
}
var Repository = (function () {
    function Repository(path, options, name, props, websocket, rest) {
        if (websocket === void 0) { websocket = false; }
        if (rest === void 0) { rest = true; }
        var _this = this;
        exports.tableModelMap[props.tableName] = name;
        this.name = name;
        this.path = path;
        this.websocket = websocket;
        props = __assign({}, props, { initialize: function () {
                if (websocket) {
                    this.on("created", function (model) {
                        event_bus_1.eventBus.emit("DB_CHANGE:" + name.toUpperCase());
                    });
                    this.on("updated", function (model) {
                        event_bus_1.eventBus.emit("DB_CHANGE:" + name.toUpperCase());
                    });
                }
            } });
        this.model = exports.bookshelf.model(name, props);
        this.makeCrud(name, options);
        this.makeReactive(name);
        if (rest) {
            this.controller = new controller_1.Controller(path, function (server, opts, next) {
                server.get("/", _this.model.findAll);
                server.get("/:id", _this.model.findById);
                server.post("/", _this.model.upsert);
                server.delete("/:id", _this.model.remove);
                server.post("/:id/undelete", _this.model.recover);
            });
        }
    }
    Repository.prototype.makeCrud = function (name, options) {
        var _this = this;
        this.model.findAll = function () { return __awaiter(_this, void 0, void 0, function () {
            return __generator(this, function (_a) {
                return [2, this.model.where("deleted", false).fetchAll(options) || []];
            });
        }); };
        this.model.findById = function (request, reply) { return __awaiter(_this, void 0, void 0, function () {
            var item;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4, this.model
                            .where("id", request.params.id)
                            .fetch(options)];
                    case 1:
                        item = _a.sent();
                        if (!item) {
                            return [2, Boom.badData("Entity " + name + " with ID " + request.params.id + " not exists")];
                        }
                        return [2, item];
                }
            });
        }); };
        this.model.upsert = function (request, reply) { return __awaiter(_this, void 0, void 0, function () {
            var item;
            return __generator(this, function (_a) {
                item = request.body;
                if (!item) {
                    return [2, Boom.badData("Entity " + name + ", Undefined Body")];
                }
                return [2, this.model.forge(item).save()];
            });
        }); };
        this.model.remove = function (request, reply) { return __awaiter(_this, void 0, void 0, function () {
            var id, old;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        id = request.params.id;
                        if (!id) {
                            return [2, Boom.badData("Entity " + name + " undefined ID")];
                        }
                        return [4, this.model.where("id", id).fetch()];
                    case 1:
                        old = _a.sent();
                        if (!old) {
                            return [2, Boom.badData("Entity " + name + " with ID " + id + " not exists")];
                        }
                        return [2, old.save({ deleted: true })];
                }
            });
        }); };
        this.model.recover = function (request, reply) { return __awaiter(_this, void 0, void 0, function () {
            var item, old;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        item = request.body;
                        if (!item) {
                            return [2, Boom.badData("Entity " + name + ", Undefined Body")];
                        }
                        return [4, this.model.where("id", item.id).fetch()];
                    case 1:
                        old = _a.sent();
                        if (!old) {
                            return [2, Boom.badData("Entity " + name + " with ID " + item.id + " not exists")];
                        }
                        return [2, old.save({ deleted: false })];
                }
            });
        }); };
    };
    Repository.prototype.makeReactive = function (name) {
        var _this = this;
        this.model.watch = function (options) {
            var subscriptions = [];
            return Observable_1.Observable.create(function (observer) {
                _this.model.fetch(options).then(function (data) {
                    observer.next(data);
                    var listenTo = [name].concat(getDependencies(data));
                    listenTo.map(function (l) { return l.toUpperCase(); }).forEach(function (dep) {
                        var sub = function () {
                            return _this.model.fetch(options).then(function (stream) { return observer.next(stream); });
                        };
                        subscriptions.push(sub);
                        event_bus_1.eventBus.on("DB_CHANGE:" + dep, sub);
                    });
                });
            }).finally(function () { return subscriptions.forEach(function (s) { return event_bus_1.eventBus.unsubscribe(s); }); });
        };
        this.model.watchAll = function (options) {
            var subscriptions = [];
            return Observable_1.Observable.create(function (observer) {
                _this.model.fetchAll(options).then(function (data) {
                    observer.next(data);
                    var listenTo = [name].concat(getCollectionDependencies(data));
                    listenTo.map(function (l) { return l.toUpperCase(); }).forEach(function (dep) {
                        var sub = function () {
                            return _this.model
                                .fetchAll(options)
                                .then(function (stream) { return observer.next(stream); });
                        };
                        subscriptions.push(sub);
                        event_bus_1.eventBus.on("DB_CHANGE:" + dep, sub);
                    });
                });
            }).finally(function () { return subscriptions.forEach(function (s) { return event_bus_1.eventBus.unsubscribe(s); }); });
        };
    };
    return Repository;
}());
exports.Repository = Repository;