blow-data/lib/manager.js

Data access layer for Blow.

'use strict';
const rxjs_1 = require('rxjs');
const util_1 = require('util');
const Connection_1 = require('./Connection');
const ModelMetadata_1 = require('./ModelMetadata');
class Manager {
    constructor() {
        this._connections = new Map();
        this._models = new Map();
    }
    _applyMetadataToModels() {
        for (const model of this._models.values()) {
            if (!model.ready) {
                model.metadata.apply(model);
                model.ready = true;
            }
        }
    }
    _attachModelsToConnections() {
        for (const model of this._models.values()) {
            this.attachModelToConnection(model, model.metadata.connectionName);
        }
    }
    attachModelToConnection(model, connection) {
        const model_ = util_1.isString(model) ? this.getModel(model) : model;
        const connection_ = util_1.isString(connection) ? this.getConnection(connection) : connection;
        if (connection_ && model_) {
            connection_.attach(model_);
        }
    }
    hasConnection(connectionName) {
        return this._connections.has(connectionName);
    }
    getConnection(connectionName) {
        return this._connections.get(connectionName);
    }
    defineConnection(options) {
        const connection = Connection_1.Connection.create(options);
        this._connections.set(connection.name, connection);
        return connection;
    }
    hasModel(modelName) {
        return this._models.has(modelName);
    }
    getModel(modelName) {
        return this._models.get(modelName);
    }
    defineModel(model, options, properties, relations) {
        const metadata = new ModelMetadata_1.ModelMetadata(options, properties, relations);
        Object.defineProperty(model, '_metadata', {
            configurable: false,
            writable: false,
            enumerable: false,
            value: metadata
        });
        this._models.set(options.name, model);
    }
    init() {
        return rxjs_1.Observable.create(observer => {
            if (this._connections.size) {
                rxjs_1.Observable.from(this._connections.values())
                    .mergeMap(connection => {
                    if (connection.isConnected) {
                        return rxjs_1.Observable.of(connection);
                    }
                    else {
                        return connection.init();
                    }
                })
                    .toArray()
                    .subscribe(() => { }, error => {
                    throw new Error(error);
                }, () => {
                    this._attachModelsToConnections();
                    this._applyMetadataToModels();
                    observer.next(this);
                    observer.complete();
                });
            }
            else {
                observer.next(this);
                observer.complete();
            }
        });
    }
}
exports.Manager = Manager;
exports.manager = new Manager();