@xnestjs/redisess 0.0.1

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/README.md

@@ -0,0 +1,3 @@
+# @xnestjs/redisess
+
+NestJS extension library for redisess

package/cjs/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./redisess.decorators.js"), exports);
+tslib_1.__exportStar(require("./redisess.interface.js"), exports);
+tslib_1.__exportStar(require("./redisess.module.js"), exports);
+tslib_1.__exportStar(require("./redisess.utils.js"), exports);

package/cjs/package.json

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

package/cjs/redisess-core.module.js

@@ -0,0 +1,110 @@
+"use strict";
+var RedisessCoreModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisessCoreModule = void 0;
+const tslib_1 = require("tslib");
+const crypto = tslib_1.__importStar(require("crypto"));
+const redisess_1 = require("redisess");
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const redisess_constants_js_1 = require("./redisess.constants.js");
+const redisess_utils_js_1 = require("./redisess.utils.js");
+let RedisessCoreModule = RedisessCoreModule_1 = class RedisessCoreModule {
+    options;
+    moduleRef;
+    constructor(options, moduleRef) {
+        this.options = options;
+        this.moduleRef = moduleRef;
+    }
+    static forRoot(options) {
+        const optionsProvider = {
+            provide: redisess_constants_js_1.REDISESS_MODULE_OPTIONS,
+            useValue: options
+        };
+        const connectionProvider = {
+            provide: (0, redisess_utils_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, redisess_utils_js_1.getSessionManagerToken)(asyncOptions.name),
+            inject: [redisess_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: redisess_constants_js_1.REDISESS_MODULE_TOKEN,
+                    useValue: crypto.randomUUID()
+                }
+            ],
+            exports: [connectionProvider]
+        };
+    }
+    async onApplicationShutdown() {
+        const sessionManager = this.moduleRef.get((0, redisess_utils_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: redisess_constants_js_1.REDISESS_MODULE_OPTIONS,
+                useFactory: asyncOptions.useFactory,
+                inject: asyncOptions.inject || []
+            };
+        }
+        const useClass = asyncOptions.useClass || asyncOptions.useExisting;
+        if (useClass) {
+            return {
+                provide: redisess_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);
+    }
+};
+RedisessCoreModule = RedisessCoreModule_1 = tslib_1.__decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({}),
+    tslib_1.__param(0, (0, common_1.Inject)(redisess_constants_js_1.REDISESS_MODULE_OPTIONS)),
+    tslib_1.__metadata("design:paramtypes", [Object, core_1.ModuleRef])
+], RedisessCoreModule);
+exports.RedisessCoreModule = RedisessCoreModule;

package/cjs/redisess.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/redisess.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 redisess_utils_js_1 = require("./redisess.utils.js");
+const InjectSessionManager = (name) => (0, common_1.Inject)((0, redisess_utils_js_1.getSessionManagerToken)(name));
+exports.InjectSessionManager = InjectSessionManager;

package/cjs/redisess.interface.js

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

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)]
+        };
+    }
+};
+RedisessModule = RedisessModule_1 = tslib_1.__decorate([
+    (0, common_1.Module)({})
+], RedisessModule);
+exports.RedisessModule = RedisessModule;

package/cjs/redisess.utils.js

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

package/esm/index.d.ts

@@ -0,0 +1,4 @@
+export * from './redisess.decorators.js';
+export * from './redisess.interface.js';
+export * from './redisess.module.js';
+export * from './redisess.utils.js';

package/esm/index.js

@@ -0,0 +1,4 @@
+export * from './redisess.decorators.js';
+export * from './redisess.interface.js';
+export * from './redisess.module.js';
+export * from './redisess.utils.js';

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

@@ -0,0 +1,14 @@
+import { DynamicModule, OnApplicationShutdown } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
+import { RedisesModuleAsyncOptions, RedisessModuleOptions } from './redisess.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: RedisesModuleAsyncOptions): DynamicModule;
+    onApplicationShutdown(): Promise<void>;
+    private static createAsyncProviders;
+    private static createAsyncOptionsProvider;
+    private static createSessionManager;
+}

package/esm/redisess-core.module.js

@@ -0,0 +1,107 @@
+var RedisessCoreModule_1;
+import { __decorate, __metadata, __param } from "tslib";
+import * as crypto from 'crypto';
+import { SessionManager } from 'redisess';
+import { Global, Inject, Module } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
+import { REDISESS_MODULE_OPTIONS, REDISESS_MODULE_TOKEN } from './redisess.constants.js';
+import { getSessionManagerToken } from './redisess.utils.js';
+let RedisessCoreModule = RedisessCoreModule_1 = class RedisessCoreModule {
+    options;
+    moduleRef;
+    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.constants.d.ts

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

package/esm/redisess.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/redisess.decorators.d.ts

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

package/esm/redisess.decorators.js

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

package/esm/redisess.interface.d.ts

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

package/esm/redisess.interface.js

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

package/esm/redisess.module.d.ts

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

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/redisess.utils.d.ts

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

package/esm/redisess.utils.js

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

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@xnestjs/redisess",
+  "version": "0.0.1",
+  "description": "NestJS extension library for redisess",
+  "author": "Panates",
+  "license": "MIT",
+  "scripts": {
+    "compile": "tsc",
+    "prebuild": "npm run lint && npm run clean",
+    "build": "npm run build:cjs && npm run build:esm",
+    "build:cjs": "tsc -b tsconfig-build-cjs.json",
+    "build:esm": "tsc -b tsconfig-build-esm.json",
+    "postbuild": "cp README.md package.json ../../LICENSE ../../build/redisess && cp ../../package.cjs.json ../../build/redisess/cjs/package.json",
+    "lint": "eslint .",
+    "test": "jest",
+    "cover": "jest --collect-coverage",
+    "clean": "npm run clean:src && npm run clean:dist && npm run clean:cover",
+    "clean:src": "ts-cleanup -s src --all",
+    "clean:dist": "rimraf ../../build/redisess",
+    "clean:cover": "rimraf ../../coverage/redisess"
+  },
+  "devDependencies": {
+    "@nestjs/common": "^9.0.11",
+    "@nestjs/core": "^9.0.11",
+    "@nestjs/testing": "^9.0.11"
+  },
+  "peerDependencies": {
+    "@nestjs/common": ">=7.4.0",
+    "redisess": "^2.1.0"
+  },
+  "type": "module",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "types": "esm/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./cjs/index.js",
+      "default": "./esm/index.js"
+    },
+    "./cjs": "./cjs/index.js",
+    "./esm": "./esm/index.js"
+  },
+  "engines": {
+    "node": ">=16.0",
+    "npm": ">=7.0.0"
+  },
+  "files": [
+    "bin/",
+    "cjs/",
+    "esm/",
+    "LICENSE",
+    "README.md"
+  ],
+  "keywords": [
+    "nestjs",
+    "redisess",
+    "session",
+    "manager",
+    "redis"
+  ]
+}