@vritti/api-sdk 0.0.3 → 0.0.5

package/dist/index.cjs

@@ -32,11 +32,16 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   AuthConfigModule: () => AuthConfigModule,
+  CsrfGuard: () => CsrfGuard,
   DatabaseModule: () => DatabaseModule,
+  HttpExceptionFilter: () => HttpExceptionFilter,
+  HttpModule: () => HttpModule,
   Onboarding: () => Onboarding,
+  PrimaryBaseRepository: () => PrimaryBaseRepository,
   PrimaryDatabaseService: () => PrimaryDatabaseService,
   Public: () => Public,
   Tenant: () => Tenant,
+  TenantBaseRepository: () => TenantBaseRepository,
   TenantContextService: () => TenantContextService,
   TenantDatabaseService: () => TenantDatabaseService,
   VrittiAuthGuard: () => VrittiAuthGuard
@@ -376,16 +381,15 @@ var PrimaryDatabaseService = class _PrimaryDatabaseService {
     this.logger.log(`Cleared ${size} cached tenant configs`);
   }
   /**
-  * Get primary database client for direct database access
-  *
-  * This is useful for platform admin operations (creating tenants, billing, etc.)
+  * Get the Prisma client for the primary database.
+  * This is a synchronous property that returns the initialized Prisma client.
   *
   * @returns Primary database client instance
   * @throws Error if primary database client is not initialized
   */
-  getPrimaryDbClient() {
+  get prismaClient() {
     if (!this.primaryDbClient) {
-      throw new Error("Primary database client not initialized. Are you in gateway mode?");
+      throw new Error("Primary database client not initialized");
     }
     return this.primaryDbClient;
   }
@@ -971,6 +975,17 @@ var TenantDatabaseService = class _TenantDatabaseService {
     this.startConnectionCleaner();
   }
   /**
+  * Get the Prisma client for the current tenant's database.
+  * This returns the tenant-scoped database client.
+  *
+  * @returns Tenant-scoped database client instance
+  * @throws UnauthorizedException if tenant context not set
+  * @throws InternalServerErrorException if connection fails
+  */
+  get prismaClient() {
+    return this.getDbClient();
+  }
+  /**
   * Get tenant-scoped database client for the current request/message
   *
   * This method:
@@ -1164,7 +1179,7 @@ var DatabaseModule = class _DatabaseModule {
   * })
   */
   static forServer(options) {
-    return this.createDynamicModule(options, "gateway");
+    return this.createDynamicModule(options, "server");
   }
   /**
   * Configure DatabaseModule for Microservice/Messaging mode (RabbitMQ workers)
@@ -1207,7 +1222,7 @@ var DatabaseModule = class _DatabaseModule {
       PrimaryDatabaseService,
       TenantDatabaseService
     ];
-    if (mode === "gateway") {
+    if (mode === "server") {
       providers.push({
         provide: import_core4.APP_INTERCEPTOR,
         useClass: TenantContextInterceptor
@@ -1238,9 +1253,548 @@ DatabaseModule = _ts_decorate10([
   (0, import_common10.Module)({})
 ], DatabaseModule);
 
-// src/database/decorators/tenant.decorator.ts
+// src/database/repositories/primary-base.repository.ts
 var import_common11 = require("@nestjs/common");
-var Tenant = (0, import_common11.createParamDecorator)((data, ctx) => {
+var PrimaryBaseRepository = class {
+  static {
+    __name(this, "PrimaryBaseRepository");
+  }
+  database;
+  logger;
+  modelGetter;
+  /**
+  * Lazy getter for Prisma client.
+  * Accesses the client from the database service only when needed,
+  * avoiding initialization timing issues with NestJS lifecycle.
+  */
+  get prisma() {
+    return this.database.prismaClient;
+  }
+  /**
+  * Lazy getter for the Prisma model delegate.
+  * Returns the specific model (e.g., prisma.user, prisma.tenant) for this repository.
+  */
+  get model() {
+    return this.modelGetter(this.prisma);
+  }
+  /**
+  * Create a new repository instance
+  *
+  * @param database - The primary database service
+  * @param getModel - Function that returns the Prisma model delegate from the client
+  *
+  * @example
+  * ```typescript
+  * // Standard usage with full parameter name
+  * constructor(database: PrimaryDatabaseService) {
+  *   super(database, (prisma) => prisma.user);
+  * }
+  *
+  * // Short syntax
+  * constructor(database: PrimaryDatabaseService) {
+  *   super(database, (p) => p.user);
+  * }
+  *
+  * // Complex model names
+  * constructor(database: PrimaryDatabaseService) {
+  *   super(database, (p) => p.emailVerification);
+  * }
+  * ```
+  */
+  constructor(database, getModel) {
+    this.database = database;
+    this.logger = new import_common11.Logger(this.constructor.name);
+    this.modelGetter = getModel;
+    this.logger.debug(`Initialized ${this.constructor.name}`);
+  }
+  /**
+  * Create a new record
+  *
+  * @param data - The data to create the record with
+  * @returns Promise resolving to the created record
+  *
+  * @example
+  * ```typescript
+  * const user = await userRepository.create({
+  *   email: 'user@example.com',
+  *   name: 'John Doe'
+  * });
+  * ```
+  */
+  async create(data) {
+    this.logger.log("Creating record");
+    return await this.model.create({
+      data
+    });
+  }
+  /**
+  * Find a single record by ID
+  *
+  * @param id - The record ID
+  * @returns Promise resolving to the record or null if not found
+  *
+  * @example
+  * ```typescript
+  * const user = await userRepository.findById('user-id-123');
+  * ```
+  */
+  async findById(id) {
+    this.logger.debug(`Finding record by ID: ${id}`);
+    return await this.model.findUnique({
+      where: {
+        id
+      }
+    });
+  }
+  /**
+  * Find a single record with custom where clause
+  *
+  * @param where - The where clause or findUnique args
+  * @returns Promise resolving to the record or null if not found
+  *
+  * @example
+  * ```typescript
+  * // Simple where clause
+  * const user = await userRepository.findOne({ email: 'user@example.com' });
+  *
+  * // With include
+  * const user = await userRepository.findOne({
+  *   where: { email: 'user@example.com' },
+  *   include: { posts: true }
+  * });
+  * ```
+  */
+  async findOne(where) {
+    this.logger.debug("Finding record with custom query");
+    return await this.model.findUnique(typeof where === "object" && "where" in where ? where : {
+      where
+    });
+  }
+  /**
+  * Find multiple records
+  *
+  * @param args - Prisma findMany arguments (where, orderBy, take, skip, etc.)
+  * @returns Promise resolving to an array of records
+  *
+  * @example
+  * ```typescript
+  * // Find all users
+  * const users = await userRepository.findMany();
+  *
+  * // Find with filtering and pagination
+  * const users = await userRepository.findMany({
+  *   where: { status: 'ACTIVE' },
+  *   orderBy: { createdAt: 'desc' },
+  *   take: 10,
+  *   skip: 0
+  * });
+  * ```
+  */
+  async findMany(args) {
+    this.logger.debug("Finding multiple records");
+    return await this.model.findMany(args);
+  }
+  /**
+  * Update a record by ID
+  *
+  * @param id - The record ID
+  * @param data - The data to update
+  * @returns Promise resolving to the updated record
+  *
+  * @example
+  * ```typescript
+  * const user = await userRepository.update('user-id-123', {
+  *   name: 'Jane Doe'
+  * });
+  * ```
+  */
+  async update(id, data) {
+    this.logger.log(`Updating record with ID: ${id}`);
+    return await this.model.update({
+      where: {
+        id
+      },
+      data
+    });
+  }
+  /**
+  * Update multiple records
+  *
+  * @param where - The where clause to match records
+  * @param data - The data to update
+  * @returns Promise resolving to the count of updated records
+  *
+  * @example
+  * ```typescript
+  * const result = await userRepository.updateMany(
+  *   { status: 'PENDING' },
+  *   { status: 'ACTIVE' }
+  * );
+  * console.log(`Updated ${result.count} users`);
+  * ```
+  */
+  async updateMany(where, data) {
+    this.logger.log("Updating multiple records");
+    return await this.model.updateMany({
+      where,
+      data
+    });
+  }
+  /**
+  * Delete a record by ID
+  *
+  * @param id - The record ID
+  * @returns Promise resolving to the deleted record
+  *
+  * @example
+  * ```typescript
+  * const user = await userRepository.delete('user-id-123');
+  * ```
+  */
+  async delete(id) {
+    this.logger.log(`Deleting record with ID: ${id}`);
+    return await this.model.delete({
+      where: {
+        id
+      }
+    });
+  }
+  /**
+  * Delete multiple records
+  *
+  * @param where - The where clause to match records
+  * @returns Promise resolving to the count of deleted records
+  *
+  * @example
+  * ```typescript
+  * const result = await userRepository.deleteMany({
+  *   status: 'INACTIVE',
+  *   createdAt: { lt: new Date('2020-01-01') }
+  * });
+  * console.log(`Deleted ${result.count} users`);
+  * ```
+  */
+  async deleteMany(where) {
+    this.logger.log("Deleting multiple records");
+    return await this.model.deleteMany({
+      where
+    });
+  }
+  /**
+  * Count records
+  *
+  * @param where - Optional where clause to filter records
+  * @returns Promise resolving to the count of records
+  *
+  * @example
+  * ```typescript
+  * // Count all users
+  * const total = await userRepository.count();
+  *
+  * // Count active users
+  * const activeCount = await userRepository.count({ status: 'ACTIVE' });
+  * ```
+  */
+  async count(where) {
+    this.logger.debug("Counting records");
+    return await this.model.count({
+      where
+    });
+  }
+  /**
+  * Check if a record exists
+  *
+  * @param where - The where clause to match records
+  * @returns Promise resolving to true if at least one record exists, false otherwise
+  *
+  * @example
+  * ```typescript
+  * const emailExists = await userRepository.exists({
+  *   email: 'user@example.com'
+  * });
+  * ```
+  */
+  async exists(where) {
+    const count = await this.model.count({
+      where
+    });
+    return count > 0;
+  }
+};
+
+// src/database/repositories/tenant-base.repository.ts
+var import_common12 = require("@nestjs/common");
+var TenantBaseRepository = class {
+  static {
+    __name(this, "TenantBaseRepository");
+  }
+  database;
+  logger;
+  modelGetter;
+  /**
+  * Lazy getter for Prisma client.
+  * Accesses the client from the database service only when needed,
+  * avoiding initialization timing issues with NestJS lifecycle.
+  */
+  get prisma() {
+    return this.database.prismaClient;
+  }
+  /**
+  * Lazy getter for the Prisma model delegate.
+  * Returns the specific model (e.g., prisma.product, prisma.order) for this repository.
+  */
+  get model() {
+    return this.modelGetter(this.prisma);
+  }
+  /**
+  * Create a new repository instance
+  *
+  * @param database - The tenant database service
+  * @param getModel - Function that returns the Prisma model delegate from the client
+  *
+  * @example
+  * ```typescript
+  * // Standard usage with full parameter name
+  * constructor(database: TenantDatabaseService) {
+  *   super(database, (prisma) => prisma.product);
+  * }
+  *
+  * // Short syntax
+  * constructor(database: TenantDatabaseService) {
+  *   super(database, (p) => p.product);
+  * }
+  *
+  * // Complex model names
+  * constructor(database: TenantDatabaseService) {
+  *   super(database, (p) => p.inventoryItem);
+  * }
+  * ```
+  */
+  constructor(database, getModel) {
+    this.database = database;
+    this.logger = new import_common12.Logger(this.constructor.name);
+    this.modelGetter = getModel;
+    this.logger.debug(`Initialized ${this.constructor.name}`);
+  }
+  /**
+  * Create a new record
+  *
+  * @param data - The data to create the record with
+  * @returns Promise resolving to the created record
+  *
+  * @example
+  * ```typescript
+  * const product = await productRepository.create({
+  *   name: 'Widget',
+  *   sku: 'WDG-001',
+  *   price: 9.99
+  * });
+  * ```
+  */
+  async create(data) {
+    this.logger.log("Creating record");
+    return await this.model.create({
+      data
+    });
+  }
+  /**
+  * Find a single record by ID
+  *
+  * @param id - The record ID
+  * @returns Promise resolving to the record or null if not found
+  *
+  * @example
+  * ```typescript
+  * const product = await productRepository.findById('product-id-123');
+  * ```
+  */
+  async findById(id) {
+    this.logger.debug(`Finding record by ID: ${id}`);
+    return await this.model.findUnique({
+      where: {
+        id
+      }
+    });
+  }
+  /**
+  * Find a single record with custom where clause
+  *
+  * @param where - The where clause or findUnique args
+  * @returns Promise resolving to the record or null if not found
+  *
+  * @example
+  * ```typescript
+  * // Simple where clause
+  * const product = await productRepository.findOne({ sku: 'WDG-001' });
+  *
+  * // With include
+  * const product = await productRepository.findOne({
+  *   where: { sku: 'WDG-001' },
+  *   include: { category: true }
+  * });
+  * ```
+  */
+  async findOne(where) {
+    this.logger.debug("Finding record with custom query");
+    return await this.model.findUnique(typeof where === "object" && "where" in where ? where : {
+      where
+    });
+  }
+  /**
+  * Find multiple records
+  *
+  * @param args - Prisma findMany arguments (where, orderBy, take, skip, etc.)
+  * @returns Promise resolving to an array of records
+  *
+  * @example
+  * ```typescript
+  * // Find all products
+  * const products = await productRepository.findMany();
+  *
+  * // Find with filtering and pagination
+  * const products = await productRepository.findMany({
+  *   where: { status: 'ACTIVE' },
+  *   orderBy: { createdAt: 'desc' },
+  *   take: 10,
+  *   skip: 0
+  * });
+  * ```
+  */
+  async findMany(args) {
+    this.logger.debug("Finding multiple records");
+    return await this.model.findMany(args);
+  }
+  /**
+  * Update a record by ID
+  *
+  * @param id - The record ID
+  * @param data - The data to update
+  * @returns Promise resolving to the updated record
+  *
+  * @example
+  * ```typescript
+  * const product = await productRepository.update('product-id-123', {
+  *   price: 12.99
+  * });
+  * ```
+  */
+  async update(id, data) {
+    this.logger.log(`Updating record with ID: ${id}`);
+    return await this.model.update({
+      where: {
+        id
+      },
+      data
+    });
+  }
+  /**
+  * Update multiple records
+  *
+  * @param where - The where clause to match records
+  * @param data - The data to update
+  * @returns Promise resolving to the count of updated records
+  *
+  * @example
+  * ```typescript
+  * const result = await productRepository.updateMany(
+  *   { status: 'PENDING' },
+  *   { status: 'ACTIVE' }
+  * );
+  * console.log(`Updated ${result.count} products`);
+  * ```
+  */
+  async updateMany(where, data) {
+    this.logger.log("Updating multiple records");
+    return await this.model.updateMany({
+      where,
+      data
+    });
+  }
+  /**
+  * Delete a record by ID
+  *
+  * @param id - The record ID
+  * @returns Promise resolving to the deleted record
+  *
+  * @example
+  * ```typescript
+  * const product = await productRepository.delete('product-id-123');
+  * ```
+  */
+  async delete(id) {
+    this.logger.log(`Deleting record with ID: ${id}`);
+    return await this.model.delete({
+      where: {
+        id
+      }
+    });
+  }
+  /**
+  * Delete multiple records
+  *
+  * @param where - The where clause to match records
+  * @returns Promise resolving to the count of deleted records
+  *
+  * @example
+  * ```typescript
+  * const result = await productRepository.deleteMany({
+  *   status: 'INACTIVE',
+  *   createdAt: { lt: new Date('2020-01-01') }
+  * });
+  * console.log(`Deleted ${result.count} products`);
+  * ```
+  */
+  async deleteMany(where) {
+    this.logger.log("Deleting multiple records");
+    return await this.model.deleteMany({
+      where
+    });
+  }
+  /**
+  * Count records
+  *
+  * @param where - Optional where clause to filter records
+  * @returns Promise resolving to the count of records
+  *
+  * @example
+  * ```typescript
+  * // Count all products
+  * const total = await productRepository.count();
+  *
+  * // Count active products
+  * const activeCount = await productRepository.count({ status: 'ACTIVE' });
+  * ```
+  */
+  async count(where) {
+    this.logger.debug("Counting records");
+    return await this.model.count({
+      where
+    });
+  }
+  /**
+  * Check if a record exists
+  *
+  * @param where - The where clause to match records
+  * @returns Promise resolving to true if at least one record exists, false otherwise
+  *
+  * @example
+  * ```typescript
+  * const skuExists = await productRepository.exists({
+  *   sku: 'WDG-001'
+  * });
+  * ```
+  */
+  async exists(where) {
+    const count = await this.model.count({
+      where
+    });
+    return count > 0;
+  }
+};
+
+// src/database/decorators/tenant.decorator.ts
+var import_common13 = require("@nestjs/common");
+var Tenant = (0, import_common13.createParamDecorator)((data, ctx) => {
   const request = ctx.switchToHttp().getRequest();
   const tenantContext = request.app?.get?.(TenantContextService);
   if (!tenantContext) {
@@ -1250,20 +1804,239 @@ var Tenant = (0, import_common11.createParamDecorator)((data, ctx) => {
 });
 
 // src/auth/decorators/onboarding.decorator.ts
-var import_common12 = require("@nestjs/common");
-var Onboarding = /* @__PURE__ */ __name(() => (0, import_common12.SetMetadata)("isOnboarding", true), "Onboarding");
+var import_common14 = require("@nestjs/common");
+var Onboarding = /* @__PURE__ */ __name(() => (0, import_common14.SetMetadata)("isOnboarding", true), "Onboarding");
 
 // src/auth/decorators/public.decorator.ts
-var import_common13 = require("@nestjs/common");
-var Public = /* @__PURE__ */ __name(() => (0, import_common13.SetMetadata)("isPublic", true), "Public");
+var import_common15 = require("@nestjs/common");
+var Public = /* @__PURE__ */ __name(() => (0, import_common15.SetMetadata)("isPublic", true), "Public");
+
+// src/http/http.module.ts
+var import_common17 = require("@nestjs/common");
+
+// src/http/guards/csrf.guard.ts
+var import_common16 = require("@nestjs/common");
+var import_core5 = require("@nestjs/core");
+function _ts_decorate11(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_decorate11, "_ts_decorate");
+function _ts_metadata7(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata7, "_ts_metadata");
+var CsrfGuard = class _CsrfGuard {
+  static {
+    __name(this, "CsrfGuard");
+  }
+  reflector;
+  logger = new import_common16.Logger(_CsrfGuard.name);
+  constructor(reflector) {
+    this.reflector = reflector;
+  }
+  async canActivate(context) {
+    const request = context.switchToHttp().getRequest();
+    const reply = context.switchToHttp().getResponse();
+    const safeMethods = [
+      "GET",
+      "HEAD",
+      "OPTIONS"
+    ];
+    if (safeMethods.includes(request.method)) {
+      return true;
+    }
+    try {
+      const fastifyInstance = request.server;
+      if (!fastifyInstance.csrfProtection) {
+        this.logger.error("CSRF protection plugin not found. Ensure @fastify/csrf-protection is registered.");
+        throw new import_common16.ForbiddenException("CSRF protection not configured");
+      }
+      await new Promise((resolve, reject) => {
+        fastifyInstance.csrfProtection(request, reply, (err) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve();
+          }
+        });
+      });
+      this.logger.debug(`CSRF validation successful for ${request.method} ${request.url}`);
+      return true;
+    } catch (error) {
+      this.logger.warn(`CSRF validation failed for ${request.method} ${request.url}: ${error instanceof Error ? error.message : "Unknown error"}`);
+      throw new import_common16.ForbiddenException({
+        errors: [
+          {
+            field: "csrf",
+            message: "Invalid or missing CSRF token"
+          }
+        ],
+        message: "CSRF validation failed"
+      });
+    }
+  }
+};
+CsrfGuard = _ts_decorate11([
+  (0, import_common16.Injectable)(),
+  _ts_metadata7("design:type", Function),
+  _ts_metadata7("design:paramtypes", [
+    typeof import_core5.Reflector === "undefined" ? Object : import_core5.Reflector
+  ])
+], CsrfGuard);
+
+// src/http/http.module.ts
+function _ts_decorate12(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_decorate12, "_ts_decorate");
+var HttpModule = class {
+  static {
+    __name(this, "HttpModule");
+  }
+};
+HttpModule = _ts_decorate12([
+  (0, import_common17.Module)({
+    providers: [
+      CsrfGuard
+    ],
+    exports: [
+      CsrfGuard
+    ]
+  })
+], HttpModule);
+
+// src/http/filters/http-exception.filter.ts
+var import_common18 = require("@nestjs/common");
+function _ts_decorate13(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_decorate13, "_ts_decorate");
+var HttpExceptionFilter = class _HttpExceptionFilter {
+  static {
+    __name(this, "HttpExceptionFilter");
+  }
+  logger = new import_common18.Logger(_HttpExceptionFilter.name);
+  catch(exception, host) {
+    const ctx = host.switchToHttp();
+    const reply = ctx.getResponse();
+    const request = ctx.getRequest();
+    let status = import_common18.HttpStatus.INTERNAL_SERVER_ERROR;
+    let errors = [];
+    let message;
+    if (exception instanceof import_common18.HttpException) {
+      status = exception.getStatus();
+      const exceptionResponse = exception.getResponse();
+      if (typeof exceptionResponse === "object" && exceptionResponse !== null) {
+        const responseObj = exceptionResponse;
+        if (Array.isArray(responseObj.message)) {
+          errors = this.parseValidationErrors(responseObj.message);
+          message = "Validation failed";
+        } else if (responseObj.message) {
+          errors = [
+            {
+              field: "general",
+              message: responseObj.message
+            }
+          ];
+          message = responseObj.message;
+        }
+      } else if (typeof exceptionResponse === "string") {
+        errors = [
+          {
+            field: "general",
+            message: exceptionResponse
+          }
+        ];
+        message = exceptionResponse;
+      }
+    } else if (exception instanceof Error) {
+      this.logger.error(`Unhandled error: ${exception.message}`, exception.stack);
+      errors = [
+        {
+          field: "general",
+          message: "Internal server error"
+        }
+      ];
+      message = "An unexpected error occurred";
+    } else {
+      this.logger.error("Unknown exception type", exception);
+      errors = [
+        {
+          field: "general",
+          message: "Internal server error"
+        }
+      ];
+      message = "An unexpected error occurred";
+    }
+    const errorResponse = {
+      errors,
+      message,
+      statusCode: status,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      path: request.url
+    };
+    if (status >= 500) {
+      this.logger.error(`HTTP ${status} Error: ${JSON.stringify(errorResponse)}`, exception instanceof Error ? exception.stack : void 0);
+    } else {
+      this.logger.warn(`HTTP ${status} Error: ${JSON.stringify(errorResponse)}`);
+    }
+    reply.status(status).send(errorResponse);
+  }
+  /**
+  * Parse class-validator error messages into field-specific errors
+  */
+  parseValidationErrors(messages) {
+    const errors = [];
+    for (const msg of messages) {
+      if (typeof msg === "string") {
+        errors.push({
+          field: "general",
+          message: msg
+        });
+      } else if (typeof msg === "object" && msg.property && msg.constraints) {
+        const field = msg.property;
+        const constraintMessages = Object.values(msg.constraints);
+        for (const constraintMsg of constraintMessages) {
+          errors.push({
+            field,
+            message: constraintMsg
+          });
+        }
+      }
+    }
+    return errors.length > 0 ? errors : [
+      {
+        field: "general",
+        message: "Validation failed"
+      }
+    ];
+  }
+};
+HttpExceptionFilter = _ts_decorate13([
+  (0, import_common18.Catch)()
+], HttpExceptionFilter);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AuthConfigModule,
+  CsrfGuard,
   DatabaseModule,
+  HttpExceptionFilter,
+  HttpModule,
   Onboarding,
+  PrimaryBaseRepository,
   PrimaryDatabaseService,
   Public,
   Tenant,
+  TenantBaseRepository,
   TenantContextService,
   TenantDatabaseService,
   VrittiAuthGuard