@citec-spbu/jwt 1.1.0 → 1.1.2

package/dist/index.d.ts

@@ -1,3 +1,2 @@
-export * from "./issuer.module";
-export * from "./consumer.module";
 export * from "./interfaces";
+export * from "./jwt.constants";

package/dist/index.js

@@ -14,6 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./issuer.module"), exports);
-__exportStar(require("./consumer.module"), exports);
 __exportStar(require("./interfaces"), exports);
+__exportStar(require("./jwt.constants"), exports);

package/dist/interfaces/index.d.ts

@@ -1 +1,2 @@
 export * from "./token.interface";
+export * from "./jwt-options.interface";

package/dist/interfaces/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./token.interface"), exports);
+__exportStar(require("./jwt-options.interface"), exports);

package/dist/interfaces/jwt-options.interface.d.ts

@@ -0,0 +1,22 @@
+import { ModuleMetadata, Provider, Type } from "@nestjs/common";
+import * as jwt from "jsonwebtoken";
+export interface JwtModuleOptions {
+    publicKey?: jwt.Secret;
+    privateKey?: jwt.Secret;
+}
+export interface JwtOptionsFactory {
+    createJwtOptions(): Promise<JwtModuleOptions> | JwtModuleOptions;
+}
+export interface JwtModuleAsyncOptions extends Pick<ModuleMetadata, "imports"> {
+    useExisting?: Type<JwtOptionsFactory>;
+    useClass?: Type<JwtOptionsFactory>;
+    useFactory?: (...args: any[]) => Promise<JwtModuleOptions> | JwtModuleOptions;
+    inject?: any[];
+    extraProviders?: Provider[];
+}
+export interface JwtSignOptions extends jwt.SignOptions {
+    privateKey?: jwt.Secret;
+}
+export interface JwtVerifyOptions extends jwt.VerifyOptions {
+    publicKey?: jwt.Secret;
+}

package/dist/interfaces/jwt-options.interface.js

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

package/dist/jwt.constants.d.ts

@@ -0,0 +1 @@
+export declare const JWT_MODULE_OPTIONS = "JWT_MODULE_OPTIONS";

package/dist/jwt.constants.js

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

package/dist/jwt.module.d.ts

@@ -0,0 +1,8 @@
+import { DynamicModule } from "@nestjs/common";
+import { JwtModuleAsyncOptions, JwtModuleOptions } from "./interfaces";
+export declare class JwtModule {
+    static register(options: JwtModuleOptions): DynamicModule;
+    static registerAsync(options: JwtModuleAsyncOptions): DynamicModule;
+    private static createAsyncProviders;
+    private static createAsyncOptionsProvider;
+}

package/dist/jwt.module.js

@@ -0,0 +1,65 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var JwtModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JwtModule = void 0;
+const common_1 = require("@nestjs/common");
+const jwt_constants_1 = require("./jwt.constants");
+const jwt_providers_1 = require("./jwt.providers");
+const jwt_service_1 = require("./jwt.service");
+let JwtModule = JwtModule_1 = class JwtModule {
+    static register(options) {
+        return {
+            module: JwtModule_1,
+            providers: (0, jwt_providers_1.createJwtProvider)(options)
+        };
+    }
+    static registerAsync(options) {
+        return {
+            module: JwtModule_1,
+            imports: options.imports || [],
+            providers: [
+                ...this.createAsyncProviders(options),
+                ...(options.extraProviders ?? [])
+            ]
+        };
+    }
+    static createAsyncProviders(options) {
+        if (options.useExisting || options.useFactory) {
+            return [this.createAsyncOptionsProvider(options)];
+        }
+        return [
+            this.createAsyncOptionsProvider(options),
+            {
+                provide: options.useClass,
+                useClass: options.useClass
+            }
+        ];
+    }
+    static createAsyncOptionsProvider(options) {
+        if (options.useFactory) {
+            return {
+                provide: jwt_constants_1.JWT_MODULE_OPTIONS,
+                useFactory: options.useFactory,
+                inject: options.inject || []
+            };
+        }
+        return {
+            provide: jwt_constants_1.JWT_MODULE_OPTIONS,
+            useFactory: async (optionsFactory) => await optionsFactory.createJwtOptions(),
+            inject: [options.useExisting || options.useClass]
+        };
+    }
+};
+exports.JwtModule = JwtModule;
+exports.JwtModule = JwtModule = JwtModule_1 = __decorate([
+    (0, common_1.Module)({
+        providers: [jwt_service_1.JwtService],
+        exports: [jwt_service_1.JwtService]
+    })
+], JwtModule);

package/dist/jwt.providers.d.ts

@@ -0,0 +1,2 @@
+import { JwtModuleOptions } from "./interfaces";
+export declare function createJwtProvider(options: JwtModuleOptions): any[];

package/dist/jwt.providers.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createJwtProvider = createJwtProvider;
+const jwt_constants_1 = require("./jwt.constants");
+function createJwtProvider(options) {
+    return [{ provide: jwt_constants_1.JWT_MODULE_OPTIONS, useValue: options || {} }];
+}

package/dist/jwt.service.d.ts

@@ -0,0 +1,13 @@
+import * as jwt from "jsonwebtoken";
+import { JwtModuleOptions, JwtSignOptions, JwtVerifyOptions, TokenPayload } from "./interfaces";
+export declare class JwtService {
+    private readonly options;
+    constructor(options?: JwtModuleOptions);
+    sign(payload: TokenPayload, options?: JwtSignOptions): string;
+    signAsync(payload: TokenPayload, options?: JwtSignOptions): Promise<string>;
+    verify(token: string, options?: JwtVerifyOptions): TokenPayload;
+    verifyAsync(token: string, options?: JwtVerifyOptions): Promise<TokenPayload>;
+    decode(token: string, options?: jwt.DecodeOptions): TokenPayload;
+    private mergeJwtOptions;
+    private getSecretKey;
+}

package/dist/jwt.service.js

@@ -0,0 +1,123 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JwtService = void 0;
+const common_1 = require("@nestjs/common");
+const jwt = __importStar(require("jsonwebtoken"));
+const jwt_constants_1 = require("./jwt.constants");
+const SIGN_OPTIONS = {
+    algorithm: "RS256",
+    issuer: "auth-service",
+    audience: "gateway-service",
+    keyid: "auth.v1"
+};
+const VERIFY_OPTIONS = {
+    algorithms: ["RS256"],
+    issuer: "auth-service",
+    audience: "gateway-service"
+};
+let JwtService = class JwtService {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    sign(payload, options) {
+        const signOptions = this.mergeJwtOptions({ ...options }, "signOptions");
+        const privateKey = this.getSecretKey(options, "privateKey");
+        if (!privateKey) {
+            throw new Error('"privateKey" must be provided for "sign" function');
+        }
+        return jwt.sign(payload, privateKey, signOptions);
+    }
+    signAsync(payload, options) {
+        const signOptions = this.mergeJwtOptions({ ...options }, "signOptions");
+        const privateKey = this.getSecretKey(options, "privateKey");
+        if (!privateKey) {
+            throw new Error('"privateKey" must be provided for "signAsync" function');
+        }
+        return new Promise((resolve, reject) => jwt.sign(payload, privateKey, signOptions, (err, token) => err ? reject(err) : resolve(token)));
+    }
+    verify(token, options) {
+        const verifyOptions = this.mergeJwtOptions({ ...options }, "verifyOptions");
+        const publicKey = this.getSecretKey(options, "publicKey");
+        if (!publicKey) {
+            throw new Error('"publicKey" must be provided for "verify" function');
+        }
+        return jwt.verify(token, publicKey, verifyOptions);
+    }
+    verifyAsync(token, options) {
+        const verifyOptions = this.mergeJwtOptions({ ...options }, "verifyOptions");
+        const publicKey = this.getSecretKey(options, "publicKey");
+        if (!publicKey) {
+            throw new Error('"publicKey" must be provided for "verifyAsync" function');
+        }
+        return new Promise((resolve, reject) => jwt.verify(token, publicKey, verifyOptions, (err, decoded) => err ? reject(err) : resolve(decoded)));
+    }
+    decode(token, options) {
+        return jwt.decode(token, options);
+    }
+    mergeJwtOptions(options, key) {
+        if (key === "signOptions") {
+            return { ...SIGN_OPTIONS, ...options };
+        }
+        return { ...VERIFY_OPTIONS, ...options };
+    }
+    getSecretKey(options, key) {
+        const secret = (key === "privateKey"
+            ? options?.privateKey || this.options.privateKey
+            : options?.publicKey || this.options.publicKey) ||
+            this.options[key];
+        return secret;
+    }
+};
+exports.JwtService = JwtService;
+exports.JwtService = JwtService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Optional)()),
+    __param(0, (0, common_1.Inject)(jwt_constants_1.JWT_MODULE_OPTIONS)),
+    __metadata("design:paramtypes", [Object])
+], JwtService);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@citec-spbu/jwt",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "Lightweight auth lib",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -16,15 +16,13 @@
   },
   "devDependencies": {
     "@citec-spbu/core": "^1.0.3",
+    "@types/jsonwebtoken": "^9.0.10",
     "@types/node": "^25.0.8",
     "prettier": "^3.7.4",
     "typescript": "^5.9.3"
   },
   "dependencies": {
     "@nestjs/common": "^11.1.12",
-    "@nestjs/core": "^11.1.12",
-    "@nestjs/jwt": "^11.0.2",
-    "reflect-metadata": "^0.2.2",
-    "rxjs": "^7.8.2"
+    "jsonwebtoken": "^9.0.3"
   }
 }

package/dist/consumer.module.d.ts

@@ -1,6 +0,0 @@
-import { DynamicModule } from "@nestjs/common";
-export interface ConsumerModuleOptions {
-    publicKey: string;
-}
-export declare function createConsumerModule(options: ConsumerModuleOptions): DynamicModule;
-export declare function createConsumerModuleAsync(useFactory: (...args: any[]) => Promise<ConsumerModuleOptions> | ConsumerModuleOptions, inject?: any[]): DynamicModule;

package/dist/consumer.module.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createConsumerModule = createConsumerModule;
-exports.createConsumerModuleAsync = createConsumerModuleAsync;
-const jwt_1 = require("@nestjs/jwt");
-const VERIFY_OPTIONS = {
-    algorithms: ["RS256"],
-    issuer: "auth-service",
-    audience: "gateway-service"
-};
-function createConsumerModule(options) {
-    const jwtOptions = {
-        publicKey: options.publicKey,
-        verifyOptions: VERIFY_OPTIONS
-    };
-    return jwt_1.JwtModule.register(jwtOptions);
-}
-function createConsumerModuleAsync(useFactory, inject) {
-    return jwt_1.JwtModule.registerAsync({
-        useFactory: async (...args) => {
-            const options = await useFactory(...args);
-            return {
-                publicKey: options.publicKey,
-                verifyOptions: VERIFY_OPTIONS
-            };
-        },
-        inject: inject || []
-    });
-}

package/dist/issuer.module.d.ts

@@ -1,6 +0,0 @@
-import { DynamicModule } from "@nestjs/common";
-export interface IssuerModuleOptions {
-    privateKey: string;
-}
-export declare function createIssuerModule(options: IssuerModuleOptions): DynamicModule;
-export declare function createIssuerModuleAsync(useFactory: (...args: any[]) => Promise<IssuerModuleOptions> | IssuerModuleOptions, inject?: any[]): DynamicModule;

package/dist/issuer.module.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createIssuerModule = createIssuerModule;
-exports.createIssuerModuleAsync = createIssuerModuleAsync;
-const jwt_1 = require("@nestjs/jwt");
-const SIGN_OPTIONS = {
-    algorithm: "RS256",
-    issuer: "auth-service",
-    audience: "gateway-service",
-    keyid: "auth.v1"
-};
-function createIssuerModule(options) {
-    const jwtOptions = {
-        privateKey: options.privateKey,
-        signOptions: SIGN_OPTIONS
-    };
-    return jwt_1.JwtModule.register(jwtOptions);
-}
-function createIssuerModuleAsync(useFactory, inject) {
-    return jwt_1.JwtModule.registerAsync({
-        useFactory: async (...args) => {
-            const options = await useFactory(...args);
-            return {
-                privateKey: options.privateKey,
-                signOptions: SIGN_OPTIONS
-            };
-        },
-        inject: inject || []
-    });
-}