@nestjs-kitchen/authz 1.0.0

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

@@ -0,0 +1,245 @@
+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 });
+};
+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 __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");
+const store = {
+  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
+}, (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;
+    }
+    /**
+    * Note: DO NOT register the same route 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
+          }
+        ]
+      });
+    }
+    /**
+    * Note: DO NOT register the same route 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
+            ]
+          }
+        ]
+      });
+    }
+    configure(consumer) {
+      consumer.apply((0, import_express_session.default)(this.sessionAuthzOptions.session), SessionAuthzAlsMiddleware).exclude(...this.routesOpt.excludes).forRoutes(...this.routesOpt.global ? [
+        "*"
+      ] : this.routesOpt.routes);
+    }
+  }, __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 {
+    AuthzModule: SessionAuthzModule,
+    AuthzGuard: SessionAuthzGuard,
+    AuthzService: SessionAuthzService
+  };
+}, "cereateSessionAuthzModule");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cereateSessionAuthzModule
+});

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

@@ -0,0 +1,20 @@
+import * as _nestjs_common from '@nestjs/common';
+import { AuthzProviderClass } from '../authz.provider.js';
+import { CookieOptionsWithSecret } 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<{
+    readonly authzProvider: AuthzProviderClass<P, U>;
+    readonly als: AsyncLocalStorage<SessionAlsType<P, U>>;
+    logIn(user: U): Promise<void>;
+    logOut(): Promise<void>;
+    setCookie(name: string, value: string, options?: CookieOptionsWithSecret | undefined): void;
+    getUser(): U | undefined;
+}, "als" | "authzProvider">>;
+
+export { createSessionAuthzService };

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

@@ -0,0 +1,93 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 });
+};
+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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var session_authz_service_exports = {};
+__export(session_authz_service_exports, {
+  createSessionAuthzService: () => createSessionAuthzService
+});
+module.exports = __toCommonJS(session_authz_service_exports);
+var import_node_async_hooks = require("node:async_hooks");
+var import_common = require("@nestjs/common");
+var import_authz = require("../authz.provider");
+var import_errors = require("../errors");
+var import_utils = require("../utils");
+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 createSessionAuthzService = /* @__PURE__ */ __name(([AUTHZ_PROVIDER, ALS_PROVIDER]) => {
+  var _a;
+  let SessionAuthzService = (_a = class {
+    constructor(authzProvider, als) {
+      __publicField(this, "authzProvider");
+      __publicField(this, "als");
+      this.authzProvider = authzProvider;
+      this.als = als;
+      if (typeof this.authzProvider.createPayload !== "function") {
+        throw new import_errors.AuthzError(`InternalError: Method 'createPayload' from abstract class 'AuthzProvider' must be implemented.`);
+      }
+    }
+    async logIn(user) {
+      const store = (0, import_utils.getAlsStore)(this.als);
+      const payload = await this.authzProvider.createPayload(user);
+      return store.logIn(payload);
+    }
+    async logOut() {
+      const store = (0, import_utils.getAlsStore)(this.als);
+      return store.logOut();
+    }
+    setCookie(...rest) {
+      const store = (0, import_utils.getAlsStore)(this.als);
+      store.setCookie(...rest);
+    }
+    getUser() {
+      const store = (0, import_utils.getAlsStore)(this.als);
+      const user = store.user;
+      return user;
+    }
+  }, __name(_a, "SessionAuthzService"), _a);
+  SessionAuthzService = _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
+    ])
+  ], SessionAuthzService);
+  return (0, import_common.mixin)(SessionAuthzService);
+}, "createSessionAuthzService");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createSessionAuthzService
+});

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

@@ -0,0 +1,24 @@
+import * as _nestjs_common from '@nestjs/common';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { Request } from 'express';
+import { AuthzProviderClass } from '../authz.provider.js';
+import { SessionAlsType } from './session-authz-als.middleware.js';
+import '../utils/types.js';
+import '@nestjs/common/interfaces';
+import './session-authz.interface.js';
+import 'express-session';
+
+declare const createSessionAuthzStrategy: ([SESSION_STRATEGY, AUTHZ_PROVIDER, ALS_PROVIDER]: [string, any, any]) => _nestjs_common.Type<Omit<{
+    readonly authzProvider: AuthzProviderClass<unknown, unknown>;
+    readonly als: AsyncLocalStorage<SessionAlsType<unknown, unknown>>;
+    validate(req: Request): Promise<{}>;
+    authenticate(req: Request, options?: any): any;
+    success(user: any, info?: any): void;
+    fail(challenge: any, status: number): void;
+    fail(status: number): void;
+    redirect(url: string, status?: number): void;
+    pass(): void;
+    error(err: Error): void;
+}, "als" | "authzProvider">>;
+
+export { createSessionAuthzStrategy };

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

@@ -0,0 +1,107 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 });
+};
+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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var session_authz_strategy_exports = {};
+__export(session_authz_strategy_exports, {
+  createSessionAuthzStrategy: () => createSessionAuthzStrategy
+});
+module.exports = __toCommonJS(session_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_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");
+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 createSessionAuthzStrategy = /* @__PURE__ */ __name(([SESSION_STRATEGY, AUTHZ_PROVIDER, ALS_PROVIDER]) => {
+  var _a;
+  let SessionAuthzStrategy = (_a = class extends (0, import_passport.PassportStrategy)(import_passport_custom.Strategy, SESSION_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;
+      req[import_constants.PASSPORT_PROPERTY] = authOptions.passportProperty;
+      const payload = req?.session?.[import_constants.SESSION_PASSPORT_KEY]?.user;
+      if (!payload) {
+        return [
+          null,
+          new import_errors.AuthzAnonymousError("AnonymousError: Cannnot find session.")
+        ];
+      }
+      let user = void 0;
+      try {
+        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;
+      if (!user) {
+        return [
+          null,
+          new import_errors.AuthzAnonymousError("AnonymousError: Cannnot find user.")
+        ];
+      }
+      return user;
+    }
+  }, __name(_a, "SessionAuthzStrategy"), _a);
+  SessionAuthzStrategy = _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
+    ])
+  ], SessionAuthzStrategy);
+  return (0, import_common.mixin)(SessionAuthzStrategy);
+}, "createSessionAuthzStrategy");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createSessionAuthzStrategy
+});

package/dist/user.decorator.d.ts

@@ -0,0 +1,6 @@
+import { ExecutionContext } from '@nestjs/common';
+
+declare const userDecoratorFactory: (_data: unknown, ctx: ExecutionContext) => unknown;
+declare const User: (...dataOrPipes: unknown[]) => ParameterDecorator;
+
+export { User, userDecoratorFactory };

package/dist/user.decorator.js

@@ -0,0 +1,36 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 });
+};
+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 user_decorator_exports = {};
+__export(user_decorator_exports, {
+  User: () => User,
+  userDecoratorFactory: () => userDecoratorFactory
+});
+module.exports = __toCommonJS(user_decorator_exports);
+var import_common = require("@nestjs/common");
+var import_utils = require("./utils");
+const userDecoratorFactory = /* @__PURE__ */ __name((_data, ctx) => {
+  const request = ctx.switchToHttp().getRequest();
+  return (0, import_utils.getPassportProperty)(request);
+}, "userDecoratorFactory");
+const User = (0, import_common.createParamDecorator)(userDecoratorFactory);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  User,
+  userDecoratorFactory
+});

package/dist/utils/cookie-parsers.d.ts

@@ -0,0 +1,12 @@
+import { Request } from 'express';
+
+declare const normalCookieParser: (req: Request, _secrets?: string[], decode?: (str: string) => string | undefined) => {
+    cookies: Record<string, any>;
+    signedCookies: Record<string, any>;
+};
+declare const customCookieParser: (req: Request, secrets?: string[], decode?: (str: string) => string | undefined) => {
+    cookies: Record<string, any>;
+    signedCookies: Record<string, any>;
+};
+
+export { customCookieParser, normalCookieParser };

package/dist/utils/cookie-parsers.js

@@ -0,0 +1,77 @@
+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 __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 });
+};
+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 __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 cookie_parsers_exports = {};
+__export(cookie_parsers_exports, {
+  customCookieParser: () => customCookieParser,
+  normalCookieParser: () => normalCookieParser
+});
+module.exports = __toCommonJS(cookie_parsers_exports);
+var cookie = __toESM(require("cookie"));
+var import_cookie_parser = __toESM(require("cookie-parser"));
+const normalCookieParser = /* @__PURE__ */ __name((req, _secrets = [], decode) => {
+  let cookies = req.cookies || {};
+  let signedCookies = req.signedCookies || {};
+  if (!req.cookies && req.headers.cookie) {
+    const parsedCookies = cookie.parse(req.headers.cookie, {
+      decode
+    });
+    if (req.secret) {
+      signedCookies = import_cookie_parser.default.JSONCookies(import_cookie_parser.default.signedCookies(parsedCookies, [
+        req.secret
+      ]));
+    }
+    cookies = import_cookie_parser.default.JSONCookies(parsedCookies);
+  }
+  return {
+    cookies,
+    signedCookies
+  };
+}, "normalCookieParser");
+const customCookieParser = /* @__PURE__ */ __name((req, secrets = [], decode) => {
+  let cookies = {};
+  let signedCookies = {};
+  if (req.headers.cookie) {
+    const parsedCookies = cookie.parse(req.headers.cookie, {
+      decode
+    });
+    if (secrets.length) {
+      signedCookies = import_cookie_parser.default.JSONCookies(import_cookie_parser.default.signedCookies(parsedCookies, secrets));
+    }
+    cookies = import_cookie_parser.default.JSONCookies(parsedCookies);
+  }
+  return {
+    cookies,
+    signedCookies
+  };
+}, "customCookieParser");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  customCookieParser,
+  normalCookieParser
+});

package/dist/utils/create-authz-decorator-factory.d.ts

@@ -0,0 +1,9 @@
+import { AuthzProviderClass } from '../authz.provider.js';
+import { AuthzDecoParams, MethodParameters, ApplyDecorators } from './types.js';
+import '@nestjs/common';
+import '@nestjs/common/interfaces';
+import 'express';
+
+declare const createAuthzDecoratorFactory: <T extends AuthzProviderClass<unknown, unknown>>(metaKey: string | Symbol) => (...args: AuthzDecoParams<MethodParameters<T, "authorize">[1]>) => ApplyDecorators;
+
+export { createAuthzDecoratorFactory };