@nestjs-kitchen/authz 2.0.2 → 2.0.4

package/dist/session/session-authz.module.d.ts

@@ -1,21 +1,14 @@
-import * as _nestjs_core from '@nestjs/core';
-import { SessionAuthzOptions, SessionOptions, SessionAuthzModuleOptions } from './session-authz.interface.js';
-import { AuthzProviderClass } from '../authz.provider.js';
-import { AbstractConstructor, RoutesOptions, AuthzModuleBaseOptions, AuthzModuleRoutesOptions, AuthzDecoParams, MethodParameters, ApplyDecorators, CookieOptionsWithSecret, DeepReadonly } from '../utils/types.js';
 import { AsyncLocalStorage } from 'node:async_hooks';
-import * as _nestjs_common from '@nestjs/common';
-import { MiddlewareConsumer, Type, DynamicModule } from '@nestjs/common';
-import { AuthzError } from '../errors.js';
-import { SessionAlsType } from './session-authz-als.middleware.js';
-import 'express-session';
-import '@nestjs/common/interfaces';
-import 'express';
-
-declare const ASYNC_OPTIONS_TYPE: _nestjs_common.ConfigurableModuleAsyncOptions<SessionAuthzModuleOptions, "createSessionAuthzModuleOptions"> & Partial<{
+import { DynamicModule, MiddlewareConsumer, type Type } from '@nestjs/common';
+import { AuthzProviderClass } from '../authz.provider';
+import { AuthzError } from '../errors';
+import { type AbstractConstructor, type AuthzModuleRoutesOptions, type RoutesOptions } from '../utils';
+import { type SessionAlsType } from './session-authz-als.middleware';
+import { type SessionAuthzModuleOptions, type SessionAuthzOptions } from './session-authz.interface';
+declare const ASYNC_OPTIONS_TYPE: import("@nestjs/common").ConfigurableModuleAsyncOptions<SessionAuthzModuleOptions, "createSessionAuthzModuleOptions"> & Partial<{
     authzProvider?: Type<AuthzProviderClass<unknown, unknown>>;
-} & AuthzModuleRoutesOptions>;
-declare const OPTIONS_TYPE: Partial<AuthzModuleBaseOptions> & {
-    session: SessionOptions & {
+} & AuthzModuleRoutesOptions>, OPTIONS_TYPE: Partial<import("../utils").AuthzModuleBaseOptions> & {
+    session: import("./session-authz.interface").SessionOptions & {
         keepSessionInfo?: boolean;
     };
 } & Partial<{
@@ -28,7 +21,7 @@ declare const OPTIONS_TYPE: Partial<AuthzModuleBaseOptions> & {
  * @param authzProvider - The implementation class of `AuthzProviderClass`
  * @returns \{AuthzModule, AuthzGuard, AuthzService}
  */
-declare const cereateSessionAuthzModule: <P, U, T extends AuthzProviderClass<P, U>>(authzProvider: AbstractConstructor<T, P, U>) => {
+export declare const cereateSessionAuthzModule: <P, U, T extends AuthzProviderClass<P, U>>(authzProvider: AbstractConstructor<T, P, U>) => {
     /**
      * A dynamic module used to configure session based authentication and authorization features for the application.
      *
@@ -97,7 +90,7 @@ declare const cereateSessionAuthzModule: <P, U, T extends AuthzProviderClass<P,
      * ```
      */
     AuthzGuard: Type<Omit<{
-        readonly reflector: _nestjs_core.Reflector;
+        readonly reflector: import("@nestjs/core").Reflector;
         readonly authzProvider: AuthzProviderClass<unknown, unknown>;
         readonly sessionAuthzOptions: SessionAuthzOptions;
         readonly als: AsyncLocalStorage<SessionAlsType<unknown, unknown>>;
@@ -106,11 +99,11 @@ declare const cereateSessionAuthzModule: <P, U, T extends AuthzProviderClass<P,
             session: boolean;
         };
         handleRequest<T_1>(_err: unknown, user: T_1, info?: AuthzError): T_1;
-        canActivate(context: _nestjs_common.ExecutionContext): Promise<boolean>;
+        canActivate(context: import("@nestjs/common").ExecutionContext): Promise<boolean>;
         logIn<TRequest extends {
             logIn: Function;
         } = any>(request: TRequest): Promise<void>;
-        getRequest(context: _nestjs_common.ExecutionContext): any;
+        getRequest(context: import("@nestjs/common").ExecutionContext): any;
     }, "als" | "reflector" | "authzProvider" | "sessionAuthzOptions">> & {
         /**
          * Verifies the user's authorization for specific meta data.
@@ -129,7 +122,7 @@ declare const cereateSessionAuthzModule: <P, U, T extends AuthzProviderClass<P,
          * }
          * ```
          */
-        Verify: (...args: AuthzDecoParams<MethodParameters<T, "authorize">[1]>) => ApplyDecorators;
+        Verify: (...args: import("../utils").AuthzDecoParams<import("../utils").MethodParameters<T, "authorize">[1]>) => import("../utils").ApplyDecorators;
         /**
          * Skips authentication & authorization checks for specific routes.
          *
@@ -164,7 +157,7 @@ declare const cereateSessionAuthzModule: <P, U, T extends AuthzProviderClass<P,
          * }
          * ```
          */
-        Apply: (...rest: Parameters<(...args: AuthzDecoParams<MethodParameters<T, "authorize">[1]>) => ApplyDecorators>) => <TFunction extends Function, Y>(target: TFunction | object, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;
+        Apply: (...rest: Parameters<(...args: import("../utils").AuthzDecoParams<import("../utils").MethodParameters<T, "authorize">[1]>) => import("../utils").ApplyDecorators>) => <TFunction extends Function, Y>(target: TFunction | object, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;
     };
     /**
      * A custom servcie to provide methods to handle authentication and authorization.
@@ -174,9 +167,8 @@ declare const cereateSessionAuthzModule: <P, U, T extends AuthzProviderClass<P,
         readonly als: AsyncLocalStorage<SessionAlsType<P, U>>;
         logIn(user: U): Promise<void>;
         logOut(): Promise<void>;
-        setCookie(name: string, value: string, options?: CookieOptionsWithSecret | undefined): void;
-        getUser(): DeepReadonly<U> | undefined;
+        setCookie(name: string, value: string, options?: import("../utils").CookieOptionsWithSecret | undefined): void;
+        getUser(): import("../utils").DeepReadonly<U> | undefined;
     }, "als" | "authzProvider">>;
 };
-
-export { cereateSessionAuthzModule };
+export {};

package/dist/session/session-authz.module.js

@@ -1,299 +1,250 @@
-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 session_authz_module_exports = {};
-__export(session_authz_module_exports, {
-  cereateSessionAuthzModule: () => cereateSessionAuthzModule
-});
-module.exports = __toCommonJS(session_authz_module_exports);
-var import_node_async_hooks = require("node:async_hooks");
-var import_common = require("@nestjs/common");
-var import_express_session = __toESM(require("express-session"));
-var import_uid = require("uid");
-var import_constants = require("../constants");
-var import_errors = require("../errors");
-var import_utils = require("../utils");
-var import_session_authz_als = require("./session-authz-als.middleware");
-var import_session_authz = require("./session-authz.guard");
-var import_session_authz2 = require("./session-authz.interface");
-var import_session_authz3 = require("./session-authz.service");
-var import_session_authz4 = require("./session-authz.strategy");
-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");
+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.cereateSessionAuthzModule = void 0;
+const node_async_hooks_1 = require("node:async_hooks");
+const common_1 = require("@nestjs/common");
+const express_session_1 = __importDefault(require("express-session"));
+const uid_1 = require("uid");
+const constants_1 = require("../constants");
+const errors_1 = require("../errors");
+const utils_1 = require("../utils");
+const session_authz_als_middleware_1 = require("./session-authz-als.middleware");
+const session_authz_guard_1 = require("./session-authz.guard");
+const session_authz_interface_1 = require("./session-authz.interface");
+const session_authz_service_1 = require("./session-authz.service");
+const session_authz_strategy_1 = require("./session-authz.strategy");
 const store = {
-  globalInited: 0
+    globalInited: 0
 };
-const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, ASYNC_OPTIONS_TYPE, OPTIONS_TYPE } = new import_common.ConfigurableModuleBuilder({
-  moduleName: "SessionAuthModule"
-}).setFactoryMethodName("createSessionAuthzModuleOptions").setExtras({
-  authzProvider: void 0,
-  global: false
+const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, ASYNC_OPTIONS_TYPE, OPTIONS_TYPE } = new common_1.ConfigurableModuleBuilder({
+    moduleName: 'SessionAuthModule'
+})
+    .setFactoryMethodName('createSessionAuthzModuleOptions')
+    .setExtras({
+    authzProvider: undefined,
+    global: false
 }, (definition, extras) => {
-  const { authzProvider, global } = extras;
-  if (!authzProvider) {
-    throw new import_errors.AuthzError(`InternalError: Missing parameter 'authzProvider' in configuration.`);
-  }
-  const routes = (0, import_utils.normalizedArray)(extras.routes) ?? [];
-  const excludes = (0, import_utils.normalizedArray)(extras.excludes) ?? [];
-  if (!global && !routes.length) {
-    throw new import_errors.AuthzError(`InternalError: Missing parameter 'global' or 'routes' in configuration.`);
-  }
-  if (store.globalInited) {
-    throw new import_errors.AuthzError(`InternalError: Cannot initialize mutiple global modules. Only one global module is allowed.`);
-  }
-  if (global) {
-    store.globalInited += 1;
-  }
-  return (0, import_utils.mergeDynamicModuleConfigs)(definition, {
-    global,
-    providers: [
-      {
-        provide: import_constants.ROUTES_OPTIONS,
-        useValue: {
-          global,
-          excludes,
-          routes
-        }
-      }
-    ],
-    exports: []
-  });
-}).build();
-const cereateSessionAuthzModule = /* @__PURE__ */ __name((authzProvider) => {
-  var _a;
-  const id = `${import_constants.PREFIX}${(0, import_uid.uid)()}`;
-  const SESSION_STRATEGY = `${id}_SESSION_STRATEGY`;
-  const AUTHZ_PROVIDER = `${id}_AUTHZ_PROVIDER`;
-  const ALS_PROVIDER = `${id}_ALS_PROVIDER`;
-  const SESSION_AUTHZ_OPTIONS = `${id}_SESSION_AUTHZ_OPTIONS`;
-  const SESSION_META_KEY = `${id}_SESSION_META_KEY`;
-  const SessionAuthzStrategy = (0, import_session_authz4.createSessionAuthzStrategy)([
-    SESSION_STRATEGY,
-    AUTHZ_PROVIDER,
-    ALS_PROVIDER
-  ]);
-  const SessionAuthzService = (0, import_session_authz3.createSessionAuthzService)([
-    AUTHZ_PROVIDER,
-    ALS_PROVIDER
-  ]);
-  const SessionAuthzAlsMiddleware = (0, import_session_authz_als.createSessionAuthzAlsMiddleware)([
-    ALS_PROVIDER,
-    SESSION_AUTHZ_OPTIONS
-  ]);
-  const als = new import_node_async_hooks.AsyncLocalStorage();
-  let isStrategyInited = false;
-  const SessionAuthzGuard = (0, import_session_authz.createSessionAuthzGuard)([
-    SESSION_STRATEGY,
-    AUTHZ_PROVIDER,
-    SESSION_AUTHZ_OPTIONS,
-    ALS_PROVIDER,
-    SESSION_META_KEY
-  ]);
-  const Verify = (0, import_utils.createAuthzDecoratorFactory)(SESSION_META_KEY);
-  const NoVerify = /* @__PURE__ */ __name(() => {
-    return (0, import_common.SetMetadata)(SESSION_META_KEY, {
-      options: {
-        public: true,
-        override: true
-      }
-    });
-  }, "NoVerify");
-  const Apply = /* @__PURE__ */ __name((...rest) => {
-    return (0, import_common.applyDecorators)(SessionAuthzGuard.Verify(...rest), (0, import_common.UseGuards)(SessionAuthzGuard));
-  }, "Apply");
-  SessionAuthzGuard.Verify = Verify;
-  SessionAuthzGuard.NoVerify = NoVerify;
-  SessionAuthzGuard.Apply = Apply;
-  const getCommonConfigs = /* @__PURE__ */ __name(() => {
-    const configs = {
-      providers: [
-        {
-          provide: AUTHZ_PROVIDER,
-          useClass: authzProvider
-        },
-        {
-          provide: ALS_PROVIDER,
-          useValue: als
-        },
-        ...!isStrategyInited ? [
-          SessionAuthzStrategy
-        ] : [],
-        SessionAuthzService
-      ],
-      exports: [
-        AUTHZ_PROVIDER,
-        ALS_PROVIDER,
-        SESSION_AUTHZ_OPTIONS,
-        SessionAuthzService
-      ]
-    };
-    isStrategyInited = true;
-    return configs;
-  }, "getCommonConfigs");
-  let SessionAuthzModule = (_a = class extends ConfigurableModuleClass {
-    constructor(routesOpt, sessionAuthzOptions) {
-      super();
-      __publicField(this, "routesOpt");
-      __publicField(this, "sessionAuthzOptions");
-      this.routesOpt = routesOpt, this.sessionAuthzOptions = sessionAuthzOptions;
+    const { authzProvider, global } = extras;
+    if (!authzProvider) {
+        throw new errors_1.AuthzError(`InternalError: Missing parameter 'authzProvider' in configuration.`);
     }
-    /**
-    * Configures authz module.
-    *
-    * Note: DO NOT register the same routes in multiple session authz modules, or import the same session authz module in the same module multiple times, express-session middleware will not work properly.
-    */
-    static register(options) {
-      const sessionAuthzOptions = (0, import_session_authz2.normalizedSessionAuthzModuleOptions)(options);
-      return (0, import_utils.mergeDynamicModuleConfigs)(super.register({
-        ...options,
-        authzProvider
-      }), getCommonConfigs(), {
-        providers: [
-          {
-            provide: SESSION_AUTHZ_OPTIONS,
-            useValue: sessionAuthzOptions
-          }
-        ]
-      });
+    const routes = (0, utils_1.normalizedArray)(extras.routes) ?? [];
+    const excludes = (0, utils_1.normalizedArray)(extras.excludes) ?? [];
+    if (!global && !routes.length) {
+        throw new errors_1.AuthzError(`InternalError: Missing parameter 'global' or 'routes' in configuration.`);
     }
-    /**
-    * Configures authz module asynchronously.
-    *
-    * Note: DO NOT register the same routes in multiple session authz modules, express-session middleware will not work properly.
-    */
-    static registerAsync(options) {
-      return (0, import_utils.mergeDynamicModuleConfigs)(super.registerAsync({
-        ...options,
-        authzProvider
-      }), getCommonConfigs(), {
-        providers: [
-          {
-            provide: SESSION_AUTHZ_OPTIONS,
-            useFactory: /* @__PURE__ */ __name((moduleOptions) => {
-              return (0, import_session_authz2.normalizedSessionAuthzModuleOptions)(moduleOptions);
-            }, "useFactory"),
-            inject: [
-              MODULE_OPTIONS_TOKEN
-            ]
-          }
-        ]
-      });
+    if (store.globalInited) {
+        throw new errors_1.AuthzError(`InternalError: Cannot initialize mutiple global modules. Only one global module is allowed.`);
     }
-    configure(consumer) {
-      consumer.apply((0, import_express_session.default)(this.sessionAuthzOptions.session), SessionAuthzAlsMiddleware).exclude(...this.routesOpt.excludes).forRoutes(...this.routesOpt.global ? [
-        "*"
-      ] : this.routesOpt.routes);
+    if (global) {
+        store.globalInited += 1;
     }
-  }, __name(_a, "SessionAuthzModule"), _a);
-  SessionAuthzModule = _ts_decorate([
-    (0, import_common.Module)({}),
-    _ts_param(0, (0, import_common.Inject)(import_constants.ROUTES_OPTIONS)),
-    _ts_param(1, (0, import_common.Inject)(SESSION_AUTHZ_OPTIONS)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-      typeof RoutesOptions === "undefined" ? Object : RoutesOptions,
-      typeof SessionAuthzOptions === "undefined" ? Object : SessionAuthzOptions
-    ])
-  ], SessionAuthzModule);
-  return {
-    /**
-    * A dynamic module used to configure session based authentication and authorization features for the application.
-    *
-    * This module can be configured using 2 static methods:
-    *
-    * - `register`
-    * - `registerAsync`
-    *
-    * ### Usage
-    *
-    * ```typescript
-    * ⁣@Module({
-    *   imports: [
-    *     // Import and configure session strategy
-    *     AuthzModule.register({
-    *       session: {
-    *         name: 'custom-session-id-name',
-    *         secret: '1234567890'
-    *       },
-    *       // Define routes that use AuthzGuard
-    *       routes: [BusinessController]
-    *     })
-    *   ],
-    *   controllers: [BusinessController]
-    * })
-    * export class BusinessModule {}
-    * ```
-    */
-    AuthzModule: SessionAuthzModule,
-    /**
-    * A custom guard that applies authentication to controllers.
-    *
-    * This guard also provides 3 utility decorators to apply and modify authorization:
-    *
-    * - `@AuthzGuard.Verify`: Used to verify the user's authorization for specific meta data.
-    * - `@AuthzGuard.NoVerify`: Used to `skip` authentication & authorization checks for specific routes.
-    * - `@AuthzGuard.Apply`: A simplified version of `@UseGuards(AuthzGuard)` and `@AuthzGuard.Verify`, combining both for convenience.
-    *
-    * ### Usage:
-    *
-    * ```typescript
-    * ⁣@UseGuards(AuthzGuard)
-    * ⁣@Controller(/⁣/ ...)
-    * export class BusinessController {
-    *   // ...
-    * }
-    * ```
-    */
-    AuthzGuard: SessionAuthzGuard,
-    /**
-    * A custom servcie to provide methods to handle authentication and authorization.
-    */
-    AuthzService: SessionAuthzService
-  };
-}, "cereateSessionAuthzModule");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  cereateSessionAuthzModule
-});
+    return (0, utils_1.mergeDynamicModuleConfigs)(definition, {
+        global,
+        providers: [
+            {
+                provide: constants_1.ROUTES_OPTIONS,
+                useValue: {
+                    global,
+                    excludes,
+                    routes
+                }
+            }
+        ],
+        exports: []
+    });
+})
+    .build();
+/**
+ * Creates a session module along with its associated guard and service,
+ * with types inferred from the provided implementation of `AuthzProviderClass`.
+ *
+ * @param authzProvider - The implementation class of `AuthzProviderClass`
+ * @returns \{AuthzModule, AuthzGuard, AuthzService}
+ */
+const cereateSessionAuthzModule = (authzProvider) => {
+    const id = `${constants_1.PREFIX}${(0, uid_1.uid)()}`;
+    // strategy tokens
+    const SESSION_STRATEGY = `${id}_SESSION_STRATEGY`;
+    // provider tokens
+    const AUTHZ_PROVIDER = `${id}_AUTHZ_PROVIDER`;
+    const ALS_PROVIDER = `${id}_ALS_PROVIDER`;
+    const SESSION_AUTHZ_OPTIONS = `${id}_SESSION_AUTHZ_OPTIONS`;
+    // meta keys
+    const SESSION_META_KEY = `${id}_SESSION_META_KEY`;
+    // strategies
+    const SessionAuthzStrategy = (0, session_authz_strategy_1.createSessionAuthzStrategy)([SESSION_STRATEGY, AUTHZ_PROVIDER, ALS_PROVIDER]);
+    // providers
+    const SessionAuthzService = (0, session_authz_service_1.createSessionAuthzService)([AUTHZ_PROVIDER, ALS_PROVIDER]);
+    const SessionAuthzAlsMiddleware = (0, session_authz_als_middleware_1.createSessionAuthzAlsMiddleware)([ALS_PROVIDER, SESSION_AUTHZ_OPTIONS]);
+    const als = new node_async_hooks_1.AsyncLocalStorage();
+    // each strategy can be only registered once in passport.
+    // no need to provide multiple times as
+    //  1. they use the same ALS and authzProvider instance.
+    //  2. guard use strategy through passport via strategy name.
+    let isStrategyInited = false;
+    // guards
+    const SessionAuthzGuard = (0, session_authz_guard_1.createSessionAuthzGuard)([
+        SESSION_STRATEGY,
+        AUTHZ_PROVIDER,
+        SESSION_AUTHZ_OPTIONS,
+        ALS_PROVIDER,
+        SESSION_META_KEY
+    ]);
+    const Verify = (0, utils_1.createAuthzDecoratorFactory)(SESSION_META_KEY);
+    const NoVerify = () => {
+        return (0, common_1.SetMetadata)(SESSION_META_KEY, {
+            options: { public: true, override: true }
+        });
+    };
+    const Apply = (...rest) => {
+        return (0, common_1.applyDecorators)(SessionAuthzGuard.Verify(...rest), (0, common_1.UseGuards)(SessionAuthzGuard));
+    };
+    SessionAuthzGuard.Verify = Verify;
+    SessionAuthzGuard.NoVerify = NoVerify;
+    SessionAuthzGuard.Apply = Apply;
+    const getCommonConfigs = () => {
+        const configs = {
+            providers: [
+                {
+                    provide: AUTHZ_PROVIDER,
+                    useClass: authzProvider
+                },
+                {
+                    provide: ALS_PROVIDER,
+                    useValue: als
+                },
+                ...(!isStrategyInited ? [SessionAuthzStrategy] : []),
+                SessionAuthzService
+            ],
+            exports: [AUTHZ_PROVIDER, ALS_PROVIDER, SESSION_AUTHZ_OPTIONS, SessionAuthzService]
+        };
+        isStrategyInited = true;
+        return configs;
+    };
+    let SessionAuthzModule = class SessionAuthzModule extends ConfigurableModuleClass {
+        /**
+         * Configures authz module.
+         *
+         * Note: DO NOT register the same routes in multiple session authz modules, or import the same session authz module in the same module multiple times, express-session middleware will not work properly.
+         */
+        static register(options) {
+            const sessionAuthzOptions = (0, session_authz_interface_1.normalizedSessionAuthzModuleOptions)(options);
+            return (0, utils_1.mergeDynamicModuleConfigs)(super.register({ ...options, authzProvider }), getCommonConfigs(), {
+                providers: [
+                    {
+                        provide: SESSION_AUTHZ_OPTIONS,
+                        useValue: sessionAuthzOptions
+                    }
+                ]
+            });
+        }
+        /**
+         * Configures authz module asynchronously.
+         *
+         * Note: DO NOT register the same routes in multiple session authz modules, express-session middleware will not work properly.
+         */
+        static registerAsync(options) {
+            return (0, utils_1.mergeDynamicModuleConfigs)(super.registerAsync({ ...options, authzProvider }), getCommonConfigs(), {
+                providers: [
+                    {
+                        provide: SESSION_AUTHZ_OPTIONS,
+                        useFactory: (moduleOptions) => {
+                            return (0, session_authz_interface_1.normalizedSessionAuthzModuleOptions)(moduleOptions);
+                        },
+                        inject: [MODULE_OPTIONS_TOKEN]
+                    }
+                ]
+            });
+        }
+        constructor(routesOpt, sessionAuthzOptions) {
+            super();
+            this.routesOpt = routesOpt;
+            this.sessionAuthzOptions = sessionAuthzOptions;
+        }
+        configure(consumer) {
+            consumer
+                .apply((0, express_session_1.default)(this.sessionAuthzOptions.session), SessionAuthzAlsMiddleware)
+                .exclude(...this.routesOpt.excludes)
+                // nestjs v11 will be compatible with splat wildcard.
+                .forRoutes(...(this.routesOpt.global ? ['*'] : this.routesOpt.routes));
+        }
+    };
+    SessionAuthzModule = __decorate([
+        (0, common_1.Module)({}),
+        __param(0, (0, common_1.Inject)(constants_1.ROUTES_OPTIONS)),
+        __param(1, (0, common_1.Inject)(SESSION_AUTHZ_OPTIONS)),
+        __metadata("design:paramtypes", [Object, Object])
+    ], SessionAuthzModule);
+    return {
+        /**
+         * A dynamic module used to configure session based authentication and authorization features for the application.
+         *
+         * This module can be configured using 2 static methods:
+         *
+         * - `register`
+         * - `registerAsync`
+         *
+         * ### Usage
+         *
+         * ```typescript
+         * ⁣@Module({
+         *   imports: [
+         *     // Import and configure session strategy
+         *     AuthzModule.register({
+         *       session: {
+         *         name: 'custom-session-id-name',
+         *         secret: '1234567890'
+         *       },
+         *       // Define routes that use AuthzGuard
+         *       routes: [BusinessController]
+         *     })
+         *   ],
+         *   controllers: [BusinessController]
+         * })
+         * export class BusinessModule {}
+         * ```
+         */
+        AuthzModule: SessionAuthzModule,
+        /**
+         * A custom guard that applies authentication to controllers.
+         *
+         * This guard also provides 3 utility decorators to apply and modify authorization:
+         *
+         * - `@AuthzGuard.Verify`: Used to verify the user's authorization for specific meta data.
+         * - `@AuthzGuard.NoVerify`: Used to `skip` authentication & authorization checks for specific routes.
+         * - `@AuthzGuard.Apply`: A simplified version of `@UseGuards(AuthzGuard)` and `@AuthzGuard.Verify`, combining both for convenience.
+         *
+         * ### Usage:
+         *
+         * ```typescript
+         * ⁣@UseGuards(AuthzGuard)
+         * ⁣@Controller(/⁣/ ...)
+         * export class BusinessController {
+         *   // ...
+         * }
+         * ```
+         */
+        AuthzGuard: SessionAuthzGuard,
+        /**
+         * A custom servcie to provide methods to handle authentication and authorization.
+         */
+        AuthzService: SessionAuthzService
+    };
+};
+exports.cereateSessionAuthzModule = cereateSessionAuthzModule;