@sqb/nestjs 4.0.9 → 4.0.13

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqbClient = void 0;
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./sqb.decorators"), exports);
+tslib_1.__exportStar(require("./sqb.interface"), exports);
+tslib_1.__exportStar(require("./sqb.module"), exports);
+tslib_1.__exportStar(require("./sqb.utils"), exports);
+var connect_1 = require("@sqb/connect");
+Object.defineProperty(exports, "SqbClient", { enumerable: true, get: function () { return connect_1.SqbClient; } });

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

@@ -0,0 +1,14 @@
+import { DynamicModule, OnApplicationShutdown } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
+import { SqbModuleAsyncOptions, SqbModuleOptions } from './sqb.interface';
+export declare class SqbCoreModule implements OnApplicationShutdown {
+    private readonly options;
+    private readonly moduleRef;
+    constructor(options: SqbModuleOptions, moduleRef: ModuleRef);
+    static forRoot(options?: SqbModuleOptions): DynamicModule;
+    static forRootAsync(options: SqbModuleAsyncOptions): DynamicModule;
+    onApplicationShutdown(): Promise<void>;
+    private static createAsyncProviders;
+    private static createAsyncOptionsProvider;
+    private static createConnection;
+}

package/dist/sqb-core.module.js

@@ -0,0 +1,128 @@
+"use strict";
+var SqbCoreModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqbCoreModule = void 0;
+const tslib_1 = require("tslib");
+const crypto = tslib_1.__importStar(require("crypto"));
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const rxjs_1 = require("rxjs");
+const rxjs = tslib_1.__importStar(require("rxjs"));
+const connect_1 = require("@sqb/connect");
+const sqb_utils_1 = require("./sqb.utils");
+const sqb_constants_1 = require("./sqb.constants");
+let SqbCoreModule = SqbCoreModule_1 = class SqbCoreModule {
+    constructor(options, moduleRef) {
+        this.options = options;
+        this.moduleRef = moduleRef;
+    }
+    static forRoot(options = {}) {
+        const optionsProvider = {
+            provide: sqb_constants_1.SQB_MODULE_OPTIONS,
+            useValue: options,
+        };
+        const connectionProvider = {
+            provide: (0, sqb_utils_1.getSQBToken)(options.name),
+            useFactory: () => this.createConnection(options),
+        };
+        return {
+            module: SqbCoreModule_1,
+            providers: [connectionProvider, optionsProvider],
+            exports: [connectionProvider],
+        };
+    }
+    static forRootAsync(options) {
+        const connectionProvider = {
+            provide: (0, sqb_utils_1.getSQBToken)(options.name),
+            inject: [sqb_constants_1.SQB_MODULE_OPTIONS],
+            useFactory: async (sqbOptions) => {
+                const name = options.name || sqbOptions.name;
+                return this.createConnection({
+                    ...sqbOptions,
+                    name
+                });
+            }
+        };
+        const asyncProviders = this.createAsyncProviders(options);
+        return {
+            module: SqbCoreModule_1,
+            imports: options.imports,
+            providers: [
+                ...asyncProviders,
+                connectionProvider,
+                {
+                    provide: sqb_constants_1.SQB_MODULE_ID,
+                    useValue: crypto.randomUUID(),
+                },
+            ],
+            exports: [connectionProvider],
+        };
+    }
+    async onApplicationShutdown() {
+        const client = this.moduleRef.get((0, sqb_utils_1.getSQBToken)(this.options.name));
+        if (client)
+            await client.close(this.options.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_constants_1.SQB_MODULE_OPTIONS,
+                useFactory: options.useFactory,
+                inject: options.inject || [],
+            };
+        }
+        const useClass = options.useClass || options.useExisting;
+        if (useClass) {
+            return {
+                provide: sqb_constants_1.SQB_MODULE_OPTIONS,
+                useFactory: (optionsFactory) => optionsFactory.createSqbOptions(options.name),
+                inject: [useClass],
+            };
+        }
+        throw new Error('Invalid configuration. Must provide useFactory, useClass or useExisting');
+    }
+    static async createConnection(options) {
+        const connectionToken = options.name;
+        // NestJS 8
+        // @ts-ignore
+        if (rxjs.lastValueFrom) {
+            // @ts-ignore
+            return await rxjs.lastValueFrom((0, rxjs_1.defer)(async () => {
+                const client = new connect_1.SqbClient(options);
+                await client.test();
+                return client;
+            }).pipe((0, sqb_utils_1.handleRetry)(connectionToken, options.retryAttempts, options.retryDelay, options.verboseRetryLog, options.toRetry)));
+        }
+        else {
+            // NestJS 7
+            // @ts-ignore
+            return await (0, rxjs_1.defer)(async () => {
+                const client = new connect_1.SqbClient(options);
+                await client.test();
+                return client;
+            })
+                .pipe((0, sqb_utils_1.handleRetry)(connectionToken, options.retryAttempts, options.retryDelay, options.verboseRetryLog, options.toRetry))
+                .toPromise();
+        }
+    }
+};
+SqbCoreModule = SqbCoreModule_1 = tslib_1.__decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({}),
+    tslib_1.__param(0, (0, common_1.Inject)(sqb_constants_1.SQB_MODULE_OPTIONS)),
+    tslib_1.__metadata("design:paramtypes", [Object, core_1.ModuleRef])
+], SqbCoreModule);
+exports.SqbCoreModule = SqbCoreModule;

package/dist/sqb.constants.d.ts

@@ -0,0 +1,2 @@
+export declare const SQB_MODULE_OPTIONS: unique symbol;
+export declare const SQB_MODULE_ID: unique symbol;

package/dist/sqb.constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQB_MODULE_ID = exports.SQB_MODULE_OPTIONS = void 0;
+exports.SQB_MODULE_OPTIONS = Symbol('SQB_MODULE_OPTIONS');
+exports.SQB_MODULE_ID = Symbol('SQB_MODULE_ID');

package/dist/sqb.decorators.d.ts

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

package/dist/sqb.decorators.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InjectSQB = void 0;
+const common_1 = require("@nestjs/common");
+const sqb_utils_1 = require("./sqb.utils");
+const InjectSQB = (name) => (0, common_1.Inject)((0, sqb_utils_1.getSQBToken)(name));
+exports.InjectSQB = InjectSQB;

package/dist/sqb.interface.d.ts

@@ -0,0 +1,50 @@
+import { Type } from '@nestjs/common';
+import { ModuleMetadata } from '@nestjs/common/interfaces';
+import { ClientConfiguration } from '@sqb/connect';
+export declare type SqbModuleOptions = {
+    /**
+     * Connection name
+     */
+    name?: string;
+    /**
+     * 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;
+} & ClientConfiguration;
+export interface SqbOptionsFactory {
+    createSqbOptions(connectionName?: string): Promise<SqbModuleOptions> | SqbModuleOptions;
+}
+export interface SqbModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    name?: string;
+    useExisting?: Type<SqbOptionsFactory>;
+    useClass?: Type<SqbOptionsFactory>;
+    useFactory?: (...args: any[]) => Promise<SqbModuleOptions> | SqbModuleOptions;
+    inject?: any[];
+}

package/dist/sqb.interface.js

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

package/dist/sqb.module.d.ts

@@ -0,0 +1,6 @@
+import { DynamicModule } from '@nestjs/common';
+import { SqbModuleAsyncOptions, SqbModuleOptions } from './sqb.interface';
+export declare class SqbModule {
+    static forRoot(options?: SqbModuleOptions): DynamicModule;
+    static forRootAsync(options: SqbModuleAsyncOptions): DynamicModule;
+}

package/dist/sqb.module.js

@@ -0,0 +1,25 @@
+"use strict";
+var SqbModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqbModule = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const sqb_core_module_1 = require("./sqb-core.module");
+let SqbModule = SqbModule_1 = class SqbModule {
+    static forRoot(options) {
+        return {
+            module: SqbModule_1,
+            imports: [sqb_core_module_1.SqbCoreModule.forRoot(options)]
+        };
+    }
+    static forRootAsync(options) {
+        return {
+            module: SqbModule_1,
+            imports: [sqb_core_module_1.SqbCoreModule.forRootAsync(options)]
+        };
+    }
+};
+SqbModule = SqbModule_1 = tslib_1.__decorate([
+    (0, common_1.Module)({})
+], SqbModule);
+exports.SqbModule = SqbModule;

package/dist/sqb.utils.d.ts

@@ -0,0 +1,11 @@
+import { Type } from '@nestjs/common';
+import { Observable } from 'rxjs';
+import { SqbClient } from '@sqb/connect';
+/**
+ * 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/dist/sqb.utils.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleRetry = exports.getSQBToken = void 0;
+const common_1 = require("@nestjs/common");
+const operators_1 = require("rxjs/operators");
+const connect_1 = require("@sqb/connect");
+const logger = new common_1.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.
+ */
+function getSQBToken(name) {
+    if (!name)
+        return connect_1.SqbClient;
+    if (typeof name === 'symbol' || typeof name === 'function')
+        return name;
+    return `${name}_SqbConnection`;
+}
+exports.getSQBToken = getSQBToken;
+function handleRetry(connectionName, retryAttempts = 9, retryDelay = 3000, verboseRetryLog = false, toRetry) {
+    return (source) => source.pipe((0, operators_1.retryWhen)((e) => e.pipe((0, operators_1.scan)((errorCount, error) => {
+        if (toRetry && !toRetry(error)) {
+            throw error;
+        }
+        const connectionInfo = !connectionName || connectionName === connect_1.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), (0, operators_1.delay)(retryDelay))));
+}
+exports.handleRetry = handleRetry;

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@sqb/nestjs",
   "description": "Nestjs module for data connection using SQB",
-  "version": "4.0.9",
-  "author": "Panates Ltd.",
+  "version": "4.0.13",
+  "author": "Panates",
   "contributors": [
     "Eray Hanoglu <e.hanoglu@panates.com>"
   ],