@nestjs-kitchen/authz 2.0.3 → 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,256 +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 __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 __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
 };
-var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
-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");
+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,
+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) => {
+}, (definition, extras) => {
     const { authzProvider, global } = extras;
     if (!authzProvider) {
-      throw new import_errors.AuthzError(`InternalError: Missing parameter 'authzProvider' in configuration.`);
+        throw new errors_1.AuthzError(`InternalError: Missing parameter 'authzProvider' in configuration.`);
     }
-    const routes = (0, import_utils.normalizedArray)(extras.routes) ?? [];
-    const excludes = (0, import_utils.normalizedArray)(extras.excludes) ?? [];
+    const routes = (0, utils_1.normalizedArray)(extras.routes) ?? [];
+    const excludes = (0, utils_1.normalizedArray)(extras.excludes) ?? [];
     if (!global && !routes.length) {
-      throw new import_errors.AuthzError(`InternalError: Missing parameter 'global' or 'routes' in configuration.`);
+        throw new errors_1.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.`
-      );
+        throw new errors_1.AuthzError(`InternalError: Cannot initialize mutiple global modules. Only one global module is allowed.`);
     }
     if (global) {
-      store.globalInited += 1;
+        store.globalInited += 1;
     }
-    return (0, import_utils.mergeDynamicModuleConfigs)(definition, {
-      global,
-      providers: [
-        {
-          provide: import_constants.ROUTES_OPTIONS,
-          useValue: {
-            global,
-            excludes,
-            routes
-          }
-        }
-      ],
-      exports: []
+    return (0, utils_1.mergeDynamicModuleConfigs)(definition, {
+        global,
+        providers: [
+            {
+                provide: constants_1.ROUTES_OPTIONS,
+                useValue: {
+                    global,
+                    excludes,
+                    routes
+                }
+            }
+        ],
+        exports: []
     });
-  }
-).build();
+})
+    .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 = `${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 = () => {
-    return (0, import_common.SetMetadata)(SESSION_META_KEY, {
-      options: { public: true, override: true }
-    });
-  };
-  const Apply = (...rest) => {
-    return (0, import_common.applyDecorators)(SessionAuthzGuard.Verify(...rest), (0, import_common.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]
+    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
     };
-    isStrategyInited = true;
-    return configs;
-  };
-  let SessionAuthzModule = class extends ConfigurableModuleClass {
-    constructor(routesOpt, sessionAuthzOptions) {
-      super();
-      this.routesOpt = routesOpt;
-      this.sessionAuthzOptions = sessionAuthzOptions;
-    }
-    /**
-     * 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
-          }
-        ]
-      });
-    }
-    /**
-     * 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: (moduleOptions) => {
-              return (0, import_session_authz2.normalizedSessionAuthzModuleOptions)(moduleOptions);
-            },
-            inject: [MODULE_OPTIONS_TOKEN]
-          }
-        ]
-      });
-    }
-    configure(consumer) {
-      consumer.apply((0, import_express_session.default)(this.sessionAuthzOptions.session), SessionAuthzAlsMiddleware).exclude(...this.routesOpt.excludes).forRoutes(...this.routesOpt.global ? ["*"] : this.routesOpt.routes);
-    }
-  };
-  SessionAuthzModule = __decorateClass([
-    (0, import_common.Module)({}),
-    __decorateParam(0, (0, import_common.Inject)(import_constants.ROUTES_OPTIONS)),
-    __decorateParam(1, (0, import_common.Inject)(SESSION_AUTHZ_OPTIONS))
-  ], 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
-  };
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  cereateSessionAuthzModule
-});
+exports.cereateSessionAuthzModule = cereateSessionAuthzModule;

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

@@ -1,14 +1,8 @@
-import * as _nestjs_common from '@nestjs/common';
-import { AuthzProviderClass } from '../authz.provider.js';
-import { CookieOptionsWithSecret, DeepReadonly } from '../utils/types.js';
 import { AsyncLocalStorage } from 'node:async_hooks';
-import { SessionAlsType } from './session-authz-als.middleware.js';
-import '@nestjs/common/interfaces';
-import 'express';
-import './session-authz.interface.js';
-import 'express-session';
-
-declare const createSessionAuthzService: <P = unknown, U = unknown>([AUTHZ_PROVIDER, ALS_PROVIDER]: [any, any]) => _nestjs_common.Type<Omit<{
+import { AuthzProviderClass } from '../authz.provider';
+import { type DeepReadonly } from '../utils';
+import type { SessionAlsType } from './session-authz-als.middleware';
+export declare const createSessionAuthzService: <P = unknown, U = unknown>([AUTHZ_PROVIDER, ALS_PROVIDER]: [any, any]) => import("@nestjs/common").Type<Omit<{
     readonly authzProvider: AuthzProviderClass<P, U>;
     readonly als: AsyncLocalStorage<SessionAlsType<P, U>>;
     /**
@@ -24,11 +18,9 @@ declare const createSessionAuthzService: <P = unknown, U = unknown>([AUTHZ_PROVI
     /**
      * Sets a secure HTTP cookie with the given name, value, and optional cookie options.
      */
-    setCookie(name: string, value: string, options?: CookieOptionsWithSecret | undefined): void;
+    setCookie(name: string, value: string, options?: import("../utils").CookieOptionsWithSecret | undefined): void;
     /**
      * Retrieves the current user associated with the request, if available.
      */
     getUser(): DeepReadonly<U> | undefined;
 }, "als" | "authzProvider">>;
-
-export { createSessionAuthzService };