@nestjs-kitchen/authz 1.0.0

package/dist/authz.provider.d.ts

@@ -0,0 +1,7 @@
+declare abstract class AuthzProviderClass<Payload, User> {
+    abstract createPayload(user: User): Payload | Promise<Payload>;
+    abstract authenticate(payload: Payload): User | Promise<User>;
+    authorize(_uesr: User, _metaData?: unknown): boolean | Promise<boolean>;
+}
+
+export { AuthzProviderClass };

package/dist/authz.provider.js

@@ -0,0 +1,34 @@
+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 authz_provider_exports = {};
+__export(authz_provider_exports, {
+  AuthzProviderClass: () => AuthzProviderClass
+});
+module.exports = __toCommonJS(authz_provider_exports);
+const _AuthzProviderClass = class _AuthzProviderClass {
+  authorize(_uesr, _metaData) {
+    return true;
+  }
+};
+__name(_AuthzProviderClass, "AuthzProviderClass");
+let AuthzProviderClass = _AuthzProviderClass;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthzProviderClass
+});

package/dist/constants.d.ts

@@ -0,0 +1,11 @@
+declare const DEFAULT_PASSPORT_PROPERTY_VALUE = "user";
+declare const PASSPORT_PROPERTY: unique symbol;
+declare const PREFIX = "`<`:";
+declare const ROUTES_OPTIONS: unique symbol;
+declare enum JwtValidationType {
+    JWT = 0,
+    REFRESH = 1
+}
+declare const SESSION_PASSPORT_KEY = "passport";
+
+export { DEFAULT_PASSPORT_PROPERTY_VALUE, JwtValidationType, PASSPORT_PROPERTY, PREFIX, ROUTES_OPTIONS, SESSION_PASSPORT_KEY };

package/dist/constants.js

@@ -0,0 +1,46 @@
+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 constants_exports = {};
+__export(constants_exports, {
+  DEFAULT_PASSPORT_PROPERTY_VALUE: () => DEFAULT_PASSPORT_PROPERTY_VALUE,
+  JwtValidationType: () => JwtValidationType,
+  PASSPORT_PROPERTY: () => PASSPORT_PROPERTY,
+  PREFIX: () => PREFIX,
+  ROUTES_OPTIONS: () => ROUTES_OPTIONS,
+  SESSION_PASSPORT_KEY: () => SESSION_PASSPORT_KEY
+});
+module.exports = __toCommonJS(constants_exports);
+const DEFAULT_PASSPORT_PROPERTY_VALUE = "user";
+const PASSPORT_PROPERTY = Symbol("PASSPORT_PROPERTY");
+const PREFIX = "`<`:";
+const ROUTES_OPTIONS = Symbol("ROUTES_OPTIONS");
+var JwtValidationType = /* @__PURE__ */ function(JwtValidationType2) {
+  JwtValidationType2[JwtValidationType2["JWT"] = 0] = "JWT";
+  JwtValidationType2[JwtValidationType2["REFRESH"] = 1] = "REFRESH";
+  return JwtValidationType2;
+}({});
+const SESSION_PASSPORT_KEY = "passport";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_PASSPORT_PROPERTY_VALUE,
+  JwtValidationType,
+  PASSPORT_PROPERTY,
+  PREFIX,
+  ROUTES_OPTIONS,
+  SESSION_PASSPORT_KEY
+});

package/dist/errors.d.ts

@@ -0,0 +1,12 @@
+declare class AuthzError extends Error {
+    cause?: unknown;
+    constructor(message?: string, cause?: unknown);
+}
+declare class AuthzVerificationError extends AuthzError {
+    constructor(message?: string, cause?: unknown);
+}
+declare class AuthzAnonymousError extends AuthzError {
+    constructor(message?: string, cause?: unknown);
+}
+
+export { AuthzAnonymousError, AuthzError, AuthzVerificationError };

package/dist/errors.js

@@ -0,0 +1,60 @@
+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 errors_exports = {};
+__export(errors_exports, {
+  AuthzAnonymousError: () => AuthzAnonymousError,
+  AuthzError: () => AuthzError,
+  AuthzVerificationError: () => AuthzVerificationError
+});
+module.exports = __toCommonJS(errors_exports);
+const _AuthzError = class _AuthzError extends Error {
+  constructor(message, cause) {
+    super(message);
+    __publicField(this, "cause");
+    this.name = "AuthzError";
+    this.cause = cause;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+__name(_AuthzError, "AuthzError");
+let AuthzError = _AuthzError;
+const _AuthzVerificationError = class _AuthzVerificationError extends AuthzError {
+  constructor(message, cause) {
+    super(message, cause);
+    this.name = "AuthzVerificationError";
+  }
+};
+__name(_AuthzVerificationError, "AuthzVerificationError");
+let AuthzVerificationError = _AuthzVerificationError;
+const _AuthzAnonymousError = class _AuthzAnonymousError extends AuthzError {
+  constructor(message, cause) {
+    super(message, cause);
+    this.name = "AuthzAnonymousError";
+  }
+};
+__name(_AuthzAnonymousError, "AuthzAnonymousError");
+let AuthzAnonymousError = _AuthzAnonymousError;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthzAnonymousError,
+  AuthzError,
+  AuthzVerificationError
+});

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+export { AuthzProviderClass } from './authz.provider.js';
+export { User } from './user.decorator.js';
+export { AuthzError, AuthzVerificationError } from './errors.js';
+export { ExtractJwt, JwtFromRequestFunction } from './jwt/extract-jwt.js';
+export { createJwtAuthzModule } from './jwt/jwt-authz.module.js';
+export { cereateSessionAuthzModule } from './session/session-authz.module.js';
+import '@nestjs/common';
+import 'cookie';
+import '@nestjs/core';
+import './jwt/jwt-authz.interface.js';
+import 'crypto';
+import 'jsonwebtoken';
+import './utils/types.js';
+import '@nestjs/common/interfaces';
+import 'express';
+import 'node:async_hooks';
+import './jwt/jwt-authz-als.middleware.js';
+import './constants.js';
+import 'express-session';
+import './session/session-authz-als.middleware.js';
+import './session/session-authz.interface.js';

package/dist/index.js

@@ -0,0 +1,43 @@
+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 src_exports = {};
+__export(src_exports, {
+  AuthzError: () => import_errors.AuthzError,
+  AuthzProviderClass: () => import_authz.AuthzProviderClass,
+  AuthzVerificationError: () => import_errors.AuthzVerificationError,
+  ExtractJwt: () => import_jwt.ExtractJwt,
+  User: () => import_user.User,
+  cereateSessionAuthzModule: () => import_session.cereateSessionAuthzModule,
+  createJwtAuthzModule: () => import_jwt.createJwtAuthzModule
+});
+module.exports = __toCommonJS(src_exports);
+var import_authz = require("./authz.provider");
+var import_user = require("./user.decorator");
+var import_errors = require("./errors");
+var import_jwt = require("./jwt");
+var import_session = require("./session");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthzError,
+  AuthzProviderClass,
+  AuthzVerificationError,
+  ExtractJwt,
+  User,
+  cereateSessionAuthzModule,
+  createJwtAuthzModule
+});

package/dist/jwt/extract-jwt.d.ts

@@ -0,0 +1,71 @@
+import { ParseOptions } from 'cookie';
+
+declare const parseAuthHeader: (hdrValue: unknown) => {
+    scheme: string;
+    value: string;
+} | null;
+interface JwtFromRequestFunction<T = any> {
+    (req: T): string | null;
+}
+declare const ExtractJwt: {
+    /**
+     * Creates an extractor function to retrieve a token from the request header.
+     *
+     * @param {string} header_name - The name of the header to extract the token from.
+     * @returns {JwtFromRequestFunction} A function that takes a request object and returns the extracted token.
+     */
+    fromHeader: (header_name: string) => JwtFromRequestFunction;
+    /**
+     * Creates an extractor function to retrieve a token from a field in the request body.
+     *
+     * @param {string} field_name - The name of the field to extract the token from.
+     * @returns {JwtFromRequestFunction} A function that takes a request object and returns the extracted token.
+     */
+    fromBodyField: (field_name: string) => JwtFromRequestFunction;
+    /**
+     * Creates an extractor function to retrieve a token from a query parameter in the URL.
+     *
+     * @param {string} param_name - The name of the query parameter to extract the token from.
+     * @returns {JwtFromRequestFunction} A function that takes a request object and returns the extracted token.
+     */
+    fromUrlQueryParameter: (param_name: string) => JwtFromRequestFunction;
+    /**
+     * Creates an extractor function to retrieve a token from the authorization header with a specific scheme.
+     *
+     * @param {string} auth_scheme - The authorization scheme (e.g., 'Bearer').
+     * @returns {JwtFromRequestFunction} A function that takes a request object and returns the extracted token.
+     */
+    fromAuthHeaderWithScheme: (auth_scheme: string) => JwtFromRequestFunction;
+    /**
+     * Creates an extractor function to retrieve a token from the authorization header as a Bearer token.
+     *
+     * @returns {JwtFromRequestFunction} A function that takes a request object and returns the extracted token.
+     */
+    fromAuthHeaderAsBearerToken: () => JwtFromRequestFunction;
+    /**
+     * Creates an extractor function to retrieve a token from the request header. Respects cookie-parser middleware if applied.
+     *
+     * @param cookie_name - The name of the cookie to extract the token from.
+     * @param options - Options to parse request cookie header.
+     * @returns A function that takes a request object and returns the extracted token.
+     */
+    fromCookies: (cookie_name: string, options?: {
+        /**
+         * a string or array used for parsing signed cookies.
+         */
+        secret?: string | string[];
+        /**
+         * Extract token from signed cookie. Default to true if secret was provided.
+         */
+        signed?: boolean;
+    } & ParseOptions) => JwtFromRequestFunction;
+    /**
+     * Creates an extractor function that combines multiple extractor functions.
+     *
+     * @param {JwtFromRequestFunction[]} extractors - An array of extractor functions.
+     * @returns {JwtFromRequestFunction} A function that takes a request object and returns the extracted token.
+     */
+    fromExtractors: (extractors: JwtFromRequestFunction[]) => JwtFromRequestFunction;
+};
+
+export { ExtractJwt, type JwtFromRequestFunction, parseAuthHeader };

package/dist/jwt/extract-jwt.js

@@ -0,0 +1,162 @@
+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 extract_jwt_exports = {};
+__export(extract_jwt_exports, {
+  ExtractJwt: () => ExtractJwt,
+  parseAuthHeader: () => parseAuthHeader
+});
+module.exports = __toCommonJS(extract_jwt_exports);
+var import_node_url = require("node:url");
+var import_utils = require("../utils");
+const re = /(\S+)\s+(\S+)/;
+const parseAuthHeader = /* @__PURE__ */ __name((hdrValue) => {
+  if (typeof hdrValue !== "string") {
+    return null;
+  }
+  var matches = hdrValue.match(re);
+  return matches && {
+    scheme: matches[1],
+    value: matches[2]
+  };
+}, "parseAuthHeader");
+const AUTH_HEADER = "authorization";
+const BEARER_AUTH_SCHEME = "bearer";
+const ExtractJwt = {
+  /**
+  * Creates an extractor function to retrieve a token from the request header.
+  *
+  * @param {string} header_name - The name of the header to extract the token from.
+  * @returns {JwtFromRequestFunction} A function that takes a request object and returns the extracted token.
+  */
+  fromHeader: /* @__PURE__ */ __name((header_name) => {
+    return function(request) {
+      let token = null;
+      if (request.headers[header_name]) {
+        token = request.headers[header_name];
+      }
+      return token;
+    };
+  }, "fromHeader"),
+  /**
+  * Creates an extractor function to retrieve a token from a field in the request body.
+  *
+  * @param {string} field_name - The name of the field to extract the token from.
+  * @returns {JwtFromRequestFunction} A function that takes a request object and returns the extracted token.
+  */
+  fromBodyField: /* @__PURE__ */ __name((field_name) => {
+    return function(request) {
+      let token = null;
+      if (request.body && Object.prototype.hasOwnProperty.call(request.body, field_name)) {
+        token = request.body[field_name];
+      }
+      return token;
+    };
+  }, "fromBodyField"),
+  /**
+  * Creates an extractor function to retrieve a token from a query parameter in the URL.
+  *
+  * @param {string} param_name - The name of the query parameter to extract the token from.
+  * @returns {JwtFromRequestFunction} A function that takes a request object and returns the extracted token.
+  */
+  fromUrlQueryParameter: /* @__PURE__ */ __name((param_name) => {
+    return function(request) {
+      let token = null;
+      const parsed_url = (0, import_node_url.parse)(request.url, true);
+      if (parsed_url.query && Object.prototype.hasOwnProperty.call(parsed_url.query, param_name)) {
+        token = parsed_url.query[param_name];
+      }
+      return token;
+    };
+  }, "fromUrlQueryParameter"),
+  /**
+  * Creates an extractor function to retrieve a token from the authorization header with a specific scheme.
+  *
+  * @param {string} auth_scheme - The authorization scheme (e.g., 'Bearer').
+  * @returns {JwtFromRequestFunction} A function that takes a request object and returns the extracted token.
+  */
+  fromAuthHeaderWithScheme: /* @__PURE__ */ __name((auth_scheme) => {
+    var auth_scheme_lower = auth_scheme.toLowerCase();
+    return function(request) {
+      let token = null;
+      if (request.headers[AUTH_HEADER]) {
+        var auth_params = parseAuthHeader(request.headers[AUTH_HEADER]);
+        if (auth_params && auth_scheme_lower === auth_params.scheme.toLowerCase()) {
+          token = auth_params.value;
+        }
+      }
+      return token;
+    };
+  }, "fromAuthHeaderWithScheme"),
+  /**
+  * Creates an extractor function to retrieve a token from the authorization header as a Bearer token.
+  *
+  * @returns {JwtFromRequestFunction} A function that takes a request object and returns the extracted token.
+  */
+  fromAuthHeaderAsBearerToken: /* @__PURE__ */ __name(() => {
+    return ExtractJwt.fromAuthHeaderWithScheme(BEARER_AUTH_SCHEME);
+  }, "fromAuthHeaderAsBearerToken"),
+  /**
+  * Creates an extractor function to retrieve a token from the request header. Respects cookie-parser middleware if applied.
+  *
+  * @param cookie_name - The name of the cookie to extract the token from.
+  * @param options - Options to parse request cookie header.
+  * @returns A function that takes a request object and returns the extracted token.
+  */
+  fromCookies: /* @__PURE__ */ __name((cookie_name, options) => {
+    const cookie_name_lower = cookie_name.toLowerCase();
+    const { secret, decode } = options ?? {};
+    const secrets = (0, import_utils.normalizedArray)(secret) ?? [];
+    const signed = options?.signed ?? Boolean(secrets.length);
+    const targetParser = Boolean(secrets.length) ? import_utils.customCookieParser : import_utils.normalCookieParser;
+    return (req) => {
+      const { cookies, signedCookies } = targetParser(req, secrets, decode);
+      let token = null;
+      const targetCookies = signed ? signedCookies : cookies;
+      if (targetCookies[cookie_name_lower]) {
+        token = targetCookies[cookie_name_lower];
+      }
+      return token;
+    };
+  }, "fromCookies"),
+  /**
+  * Creates an extractor function that combines multiple extractor functions.
+  *
+  * @param {JwtFromRequestFunction[]} extractors - An array of extractor functions.
+  * @returns {JwtFromRequestFunction} A function that takes a request object and returns the extracted token.
+  */
+  fromExtractors: /* @__PURE__ */ __name((extractors) => {
+    if (!Array.isArray(extractors)) {
+      throw new TypeError("extractors.fromExtractors expects an array");
+    }
+    return function(request) {
+      let token = null;
+      let index = 0;
+      while (!token && index < extractors.length) {
+        token = extractors[index].call(this, request);
+        index++;
+      }
+      return token;
+    };
+  }, "fromExtractors")
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ExtractJwt,
+  parseAuthHeader
+});

package/dist/jwt/index.d.ts

@@ -0,0 +1,16 @@
+export { ExtractJwt, JwtFromRequestFunction } from './extract-jwt.js';
+export { createJwtAuthzModule } from './jwt-authz.module.js';
+import 'cookie';
+import '@nestjs/core';
+import './jwt-authz.interface.js';
+import 'crypto';
+import 'jsonwebtoken';
+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 './jwt-authz-als.middleware.js';
+import '../constants.js';

package/dist/jwt/index.js

@@ -0,0 +1,30 @@
+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 jwt_exports = {};
+__export(jwt_exports, {
+  ExtractJwt: () => import_extract_jwt.ExtractJwt,
+  createJwtAuthzModule: () => import_jwt_authz.createJwtAuthzModule
+});
+module.exports = __toCommonJS(jwt_exports);
+var import_extract_jwt = require("./extract-jwt");
+var import_jwt_authz = require("./jwt-authz.module");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ExtractJwt,
+  createJwtAuthzModule
+});

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

@@ -0,0 +1,28 @@
+import * as _nestjs_common from '@nestjs/common';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { Request, Response, NextFunction } from 'express';
+import { JwtValidationType } from '../constants.js';
+import { CookieOptionsWithSecret } from '../utils/types.js';
+import { JwtAuthzOptions } from './jwt-authz.interface.js';
+import '@nestjs/common/interfaces';
+import '../authz.provider.js';
+import 'crypto';
+import 'jsonwebtoken';
+import './extract-jwt.js';
+import 'cookie';
+
+interface JwtAlsType<U> {
+    user?: U;
+    jwtVerifiedBy?: JwtValidationType;
+    allowAnonymous?: boolean;
+    guardResult?: boolean;
+    authOptions: JwtAuthzOptions;
+    setCookie: (name: string, value: string, options?: CookieOptionsWithSecret) => void;
+}
+declare const createJwtAuthzAlsMiddleware: ([ALS_PROVIDER, JWT_AUTHZ_OPTIONS]: [any, any]) => _nestjs_common.Type<Omit<{
+    readonly als: AsyncLocalStorage<JwtAlsType<unknown>>;
+    readonly jwtAuthzOptions: JwtAuthzOptions;
+    use(req: Request, res: Response, next: NextFunction): void;
+}, "als" | "jwtAuthzOptions">>;
+
+export { type JwtAlsType, createJwtAuthzAlsMiddleware };

package/dist/jwt/jwt-authz-als.middleware.js

@@ -0,0 +1,83 @@
+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 jwt_authz_als_middleware_exports = {};
+__export(jwt_authz_als_middleware_exports, {
+  createJwtAuthzAlsMiddleware: () => createJwtAuthzAlsMiddleware
+});
+module.exports = __toCommonJS(jwt_authz_als_middleware_exports);
+var import_node_async_hooks = require("node:async_hooks");
+var import_common = require("@nestjs/common");
+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 createJwtAuthzAlsMiddleware = /* @__PURE__ */ __name(([ALS_PROVIDER, JWT_AUTHZ_OPTIONS]) => {
+  var _a;
+  let JwtAuthzAlsMiddleware = (_a = class {
+    constructor(als, jwtAuthzOptions) {
+      __publicField(this, "als");
+      __publicField(this, "jwtAuthzOptions");
+      this.als = als;
+      this.jwtAuthzOptions = jwtAuthzOptions;
+    }
+    use(req, res, next) {
+      this.als.run({
+        user: void 0,
+        jwtVerifiedBy: void 0,
+        allowAnonymous: void 0,
+        guardResult: void 0,
+        // a workaround to pass jwtAuthzOptions to passport strategy.
+        authOptions: this.jwtAuthzOptions,
+        setCookie: (0, import_utils.createSetCookieFn)(req, res)
+      }, () => {
+        next();
+      });
+    }
+  }, __name(_a, "JwtAuthzAlsMiddleware"), _a);
+  JwtAuthzAlsMiddleware = _ts_decorate([
+    _ts_param(0, (0, import_common.Inject)(ALS_PROVIDER)),
+    _ts_param(1, (0, import_common.Inject)(JWT_AUTHZ_OPTIONS)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+      typeof import_node_async_hooks.AsyncLocalStorage === "undefined" ? Object : import_node_async_hooks.AsyncLocalStorage,
+      typeof JwtAuthzOptions === "undefined" ? Object : JwtAuthzOptions
+    ])
+  ], JwtAuthzAlsMiddleware);
+  return (0, import_common.mixin)(JwtAuthzAlsMiddleware);
+}, "createJwtAuthzAlsMiddleware");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createJwtAuthzAlsMiddleware
+});