@xnestjs/redisess 1.2.0 → 1.2.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Panates
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/cjs/constants.js

@@ -0,0 +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');

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

@@ -0,0 +1,7 @@
+"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/index.js

@@ -0,0 +1,8 @@
+"use strict";
+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);

package/cjs/interfaces/module-options.interface.js

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

package/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/cjs/redisess-core.module.js

@@ -0,0 +1,109 @@
+"use strict";
+var RedisessCoreModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisessCoreModule = void 0;
+const tslib_1 = require("tslib");
+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");
+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],
+        };
+    }
+    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,
+                });
+            },
+        };
+        const asyncProviders = this.createAsyncProviders(asyncOptions);
+        return {
+            module: RedisessCoreModule_1,
+            imports: asyncOptions.imports,
+            providers: [
+                ...asyncProviders,
+                connectionProvider,
+                {
+                    provide: constants_js_1.REDISESS_MODULE_TOKEN,
+                    useValue: crypto.randomUUID(),
+                },
+            ],
+            exports: [connectionProvider],
+        };
+    }
+    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');
+    }
+    static async createSessionManager(options) {
+        const opts = { ...options };
+        delete opts.client;
+        delete opts.name;
+        return new redisess_1.SessionManager(options.client, opts);
+    }
+};
+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])
+], RedisessCoreModule);

package/cjs/redisess.module.js

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

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

@@ -0,0 +1,12 @@
+"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/constants.js

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

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

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

package/esm/index.js

@@ -0,0 +1,5 @@
+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';

package/esm/interfaces/module-options.interface.js

@@ -0,0 +1 @@
+export {};

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/esm/redisess-core.module.js

@@ -0,0 +1,106 @@
+var RedisessCoreModule_1;
+import { __decorate, __metadata, __param } from "tslib";
+import { Global, Inject, Module } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
+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';
+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],
+        };
+    }
+    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,
+                });
+            },
+        };
+        const asyncProviders = this.createAsyncProviders(asyncOptions);
+        return {
+            module: RedisessCoreModule_1,
+            imports: asyncOptions.imports,
+            providers: [
+                ...asyncProviders,
+                connectionProvider,
+                {
+                    provide: REDISESS_MODULE_TOKEN,
+                    useValue: crypto.randomUUID(),
+                },
+            ],
+            exports: [connectionProvider],
+        };
+    }
+    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');
+    }
+    static async createSessionManager(options) {
+        const opts = { ...options };
+        delete opts.client;
+        delete opts.name;
+        return new SessionManager(options.client, opts);
+    }
+};
+RedisessCoreModule = RedisessCoreModule_1 = __decorate([
+    Global(),
+    Module({}),
+    __param(0, Inject(REDISESS_MODULE_OPTIONS)),
+    __metadata("design:paramtypes", [Object, ModuleRef])
+], RedisessCoreModule);
+export { RedisessCoreModule };

package/esm/redisess.module.js

@@ -0,0 +1,22 @@
+var RedisessModule_1;
+import { __decorate } from "tslib";
+import { Module } from '@nestjs/common';
+import { RedisessCoreModule } from './redisess-core.module.js';
+let RedisessModule = RedisessModule_1 = class RedisessModule {
+    static forRoot(options) {
+        return {
+            module: RedisessModule_1,
+            imports: [RedisessCoreModule.forRoot(options)],
+        };
+    }
+    static forRootAsync(options) {
+        return {
+            module: RedisessModule_1,
+            imports: [RedisessCoreModule.forRootAsync(options)],
+        };
+    }
+};
+RedisessModule = RedisessModule_1 = __decorate([
+    Module({})
+], RedisessModule);
+export { RedisessModule };

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

@@ -0,0 +1,9 @@
+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/package.json

@@ -1,37 +1,18 @@
 {
   "name": "@xnestjs/redisess",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "NestJS extension library for redisess",
   "author": "Panates",
   "license": "MIT",
-  "scripts": {
-    "compile": "tsc --noEmit",
-    "prebuild": "npm run lint && npm run clean",
-    "build": "npm run build:cjs && npm run build:esm",
-    "build:cjs": "tsc -b tsconfig-build-cjs.json && cp ../../support/package.cjs.json ./build/cjs/package.json",
-    "build:esm": "tsc -b tsconfig-build-esm.json && cp ../../support/package.esm.json ./build/esm/package.json",
-    "postbuild": "cp README.md ../../LICENSE ./build && node ../../support/postbuild.cjs",
-    "lint": "eslint . --max-warnings=0",
-    "lint:fix": "eslint . --max-warnings=0 --fix",
-    "format": "prettier . --write --log-level=warn",
-    "check": "madge --circular src/**",
-    "test": "jest",
-    "cover": "jest --collect-coverage",
-    "clean": "npm run clean:src && npm run clean:build && npm run clean:cover",
-    "clean:src": "ts-cleanup -s src --all && ts-cleanup -s test --all",
-    "clean:build": "rimraf build",
-    "clean:cover": "rimraf coverage"
+  "dependencies": {
+    "tslib": "^2.8.1"
   },
   "peerDependencies": {
     "@nestjs/common": "^10.0.0 || ^11.0.0",
     "@nestjs/core": "^10.0.0 || ^11.0.0",
-    "@xnestjs/ioredis": "^1.2.0",
     "ioredis": "^5.0.0",
     "redisess": "^2.0.0"
   },
-  "devDependencies": {
-    "@nestjs/testing": "^11.0.2"
-  },
   "type": "module",
   "exports": {
     ".": {

package/types/constants.d.ts

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

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

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

package/types/index.d.cts

@@ -0,0 +1,5 @@
+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';

package/types/index.d.ts

@@ -0,0 +1,5 @@
+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';

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

@@ -0,0 +1,21 @@
+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/redisess-core.module.d.ts

@@ -0,0 +1,14 @@
+import { DynamicModule, OnApplicationShutdown } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
+import { RedisessModuleAsyncOptions, type RedisessModuleOptions } from './interfaces/module-options.interface.js';
+export declare class RedisessCoreModule implements OnApplicationShutdown {
+    private readonly options;
+    private readonly moduleRef;
+    constructor(options: RedisessModuleOptions, moduleRef: ModuleRef);
+    static forRoot(options: RedisessModuleOptions): DynamicModule;
+    static forRootAsync(asyncOptions: RedisessModuleAsyncOptions): DynamicModule;
+    onApplicationShutdown(): Promise<void>;
+    private static createAsyncProviders;
+    private static createAsyncOptionsProvider;
+    private static createSessionManager;
+}

package/types/redisess.module.d.ts

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

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

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