@mvx/typeorm-adapter/fesm2015/typeorm-adapter.js

@mvx/typeorm-adapter is typeorm adapter orm for mvc, type-mvc is base on koa. Decorator, Ioc, AOP mvc frameworker on server.

'use strict';

function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }

var tslib = _interopDefault(require('tslib'));
require('reflect-metadata');
var typeorm = _interopDefault(require('typeorm'));
var ioc = _interopDefault(require('@tsdi/ioc'));
var mvc = _interopDefault(require('@mvx/mvc'));
var mongodb = _interopDefault(require('mongodb'));
var boot = _interopDefault(require('@tsdi/boot'));

function unwrapExports (x) {
	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}

function createCommonjsModule(fn, module) {
	return module = { exports: {} }, fn(module, module.exports), module.exports;
}

var TypeOrmHelper_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });





let OrmInitService = class OrmInitService {
    static getClassAnnations() {
        return { "name": "OrmInitService", "params": { "init": ["connect"] } };
    }
};
OrmInitService = tslib.__decorate([
    ioc.Abstract()
], OrmInitService);
exports.OrmInitService = OrmInitService;
let TypeOrmHelper = class TypeOrmHelper {
    constructor(ctx) {
        this.ctx = ctx;
        this.hasInit = false;
    }
    getRepository(type) {
        return tslib.__awaiter(this, void 0, void 0, function* () {
            let conn = yield this.getConnection();
            return conn.getRepository(type);
        });
    }
    getMongoRepository(type) {
        return tslib.__awaiter(this, void 0, void 0, function* () {
            let conn = yield this.getConnection();
            return conn.getMongoRepository(type);
        });
    }
    getConnection() {
        return tslib.__awaiter(this, void 0, void 0, function* () {
            let options = yield this.getOptions();
            if (!this.hasInit) {
                this.hasInit = true;
                try {
                    let connect = yield typeorm.createConnection(options);
                    if (options.initDb) {
                        yield options.initDb(connect);
                    }
                    let initService = this.ctx.getService(OrmInitService);
                    if (initService instanceof OrmInitService) {
                        yield initService.init(connect);
                    }
                    return connect;
                }
                catch (err) {
                    console.error(err);
                }
            }
            return yield typeorm.getConnection(options.name);
        });
    }
    getOptions() {
        return tslib.__awaiter(this, void 0, void 0, function* () {
            if (!this.options) {
                let config = this.ctx.getConfiguration();
                let options = config.connections || {};
                if (!options.entities) {
                    let entities = [];
                    let loader = this.ctx.getContainer().getLoader();
                    if (config.models.some(m => ioc.isString(m))) {
                        let models = yield loader.loadTypes({ files: config.models, basePath: this.ctx.getRootPath() });
                        models.forEach(ms => {
                            ms.forEach(mdl => {
                                if (mdl && entities.indexOf(mdl) < 0) {
                                    entities.push(mdl);
                                }
                            });
                        });
                    }
                    else {
                        entities = config.models;
                    }
                    options.entities = entities;
                }
                this.options = options;
            }
            return this.options;
        });
    }
    static getClassAnnations() {
        return { "name": "TypeOrmHelper", "params": { "constructor": ["ctx"], "getRepository": ["type"], "getMongoRepository": ["type"], "getConnection": [], "getOptions": [] } };
    }
};
TypeOrmHelper = tslib.__decorate([
    ioc.Singleton,
    tslib.__param(0, ioc.Inject(mvc.MvcContextToken)),
    tslib.__metadata("design:paramtypes", [mvc.MvcContext])
], TypeOrmHelper);
exports.TypeOrmHelper = TypeOrmHelper;


});

unwrapExports(TypeOrmHelper_1);
var TypeOrmHelper_2 = TypeOrmHelper_1.OrmInitService;
var TypeOrmHelper_3 = TypeOrmHelper_1.TypeOrmHelper;

var TypeOrmModelParser_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });





let TypeOrmModelParser = class TypeOrmModelParser extends mvc.ModelParser {
    constructor() {
        super();
    }
    setup() {
        this.getTypeMap()
            .register(mongodb.ObjectID, (id) => new mongodb.ObjectID(id));
    }
    getPropertyMeta(type) {
        let metas = {};
        typeorm.getMetadataArgsStorage().columns.filter(col => col.target === type)
            .forEach(col => {
            metas[col.propertyName] = metas[col.propertyName] || [];
            metas[col.propertyName].push({
                propertyKey: col.propertyName,
                dbtype: ioc.isString(col.options.type) ? col.options.type : '',
                type: this.getModeType(col)
            });
        });
        typeorm.getMetadataArgsStorage().relations.filter(col => col.target === type)
            .forEach(col => {
            metas[col.propertyName] = metas[col.propertyName] || [];
            let relaModel = ioc.isFunction(col.type) ? col.type() : undefined;
            metas[col.propertyName].push({
                propertyKey: col.propertyName,
                provider: relaModel,
                type: (col.relationType === 'one-to-many' || col.relationType === 'many-to-many') ? Array : relaModel
            });
        });
        return metas;
    }
    isExtendBaseType(type, propmeta) {
        if (propmeta.dbtype) {
            if (/int/.test(propmeta.dbtype)) {
                return true;
            }
        }
        if (type === mongodb.ObjectID) {
            return true;
        }
        return super.isExtendBaseType(type, propmeta);
    }
    resolveExtendType(type, value, propmeta) {
        if (propmeta.dbtype) {
            if (/int/.test(propmeta.dbtype)) {
                return parseInt(value);
            }
        }
        if (type === mongodb.ObjectID) {
            return new mongodb.ObjectID(value);
        }
        return super.resolveExtendType(type, propmeta);
    }
    getModeType(col) {
        let type = col.options.type;
        if (type) {
            if (ioc.isString(type)) {
                if (type === 'uuid') {
                    return String;
                }
                else if (/(int|float|double|dec|numeric|number)/.test(type)) {
                    return Number;
                }
                else if (/(bool|bit)/.test(type)) {
                    return Boolean;
                }
                else if (/(char|var|string|text)/.test(type)) {
                    return String;
                }
                else if (/(time|date)/.test(type)) {
                    return Date;
                }
                else if (/array/.test(type)) {
                    return Array;
                }
                else if (/(bytes|bytea)/.test(type)) {
                    return Buffer;
                }
                else {
                    return Object;
                }
            }
            return type;
        }
        switch (col.mode) {
            case 'objectId':
                type = mongodb.ObjectID;
                break;
        }
        return type;
    }
    static getClassAnnations() {
        return { "name": "TypeOrmModelParser", "params": { "constructor": [], "setup": [], "getPropertyMeta": ["type"], "isExtendBaseType": ["type", "propmeta"], "resolveExtendType": ["type", "value", "propmeta"], "getModeType": ["col"] } };
    }
};
TypeOrmModelParser = tslib.__decorate([
    ioc.Singleton(mvc.DefaultModelParserToken),
    ioc.Autorun('setup'),
    tslib.__metadata("design:paramtypes", [])
], TypeOrmModelParser);
exports.TypeOrmModelParser = TypeOrmModelParser;


});

unwrapExports(TypeOrmModelParser_1);
var TypeOrmModelParser_2 = TypeOrmModelParser_1.TypeOrmModelParser;

var TypeOrmModule_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });




let TypeOrmModule = class TypeOrmModule {
    static getClassAnnations() {
        return { "name": "TypeOrmModule", "params": {} };
    }
};
TypeOrmModule = tslib.__decorate([
    boot.DIModule({
        regIn: 'root',
        providers: [
            TypeOrmHelper_1.TypeOrmHelper,
            TypeOrmModelParser_1.TypeOrmModelParser
        ]
    })
], TypeOrmModule);
exports.TypeOrmModule = TypeOrmModule;


});

unwrapExports(TypeOrmModule_1);
var TypeOrmModule_2 = TypeOrmModule_1.TypeOrmModule;

var es2015 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });

tslib.__exportStar(TypeOrmHelper_1, exports);
tslib.__exportStar(TypeOrmModelParser_1, exports);
tslib.__exportStar(TypeOrmModule_1, exports);


});

var index = unwrapExports(es2015);

module.exports = index;
//# sourceMappingURL=typeorm-adapter.js.map