@xnestjs/redisess 1.2.4 → 1.3.1

package/README.md

@@ -1,3 +1,65 @@
 # @xnestjs/redisess
 
-NestJS extension library for redisess
+NestJS extension library for Redisess
+
+
+## Install
+
+```sh
+npm install @xnestjs/redisess
+# or using yarn
+yarn add @xnestjs/redisess
+```
+
+## Usage
+
+### Register sync
+
+An example of nestjs module that import the @xnestjs/mongodb
+
+```ts
+// module.ts
+import { Module } from '@nestjs/common';
+import { RedisessModule } from '@xnestjs/redisess';
+
+const client = new Redis();
+
+@Module({
+    imports: [
+        RedisessModule.forRoot({
+            useValue: {
+                client,
+                namespace: 'sessions',
+            },
+        }),
+    ],
+})
+export class MyModule {
+}
+```
+
+### Register async
+
+An example of nestjs module that import the @xnestjs/mongodb async
+
+```ts
+// module.ts
+import { Module } from '@nestjs/common';
+import { RedisessModule } from '@xnestjs/redisess';
+
+const client = new Redis();
+
+@Module({
+    imports: [
+        RedisessModule.forRootAsync({
+            inject: [ConfigModule],
+            useFactory: (config: ConfigService) => ({
+                client,
+                namespace: config.get('SESSION_NAMESPACE'),
+            }),
+        }),
+    ]
+})
+export class MyModule {
+}
+```

package/cjs/constants.js

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

package/cjs/index.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./constants.js"), exports);
-tslib_1.__exportStar(require("./decorators/inject-session-manager.decorators.js"), exports);
-tslib_1.__exportStar(require("./interfaces/module-options.interface.js"), exports);
 tslib_1.__exportStar(require("./redisess.module.js"), exports);
-tslib_1.__exportStar(require("./utils/get-session-manager-token.util.js"), exports);
+tslib_1.__exportStar(require("./types.js"), exports);
+tslib_1.__exportStar(require("redisess"), exports);

package/cjs/redisess-core.module.js

@@ -3,107 +3,91 @@ var RedisessCoreModule_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedisessCoreModule = void 0;
 const tslib_1 = require("tslib");
+const assert = tslib_1.__importStar(require("node:assert"));
+const objects_1 = require("@jsopen/objects");
 const common_1 = require("@nestjs/common");
-const core_1 = require("@nestjs/core");
 const crypto = tslib_1.__importStar(require("crypto"));
 const redisess_1 = require("redisess");
 const constants_js_1 = require("./constants.js");
-const get_session_manager_token_util_js_1 = require("./utils/get-session-manager-token.util.js");
+const CLIENT_TOKEN = Symbol('CLIENT_TOKEN');
 let RedisessCoreModule = RedisessCoreModule_1 = class RedisessCoreModule {
-    constructor(options, moduleRef) {
-        this.options = options;
-        this.moduleRef = moduleRef;
-    }
-    static forRoot(options) {
-        const optionsProvider = {
-            provide: constants_js_1.REDISESS_MODULE_OPTIONS,
-            useValue: options,
-        };
-        const connectionProvider = {
-            provide: (0, get_session_manager_token_util_js_1.getSessionManagerToken)(options.name),
-            useFactory: () => this.createSessionManager(options),
-        };
-        return {
-            module: RedisessCoreModule_1,
-            providers: [connectionProvider, optionsProvider],
-            exports: [connectionProvider],
-        };
+    /**
+     * Configures and returns a dynamic module
+     */
+    static forRoot(moduleOptions) {
+        return this._createDynamicModule(moduleOptions, {
+            global: moduleOptions.global,
+            providers: [
+                {
+                    provide: constants_js_1.REDISESS_SESSION_OPTIONS,
+                    useValue: moduleOptions.useValue,
+                },
+            ],
+        });
     }
+    /**
+     * Configures and returns an async dynamic module
+     */
     static forRootAsync(asyncOptions) {
-        const connectionProvider = {
-            provide: (0, get_session_manager_token_util_js_1.getSessionManagerToken)(asyncOptions.name),
-            inject: [constants_js_1.REDISESS_MODULE_OPTIONS],
-            useFactory: async (oOptions) => {
-                const name = asyncOptions.name || oOptions.name;
-                return this.createSessionManager({
-                    ...oOptions,
-                    name,
-                });
+        assert.ok(asyncOptions.useFactory, 'useFactory is required');
+        return this._createDynamicModule(asyncOptions, {
+            global: asyncOptions.global,
+            providers: [
+                {
+                    provide: constants_js_1.REDISESS_SESSION_OPTIONS,
+                    inject: asyncOptions.inject,
+                    useFactory: asyncOptions.useFactory,
+                },
+            ],
+        });
+    }
+    static _createDynamicModule(opts, metadata) {
+        const token = opts.token ?? redisess_1.SessionManager;
+        const providers = [
+            {
+                provide: token,
+                inject: [constants_js_1.REDISESS_SESSION_OPTIONS],
+                useFactory: async (sessionOptions) => {
+                    const redisessOptions = (0, objects_1.omit)(sessionOptions, ['client']);
+                    return new redisess_1.SessionManager(sessionOptions.client, redisessOptions);
+                },
             },
-        };
-        const asyncProviders = this.createAsyncProviders(asyncOptions);
+            {
+                provide: CLIENT_TOKEN,
+                useExisting: token,
+            },
+            {
+                provide: common_1.Logger,
+                useValue: typeof opts.logger === 'string' ? new common_1.Logger(opts.logger) : opts.logger,
+            },
+        ];
         return {
             module: RedisessCoreModule_1,
-            imports: asyncOptions.imports,
+            ...metadata,
             providers: [
-                ...asyncProviders,
-                connectionProvider,
+                ...(metadata.providers ?? []),
+                ...providers,
                 {
-                    provide: constants_js_1.REDISESS_MODULE_TOKEN,
+                    provide: constants_js_1.REDISESS_MODULE_ID,
                     useValue: crypto.randomUUID(),
                 },
             ],
-            exports: [connectionProvider],
+            exports: [constants_js_1.REDISESS_SESSION_OPTIONS, token, ...(metadata.exports ?? [])],
         };
     }
-    async onApplicationShutdown() {
-        const sessionManager = this.moduleRef.get((0, get_session_manager_token_util_js_1.getSessionManagerToken)(this.options.name));
-        if (sessionManager)
-            sessionManager.quit();
-    }
-    static createAsyncProviders(asyncOptions) {
-        if (asyncOptions.useExisting || asyncOptions.useFactory)
-            return [this.createAsyncOptionsProvider(asyncOptions)];
-        if (asyncOptions.useClass) {
-            return [
-                this.createAsyncOptionsProvider(asyncOptions),
-                {
-                    provide: asyncOptions.useClass,
-                    useClass: asyncOptions.useClass,
-                },
-            ];
-        }
-        throw new Error('Invalid configuration. Must provide useFactory, useClass or useExisting');
-    }
-    static createAsyncOptionsProvider(asyncOptions) {
-        if (asyncOptions.useFactory) {
-            return {
-                provide: constants_js_1.REDISESS_MODULE_OPTIONS,
-                useFactory: asyncOptions.useFactory,
-                inject: asyncOptions.inject || [],
-            };
-        }
-        const useClass = asyncOptions.useClass || asyncOptions.useExisting;
-        if (useClass) {
-            return {
-                provide: constants_js_1.REDISESS_MODULE_OPTIONS,
-                useFactory: (optionsFactory) => optionsFactory.createOptions(asyncOptions.name),
-                inject: [useClass],
-            };
-        }
-        throw new Error('Invalid configuration. Must provide useFactory, useClass or useExisting');
+    /**
+     *
+     * @constructor
+     */
+    constructor(sessionManager) {
+        this.sessionManager = sessionManager;
     }
-    static async createSessionManager(options) {
-        const opts = { ...options };
-        delete opts.client;
-        delete opts.name;
-        return new redisess_1.SessionManager(options.client, opts);
+    async onApplicationShutdown() {
+        this.sessionManager.quit();
     }
 };
 exports.RedisessCoreModule = RedisessCoreModule;
 exports.RedisessCoreModule = RedisessCoreModule = RedisessCoreModule_1 = tslib_1.__decorate([
-    (0, common_1.Global)(),
-    (0, common_1.Module)({}),
-    tslib_1.__param(0, (0, common_1.Inject)(constants_js_1.REDISESS_MODULE_OPTIONS)),
-    tslib_1.__metadata("design:paramtypes", [Object, core_1.ModuleRef])
+    tslib_1.__param(0, (0, common_1.Inject)(CLIENT_TOKEN)),
+    tslib_1.__metadata("design:paramtypes", [redisess_1.SessionManager])
 ], RedisessCoreModule);

package/esm/constants.js

@@ -1,2 +1,2 @@
-export const REDISESS_MODULE_OPTIONS = Symbol('REDISESS_MODULE_OPTIONS');
-export const REDISESS_MODULE_TOKEN = Symbol('REDISESS_MODULE_ID');
+export const REDISESS_SESSION_OPTIONS = Symbol('REDISESS_SESSION_OPTIONS');
+export const REDISESS_MODULE_ID = Symbol('REDISESS_MODULE_ID');

package/esm/index.js

@@ -1,5 +1,4 @@
 export * from './constants.js';
-export * from './decorators/inject-session-manager.decorators.js';
-export * from './interfaces/module-options.interface.js';
 export * from './redisess.module.js';
-export * from './utils/get-session-manager-token.util.js';
+export * from './types.js';
+export * from 'redisess';

package/esm/redisess-core.module.js

@@ -1,106 +1,90 @@
 var RedisessCoreModule_1;
 import { __decorate, __metadata, __param } from "tslib";
-import { Global, Inject, Module } from '@nestjs/common';
-import { ModuleRef } from '@nestjs/core';
+import * as assert from 'node:assert';
+import { omit } from '@jsopen/objects';
+import { Inject, Logger } from '@nestjs/common';
 import * as crypto from 'crypto';
 import { SessionManager } from 'redisess';
-import { REDISESS_MODULE_OPTIONS, REDISESS_MODULE_TOKEN } from './constants.js';
-import { getSessionManagerToken } from './utils/get-session-manager-token.util.js';
+import { REDISESS_MODULE_ID, REDISESS_SESSION_OPTIONS } from './constants.js';
+const CLIENT_TOKEN = Symbol('CLIENT_TOKEN');
 let RedisessCoreModule = RedisessCoreModule_1 = class RedisessCoreModule {
-    constructor(options, moduleRef) {
-        this.options = options;
-        this.moduleRef = moduleRef;
-    }
-    static forRoot(options) {
-        const optionsProvider = {
-            provide: REDISESS_MODULE_OPTIONS,
-            useValue: options,
-        };
-        const connectionProvider = {
-            provide: getSessionManagerToken(options.name),
-            useFactory: () => this.createSessionManager(options),
-        };
-        return {
-            module: RedisessCoreModule_1,
-            providers: [connectionProvider, optionsProvider],
-            exports: [connectionProvider],
-        };
+    /**
+     * Configures and returns a dynamic module
+     */
+    static forRoot(moduleOptions) {
+        return this._createDynamicModule(moduleOptions, {
+            global: moduleOptions.global,
+            providers: [
+                {
+                    provide: REDISESS_SESSION_OPTIONS,
+                    useValue: moduleOptions.useValue,
+                },
+            ],
+        });
     }
+    /**
+     * Configures and returns an async dynamic module
+     */
     static forRootAsync(asyncOptions) {
-        const connectionProvider = {
-            provide: getSessionManagerToken(asyncOptions.name),
-            inject: [REDISESS_MODULE_OPTIONS],
-            useFactory: async (oOptions) => {
-                const name = asyncOptions.name || oOptions.name;
-                return this.createSessionManager({
-                    ...oOptions,
-                    name,
-                });
+        assert.ok(asyncOptions.useFactory, 'useFactory is required');
+        return this._createDynamicModule(asyncOptions, {
+            global: asyncOptions.global,
+            providers: [
+                {
+                    provide: REDISESS_SESSION_OPTIONS,
+                    inject: asyncOptions.inject,
+                    useFactory: asyncOptions.useFactory,
+                },
+            ],
+        });
+    }
+    static _createDynamicModule(opts, metadata) {
+        const token = opts.token ?? SessionManager;
+        const providers = [
+            {
+                provide: token,
+                inject: [REDISESS_SESSION_OPTIONS],
+                useFactory: async (sessionOptions) => {
+                    const redisessOptions = omit(sessionOptions, ['client']);
+                    return new SessionManager(sessionOptions.client, redisessOptions);
+                },
             },
-        };
-        const asyncProviders = this.createAsyncProviders(asyncOptions);
+            {
+                provide: CLIENT_TOKEN,
+                useExisting: token,
+            },
+            {
+                provide: Logger,
+                useValue: typeof opts.logger === 'string' ? new Logger(opts.logger) : opts.logger,
+            },
+        ];
         return {
             module: RedisessCoreModule_1,
-            imports: asyncOptions.imports,
+            ...metadata,
             providers: [
-                ...asyncProviders,
-                connectionProvider,
+                ...(metadata.providers ?? []),
+                ...providers,
                 {
-                    provide: REDISESS_MODULE_TOKEN,
+                    provide: REDISESS_MODULE_ID,
                     useValue: crypto.randomUUID(),
                 },
             ],
-            exports: [connectionProvider],
+            exports: [REDISESS_SESSION_OPTIONS, token, ...(metadata.exports ?? [])],
         };
     }
-    async onApplicationShutdown() {
-        const sessionManager = this.moduleRef.get(getSessionManagerToken(this.options.name));
-        if (sessionManager)
-            sessionManager.quit();
-    }
-    static createAsyncProviders(asyncOptions) {
-        if (asyncOptions.useExisting || asyncOptions.useFactory)
-            return [this.createAsyncOptionsProvider(asyncOptions)];
-        if (asyncOptions.useClass) {
-            return [
-                this.createAsyncOptionsProvider(asyncOptions),
-                {
-                    provide: asyncOptions.useClass,
-                    useClass: asyncOptions.useClass,
-                },
-            ];
-        }
-        throw new Error('Invalid configuration. Must provide useFactory, useClass or useExisting');
-    }
-    static createAsyncOptionsProvider(asyncOptions) {
-        if (asyncOptions.useFactory) {
-            return {
-                provide: REDISESS_MODULE_OPTIONS,
-                useFactory: asyncOptions.useFactory,
-                inject: asyncOptions.inject || [],
-            };
-        }
-        const useClass = asyncOptions.useClass || asyncOptions.useExisting;
-        if (useClass) {
-            return {
-                provide: REDISESS_MODULE_OPTIONS,
-                useFactory: (optionsFactory) => optionsFactory.createOptions(asyncOptions.name),
-                inject: [useClass],
-            };
-        }
-        throw new Error('Invalid configuration. Must provide useFactory, useClass or useExisting');
+    /**
+     *
+     * @constructor
+     */
+    constructor(sessionManager) {
+        this.sessionManager = sessionManager;
     }
-    static async createSessionManager(options) {
-        const opts = { ...options };
-        delete opts.client;
-        delete opts.name;
-        return new SessionManager(options.client, opts);
+    async onApplicationShutdown() {
+        this.sessionManager.quit();
     }
 };
 RedisessCoreModule = RedisessCoreModule_1 = __decorate([
-    Global(),
-    Module({}),
-    __param(0, Inject(REDISESS_MODULE_OPTIONS)),
-    __metadata("design:paramtypes", [Object, ModuleRef])
+    __param(0, Inject(CLIENT_TOKEN)),
+    __metadata("design:paramtypes", [SessionManager])
 ], RedisessCoreModule);
 export { RedisessCoreModule };

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "@xnestjs/redisess",
-  "version": "1.2.4",
+  "version": "1.3.1",
   "description": "NestJS extension library for redisess",
   "author": "Panates",
   "license": "MIT",
   "dependencies": {
+    "@jsopen/objects": "^1.5.2",
+    "ansi-colors": "^4.1.3",
+    "putil-varhelpers": "^1.6.5",
     "tslib": "^2.8.1"
   },
   "peerDependencies": {

package/types/constants.d.ts

@@ -1,2 +1,2 @@
-export declare const REDISESS_MODULE_OPTIONS: unique symbol;
-export declare const REDISESS_MODULE_TOKEN: unique symbol;
+export declare const REDISESS_SESSION_OPTIONS: unique symbol;
+export declare const REDISESS_MODULE_ID: unique symbol;

package/types/index.d.cts

@@ -1,5 +1,4 @@
 export * from './constants.js';
-export * from './decorators/inject-session-manager.decorators.js';
-export * from './interfaces/module-options.interface.js';
 export * from './redisess.module.js';
-export * from './utils/get-session-manager-token.util.js';
+export * from './types.js';
+export * from 'redisess';

package/types/index.d.ts

@@ -1,5 +1,4 @@
 export * from './constants.js';
-export * from './decorators/inject-session-manager.decorators.js';
-export * from './interfaces/module-options.interface.js';
 export * from './redisess.module.js';
-export * from './utils/get-session-manager-token.util.js';
+export * from './types.js';
+export * from 'redisess';

package/types/redisess-core.module.d.ts

@@ -1,14 +1,21 @@
 import { DynamicModule, OnApplicationShutdown } from '@nestjs/common';
-import { ModuleRef } from '@nestjs/core';
-import { RedisessModuleAsyncOptions, type RedisessModuleOptions } from './interfaces/module-options.interface.js';
+import { SessionManager } from 'redisess';
+import type { RedisessModuleAsyncOptions, RedisessModuleOptions } from './types.js';
 export declare class RedisessCoreModule implements OnApplicationShutdown {
-    private readonly options;
-    private readonly moduleRef;
-    constructor(options: RedisessModuleOptions, moduleRef: ModuleRef);
-    static forRoot(options: RedisessModuleOptions): DynamicModule;
+    private readonly sessionManager;
+    /**
+     * Configures and returns a dynamic module
+     */
+    static forRoot(moduleOptions: RedisessModuleOptions): DynamicModule;
+    /**
+     * Configures and returns an async dynamic module
+     */
     static forRootAsync(asyncOptions: RedisessModuleAsyncOptions): DynamicModule;
+    private static _createDynamicModule;
+    /**
+     *
+     * @constructor
+     */
+    constructor(sessionManager: SessionManager);
     onApplicationShutdown(): Promise<void>;
-    private static createAsyncProviders;
-    private static createAsyncOptionsProvider;
-    private static createSessionManager;
 }

package/types/redisess.module.d.ts

@@ -1,5 +1,5 @@
 import { DynamicModule } from '@nestjs/common';
-import type { RedisessModuleAsyncOptions, RedisessModuleOptions } from './interfaces/module-options.interface.js';
+import type { RedisessModuleAsyncOptions, RedisessModuleOptions } from './types';
 export declare class RedisessModule {
     static forRoot(options: RedisessModuleOptions): DynamicModule;
     static forRootAsync(options: RedisessModuleAsyncOptions): DynamicModule;

package/types/types.d.ts

@@ -0,0 +1,21 @@
+import type { Logger } from '@nestjs/common';
+import type { ModuleMetadata } from '@nestjs/common/interfaces';
+import type { InjectionToken } from '@nestjs/common/interfaces/modules/injection-token.interface';
+import type { Cluster, Redis } from 'ioredis';
+import type { SessionManager } from 'redisess';
+export interface RedisessSessionOptions extends SessionManager.Options {
+    client: Redis | Cluster;
+}
+export interface RedisessModuleOptions extends BaseModuleOptions {
+    useValue: RedisessSessionOptions;
+}
+export interface RedisessModuleAsyncOptions extends BaseModuleOptions, Pick<ModuleMetadata, 'imports'> {
+    useFactory?: (...args: any[]) => Promise<RedisessSessionOptions> | RedisessSessionOptions;
+    inject?: any[];
+}
+interface BaseModuleOptions {
+    token?: InjectionToken;
+    logger?: Logger | string;
+    global?: boolean;
+}
+export {};

package/cjs/decorators/inject-session-manager.decorators.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InjectSessionManager = void 0;
-const common_1 = require("@nestjs/common");
-const get_session_manager_token_util_js_1 = require("../utils/get-session-manager-token.util.js");
-const InjectSessionManager = (name) => (0, common_1.Inject)((0, get_session_manager_token_util_js_1.getSessionManagerToken)(name));
-exports.InjectSessionManager = InjectSessionManager;

package/cjs/utils/get-session-manager-token.util.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSessionManagerToken = getSessionManagerToken;
-const redisess_1 = require("redisess");
-function getSessionManagerToken(name) {
-    if (!name)
-        return redisess_1.SessionManager;
-    // noinspection SuspiciousTypeOfGuard
-    if (typeof name === 'symbol' || typeof name === 'function')
-        return name;
-    return `${name}_SessionManager`;
-}

package/esm/decorators/inject-session-manager.decorators.js

@@ -1,3 +0,0 @@
-import { Inject } from '@nestjs/common';
-import { getSessionManagerToken } from '../utils/get-session-manager-token.util.js';
-export const InjectSessionManager = (name) => Inject(getSessionManagerToken(name));

package/esm/utils/get-session-manager-token.util.js

@@ -1,9 +0,0 @@
-import { SessionManager } from 'redisess';
-export function getSessionManagerToken(name) {
-    if (!name)
-        return SessionManager;
-    // noinspection SuspiciousTypeOfGuard
-    if (typeof name === 'symbol' || typeof name === 'function')
-        return name;
-    return `${name}_SessionManager`;
-}

package/types/decorators/inject-session-manager.decorators.d.ts

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

package/types/interfaces/module-options.interface.d.ts

@@ -1,21 +0,0 @@
-import type { Type } from '@nestjs/common';
-import type { ModuleMetadata } from '@nestjs/common/interfaces';
-import Redis, { Cluster } from 'ioredis';
-import type { SessionManager } from 'redisess';
-export interface RedisessModuleOptions extends SessionManager.Options {
-    /**
-     * Connection name
-     */
-    name?: string;
-    client: Redis | Cluster;
-}
-export interface RedisessModuleOptionsFactory {
-    createOptions(connectionName?: string): Promise<RedisessModuleOptions> | RedisessModuleOptions;
-}
-export interface RedisessModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
-    name?: string;
-    useExisting?: Type<RedisessModuleOptionsFactory>;
-    useClass?: Type<RedisessModuleOptionsFactory>;
-    useFactory?: (...args: any[]) => Promise<RedisessModuleOptions> | RedisessModuleOptions;
-    inject?: any[];
-}

package/types/utils/get-session-manager-token.util.d.ts

@@ -1,3 +0,0 @@
-import { Type } from '@nestjs/common';
-import { SessionManager } from 'redisess';
-export declare function getSessionManagerToken(name?: string | symbol | Type<SessionManager>): string | symbol | Type<SessionManager>;