@sqb/nestjs 4.21.1 → 4.23.0

package/get-sqb-config.d.ts

@@ -1,2 +1,2 @@
-import { SqbClientConnectionOptions } from './sqb.interface.js';
+import type { SqbClientConnectionOptions } from './sqb.interface.js';
 export declare function getSqbConfig(moduleOptions: SqbClientConnectionOptions, prefix?: string): SqbClientConnectionOptions;

package/index.d.ts

@@ -1,5 +1,3 @@
-export * from './sqb.decorators.js';
 export * from './sqb.interface.js';
 export * from './sqb.module.js';
-export * from './sqb.utils.js';
 export { SqbClient } from '@sqb/connect';

package/index.js

@@ -1,5 +1,3 @@
-export * from './sqb.decorators.js';
 export * from './sqb.interface.js';
 export * from './sqb.module.js';
-export * from './sqb.utils.js';
 export { SqbClient } from '@sqb/connect';

package/package.json

@@ -1,19 +1,20 @@
 {
   "name": "@sqb/nestjs",
   "description": "Nestjs module for data connection using SQB",
-  "version": "4.21.1",
+  "version": "4.23.0",
   "author": "Panates",
   "license": "Apache-2.0",
   "dependencies": {
-    "@jsopen/objects": "^2.0.2",
-    "putil-varhelpers": "^1.6.5",
+    "@jsopen/objects": "^2.2.0",
+    "ansi-colors": "^4.1.3",
+    "putil-varhelpers": "^1.7.0",
     "tslib": "^2.8.1"
   },
   "peerDependencies": {
     "@nestjs/common": ">=7.4.0",
     "@nestjs/core": ">=7.4.0",
-    "@sqb/builder": "^4.21.1",
-    "@sqb/connect": "^4.21.1",
+    "@sqb/builder": "^4.23.0",
+    "@sqb/connect": "^4.23.0",
     "reflect-metadata": "^0.2.2",
     "rxjs": ">=6.6.0"
   },

package/sqb-core.module.d.ts

@@ -1,16 +1,14 @@
-import { DynamicModule, Logger, OnApplicationShutdown } from '@nestjs/common';
-import { ModuleRef } from '@nestjs/core';
-import type { SqbModuleAsyncOptions, SqbModuleOptions } from './sqb.interface.js';
-export declare class SqbCoreModule implements OnApplicationShutdown {
-    private readonly options;
-    private readonly moduleRef;
-    private logger?;
-    constructor(options: SqbModuleOptions, moduleRef: ModuleRef, logger?: Logger | undefined);
-    static forRoot(options?: SqbModuleOptions): DynamicModule;
-    static forRootAsync(options: SqbModuleAsyncOptions): DynamicModule;
+import { DynamicModule, Logger, OnApplicationBootstrap, OnApplicationShutdown } from '@nestjs/common';
+import { SqbClient } from '@sqb/connect';
+import type { SqbClientConnectionOptions, SqbModuleAsyncOptions, SqbModuleOptions } from './sqb.interface.js';
+export declare class SqbCoreModule implements OnApplicationBootstrap, OnApplicationShutdown {
+    protected readonly client: SqbClient;
+    private readonly connectionOptions;
+    private logger;
+    static forRoot(moduleOptions?: SqbModuleOptions): DynamicModule;
+    static forRootAsync(asyncOptions: SqbModuleAsyncOptions): DynamicModule;
+    private static _createDynamicModule;
+    constructor(client: SqbClient, connectionOptions: SqbClientConnectionOptions, logger: Logger);
     onApplicationBootstrap(): Promise<void> | undefined;
     onApplicationShutdown(): Promise<void>;
-    private static createAsyncProviders;
-    private static createAsyncOptionsProvider;
-    private static createConnection;
 }

package/sqb-core.module.js

@@ -1,153 +1,112 @@
 var SqbCoreModule_1;
 import { __decorate, __metadata, __param } from "tslib";
+import assert from 'node:assert';
 import { Global, Inject, Logger, Module, } from '@nestjs/common';
-import { ModuleRef } from '@nestjs/core';
 import { SqbClient } from '@sqb/connect';
+import colors from 'ansi-colors';
 import * as crypto from 'crypto';
-import { defer } from 'rxjs';
-import * as rxjs from 'rxjs';
 import { getSqbConfig } from './get-sqb-config.js';
 import { SQB_CONNECTION_OPTIONS, SQB_MODULE_ID, SQB_MODULE_OPTIONS, } from './sqb.constants.js';
-import { getSQBToken, handleRetry } from './sqb.utils.js';
+const CLIENT_TOKEN = Symbol('CLIENT_TOKEN');
 let SqbCoreModule = SqbCoreModule_1 = class SqbCoreModule {
-    options;
-    moduleRef;
+    client;
+    connectionOptions;
     logger;
-    constructor(options, moduleRef, logger) {
-        this.options = options;
-        this.moduleRef = moduleRef;
-        this.logger = logger;
-    }
-    static forRoot(options = {}) {
-        const optionsProvider = {
-            provide: SQB_MODULE_OPTIONS,
-            useValue: options,
-        };
-        const connectionProvider = {
-            provide: getSQBToken(options.name),
-            inject: [SQB_CONNECTION_OPTIONS],
-            useFactory: (sqbConnectionOptions) => this.createConnection(options, sqbConnectionOptions),
-        };
-        return {
-            module: SqbCoreModule_1,
+    static forRoot(moduleOptions = {}) {
+        const connectionOptions = getSqbConfig(moduleOptions.useValue || {}, moduleOptions.envPrefix);
+        return this._createDynamicModule(moduleOptions, {
+            global: moduleOptions.global,
             providers: [
-                connectionProvider,
-                optionsProvider,
                 {
                     provide: SQB_CONNECTION_OPTIONS,
-                    useValue: getSqbConfig(options.useValue || {}, options.envPrefix),
-                },
-                {
-                    provide: Logger,
-                    useValue: typeof options.logger === 'string'
-                        ? new Logger(options.logger)
-                        : options.logger,
+                    useValue: connectionOptions,
                 },
             ],
-            exports: [connectionProvider],
-        };
+        });
     }
-    static forRootAsync(options) {
-        const connectionProvider = {
-            provide: getSQBToken(options.name),
-            inject: [SQB_MODULE_OPTIONS, SQB_CONNECTION_OPTIONS],
-            useFactory: async (sqbOptions, sqbConnectionOptions) => this.createConnection(sqbOptions, sqbConnectionOptions),
-        };
-        const asyncProviders = this.createAsyncProviders(options);
-        return {
-            module: SqbCoreModule_1,
-            imports: options.imports,
+    static forRootAsync(asyncOptions) {
+        assert.ok(asyncOptions.useFactory, 'useFactory is required');
+        return this._createDynamicModule(asyncOptions, {
+            global: asyncOptions.global,
             providers: [
-                ...asyncProviders,
-                connectionProvider,
-                {
-                    provide: SQB_MODULE_OPTIONS,
-                    useValue: options,
-                },
                 {
-                    provide: SQB_MODULE_ID,
-                    useValue: crypto.randomUUID(),
-                },
-                {
-                    provide: Logger,
-                    useValue: typeof options.logger === 'string'
-                        ? new Logger(options.logger)
-                        : options.logger,
+                    provide: SQB_CONNECTION_OPTIONS,
+                    inject: asyncOptions.inject,
+                    useFactory: async (...args) => {
+                        const opts = await asyncOptions.useFactory(...args);
+                        return getSqbConfig(opts, asyncOptions.envPrefix);
+                    },
                 },
             ],
-            exports: [connectionProvider],
+        });
+    }
+    static _createDynamicModule(opts, metadata) {
+        const token = opts.token || SqbClient;
+        const providers = [
+            ...(metadata.providers ?? []),
+            {
+                provide: SQB_MODULE_OPTIONS,
+                useValue: opts,
+            },
+            {
+                provide: token,
+                inject: [SQB_CONNECTION_OPTIONS],
+                useFactory: (sqbConnectionOptions) => new SqbClient(sqbConnectionOptions),
+            },
+            {
+                provide: CLIENT_TOKEN,
+                useExisting: token,
+            },
+            {
+                provide: SQB_MODULE_ID,
+                useValue: crypto.randomUUID(),
+            },
+            {
+                provide: Logger,
+                useValue: opts.logger || new Logger('SQB'),
+            },
+        ];
+        return {
+            module: SqbCoreModule_1,
+            ...metadata,
+            providers,
+            exports: [...(metadata.exports ?? []), SQB_CONNECTION_OPTIONS, token],
         };
     }
+    constructor(client, connectionOptions, logger) {
+        this.client = client;
+        this.connectionOptions = connectionOptions;
+        this.logger = logger;
+    }
     onApplicationBootstrap() {
-        const client = this.moduleRef.get(getSQBToken(this.options.name));
-        const op = this.moduleRef.get(SQB_CONNECTION_OPTIONS);
-        if (this.options.lazyConnect)
+        if (this.connectionOptions.lazyConnect)
             return;
-        this.logger?.log(`Connecting to database [${op.database}] at ${op.host}:${op.port} using ${op.dialect} dialect`);
         Logger.flush();
-        return client.test().catch(e => {
-            this.logger?.error(`${op.dialect} connection failed: ` + e.message);
+        const logTimer = setTimeout(() => {
+            this.logger?.verbose(`Waiting to connect to Database [${colors.blue(this.connectionOptions.dialect || '')}]`);
+        }, 1000);
+        return this.client
+            .test()
+            .catch(e => {
+            clearTimeout(logTimer);
+            this.logger?.error('Database connection failed: ' + e.message);
             throw e;
+        })
+            .then(() => {
+            clearTimeout(logTimer);
+            this.logger?.log(`Database connection established`);
         });
     }
     async onApplicationShutdown() {
-        const client = this.moduleRef.get(getSQBToken(this.options.name));
-        const op = this.moduleRef.get(SQB_CONNECTION_OPTIONS);
-        if (client)
-            await client.close(op.shutdownWaitMs);
-    }
-    static createAsyncProviders(options) {
-        if (options.useExisting || options.useFactory)
-            return [this.createAsyncOptionsProvider(options)];
-        if (options.useClass) {
-            return [
-                this.createAsyncOptionsProvider(options),
-                {
-                    provide: options.useClass,
-                    useClass: options.useClass,
-                },
-            ];
-        }
-        throw new Error('Invalid configuration. Must provide useFactory, useClass or useExisting');
-    }
-    static createAsyncOptionsProvider(options) {
-        if (options.useFactory) {
-            return {
-                provide: SQB_CONNECTION_OPTIONS,
-                useFactory: options.useFactory,
-                inject: options.inject || [],
-            };
-        }
-        const useClass = options.useClass || options.useExisting;
-        if (useClass) {
-            return {
-                provide: SQB_CONNECTION_OPTIONS,
-                useFactory: (optionsFactory) => optionsFactory.createSqbOptions(options.name),
-                inject: [useClass],
-            };
-        }
-        throw new Error('Invalid configuration. Must provide useFactory, useClass or useExisting');
-    }
-    static async createConnection(moduleOptions, sqbConnectionOptions) {
-        const connectionToken = moduleOptions.name;
-        // NestJS 8
-        // @ts-ignore
-        if (rxjs.lastValueFrom) {
-            // @ts-ignore
-            return await rxjs.lastValueFrom(defer(async () => new SqbClient(sqbConnectionOptions)).pipe(handleRetry(connectionToken, sqbConnectionOptions.retryAttempts, sqbConnectionOptions.retryDelay, sqbConnectionOptions.verboseRetryLog, sqbConnectionOptions.toRetry)));
-        }
-        // NestJS 7
-        // @ts-ignore
-        return await defer(async () => new SqbClient(sqbConnectionOptions))
-            .pipe(handleRetry(connectionToken, sqbConnectionOptions.retryAttempts, sqbConnectionOptions.retryDelay, sqbConnectionOptions.verboseRetryLog, sqbConnectionOptions.toRetry))
-            .toPromise();
+        await this.client.close(this.connectionOptions.shutdownWaitMs);
     }
 };
 SqbCoreModule = SqbCoreModule_1 = __decorate([
     Global(),
     Module({}),
-    __param(0, Inject(SQB_MODULE_OPTIONS)),
-    __metadata("design:paramtypes", [Object, ModuleRef,
-        Logger])
+    __param(0, Inject(CLIENT_TOKEN)),
+    __param(1, Inject(SQB_CONNECTION_OPTIONS)),
+    __param(2, Inject(Logger)),
+    __metadata("design:paramtypes", [SqbClient, Object, Logger])
 ], SqbCoreModule);
 export { SqbCoreModule };

package/sqb.interface.d.ts

@@ -1,57 +1,29 @@
-import { LoggerService, Type } from '@nestjs/common';
-import { ModuleMetadata } from '@nestjs/common/interfaces';
-import { ClientConfiguration } from '@sqb/connect';
+import type { InjectionToken, LoggerService } from '@nestjs/common';
+import type { ModuleMetadata } from '@nestjs/common/interfaces';
+import type { ClientConfiguration } from '@sqb/connect';
 export interface SqbClientConnectionOptions extends ClientConfiguration {
-    /**
-     * Number of times to retry connecting
-     * Default: 10
-     */
-    retryAttempts?: number;
-    /**
-     * Delay between connection retry attempts (ms)
-     * Default: 3000
-     */
-    retryDelay?: number;
-    /**
-     * Function that determines whether the module should
-     * attempt to connect upon failure.
-     *
-     * @param err error that was thrown
-     * @returns whether to retry connection or not
-     */
-    toRetry?: (err: any) => boolean;
-    /**
-     * If `true`, connection will not be closed on application shutdown.
-     */
-    keepConnectionAlive?: boolean;
-    /**
-     * If `true`, will show verbose error messages on each connection retry.
-     */
-    verboseRetryLog?: boolean;
     /**
      * Number of ms to wait closing connection on shutdown
      * Default: 10
      */
     shutdownWaitMs?: number;
+    /**
+     * If `true`, will not connect to database on application start
+     * Default: `false`
+     */
+    lazyConnect?: boolean;
 }
 interface BaseModuleOptions {
+    token?: InjectionToken;
     envPrefix?: string;
     logger?: LoggerService | string;
     global?: boolean;
-    name?: string;
-    lazyConnect?: boolean;
 }
 export interface SqbModuleOptions extends BaseModuleOptions {
     useValue?: SqbClientConnectionOptions;
 }
-export interface SqbOptionsFactory {
-    createSqbOptions(connectionName?: string): Promise<SqbClientConnectionOptions> | SqbClientConnectionOptions;
-}
-export interface SqbModuleAsyncOptions extends BaseModuleOptions, Pick<ModuleMetadata, 'imports'> {
-    name?: string;
-    useExisting?: Type<SqbOptionsFactory>;
-    useClass?: Type<SqbOptionsFactory>;
-    useFactory?: (...args: any[]) => Promise<SqbClientConnectionOptions> | SqbClientConnectionOptions;
+export interface SqbModuleAsyncOptions extends BaseModuleOptions, Partial<Pick<ModuleMetadata, 'imports'>> {
     inject?: any[];
+    useFactory?: (...args: any[]) => Promise<SqbClientConnectionOptions> | SqbClientConnectionOptions;
 }
 export {};

package/sqb.decorators.d.ts

@@ -1 +0,0 @@
-export declare const InjectSQB: (name?: string) => ParameterDecorator;

package/sqb.decorators.js

@@ -1,3 +0,0 @@
-import { Inject } from '@nestjs/common';
-import { getSQBToken } from './sqb.utils.js';
-export const InjectSQB = (name) => Inject(getSQBToken(name));

package/sqb.utils.d.ts

@@ -1,11 +0,0 @@
-import { Type } from '@nestjs/common';
-import { SqbClient } from '@sqb/connect';
-import { Observable } from 'rxjs';
-/**
- * This function returns a Connection injection token for the given connection name.
- * @param {string | symbol} [name=SQB_DEFAULT_CONNECTION] This optional parameter is either
- * a SqbClient, or a ConnectionOptions or a string.
- * @returns {string | symbol} The Connection injection token.
- */
-export declare function getSQBToken(name?: string | symbol | Type<SqbClient>): string | symbol | Type<SqbClient>;
-export declare function handleRetry(connectionName?: string | symbol | Type<SqbClient>, retryAttempts?: number, retryDelay?: number, verboseRetryLog?: boolean, toRetry?: (err: any) => boolean): <T>(source: Observable<T>) => Observable<T>;

package/sqb.utils.js

@@ -1,35 +0,0 @@
-import { Logger } from '@nestjs/common';
-import { SqbClient } from '@sqb/connect';
-import { delay, retryWhen, scan } from 'rxjs/operators';
-const logger = new Logger('SqbModule');
-/**
- * This function returns a Connection injection token for the given connection name.
- * @param {string | symbol} [name=SQB_DEFAULT_CONNECTION] This optional parameter is either
- * a SqbClient, or a ConnectionOptions or a string.
- * @returns {string | symbol} The Connection injection token.
- */
-export function getSQBToken(name) {
-    if (!name)
-        return SqbClient;
-    if (typeof name === 'symbol' || typeof name === 'function')
-        return name;
-    return `${name}_SqbConnection`;
-}
-export function handleRetry(connectionName, retryAttempts = 9, retryDelay = 3000, verboseRetryLog = false, toRetry) {
-    return (source) => source.pipe(retryWhen(e => e.pipe(scan((errorCount, error) => {
-        if (toRetry && !toRetry(error)) {
-            throw error;
-        }
-        const connectionInfo = !connectionName || connectionName === SqbClient
-            ? 'default'
-            : ` (${String(connectionName)})`;
-        const verboseMessage = verboseRetryLog
-            ? ` Message: ${error.message}.`
-            : '';
-        logger.error(`Unable to connect to the database ${connectionInfo}.${verboseMessage} Retrying (${errorCount + 1})...`, error.stack);
-        if (errorCount + 1 >= retryAttempts) {
-            throw error;
-        }
-        return errorCount + 1;
-    }, 0), delay(retryDelay))));
-}