@willsoto/nestjs-objection/dist/core.js

Objection module for NestJS

"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
    return function (target, key) { decorator(target, key, paramIndex); }
};
var ObjectionCoreModule_1;
Object.defineProperty(exports, "__esModule", { value: true });
exports.ObjectionCoreModule = void 0;
const common_1 = require("@nestjs/common");
const core_1 = require("@nestjs/core");
const knex_1 = require("knex");
const objection_1 = require("objection");
const constants_1 = require("./constants");
let ObjectionCoreModule = ObjectionCoreModule_1 = class ObjectionCoreModule {
    constructor(options, moduleRef) {
        this.options = options;
        this.moduleRef = moduleRef;
    }
    static register(options) {
        const BaseModel = options.Model || objection_1.Model;
        const connection = (0, knex_1.knex)(options.config);
        BaseModel.knex(connection);
        const objectionModuleOptions = {
            provide: constants_1.OBJECTION_MODULE_OPTIONS,
            useValue: options,
        };
        const objectionBaseModelProvider = {
            provide: BaseModel,
            useValue: BaseModel,
        };
        const knexConnectionProvider = {
            provide: options.name || constants_1.KNEX_CONNECTION,
            useValue: connection,
        };
        return {
            module: ObjectionCoreModule_1,
            providers: [
                objectionModuleOptions,
                objectionBaseModelProvider,
                knexConnectionProvider,
            ],
            exports: [objectionBaseModelProvider, knexConnectionProvider],
        };
    }
    static registerAsync(options = {}) {
        const connectionToken = options.name || constants_1.KNEX_CONNECTION;
        const knexConnectionProvider = {
            provide: connectionToken,
            inject: [constants_1.OBJECTION_MODULE_OPTIONS],
            useFactory(objectionModuleOptions) {
                return (0, knex_1.knex)(objectionModuleOptions.config);
            },
        };
        const objectionBaseModelProvider = {
            provide: constants_1.OBJECTION_BASE_MODEL,
            inject: [connectionToken, constants_1.OBJECTION_MODULE_OPTIONS],
            useFactory(connection, objectionModuleOptions) {
                const BaseModel = objectionModuleOptions.Model || objection_1.Model;
                BaseModel.knex(connection);
                return BaseModel;
            },
        };
        const asyncProviders = this.createAsyncProviders(options);
        return {
            module: ObjectionCoreModule_1,
            imports: options.imports,
            providers: [
                ...asyncProviders,
                knexConnectionProvider,
                objectionBaseModelProvider,
            ],
            exports: [objectionBaseModelProvider, knexConnectionProvider],
        };
    }
    static createAsyncProviders(options) {
        if (options.useExisting || options.useFactory) {
            return [this.createAsyncOptionsProvider(options)];
        }
        else if (!options.useClass) {
            throw new Error("Invalid configuration");
        }
        return [
            this.createAsyncOptionsProvider(options),
            {
                provide: options.useClass,
                useClass: options.useClass,
            },
        ];
    }
    static createAsyncOptionsProvider(options) {
        if (options.useFactory) {
            return {
                provide: constants_1.OBJECTION_MODULE_OPTIONS,
                // eslint-disable-next-line @typescript-eslint/unbound-method
                useFactory: options.useFactory,
                inject: options.inject || [],
            };
        }
        const inject = options.useClass || options.useExisting;
        if (!inject) {
            throw new Error("Invalid configuration. Must provide useFactory, useClass or useExisting");
        }
        return {
            provide: constants_1.OBJECTION_MODULE_OPTIONS,
            async useFactory(optionsFactory) {
                const opts = await optionsFactory.createObjectionModuleOptions(options.name);
                return opts;
            },
            inject: [inject],
        };
    }
    async onApplicationShutdown() {
        await this.disconnect();
    }
    async disconnect() {
        const name = this.options.name || constants_1.KNEX_CONNECTION;
        const connection = this.moduleRef.get(name);
        await connection.destroy();
    }
};
exports.ObjectionCoreModule = ObjectionCoreModule;
exports.ObjectionCoreModule = ObjectionCoreModule = ObjectionCoreModule_1 = __decorate([
    (0, common_1.Global)(),
    (0, common_1.Module)({}),
    __param(0, (0, common_1.Inject)(constants_1.OBJECTION_MODULE_OPTIONS)),
    __metadata("design:paramtypes", [Object, core_1.ModuleRef])
], ObjectionCoreModule);
//# sourceMappingURL=core.js.map