@miguelmorales13/nestkit 0.1.1 → 0.3.0

package/dist/auth/index.cjs

@@ -0,0 +1,265 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+var _chunkFDNGAYTZcjs = require('../chunk-FDNGAYTZ.cjs');
+require('../chunk-R7BVS6CI.cjs');
+
+
+
+var _chunk2REOCMUDcjs = require('../chunk-2REOCMUD.cjs');
+
+// src/auth/hash.util.ts
+var _bcryptjs = require('bcryptjs');
+var SALT_ROUNDS = 10;
+function hashPassword(plain) {
+  return _bcryptjs.hash.call(void 0, plain, SALT_ROUNDS);
+}
+function verifyPassword(plain, passwordHash) {
+  return _bcryptjs.compare.call(void 0, plain, passwordHash);
+}
+
+// src/auth/token.service.ts
+var _jsonwebtoken = require('jsonwebtoken'); var _jsonwebtoken2 = _interopRequireDefault(_jsonwebtoken);
+function requireEnv(name) {
+  const value = process.env[name];
+  if (!value) {
+    throw new Error(`TokenService: ${name} environment variable is not set`);
+  }
+  return value;
+}
+var TokenService = class {
+  signAccessToken(payload) {
+    return _jsonwebtoken2.default.sign(payload, requireEnv("JWT_ACCESS_SECRET"), {
+      expiresIn: _nullishCoalesce(process.env.JWT_ACCESS_EXPIRES_IN, () => ( "15m"))
+    });
+  }
+  signRefreshToken(payload) {
+    return _jsonwebtoken2.default.sign(payload, requireEnv("JWT_REFRESH_SECRET"), {
+      expiresIn: _nullishCoalesce(process.env.JWT_REFRESH_EXPIRES_IN, () => ( "30d"))
+    });
+  }
+  verifyAccessToken(token) {
+    try {
+      return _jsonwebtoken2.default.verify(token, requireEnv("JWT_ACCESS_SECRET"));
+    } catch (e) {
+      throw new (0, _chunkFDNGAYTZcjs.UnauthorizedAppException)("Invalid or expired access token");
+    }
+  }
+  verifyRefreshToken(token) {
+    try {
+      return _jsonwebtoken2.default.verify(token, requireEnv("JWT_REFRESH_SECRET"));
+    } catch (e2) {
+      throw new (0, _chunkFDNGAYTZcjs.UnauthorizedAppException)("Invalid or expired refresh token");
+    }
+  }
+};
+
+// src/auth/jwt-auth.guard.ts
+var _common = require('@nestjs/common');
+var JwtAuthGuard = class {
+  constructor() {
+    this.tokens = new TokenService();
+  }
+  canActivate(context) {
+    const req = context.switchToHttp().getRequest();
+    const header = req.headers.authorization;
+    const token = _optionalChain([header, 'optionalAccess', _2 => _2.startsWith, 'call', _3 => _3("Bearer ")]) ? header.slice("Bearer ".length) : void 0;
+    if (!token) {
+      throw new (0, _chunkFDNGAYTZcjs.UnauthorizedAppException)("Missing Authorization bearer token");
+    }
+    req.user = this.tokens.verifyAccessToken(token);
+    return true;
+  }
+};
+JwtAuthGuard = exports.JwtAuthGuard = _chunk2REOCMUDcjs.__decorateClass.call(void 0, [
+  _common.Injectable.call(void 0, )
+], JwtAuthGuard);
+
+// src/auth/roles.decorator.ts
+
+var ROLES_KEY = "nestkit:roles";
+var Roles = (...roles) => _common.SetMetadata.call(void 0, ROLES_KEY, roles);
+
+// src/auth/roles.guard.ts
+
+require('@nestjs/core');
+var RolesGuard = class {
+  constructor(reflector) {
+    this.reflector = reflector;
+  }
+  canActivate(context) {
+    const required = this.reflector.getAllAndOverride(ROLES_KEY, [
+      context.getHandler(),
+      context.getClass()
+    ]);
+    if (!required || required.length === 0) return true;
+    const req = context.switchToHttp().getRequest();
+    const has = _nullishCoalesce(_optionalChain([req, 'access', _4 => _4.user, 'optionalAccess', _5 => _5.roles, 'access', _6 => _6.some, 'call', _7 => _7((role) => required.includes(role))]), () => ( false));
+    if (!has) {
+      throw new (0, _chunkFDNGAYTZcjs.ForbiddenAppException)("Insufficient role");
+    }
+    return true;
+  }
+};
+RolesGuard = exports.RolesGuard = _chunk2REOCMUDcjs.__decorateClass.call(void 0, [
+  _common.Injectable.call(void 0, )
+], RolesGuard);
+
+// src/auth/current-user.decorator.ts
+
+var CurrentUser = _common.createParamDecorator.call(void 0, 
+  (_, ctx) => ctx.switchToHttp().getRequest().user
+);
+
+// src/auth/current-tenant.decorator.ts
+
+var CurrentTenant = _common.createParamDecorator.call(void 0, 
+  (_, ctx) => _optionalChain([ctx, 'access', _8 => _8.switchToHttp, 'call', _9 => _9(), 'access', _10 => _10.getRequest, 'call', _11 => _11(), 'access', _12 => _12.user, 'optionalAccess', _13 => _13.tenantId])
+);
+
+// src/auth/require-tenant.guard.ts
+
+var RequireTenantGuard = class {
+  canActivate(context) {
+    const req = context.switchToHttp().getRequest();
+    if (!_optionalChain([req, 'access', _14 => _14.user, 'optionalAccess', _15 => _15.tenantId])) {
+      throw new (0, _chunkFDNGAYTZcjs.ForbiddenAppException)("This action requires a company account");
+    }
+    return true;
+  }
+};
+RequireTenantGuard = exports.RequireTenantGuard = _chunk2REOCMUDcjs.__decorateClass.call(void 0, [
+  _common.Injectable.call(void 0, )
+], RequireTenantGuard);
+
+// src/auth/auth.dto.ts
+var _classvalidator = require('class-validator');
+var RegisterDto = class {
+};
+_chunk2REOCMUDcjs.__decorateClass.call(void 0, [
+  _classvalidator.IsEmail.call(void 0, )
+], RegisterDto.prototype, "email", 2);
+_chunk2REOCMUDcjs.__decorateClass.call(void 0, [
+  _classvalidator.IsString.call(void 0, ),
+  _classvalidator.MinLength.call(void 0, 8)
+], RegisterDto.prototype, "password", 2);
+_chunk2REOCMUDcjs.__decorateClass.call(void 0, [
+  _classvalidator.IsOptional.call(void 0, ),
+  _classvalidator.IsString.call(void 0, )
+], RegisterDto.prototype, "tenantId", 2);
+var LoginDto = class {
+};
+_chunk2REOCMUDcjs.__decorateClass.call(void 0, [
+  _classvalidator.IsEmail.call(void 0, )
+], LoginDto.prototype, "email", 2);
+_chunk2REOCMUDcjs.__decorateClass.call(void 0, [
+  _classvalidator.IsString.call(void 0, )
+], LoginDto.prototype, "password", 2);
+var RefreshDto = class {
+};
+_chunk2REOCMUDcjs.__decorateClass.call(void 0, [
+  _classvalidator.IsString.call(void 0, )
+], RefreshDto.prototype, "refreshToken", 2);
+
+// src/auth/auth.service.ts
+var BaseAuthService = class {
+  constructor(users, tokens = new TokenService()) {
+    this.users = users;
+    this.tokens = tokens;
+  }
+  async register(data) {
+    const existing = await this.users.findByEmail(data.email);
+    if (existing) {
+      throw new (0, _chunkFDNGAYTZcjs.ConflictAppException)("Email already registered", { email: data.email }, "EMAIL_TAKEN");
+    }
+    const passwordHash = await hashPassword(data.password);
+    const user = await this.users.create({
+      email: data.email,
+      passwordHash,
+      tenantId: data.tenantId,
+      roles: ["user"]
+    });
+    return { user, ...this.issueTokens(user) };
+  }
+  async login(email, password) {
+    const user = await this.users.findByEmail(email);
+    if (!user || !await verifyPassword(password, user.passwordHash)) {
+      throw new (0, _chunkFDNGAYTZcjs.UnauthorizedAppException)("Invalid credentials");
+    }
+    return { user, ...this.issueTokens(user) };
+  }
+  async refresh(refreshToken) {
+    const payload = this.tokens.verifyRefreshToken(refreshToken);
+    const user = await this.users.findById(payload.sub);
+    if (!user) {
+      throw new (0, _chunkFDNGAYTZcjs.UnauthorizedAppException)("User no longer exists");
+    }
+    return this.issueTokens(user);
+  }
+  issueTokens(user) {
+    const payload = {
+      sub: user.id,
+      email: user.email,
+      tenantId: user.tenantId,
+      roles: user.roles
+    };
+    return {
+      accessToken: this.tokens.signAccessToken(payload),
+      refreshToken: this.tokens.signRefreshToken(payload)
+    };
+  }
+};
+
+// src/auth/auth.controller.ts
+
+function createAuthController(serviceToken, options = {}) {
+  let AuthControllerHost = class {
+    constructor(service) {
+      this.service = service;
+    }
+    register(body) {
+      return this.service.register(body);
+    }
+    login(body) {
+      return this.service.login(body.email, body.password);
+    }
+    refresh(body) {
+      return this.service.refresh(body.refreshToken);
+    }
+  };
+  _chunk2REOCMUDcjs.__decorateClass.call(void 0, [
+    _common.Post.call(void 0, "register"),
+    _chunk2REOCMUDcjs.__decorateParam.call(void 0, 0, _common.Body.call(void 0, ))
+  ], AuthControllerHost.prototype, "register", 1);
+  _chunk2REOCMUDcjs.__decorateClass.call(void 0, [
+    _common.Post.call(void 0, "login"),
+    _chunk2REOCMUDcjs.__decorateParam.call(void 0, 0, _common.Body.call(void 0, ))
+  ], AuthControllerHost.prototype, "login", 1);
+  _chunk2REOCMUDcjs.__decorateClass.call(void 0, [
+    _common.Post.call(void 0, "refresh"),
+    _chunk2REOCMUDcjs.__decorateParam.call(void 0, 0, _common.Body.call(void 0, ))
+  ], AuthControllerHost.prototype, "refresh", 1);
+  AuthControllerHost = _chunk2REOCMUDcjs.__decorateClass.call(void 0, [
+    _common.Controller.call(void 0, _nullishCoalesce(options.path, () => ( "auth"))),
+    _chunk2REOCMUDcjs.__decorateParam.call(void 0, 0, _common.Inject.call(void 0, serviceToken))
+  ], AuthControllerHost);
+  return AuthControllerHost;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.BaseAuthService = BaseAuthService; exports.CurrentTenant = CurrentTenant; exports.CurrentUser = CurrentUser; exports.JwtAuthGuard = JwtAuthGuard; exports.LoginDto = LoginDto; exports.ROLES_KEY = ROLES_KEY; exports.RefreshDto = RefreshDto; exports.RegisterDto = RegisterDto; exports.RequireTenantGuard = RequireTenantGuard; exports.Roles = Roles; exports.RolesGuard = RolesGuard; exports.TokenService = TokenService; exports.createAuthController = createAuthController; exports.hashPassword = hashPassword; exports.verifyPassword = verifyPassword;

package/dist/auth/index.d.ts

@@ -0,0 +1,16 @@
+export type { AuthUser } from './auth-user.entity.js';
+export type { AuthUserPort } from './auth-user.port.js';
+export type { AuthenticatedUser } from './authenticated-user.js';
+export { hashPassword, verifyPassword } from './hash.util.js';
+export { TokenService } from './token.service.js';
+export { JwtAuthGuard } from './jwt-auth.guard.js';
+export { Roles, ROLES_KEY } from './roles.decorator.js';
+export { RolesGuard } from './roles.guard.js';
+export { CurrentUser } from './current-user.decorator.js';
+export { CurrentTenant } from './current-tenant.decorator.js';
+export { RequireTenantGuard } from './require-tenant.guard.js';
+export { RegisterDto, LoginDto, RefreshDto } from './auth.dto.js';
+export { BaseAuthService } from './auth.service.js';
+export type { AuthTokens } from './auth.service.js';
+export { createAuthController } from './auth.controller.js';
+export type { CreateAuthControllerOptions } from './auth.controller.js';

package/dist/auth/index.js

@@ -0,0 +1,265 @@
+import {
+  ConflictAppException,
+  ForbiddenAppException,
+  UnauthorizedAppException
+} from "../chunk-ORWJ7LES.js";
+import "../chunk-YFYHLYHN.js";
+import {
+  __decorateClass,
+  __decorateParam
+} from "../chunk-4MGIQFAJ.js";
+
+// src/auth/hash.util.ts
+import { compare, hash } from "bcryptjs";
+var SALT_ROUNDS = 10;
+function hashPassword(plain) {
+  return hash(plain, SALT_ROUNDS);
+}
+function verifyPassword(plain, passwordHash) {
+  return compare(plain, passwordHash);
+}
+
+// src/auth/token.service.ts
+import jwt from "jsonwebtoken";
+function requireEnv(name) {
+  const value = process.env[name];
+  if (!value) {
+    throw new Error(`TokenService: ${name} environment variable is not set`);
+  }
+  return value;
+}
+var TokenService = class {
+  signAccessToken(payload) {
+    return jwt.sign(payload, requireEnv("JWT_ACCESS_SECRET"), {
+      expiresIn: process.env.JWT_ACCESS_EXPIRES_IN ?? "15m"
+    });
+  }
+  signRefreshToken(payload) {
+    return jwt.sign(payload, requireEnv("JWT_REFRESH_SECRET"), {
+      expiresIn: process.env.JWT_REFRESH_EXPIRES_IN ?? "30d"
+    });
+  }
+  verifyAccessToken(token) {
+    try {
+      return jwt.verify(token, requireEnv("JWT_ACCESS_SECRET"));
+    } catch {
+      throw new UnauthorizedAppException("Invalid or expired access token");
+    }
+  }
+  verifyRefreshToken(token) {
+    try {
+      return jwt.verify(token, requireEnv("JWT_REFRESH_SECRET"));
+    } catch {
+      throw new UnauthorizedAppException("Invalid or expired refresh token");
+    }
+  }
+};
+
+// src/auth/jwt-auth.guard.ts
+import { Injectable } from "@nestjs/common";
+var JwtAuthGuard = class {
+  constructor() {
+    this.tokens = new TokenService();
+  }
+  canActivate(context) {
+    const req = context.switchToHttp().getRequest();
+    const header = req.headers.authorization;
+    const token = header?.startsWith("Bearer ") ? header.slice("Bearer ".length) : void 0;
+    if (!token) {
+      throw new UnauthorizedAppException("Missing Authorization bearer token");
+    }
+    req.user = this.tokens.verifyAccessToken(token);
+    return true;
+  }
+};
+JwtAuthGuard = __decorateClass([
+  Injectable()
+], JwtAuthGuard);
+
+// src/auth/roles.decorator.ts
+import { SetMetadata } from "@nestjs/common";
+var ROLES_KEY = "nestkit:roles";
+var Roles = (...roles) => SetMetadata(ROLES_KEY, roles);
+
+// src/auth/roles.guard.ts
+import { Injectable as Injectable2 } from "@nestjs/common";
+import "@nestjs/core";
+var RolesGuard = class {
+  constructor(reflector) {
+    this.reflector = reflector;
+  }
+  canActivate(context) {
+    const required = this.reflector.getAllAndOverride(ROLES_KEY, [
+      context.getHandler(),
+      context.getClass()
+    ]);
+    if (!required || required.length === 0) return true;
+    const req = context.switchToHttp().getRequest();
+    const has = req.user?.roles.some((role) => required.includes(role)) ?? false;
+    if (!has) {
+      throw new ForbiddenAppException("Insufficient role");
+    }
+    return true;
+  }
+};
+RolesGuard = __decorateClass([
+  Injectable2()
+], RolesGuard);
+
+// src/auth/current-user.decorator.ts
+import { createParamDecorator } from "@nestjs/common";
+var CurrentUser = createParamDecorator(
+  (_, ctx) => ctx.switchToHttp().getRequest().user
+);
+
+// src/auth/current-tenant.decorator.ts
+import { createParamDecorator as createParamDecorator2 } from "@nestjs/common";
+var CurrentTenant = createParamDecorator2(
+  (_, ctx) => ctx.switchToHttp().getRequest().user?.tenantId
+);
+
+// src/auth/require-tenant.guard.ts
+import { Injectable as Injectable3 } from "@nestjs/common";
+var RequireTenantGuard = class {
+  canActivate(context) {
+    const req = context.switchToHttp().getRequest();
+    if (!req.user?.tenantId) {
+      throw new ForbiddenAppException("This action requires a company account");
+    }
+    return true;
+  }
+};
+RequireTenantGuard = __decorateClass([
+  Injectable3()
+], RequireTenantGuard);
+
+// src/auth/auth.dto.ts
+import { IsEmail, IsOptional, IsString, MinLength } from "class-validator";
+var RegisterDto = class {
+};
+__decorateClass([
+  IsEmail()
+], RegisterDto.prototype, "email", 2);
+__decorateClass([
+  IsString(),
+  MinLength(8)
+], RegisterDto.prototype, "password", 2);
+__decorateClass([
+  IsOptional(),
+  IsString()
+], RegisterDto.prototype, "tenantId", 2);
+var LoginDto = class {
+};
+__decorateClass([
+  IsEmail()
+], LoginDto.prototype, "email", 2);
+__decorateClass([
+  IsString()
+], LoginDto.prototype, "password", 2);
+var RefreshDto = class {
+};
+__decorateClass([
+  IsString()
+], RefreshDto.prototype, "refreshToken", 2);
+
+// src/auth/auth.service.ts
+var BaseAuthService = class {
+  constructor(users, tokens = new TokenService()) {
+    this.users = users;
+    this.tokens = tokens;
+  }
+  async register(data) {
+    const existing = await this.users.findByEmail(data.email);
+    if (existing) {
+      throw new ConflictAppException("Email already registered", { email: data.email }, "EMAIL_TAKEN");
+    }
+    const passwordHash = await hashPassword(data.password);
+    const user = await this.users.create({
+      email: data.email,
+      passwordHash,
+      tenantId: data.tenantId,
+      roles: ["user"]
+    });
+    return { user, ...this.issueTokens(user) };
+  }
+  async login(email, password) {
+    const user = await this.users.findByEmail(email);
+    if (!user || !await verifyPassword(password, user.passwordHash)) {
+      throw new UnauthorizedAppException("Invalid credentials");
+    }
+    return { user, ...this.issueTokens(user) };
+  }
+  async refresh(refreshToken) {
+    const payload = this.tokens.verifyRefreshToken(refreshToken);
+    const user = await this.users.findById(payload.sub);
+    if (!user) {
+      throw new UnauthorizedAppException("User no longer exists");
+    }
+    return this.issueTokens(user);
+  }
+  issueTokens(user) {
+    const payload = {
+      sub: user.id,
+      email: user.email,
+      tenantId: user.tenantId,
+      roles: user.roles
+    };
+    return {
+      accessToken: this.tokens.signAccessToken(payload),
+      refreshToken: this.tokens.signRefreshToken(payload)
+    };
+  }
+};
+
+// src/auth/auth.controller.ts
+import { Body, Controller, Inject, Post } from "@nestjs/common";
+function createAuthController(serviceToken, options = {}) {
+  let AuthControllerHost = class {
+    constructor(service) {
+      this.service = service;
+    }
+    register(body) {
+      return this.service.register(body);
+    }
+    login(body) {
+      return this.service.login(body.email, body.password);
+    }
+    refresh(body) {
+      return this.service.refresh(body.refreshToken);
+    }
+  };
+  __decorateClass([
+    Post("register"),
+    __decorateParam(0, Body())
+  ], AuthControllerHost.prototype, "register", 1);
+  __decorateClass([
+    Post("login"),
+    __decorateParam(0, Body())
+  ], AuthControllerHost.prototype, "login", 1);
+  __decorateClass([
+    Post("refresh"),
+    __decorateParam(0, Body())
+  ], AuthControllerHost.prototype, "refresh", 1);
+  AuthControllerHost = __decorateClass([
+    Controller(options.path ?? "auth"),
+    __decorateParam(0, Inject(serviceToken))
+  ], AuthControllerHost);
+  return AuthControllerHost;
+}
+export {
+  BaseAuthService,
+  CurrentTenant,
+  CurrentUser,
+  JwtAuthGuard,
+  LoginDto,
+  ROLES_KEY,
+  RefreshDto,
+  RegisterDto,
+  RequireTenantGuard,
+  Roles,
+  RolesGuard,
+  TokenService,
+  createAuthController,
+  hashPassword,
+  verifyPassword
+};

package/dist/auth/jwt-auth.guard.d.ts

@@ -0,0 +1,5 @@
+import { type CanActivate, type ExecutionContext } from '@nestjs/common';
+export declare class JwtAuthGuard implements CanActivate {
+    private readonly tokens;
+    canActivate(context: ExecutionContext): boolean;
+}

package/dist/auth/require-tenant.guard.d.ts

@@ -0,0 +1,9 @@
+import { type CanActivate, type ExecutionContext } from '@nestjs/common';
+/**
+ * Opt-in guard for endpoints that are company-only (denies individual/solo
+ * accounts, which have no `tenantId`). Use after JwtAuthGuard:
+ * `@UseGuards(JwtAuthGuard, RequireTenantGuard)`.
+ */
+export declare class RequireTenantGuard implements CanActivate {
+    canActivate(context: ExecutionContext): boolean;
+}

package/dist/auth/roles.decorator.d.ts

@@ -0,0 +1,3 @@
+export declare const ROLES_KEY = "nestkit:roles";
+/** Use with RolesGuard, after JwtAuthGuard: `@UseGuards(JwtAuthGuard, RolesGuard)`. */
+export declare const Roles: (...roles: string[]) => import("@nestjs/common").CustomDecorator<string>;

package/dist/auth/roles.guard.d.ts

@@ -0,0 +1,11 @@
+import { type CanActivate, type ExecutionContext } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+/**
+ * Reads `request.user`, populated by JwtAuthGuard — always use
+ * `@UseGuards(JwtAuthGuard, RolesGuard)` in that order.
+ */
+export declare class RolesGuard implements CanActivate {
+    private readonly reflector;
+    constructor(reflector: Reflector);
+    canActivate(context: ExecutionContext): boolean;
+}

package/dist/auth/token.service.d.ts

@@ -0,0 +1,7 @@
+import type { AuthenticatedUser } from './authenticated-user.js';
+export declare class TokenService {
+    signAccessToken(payload: AuthenticatedUser): string;
+    signRefreshToken(payload: AuthenticatedUser): string;
+    verifyAccessToken(token: string): AuthenticatedUser;
+    verifyRefreshToken(token: string): AuthenticatedUser;
+}

package/dist/bootstrap/index.cjs

@@ -1,10 +1,11 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkAUA4X3REcjs = require('../chunk-AUA4X3RE.cjs');
-require('../chunk-4IDLJMQA.cjs');
+var _chunkO2ZMI3EKcjs = require('../chunk-O2ZMI3EK.cjs');
+require('../chunk-7FQQDWOZ.cjs');
+require('../chunk-R7BVS6CI.cjs');
 require('../chunk-TJHRABML.cjs');
 require('../chunk-ZA56XBCK.cjs');
 require('../chunk-2REOCMUD.cjs');
 
 
-exports.applyNestKitDefaults = _chunkAUA4X3REcjs.applyNestKitDefaults;
+exports.applyNestKitDefaults = _chunkO2ZMI3EKcjs.applyNestKitDefaults;

package/dist/bootstrap/index.js

@@ -1,7 +1,8 @@
 import {
   applyNestKitDefaults
-} from "../chunk-VPS5CLHT.js";
-import "../chunk-EQXYK6AL.js";
+} from "../chunk-RHNQGTAT.js";
+import "../chunk-Q45IEPWU.js";
+import "../chunk-YFYHLYHN.js";
 import "../chunk-KDAA6GFF.js";
 import "../chunk-EBO6UKHL.js";
 import "../chunk-4MGIQFAJ.js";

package/dist/{chunk-4IDLJMQA.cjs → chunk-7FQQDWOZ.cjs}

@@ -1,27 +1,20 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
 
+var _chunkR7BVS6CIcjs = require('./chunk-R7BVS6CI.cjs');
+
+
 var _chunkZA56XBCKcjs = require('./chunk-ZA56XBCK.cjs');
 
 
 var _chunk2REOCMUDcjs = require('./chunk-2REOCMUD.cjs');
 
-// src/errors/app.exception.ts
-var _common = require('@nestjs/common');
-var AppException = class extends _common.HttpException {
-  constructor(code, message, status, details) {
-    super({ code, message, details }, status);
-    this.code = code;
-    this.details = details;
-  }
-};
-
 // src/errors/global-exception.filter.ts
 
 
 
 
 
-
+var _common = require('@nestjs/common');
 var GlobalExceptionFilter = class {
   constructor() {
     this.logger = new (0, _common.Logger)(GlobalExceptionFilter.name);
@@ -46,7 +39,7 @@ var GlobalExceptionFilter = class {
     response.status(resolved.status).send(body);
   }
   resolve(exception) {
-    if (exception instanceof AppException) {
+    if (exception instanceof _chunkR7BVS6CIcjs.AppException) {
       return {
         status: exception.getStatus(),
         code: exception.code,
@@ -77,5 +70,4 @@ GlobalExceptionFilter = exports.GlobalExceptionFilter = _chunk2REOCMUDcjs.__deco
 
 
 
-
-exports.AppException = AppException; exports.GlobalExceptionFilter = GlobalExceptionFilter;
+exports.GlobalExceptionFilter = GlobalExceptionFilter;

package/dist/chunk-7SOM7EZP.cjs

@@ -0,0 +1 @@
+"use strict";