@nestjs-kitchen/authz 2.0.2 → 2.0.4

package/dist/jwt/jwt-authz.strategy.js

@@ -1,194 +1,134 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+"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 __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-var jwt_authz_strategy_exports = {};
-__export(jwt_authz_strategy_exports, {
-  createJwtStrategy: () => createJwtStrategy,
-  createRefreshStrategy: () => createRefreshStrategy
-});
-module.exports = __toCommonJS(jwt_authz_strategy_exports);
-var import_node_async_hooks = require("node:async_hooks");
-var import_common = require("@nestjs/common");
-var import_passport = require("@nestjs/passport");
-var import_jsonwebtoken = __toESM(require("jsonwebtoken"));
-var import_passport_custom = require("passport-custom");
-var import_authz = require("../authz.provider");
-var import_constants = require("../constants");
-var import_errors = require("../errors");
-var import_utils = require("../utils");
-var import_extract_jwt = require("./extract-jwt");
-function _ts_decorate(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;
-}
-__name(_ts_decorate, "_ts_decorate");
-function _ts_metadata(k, v) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-__name(_ts_metadata, "_ts_metadata");
-function _ts_param(paramIndex, decorator) {
-  return function(target, key) {
-    decorator(target, key, paramIndex);
-  };
-}
-__name(_ts_param, "_ts_param");
-const createJwtStrategy = /* @__PURE__ */ __name(([JWT_STRATEGY, AUTHZ_PROVIDER, ALS_PROVIDER]) => {
-  var _a;
-  let JwtStrategy = (_a = class extends (0, import_passport.PassportStrategy)(import_passport_custom.Strategy, JWT_STRATEGY) {
-    constructor(authzProvider, als) {
-      super();
-      __publicField(this, "authzProvider");
-      __publicField(this, "als");
-      this.authzProvider = authzProvider, this.als = als;
-      if (typeof this.authzProvider.authenticate !== "function") {
-        throw new import_errors.AuthzError(`InternalError: Method 'authenticate' from abstract class 'AuthzProvider' must be implemented.`);
-      }
-    }
-    async validate(req) {
-      const store = (0, import_utils.getAlsStore)(this.als);
-      const authOptions = store.authOptions;
-      if (!authOptions.jwt.verify) {
-        return [
-          null,
-          new import_errors.AuthzError(`InternalError: Refresh verify options must be implemented.`)
-        ];
-      }
-      const extractor = import_extract_jwt.ExtractJwt.fromExtractors(authOptions.jwt.jwtFromRequest);
-      req[import_constants.PASSPORT_PROPERTY] = authOptions.passportProperty;
-      const token = extractor(req);
-      if (!token) {
-        return [
-          null,
-          new import_errors.AuthzAnonymousError("AnonymousError: Cannnot find token.")
-        ];
-      }
-      let user = void 0;
-      try {
-        const payload = import_jsonwebtoken.default.verify(token, authOptions.jwt.secretOrPublicKey, authOptions.jwt.verify);
-        user = await this.authzProvider.authenticate(payload);
-      } catch (error) {
-        return [
-          null,
-          error instanceof Error ? new import_errors.AuthzVerificationError(`${error.name}: ${error.message}`, error) : new import_errors.AuthzVerificationError(`${error}`)
-        ];
-      }
-      store.user = user;
-      store.jwtVerifiedBy = import_constants.JwtValidationType.JWT;
-      if (!user) {
-        return [
-          null,
-          new import_errors.AuthzAnonymousError("AnonymousError: Cannnot find user.")
-        ];
-      }
-      return user;
-    }
-  }, __name(_a, "JwtStrategy"), _a);
-  JwtStrategy = _ts_decorate([
-    _ts_param(0, (0, import_common.Inject)(AUTHZ_PROVIDER)),
-    _ts_param(1, (0, import_common.Inject)(ALS_PROVIDER)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-      typeof import_authz.AuthzProviderClass === "undefined" ? Object : import_authz.AuthzProviderClass,
-      typeof import_node_async_hooks.AsyncLocalStorage === "undefined" ? Object : import_node_async_hooks.AsyncLocalStorage
-    ])
-  ], JwtStrategy);
-  return (0, import_common.mixin)(JwtStrategy);
-}, "createJwtStrategy");
-const createRefreshStrategy = /* @__PURE__ */ __name(([JWT_REFRESH_STRATEGY, AUTHZ_PROVIDER, ALS_PROVIDER]) => {
-  var _a;
-  let RefreshStrategy = (_a = class extends (0, import_passport.PassportStrategy)(import_passport_custom.Strategy, JWT_REFRESH_STRATEGY) {
-    constructor(authzProvider, als) {
-      super();
-      __publicField(this, "authzProvider");
-      __publicField(this, "als");
-      this.authzProvider = authzProvider, this.als = als;
-      if (typeof this.authzProvider.authenticate !== "function") {
-        throw new import_errors.AuthzError(`InternalError: Method 'authenticate' from abstract class 'AuthzProvider' must be implemented.`);
-      }
-    }
-    async validate(req) {
-      const store = (0, import_utils.getAlsStore)(this.als);
-      const authOptions = store.authOptions;
-      if (!authOptions.refresh.verify) {
-        return [
-          null,
-          new import_errors.AuthzError(`InternalError: Refresh verify options must be implemented.`)
-        ];
-      }
-      const extractor = import_extract_jwt.ExtractJwt.fromExtractors(authOptions.refresh.jwtFromRequest);
-      req[import_constants.PASSPORT_PROPERTY] = authOptions.passportProperty;
-      const token = extractor(req);
-      if (!token) {
-        return [
-          null,
-          new import_errors.AuthzAnonymousError("AnonymousError: Cannnot find token.")
-        ];
-      }
-      let user = void 0;
-      try {
-        const payload = import_jsonwebtoken.default.verify(token, authOptions.refresh.secretOrPublicKey, authOptions.refresh.verify);
-        const decodePayload = (0, import_utils.decodeMsgpackrString)(payload.data);
-        user = await this.authzProvider.authenticate(decodePayload);
-      } catch (error) {
-        return [
-          null,
-          error instanceof Error ? new import_errors.AuthzVerificationError(`${error.name}: ${error.message}`, error) : new import_errors.AuthzVerificationError(`${error}`)
-        ];
-      }
-      store.user = user;
-      store.jwtVerifiedBy = import_constants.JwtValidationType.REFRESH;
-      if (!user) {
-        return [
-          null,
-          new import_errors.AuthzAnonymousError("AnonymousError: Cannnot find user.")
-        ];
-      }
-      return user;
-    }
-  }, __name(_a, "RefreshStrategy"), _a);
-  RefreshStrategy = _ts_decorate([
-    (0, import_common.Injectable)(),
-    _ts_param(0, (0, import_common.Inject)(AUTHZ_PROVIDER)),
-    _ts_param(1, (0, import_common.Inject)(ALS_PROVIDER)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-      typeof import_authz.AuthzProviderClass === "undefined" ? Object : import_authz.AuthzProviderClass,
-      typeof import_node_async_hooks.AsyncLocalStorage === "undefined" ? Object : import_node_async_hooks.AsyncLocalStorage
-    ])
-  ], RefreshStrategy);
-  return (0, import_common.mixin)(RefreshStrategy);
-}, "createRefreshStrategy");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createJwtStrategy,
-  createRefreshStrategy
-});
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRefreshStrategy = exports.createJwtStrategy = void 0;
+const node_async_hooks_1 = require("node:async_hooks");
+const common_1 = require("@nestjs/common");
+const passport_1 = require("@nestjs/passport");
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const passport_custom_1 = require("passport-custom");
+const authz_provider_1 = require("../authz.provider");
+const constants_1 = require("../constants");
+const errors_1 = require("../errors");
+const utils_1 = require("../utils");
+const extract_jwt_1 = require("./extract-jwt");
+const createJwtStrategy = ([JWT_STRATEGY, AUTHZ_PROVIDER, ALS_PROVIDER]) => {
+    let JwtStrategy = class JwtStrategy extends (0, passport_1.PassportStrategy)(passport_custom_1.Strategy, JWT_STRATEGY) {
+        constructor(authzProvider, als) {
+            super();
+            this.authzProvider = authzProvider;
+            this.als = als;
+            if (typeof this.authzProvider.authenticate !== 'function') {
+                throw new errors_1.AuthzError(`InternalError: Method 'authenticate' from abstract class 'AuthzProvider' must be implemented.`);
+            }
+        }
+        async validate(req) {
+            const store = (0, utils_1.getAlsStore)(this.als);
+            const authOptions = store.authOptions;
+            if (!authOptions.jwt.verify) {
+                return [null, new errors_1.AuthzError(`InternalError: Refresh verify options must be implemented.`)];
+            }
+            const extractor = extract_jwt_1.ExtractJwt.fromExtractors(authOptions.jwt.jwtFromRequest);
+            req[constants_1.PASSPORT_PROPERTY] = authOptions.passportProperty;
+            const token = extractor(req);
+            if (!token) {
+                return [null, new errors_1.AuthzAnonymousError('AnonymousError: Cannnot find token.')];
+            }
+            let user = undefined;
+            try {
+                const payload = jsonwebtoken_1.default.verify(token, authOptions.jwt.secretOrPublicKey, authOptions.jwt.verify);
+                user = await this.authzProvider.authenticate(payload);
+            }
+            catch (error) {
+                return [
+                    null,
+                    error instanceof Error
+                        ? new errors_1.AuthzVerificationError(`${error.name}: ${error.message}`, error)
+                        : new errors_1.AuthzVerificationError(`${error}`)
+                ];
+            }
+            store.user = user;
+            store.jwtVerifiedBy = constants_1.JwtValidationType.JWT;
+            if (!user) {
+                return [null, new errors_1.AuthzAnonymousError('AnonymousError: Cannnot find user.')];
+            }
+            return user;
+        }
+    };
+    JwtStrategy = __decorate([
+        __param(0, (0, common_1.Inject)(AUTHZ_PROVIDER)),
+        __param(1, (0, common_1.Inject)(ALS_PROVIDER)),
+        __metadata("design:paramtypes", [authz_provider_1.AuthzProviderClass,
+            node_async_hooks_1.AsyncLocalStorage])
+    ], JwtStrategy);
+    return (0, common_1.mixin)(JwtStrategy);
+};
+exports.createJwtStrategy = createJwtStrategy;
+const createRefreshStrategy = ([JWT_REFRESH_STRATEGY, AUTHZ_PROVIDER, ALS_PROVIDER]) => {
+    let RefreshStrategy = class RefreshStrategy extends (0, passport_1.PassportStrategy)(passport_custom_1.Strategy, JWT_REFRESH_STRATEGY) {
+        constructor(authzProvider, als) {
+            super();
+            this.authzProvider = authzProvider;
+            this.als = als;
+            if (typeof this.authzProvider.authenticate !== 'function') {
+                throw new errors_1.AuthzError(`InternalError: Method 'authenticate' from abstract class 'AuthzProvider' must be implemented.`);
+            }
+        }
+        async validate(req) {
+            const store = (0, utils_1.getAlsStore)(this.als);
+            const authOptions = store.authOptions;
+            if (!authOptions.refresh.verify) {
+                return [null, new errors_1.AuthzError(`InternalError: Refresh verify options must be implemented.`)];
+            }
+            const extractor = extract_jwt_1.ExtractJwt.fromExtractors(authOptions.refresh.jwtFromRequest);
+            req[constants_1.PASSPORT_PROPERTY] = authOptions.passportProperty;
+            const token = extractor(req);
+            if (!token) {
+                return [null, new errors_1.AuthzAnonymousError('AnonymousError: Cannnot find token.')];
+            }
+            let user = undefined;
+            try {
+                const payload = jsonwebtoken_1.default.verify(token, authOptions.refresh.secretOrPublicKey, authOptions.refresh.verify);
+                const decodePayload = (0, utils_1.decodeMsgpackrString)(payload.data);
+                user = await this.authzProvider.authenticate(decodePayload);
+            }
+            catch (error) {
+                return [
+                    null,
+                    error instanceof Error
+                        ? new errors_1.AuthzVerificationError(`${error.name}: ${error.message}`, error)
+                        : new errors_1.AuthzVerificationError(`${error}`)
+                ];
+            }
+            store.user = user;
+            store.jwtVerifiedBy = constants_1.JwtValidationType.REFRESH;
+            if (!user) {
+                return [null, new errors_1.AuthzAnonymousError('AnonymousError: Cannnot find user.')];
+            }
+            return user;
+        }
+    };
+    RefreshStrategy = __decorate([
+        (0, common_1.Injectable)(),
+        __param(0, (0, common_1.Inject)(AUTHZ_PROVIDER)),
+        __param(1, (0, common_1.Inject)(ALS_PROVIDER)),
+        __metadata("design:paramtypes", [authz_provider_1.AuthzProviderClass,
+            node_async_hooks_1.AsyncLocalStorage])
+    ], RefreshStrategy);
+    return (0, common_1.mixin)(RefreshStrategy);
+};
+exports.createRefreshStrategy = createRefreshStrategy;

package/dist/session/index.d.ts

@@ -1,12 +1 @@
-export { cereateSessionAuthzModule } from './session-authz.module.js';
-import '@nestjs/core';
-import './session-authz.interface.js';
-import 'express-session';
-import '../utils/types.js';
-import '@nestjs/common';
-import '@nestjs/common/interfaces';
-import 'express';
-import '../authz.provider.js';
-import 'node:async_hooks';
-import '../errors.js';
-import './session-authz-als.middleware.js';
+export { cereateSessionAuthzModule } from './session-authz.module';

package/dist/session/index.js

@@ -1,27 +1,5 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var session_exports = {};
-__export(session_exports, {
-  cereateSessionAuthzModule: () => import_session_authz.cereateSessionAuthzModule
-});
-module.exports = __toCommonJS(session_exports);
-var import_session_authz = require("./session-authz.module");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  cereateSessionAuthzModule
-});
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cereateSessionAuthzModule = void 0;
+var session_authz_module_1 = require("./session-authz.module");
+Object.defineProperty(exports, "cereateSessionAuthzModule", { enumerable: true, get: function () { return session_authz_module_1.cereateSessionAuthzModule; } });

package/dist/session/session-authz-als.middleware.d.ts

@@ -1,13 +1,8 @@
-import * as _nestjs_common from '@nestjs/common';
 import { AsyncLocalStorage } from 'node:async_hooks';
-import { Request, Response, NextFunction } from 'express';
-import { CookieOptionsWithSecret } from '../utils/types.js';
-import { SessionAuthzOptions } from './session-authz.interface.js';
-import '@nestjs/common/interfaces';
-import '../authz.provider.js';
-import 'express-session';
-
-interface SessionAlsType<P, U> {
+import type { NextFunction, Request, Response } from 'express';
+import { type CookieOptionsWithSecret } from '../utils';
+import type { SessionAuthzOptions } from './session-authz.interface';
+export interface SessionAlsType<P, U> {
     user?: U;
     allowAnonymous?: boolean;
     guardResult?: boolean;
@@ -16,10 +11,8 @@ interface SessionAlsType<P, U> {
     logOut: () => Promise<void>;
     setCookie: (name: string, value: string, options?: CookieOptionsWithSecret) => void;
 }
-declare const createSessionAuthzAlsMiddleware: ([ALS_PROVIDER, SESSION_AUTHZ_OPTIONS]: [any, any]) => _nestjs_common.Type<Omit<{
+export declare const createSessionAuthzAlsMiddleware: ([ALS_PROVIDER, SESSION_AUTHZ_OPTIONS]: [any, any]) => import("@nestjs/common").Type<Omit<{
     readonly als: AsyncLocalStorage<SessionAlsType<unknown, unknown>>;
     readonly sessionAuthzOptions: SessionAuthzOptions;
     use(req: Request, res: Response, next: NextFunction): void;
 }, "als" | "sessionAuthzOptions">>;
-
-export { type SessionAlsType, createSessionAuthzAlsMiddleware };