nest-knexjs 0.0.7 → 0.0.8

package/dist/common/index.d.ts

@@ -0,0 +1,2 @@
+export * from './knex.decorators';
+export * from './knex.utils';

package/dist/common/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./knex.decorators"), exports);
+__exportStar(require("./knex.utils"), exports);

package/dist/common/knex.decorators.d.ts

@@ -0,0 +1,3 @@
+import { KnexModuleOptions } from '../interfaces/knex-options.interface';
+export declare const InjectModel: (connection?: string) => (target: object, key: string | symbol, index?: number) => void;
+export declare const InjectConnection: (connection?: KnexModuleOptions | string) => ParameterDecorator;

package/dist/common/knex.decorators.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InjectConnection = exports.InjectModel = void 0;
+const common_1 = require("@nestjs/common");
+const knex_utils_1 = require("./knex.utils");
+const InjectModel = (connection) => {
+    return (0, common_1.Inject)((0, knex_utils_1.getConnectionToken)(connection));
+};
+exports.InjectModel = InjectModel;
+const InjectConnection = (connection) => (0, common_1.Inject)((0, knex_utils_1.getConnectionToken)(connection));
+exports.InjectConnection = InjectConnection;

package/dist/common/knex.utils.d.ts

@@ -0,0 +1,20 @@
+import { KnexModuleOptions } from '../interfaces';
+import { Observable } from 'rxjs';
+/**
+ * This function generates an injection token for an Model
+ * @param {Function} This parameter can either be a Model
+ * @param {string} [connection='default'] Connection name
+ * @returns {string} The Entity injection token
+ */
+export declare function getModelToken(model: Function, connection?: KnexModuleOptions | string): string;
+export declare function getConnectionToken(connection?: KnexModuleOptions | any): string | Function;
+/**
+ * This function returns a Connection prefix based on the connection name
+ * @param {KnexModuleOptions | string} [connection='default'] This optional parameter is either
+ * a KnexModuleOptions or a string.
+ * @returns {string | Function} The Connection injection token.
+ */
+export declare function getConnectionPrefix(connection?: KnexModuleOptions | string): string;
+export declare function handleRetry(retryAttempts?: number, retryDelay?: number): <T>(source: Observable<T>) => Observable<T>;
+export declare function getConnectionName(options: KnexModuleOptions): string;
+export declare const generateString: () => any;

package/dist/common/knex.utils.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateString = exports.getConnectionName = exports.handleRetry = exports.getConnectionPrefix = exports.getConnectionToken = exports.getModelToken = void 0;
+const knex_constants_1 = require("../knex.constants");
+const operators_1 = require("rxjs/operators");
+const uuid_1 = require("uuid");
+const common_1 = require("@nestjs/common");
+const circular_dependency_exception_1 = require("../exceptions/circular-dependency.exception");
+const logger = new common_1.Logger('KnexModule');
+/**
+ * This function generates an injection token for an Model
+ * @param {Function} This parameter can either be a Model
+ * @param {string} [connection='default'] Connection name
+ * @returns {string} The Entity injection token
+ */
+function getModelToken(model, connection = knex_constants_1.DEFAULT_CONNECTION_NAME) {
+    if (model === null || model === undefined) {
+        throw new circular_dependency_exception_1.CircularDependencyException('@InjectModel()');
+    }
+    const connectionPrefix = getConnectionPrefix(connection);
+    return `${connectionPrefix}${model.name}`;
+}
+exports.getModelToken = getModelToken;
+function getConnectionToken(connection = knex_constants_1.DEFAULT_CONNECTION_NAME) {
+    return `${connection.name || knex_constants_1.DEFAULT_CONNECTION_NAME}`;
+}
+exports.getConnectionToken = getConnectionToken;
+/**
+ * This function returns a Connection prefix based on the connection name
+ * @param {KnexModuleOptions | string} [connection='default'] This optional parameter is either
+ * a KnexModuleOptions or a string.
+ * @returns {string | Function} The Connection injection token.
+ */
+function getConnectionPrefix(connection = knex_constants_1.DEFAULT_CONNECTION_NAME) {
+    if (connection === knex_constants_1.DEFAULT_CONNECTION_NAME) {
+        return '';
+    }
+    if (typeof connection === 'string') {
+        return connection + '_';
+    }
+    if (connection.name === knex_constants_1.DEFAULT_CONNECTION_NAME || !connection.name) {
+        return '';
+    }
+    return connection.name + '_';
+}
+exports.getConnectionPrefix = getConnectionPrefix;
+function handleRetry(retryAttempts = 9, retryDelay = 3000) {
+    return (source) => source.pipe((0, operators_1.retryWhen)((e) => e.pipe((0, operators_1.scan)((errorCount, error) => {
+        logger.error(`Unable to connect to the database. Retrying (${errorCount + 1})...`, error.stack);
+        if (errorCount + 1 >= retryAttempts) {
+            throw error;
+        }
+        return errorCount + 1;
+    }, 0), (0, operators_1.delay)(retryDelay))));
+}
+exports.handleRetry = handleRetry;
+function getConnectionName(options) {
+    return options && options.name ? options.name : knex_constants_1.DEFAULT_CONNECTION_NAME;
+}
+exports.getConnectionName = getConnectionName;
+const generateString = () => (0, uuid_1.v4)();
+exports.generateString = generateString;

package/dist/entities-metadata.storage.d.ts

@@ -0,0 +1,8 @@
+import { KnexModuleOptions } from './interfaces';
+declare type ConnectionToken = KnexModuleOptions | string;
+export declare class EntitiesMetadataStorage {
+    private static readonly storage;
+    static addEntitiesByConnection(connection: ConnectionToken, entities: Function[]): void;
+    static getEntitiesByConnection(connection: ConnectionToken): Function[];
+}
+export {};

package/dist/entities-metadata.storage.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntitiesMetadataStorage = void 0;
+class EntitiesMetadataStorage {
+    static addEntitiesByConnection(connection, entities) {
+        const connectionToken = typeof connection === 'string' ? connection : connection.name;
+        if (!connectionToken) {
+            return;
+        }
+        let collection = this.storage.get(connectionToken);
+        if (!collection) {
+            collection = [];
+            this.storage.set(connectionToken, collection);
+        }
+        entities.forEach(entity => {
+            if (collection.includes(entity)) {
+                return;
+            }
+            collection.push(entity);
+        });
+    }
+    static getEntitiesByConnection(connection) {
+        const connectionToken = typeof connection === 'string' ? connection : connection.name;
+        if (!connectionToken) {
+            return [];
+        }
+        return this.storage.get(connectionToken) || [];
+    }
+}
+exports.EntitiesMetadataStorage = EntitiesMetadataStorage;
+EntitiesMetadataStorage.storage = new Map();

package/dist/exceptions/circular-dependency.exception.d.ts

@@ -0,0 +1,3 @@
+export declare class CircularDependencyException extends Error {
+    constructor(context?: string);
+}

package/dist/exceptions/circular-dependency.exception.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CircularDependencyException = void 0;
+class CircularDependencyException extends Error {
+    constructor(context) {
+        const ctx = context ? ` inside ${context}` : ``;
+        super(`A circular dependency has been detected${ctx}. Please, make sure that each side of a bidirectional relationships are decorated with "forwardRef()". Also, try to eliminate barrel files because they can lead to an unexpected behavior too.`);
+    }
+}
+exports.CircularDependencyException = CircularDependencyException;

package/dist/exceptions/index.d.ts

@@ -0,0 +1 @@
+export * from './circular-dependency.exception';

package/dist/exceptions/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./circular-dependency.exception"), exports);

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './common';
+export * from './interfaces';
+export * from './knex.module';

package/dist/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./common"), exports);
+__exportStar(require("./interfaces"), exports);
+__exportStar(require("./knex.module"), exports);

package/dist/interfaces/index.d.ts

@@ -0,0 +1,3 @@
+export * from './knex-options.interface';
+export * from './knex-options-factory.interface';
+export * from './knex-module-async-options.interface';

package/dist/interfaces/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./knex-options.interface"), exports);
+__exportStar(require("./knex-options-factory.interface"), exports);
+__exportStar(require("./knex-module-async-options.interface"), exports);

package/dist/interfaces/knex-module-async-options.interface.d.ts

@@ -0,0 +1,10 @@
+import { ModuleMetadata, Type } from "@nestjs/common/interfaces";
+import { KnexModuleOptions } from './knex-options.interface';
+import { KnexOptionsFactory } from './knex-options-factory.interface';
+export interface KnexModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    name?: string;
+    inject?: any[];
+    useClass?: Type<KnexOptionsFactory>;
+    useExisting?: Type<KnexOptionsFactory>;
+    useFactory?: (...args: any[]) => Promise<KnexModuleOptions> | KnexModuleOptions;
+}

package/dist/interfaces/knex-module-async-options.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/knex-options-factory.interface.d.ts

@@ -0,0 +1,4 @@
+import { KnexModuleOptions } from './knex-options.interface';
+export interface KnexOptionsFactory {
+    createKnexOptions(connectionName?: string): Promise<KnexModuleOptions> | KnexModuleOptions;
+}

package/dist/interfaces/knex-options-factory.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/knex-options.interface.d.ts

@@ -0,0 +1,7 @@
+import { Knex } from 'knex';
+export interface KnexModuleOptions {
+    name?: string;
+    config: Knex.Config;
+    retryAttempts?: number;
+    retryDelay?: number;
+}

package/dist/interfaces/knex-options.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/knex-core.module.d.ts

@@ -0,0 +1,14 @@
+import { DynamicModule, Provider, OnApplicationShutdown } from '@nestjs/common';
+import { KnexModuleAsyncOptions, KnexModuleOptions } from './interfaces';
+import { ModuleRef } from '@nestjs/core';
+export declare class KnexCoreModule implements OnApplicationShutdown {
+    private readonly options;
+    private readonly moduleRef;
+    constructor(options: KnexModuleOptions, moduleRef: ModuleRef);
+    static forRoot(options: KnexModuleOptions, connection?: string): DynamicModule;
+    static forRootAsync(options: KnexModuleAsyncOptions, connection: string): DynamicModule;
+    onApplicationShutdown(): Promise<any>;
+    static createAsyncProviders(options: KnexModuleAsyncOptions): Provider[];
+    static createAsyncOptionsProvider(options: KnexModuleAsyncOptions): Provider;
+    private static createConnectionFactory;
+}

package/dist/knex-core.module.js

@@ -0,0 +1,107 @@
+"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 KnexCoreModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KnexCoreModule = void 0;
+const common_1 = require("@nestjs/common");
+const knex_utils_1 = require("./common/knex.utils");
+const knex_constants_1 = require("./knex.constants");
+const knex_1 = require("knex");
+const core_1 = require("@nestjs/core");
+const rxjs_1 = require("rxjs");
+let KnexCoreModule = KnexCoreModule_1 = class KnexCoreModule {
+    constructor(options, moduleRef) {
+        this.options = options;
+        this.moduleRef = moduleRef;
+    }
+    static forRoot(options, connection) {
+        const knexModuleOptions = {
+            provide: knex_constants_1.KNEX_MODULE_OPTIONS,
+            useValue: options,
+        };
+        const connectionProvider = {
+            provide: (0, knex_utils_1.getConnectionToken)(connection),
+            useFactory: async () => await this.createConnectionFactory(options),
+        };
+        return {
+            module: KnexCoreModule_1,
+            providers: [connectionProvider, knexModuleOptions],
+            exports: [connectionProvider],
+        };
+    }
+    static forRootAsync(options, connection) {
+        const connectionProvider = {
+            provide: (0, knex_utils_1.getConnectionToken)(connection),
+            useFactory: async (options) => {
+                return await this.createConnectionFactory(options);
+            },
+            inject: [knex_constants_1.KNEX_MODULE_OPTIONS],
+        };
+        return {
+            module: KnexCoreModule_1,
+            imports: options.imports,
+            providers: [...this.createAsyncProviders(options), connectionProvider],
+            exports: [connectionProvider],
+        };
+    }
+    async onApplicationShutdown() {
+        const connection = this.moduleRef.get((0, knex_utils_1.getConnectionToken)(this.options));
+        connection && (await connection.destroy());
+    }
+    static createAsyncProviders(options) {
+        if (options.useExisting || options.useFactory) {
+            return [this.createAsyncOptionsProvider(options)];
+        }
+        const useClass = options.useClass;
+        return [
+            this.createAsyncOptionsProvider(options),
+            {
+                provide: useClass,
+                useClass,
+            },
+        ];
+    }
+    static createAsyncOptionsProvider(options) {
+        if (options.useFactory) {
+            return {
+                provide: knex_constants_1.KNEX_MODULE_OPTIONS,
+                useFactory: options.useFactory,
+                inject: options.inject || [],
+            };
+        }
+        // `as Type<KnexOptionsFactory>` is a workaround for microsoft/TypeScript#31603
+        const inject = [
+            (options.useClass || options.useExisting),
+        ];
+        return {
+            provide: knex_constants_1.KNEX_MODULE_OPTIONS,
+            useFactory: async (optionsFactory) => {
+                return await optionsFactory.createKnexOptions();
+            },
+            inject
+        };
+    }
+    static async createConnectionFactory(options) {
+        return (0, rxjs_1.lastValueFrom)((0, rxjs_1.defer)(async () => {
+            return (0, knex_1.knex)(options.config);
+        }).pipe((0, knex_utils_1.handleRetry)(options.retryAttempts, options.retryDelay)));
+    }
+};
+KnexCoreModule = KnexCoreModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({}),
+    __param(0, (0, common_1.Inject)(knex_constants_1.KNEX_MODULE_OPTIONS)),
+    __metadata("design:paramtypes", [Object, core_1.ModuleRef])
+], KnexCoreModule);
+exports.KnexCoreModule = KnexCoreModule;

package/dist/knex.constants.d.ts

@@ -0,0 +1,3 @@
+export declare const KNEX_MODULE_OPTIONS = "KnexModuleOptions";
+export declare const KNEX_MODULE_ID = "KnexModuleId";
+export declare const DEFAULT_CONNECTION_NAME = "default";

package/dist/knex.constants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CONNECTION_NAME = exports.KNEX_MODULE_ID = exports.KNEX_MODULE_OPTIONS = void 0;
+exports.KNEX_MODULE_OPTIONS = 'KnexModuleOptions';
+exports.KNEX_MODULE_ID = 'KnexModuleId';
+exports.DEFAULT_CONNECTION_NAME = 'default';

package/dist/knex.module.d.ts

@@ -0,0 +1,6 @@
+import { DynamicModule } from '@nestjs/common';
+import { KnexModuleAsyncOptions, KnexModuleOptions } from './interfaces';
+export declare class KnexModule {
+    static forRoot(options: KnexModuleOptions, connection?: string): DynamicModule;
+    static forRootAsync(options: KnexModuleAsyncOptions, connection?: string): DynamicModule;
+}

package/dist/knex.module.js

@@ -0,0 +1,30 @@
+"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 KnexModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KnexModule = void 0;
+const common_1 = require("@nestjs/common");
+const knex_core_module_1 = require("./knex-core.module");
+let KnexModule = KnexModule_1 = class KnexModule {
+    static forRoot(options, connection) {
+        return {
+            module: KnexModule_1,
+            imports: [knex_core_module_1.KnexCoreModule.forRoot(options, connection)],
+        };
+    }
+    static forRootAsync(options, connection) {
+        return {
+            module: KnexModule_1,
+            imports: [knex_core_module_1.KnexCoreModule.forRootAsync(options, connection)],
+        };
+    }
+};
+KnexModule = KnexModule_1 = __decorate([
+    (0, common_1.Module)({})
+], KnexModule);
+exports.KnexModule = KnexModule;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nest-knexjs",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "description": "Knexjs module for Nest framework (node.js) 😻",
   "author": "Tony133",
   "license": "MIT",
@@ -18,19 +18,19 @@
     "release": "release-it"
   },
   "devDependencies": {
-    "@commitlint/cli": "16.0.2",
+    "@commitlint/cli": "16.1.0",
     "@commitlint/config-angular": "16.0.0",
-    "@nestjs/common": "8.2.5",
-    "@nestjs/core": "8.2.5",
-    "@nestjs/platform-express": "8.2.5",
-    "@nestjs/testing": "8.2.5",
+    "@nestjs/common": "8.2.6",
+    "@nestjs/core": "8.2.6",
+    "@nestjs/platform-express": "8.2.6",
+    "@nestjs/testing": "8.2.6",
     "@types/express": "4.17.13",
-    "@types/node": "16.11.19",
+    "@types/node": "16.11.21",
     "@types/jest": "27.4.0",
     "@types/supertest": "2.0.11",
-    "@typescript-eslint/eslint-plugin": "5.9.1",
-    "@typescript-eslint/parser": "5.9.1",
-    "eslint": "8.7.0",
+    "@typescript-eslint/eslint-plugin": "5.10.1",
+    "@typescript-eslint/parser": "5.10.1",
+    "eslint": "8.8.0",
     "eslint-config-prettier": "8.3.0",
     "eslint-plugin-import": "2.25.4",
     "knex": "1.0.1",
@@ -39,13 +39,13 @@
     "prettier": "2.5.1",
     "jest": "27.4.7",
     "reflect-metadata": "0.1.13",
-    "release-it": "14.12.3",
-    "supertest": "6.2.1",
+    "release-it": "14.12.4",
+    "supertest": "6.2.2",
     "ts-node": "10.4.0",
     "rxjs": "7.5.2",
     "ts-jest": "27.1.3",
     "tsconfig-paths": "3.12.0",
-    "typescript": "4.5.4"
+    "typescript": "4.5.5"
   },
   "peerDependencies": {
     "@nestjs/common": "^7.0.0 || ^8.0.0",