@exyconn/common 2.1.0 → 2.3.3

package/dist/index.mjs

@@ -1,15 +1,16 @@
 import winston from 'winston';
 import DailyRotateFile from 'winston-daily-rotate-file';
 import path, { resolve } from 'path';
-import mongoose from 'mongoose';
+import mongoose, { Types } from 'mongoose';
 import jwt from 'jsonwebtoken';
 import { existsSync, readFileSync } from 'fs';
+import rateLimit from 'express-rate-limit';
 import axios from 'axios';
 import { createContext, useState, useCallback, useMemo, useRef, useEffect, useContext } from 'react';
 import { jsx, jsxs } from 'react/jsx-runtime';
 import * as Yup from 'yup';
 import { Formik, Form, Field, ErrorMessage } from 'formik';
-import { subYears, subWeeks, subMonths, subMinutes, subHours, subDays, startOfYear, startOfWeek, startOfMonth, startOfDay as startOfDay$1, setSeconds, setMinutes, setHours, parseISO, isYesterday, isValid, isTomorrow, isToday as isToday$1, isThisYear, isThisWeek, isThisMonth, isSameYear, isSameWeek, isSameMonth, isSameDay, isPast as isPast$1, isFuture as isFuture$1, isEqual, isBefore, isAfter, intervalToDuration, getYear, getSeconds, getMonth, getMinutes, getHours, getDay, getDate, formatRelative, formatDuration, formatDistanceToNow, formatDistance, format, endOfYear, endOfWeek, endOfMonth, endOfDay as endOfDay$1, eachWeekOfInterval, eachMonthOfInterval, eachDayOfInterval, differenceInYears, differenceInWeeks, differenceInSeconds, differenceInMonths, differenceInMinutes, differenceInHours, differenceInDays, addYears, addWeeks, addMonths, addMinutes, addHours, addDays as addDays$1 } from 'date-fns';
+import { subYears, subWeeks, subMonths, subMinutes, subHours, subDays, startOfYear, startOfWeek, startOfMonth, startOfDay, setSeconds, setMinutes, setHours, parseISO, isYesterday, isValid, isTomorrow, isToday, isThisYear, isThisWeek, isThisMonth, isSameYear, isSameWeek, isSameMonth, isSameDay, isPast, isFuture, isEqual, isBefore, isAfter, intervalToDuration, getYear, getSeconds, getMonth, getMinutes, getHours, getDay, getDate, formatRelative, formatDuration, formatDistanceToNow, formatDistance, format, endOfYear, endOfWeek, endOfMonth, endOfDay, eachWeekOfInterval, eachMonthOfInterval, eachDayOfInterval, differenceInYears, differenceInWeeks, differenceInSeconds, differenceInMonths, differenceInMinutes, differenceInHours, differenceInDays, addYears, addWeeks, addMonths, addMinutes, addHours, addDays } from 'date-fns';
 import { toZonedTime, fromZonedTime, formatInTimeZone } from 'date-fns-tz';
 
 var __defProp = Object.defineProperty;
@@ -21,44 +22,89 @@ var __export = (target, all) => {
 // src/server/index.ts
 var server_exports = {};
 __export(server_exports, {
+  ConfigBuilder: () => ConfigBuilder,
+  DEFAULT_AUTH_CONFIG: () => DEFAULT_AUTH_CONFIG,
+  DEFAULT_CORS_CONFIG: () => DEFAULT_CORS_CONFIG,
+  DEFAULT_CORS_ORIGINS: () => DEFAULT_CORS_ORIGINS,
+  DEFAULT_DATABASE_CONFIG: () => DEFAULT_DATABASE_CONFIG,
+  DEFAULT_LOGGING_CONFIG: () => DEFAULT_LOGGING_CONFIG,
+  DEFAULT_RATE_LIMIT_CONFIG: () => DEFAULT_RATE_LIMIT_CONFIG,
+  DEFAULT_RATE_LIMIT_TIERS: () => DEFAULT_RATE_LIMIT_TIERS,
+  DEFAULT_SERVER_CONFIG: () => DEFAULT_SERVER_CONFIG,
+  EXYCONN_CORS_CONFIG: () => EXYCONN_CORS_CONFIG,
+  PERMISSIVE_CORS_CONFIG: () => PERMISSIVE_CORS_CONFIG,
+  RATE_LIMIT_CONFIG: () => RATE_LIMIT_CONFIG,
+  RateLimiterBuilder: () => RateLimiterBuilder,
+  STRICT_CORS_CONFIG: () => STRICT_CORS_CONFIG,
   StatusCode: () => StatusCode,
   StatusMessage: () => StatusMessage,
   authenticateApiKey: () => authenticateApiKey,
   authenticateJWT: () => authenticateJWT,
   badRequestResponse: () => badRequestResponse,
+  buildConfig: () => buildConfig,
+  buildDeleteFilter: () => buildDeleteFilter,
   buildFilter: () => buildFilter,
   buildPagination: () => buildPagination,
   buildPaginationMeta: () => buildPaginationMeta,
   checkPackageServer: () => checkPackageServer,
   conflictResponse: () => conflictResponse,
   connectDB: () => connectDB,
+  corsOptions: () => corsOptions,
+  createApiKeyGenerator: () => createApiKeyGenerator,
+  createApiRateLimiter: () => createApiRateLimiter,
+  createBrandCorsOptions: () => createBrandCorsOptions,
+  createBulkDeleteHandler: () => createBulkDeleteHandler,
+  createConfig: () => createConfig,
+  createCorsOptions: () => createCorsOptions,
+  createCrudControllers: () => createCrudControllers,
+  createDdosRateLimiter: () => createDdosRateLimiter,
   createLogger: () => createLogger,
   createMorganStream: () => createMorganStream,
+  createMultiBrandCorsOptions: () => createMultiBrandCorsOptions,
+  createPaginationMiddleware: () => createPaginationMiddleware,
+  createPrefixedKeyGenerator: () => createPrefixedKeyGenerator,
+  createRateLimiter: () => createRateLimiter,
+  createStandardRateLimiter: () => createStandardRateLimiter,
+  createStrictRateLimiter: () => createStrictRateLimiter,
+  createUserKeyGenerator: () => createUserKeyGenerator,
   createdResponse: () => createdResponse,
+  ddosProtectionLimiter: () => ddosProtectionLimiter,
+  defaultKeyGenerator: () => defaultKeyGenerator,
   disconnectDB: () => disconnectDB,
   errorResponse: () => errorResponse,
   extractColumns: () => extractColumns,
   extractOrganization: () => extractOrganization,
+  extractSchemaMeta: () => extractSchemaMeta,
   forbiddenResponse: () => forbiddenResponse,
   formatPackageCheckResult: () => formatPackageCheckResult,
   generateNcuCommand: () => generateNcuCommand,
   getConnectionStatus: () => getConnectionStatus,
+  getDatabaseOptions: () => getDatabaseOptions,
+  isDevelopment: () => isDevelopment,
+  isProduction: () => isProduction,
+  isTest: () => isTest,
   logger: () => logger,
   noContentResponse: () => noContentResponse,
   notFoundResponse: () => notFoundResponse,
   omitFields: () => omitFields,
   optionalAuthenticateJWT: () => optionalAuthenticateJWT,
   packageCheckServer: () => packageCheckServer,
+  parseBulkDelete: () => parseBulkDelete,
   pickFields: () => pickFields,
   printPackageCheckSummary: () => printPackageCheckSummary,
+  queryPagination: () => queryPagination,
+  queryParser: () => queryParser,
   rateLimitResponse: () => rateLimitResponse,
+  rateLimiter: () => rateLimiter,
   requireOrganization: () => requireOrganization,
   sanitizeDocument: () => sanitizeDocument,
   sanitizeUser: () => sanitizeUser,
   simpleLogger: () => simpleLogger,
+  standardRateLimiter: () => standardRateLimiter,
   statusCode: () => statusCode,
   statusMessage: () => statusMessage,
   stream: () => stream,
+  strictRateLimiter: () => strictRateLimiter,
   successResponse: () => successResponse,
   successResponseArr: () => successResponseArr,
   unauthorizedResponse: () => unauthorizedResponse,
@@ -341,37 +387,37 @@ var defaultOptions = {
   retryReads: true,
   w: "majority"
 };
-var connectDB = async (mongoUri, options = {}, logger2) => {
+var connectDB = async (mongoUri, options = {}, logger3) => {
   if (mongoose.connection.readyState === 1) {
-    logger2?.info("Database already connected, reusing connection");
+    logger3?.info("Database already connected, reusing connection");
     return mongoose;
   }
   const finalOptions = { ...defaultOptions, ...options };
   try {
     await mongoose.connect(mongoUri, finalOptions);
-    logger2?.info("MongoDB connected successfully");
+    logger3?.info("MongoDB connected successfully");
     mongoose.connection.on("error", (err) => {
-      logger2?.error("MongoDB connection error", err);
+      logger3?.error("MongoDB connection error", err);
     });
     mongoose.connection.on("disconnected", () => {
-      logger2?.info("MongoDB disconnected");
+      logger3?.info("MongoDB disconnected");
     });
     mongoose.connection.on("reconnected", () => {
-      logger2?.info("MongoDB reconnected");
+      logger3?.info("MongoDB reconnected");
     });
     return mongoose;
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
-    logger2?.error("MongoDB connection failed", { error: errorMessage });
+    logger3?.error("MongoDB connection failed", { error: errorMessage });
     throw error;
   }
 };
-var disconnectDB = async (logger2) => {
+var disconnectDB = async (logger3) => {
   try {
     await mongoose.disconnect();
-    logger2?.info("MongoDB disconnected successfully");
+    logger3?.info("MongoDB disconnected successfully");
   } catch (error) {
-    logger2?.error("Error disconnecting from MongoDB", error);
+    logger3?.error("Error disconnecting from MongoDB", error);
     throw error;
   }
 };
@@ -476,6 +522,629 @@ var requireOrganization = (req, res, next) => {
   next();
 };
 
+// src/server/middleware/queryParser.middleware.ts
+var queryParser = (req, _, next) => {
+  const { page, limit, sort, sortBy, sortOrder, search, filter, ...otherParams } = req.query;
+  const parsed = {
+    page: Math.max(Number(page) || 1, 1),
+    limit: Math.min(Number(limit) || 10, 100),
+    filter: {}
+  };
+  if (typeof sort === "string") {
+    const [field, order] = sort.split(":");
+    parsed.sort = {
+      field,
+      order: order === "asc" ? "asc" : "desc"
+    };
+  } else if (typeof sortBy === "string") {
+    parsed.sort = {
+      field: sortBy,
+      order: sortOrder === "asc" ? "asc" : "desc"
+    };
+  }
+  if (typeof search === "string") {
+    parsed.search = search;
+  }
+  if (typeof filter === "object" && filter !== null) {
+    Object.entries(filter).forEach(([key, value]) => {
+      if (value !== "all") {
+        parsed.filter[key] = value;
+      }
+    });
+  }
+  Object.entries(otherParams).forEach(([key, value]) => {
+    if (typeof value === "string" && value !== "all" && !["page", "limit", "sort", "sortBy", "sortOrder", "search"].includes(key)) {
+      parsed.filter[key] = value;
+    }
+  });
+  req.parsedQuery = parsed;
+  next();
+};
+
+// src/server/middleware/utils/schemaMeta.util.ts
+var getZodTypeName = (schema) => {
+  const typeName = schema._def?.typeName;
+  switch (typeName) {
+    case "ZodString":
+      return "string";
+    case "ZodNumber":
+      return "number";
+    case "ZodBoolean":
+      return "boolean";
+    case "ZodDate":
+      return "date";
+    case "ZodArray":
+      return "array";
+    case "ZodObject":
+      return "object";
+    case "ZodOptional":
+    case "ZodNullable":
+      return schema._def?.innerType ? getZodTypeName(schema._def.innerType) : "unknown";
+    case "ZodDefault":
+      return schema._def?.innerType ? getZodTypeName(schema._def.innerType) : "unknown";
+    case "ZodEnum":
+      return "enum";
+    case "ZodUnion":
+      return "union";
+    default:
+      return "unknown";
+  }
+};
+var isZodRequired = (schema) => {
+  const typeName = schema._def?.typeName;
+  return typeName !== "ZodOptional" && typeName !== "ZodNullable";
+};
+var extractSchemaMeta = (model, zodSchema) => {
+  const columns = [];
+  if (zodSchema && zodSchema.shape) {
+    const shape = zodSchema.shape;
+    for (const [key, value] of Object.entries(shape)) {
+      if (key.startsWith("_")) continue;
+      columns.push({
+        name: key,
+        datatype: getZodTypeName(value),
+        required: isZodRequired(value)
+      });
+    }
+    return columns;
+  }
+  try {
+    const schema = model.schema;
+    const paths = schema.paths;
+    for (const [key, pathInfo] of Object.entries(paths)) {
+      if (key.startsWith("_") || key === "__v") continue;
+      const schemaType = pathInfo;
+      columns.push({
+        name: key,
+        datatype: (schemaType.instance || "unknown").toLowerCase(),
+        required: schemaType.isRequired || false
+      });
+    }
+  } catch {
+  }
+  return columns;
+};
+
+// src/server/middleware/pagination.middleware.ts
+var queryPagination = (model, options = {}, withOrgId = true) => {
+  return async (req, res, next) => {
+    try {
+      const { page, limit, sort, search, filter } = req.parsedQuery;
+      const query = {};
+      Object.entries(filter).forEach(([key, value]) => {
+        if (options.regexFilterFields?.includes(key)) {
+          query[key] = { $regex: value, $options: "i" };
+        } else {
+          query[key] = value;
+        }
+      });
+      const organizationId = req.headers["x-organization-id"];
+      if (organizationId && typeof organizationId === "string" && withOrgId) {
+        query.organizationId = organizationId;
+      }
+      if (search && options.searchFields?.length) {
+        query.$or = options.searchFields.map((field) => ({
+          [field]: { $regex: search, $options: "i" }
+        }));
+      }
+      const sortQuery = sort ? { [sort.field]: sort.order } : { createdAt: "desc" };
+      const skip = (page - 1) * limit;
+      const [data, total] = await Promise.all([
+        model.find(query).sort(sortQuery).skip(skip).limit(limit),
+        model.countDocuments(query)
+      ]);
+      res.paginatedResult = {
+        data,
+        meta: {
+          page,
+          limit,
+          total,
+          totalPages: Math.ceil(total / limit)
+        },
+        columns: extractSchemaMeta(model, options.validatorSchema)
+      };
+      next();
+    } catch (error) {
+      next(error);
+    }
+  };
+};
+var isZodError = (error) => {
+  return error !== null && typeof error === "object" && "errors" in error && Array.isArray(error.errors);
+};
+var getOrgId = (req, orgField = "organizationId") => {
+  const orgReq = req;
+  return orgReq.organizationId || req.headers["x-organization-id"] || req.query[orgField];
+};
+var buildOrgFilter = (req, config) => {
+  const filter = {};
+  if (config.withOrganization !== false) {
+    const orgId = getOrgId(req, config.orgField);
+    if (orgId) {
+      filter[config.orgField || "organizationId"] = orgId;
+    }
+  }
+  return filter;
+};
+var formatZodError = (error) => {
+  return error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ");
+};
+function createCrudControllers(config) {
+  const {
+    model,
+    resourceName,
+    createSchema,
+    updateSchema,
+    searchFields = [],
+    regexFilterFields = [],
+    withOrganization = true,
+    orgField = "organizationId",
+    transformCreate,
+    transformUpdate,
+    afterCreate,
+    afterUpdate,
+    afterDelete,
+    excludeFields = [],
+    populateFields = [],
+    buildQuery
+  } = config;
+  const getAll = async (req, res, _next) => {
+    try {
+      const paginatedRes = res;
+      if (paginatedRes.paginatedResult) {
+        successResponse(res, paginatedRes.paginatedResult, `${resourceName} list fetched successfully`);
+        return;
+      }
+      const page = parseInt(req.query.page) || 1;
+      const limit = parseInt(req.query.limit) || 10;
+      const sortField = req.query.sortBy || "createdAt";
+      const sortOrder = req.query.sortOrder || "desc";
+      const search = req.query.search;
+      let query = {};
+      if (withOrganization) {
+        const orgId = getOrgId(req, orgField);
+        if (orgId) {
+          query[orgField] = orgId;
+        }
+      }
+      if (search && searchFields.length > 0) {
+        query.$or = searchFields.map((field) => ({
+          [field]: { $regex: search, $options: "i" }
+        }));
+      }
+      const filterableParams = Object.keys(req.query).filter(
+        (key) => !["page", "limit", "sortBy", "sortOrder", "search"].includes(key)
+      );
+      filterableParams.forEach((key) => {
+        const value = req.query[key];
+        if (value !== void 0 && value !== "" && value !== "all") {
+          if (regexFilterFields.includes(key)) {
+            query[key] = { $regex: value, $options: "i" };
+          } else {
+            query[key] = value;
+          }
+        }
+      });
+      if (buildQuery) {
+        query = buildQuery(req, query);
+      }
+      const sortQuery = { [sortField]: sortOrder };
+      const skip = (page - 1) * limit;
+      let projection = {};
+      if (excludeFields.length > 0) {
+        projection = excludeFields.reduce(
+          (acc, field) => ({ ...acc, [field]: 0 }),
+          {}
+        );
+      }
+      let dbQuery = model.find(query, projection);
+      if (populateFields.length > 0) {
+        populateFields.forEach((field) => {
+          dbQuery = dbQuery.populate(field);
+        });
+      }
+      const [data, total] = await Promise.all([
+        dbQuery.sort(sortQuery).skip(skip).limit(limit),
+        model.countDocuments(query)
+      ]);
+      successResponse(
+        res,
+        {
+          data,
+          meta: {
+            page,
+            limit,
+            total,
+            totalPages: Math.ceil(total / limit)
+          },
+          columns: extractSchemaMeta(model, createSchema)
+        },
+        `${resourceName} list fetched successfully`
+      );
+    } catch (error) {
+      logger.error(`Error in getAll ${resourceName}`, {
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+      errorResponse(res, `Failed to fetch ${resourceName.toLowerCase()} list`);
+    }
+  };
+  const getById = async (req, res, _next) => {
+    try {
+      const { id } = req.params;
+      if (!id || !Types.ObjectId.isValid(id)) {
+        badRequestResponse(res, "Invalid ID format");
+        return;
+      }
+      const query = {
+        _id: new Types.ObjectId(id),
+        ...buildOrgFilter(req, { ...config, withOrganization, orgField })
+      };
+      let dbQuery = model.findOne(query);
+      if (populateFields.length > 0) {
+        populateFields.forEach((field) => {
+          dbQuery = dbQuery.populate(field);
+        });
+      }
+      const doc = await dbQuery;
+      if (!doc) {
+        notFoundResponse(res, `${resourceName} not found`);
+        return;
+      }
+      successResponse(res, doc, `${resourceName} fetched successfully`);
+    } catch (error) {
+      logger.error(`Error in getById ${resourceName}`, {
+        error: error instanceof Error ? error.message : "Unknown error",
+        id: req.params.id
+      });
+      errorResponse(res, `Failed to fetch ${resourceName.toLowerCase()}`);
+    }
+  };
+  const create = async (req, res, _next) => {
+    try {
+      let input = req.body;
+      if (createSchema) {
+        try {
+          input = createSchema.parse(input);
+        } catch (error) {
+          if (isZodError(error)) {
+            badRequestResponse(res, formatZodError(error));
+            return;
+          }
+          throw error;
+        }
+      }
+      if (transformCreate) {
+        input = transformCreate(input, req);
+      }
+      if (withOrganization) {
+        const orgId = getOrgId(req, orgField);
+        if (orgId) {
+          input[orgField] = orgId;
+        }
+      }
+      const doc = new model(input);
+      await doc.save();
+      if (afterCreate) {
+        await afterCreate(doc, req);
+      }
+      logger.info(`${resourceName} created successfully`, {
+        id: doc._id,
+        [orgField]: input[orgField]
+      });
+      createdResponse(res, doc, `${resourceName} created successfully`);
+    } catch (error) {
+      logger.error(`Error in create ${resourceName}`, {
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+      if (error.code === 11e3) {
+        badRequestResponse(res, `A ${resourceName.toLowerCase()} with this data already exists`);
+        return;
+      }
+      errorResponse(res, `Failed to create ${resourceName.toLowerCase()}`);
+    }
+  };
+  const update = async (req, res, _next) => {
+    try {
+      const { id } = req.params;
+      if (!id || !Types.ObjectId.isValid(id)) {
+        badRequestResponse(res, "Invalid ID format");
+        return;
+      }
+      let input = req.body;
+      if (updateSchema) {
+        try {
+          input = updateSchema.parse(input);
+        } catch (error) {
+          if (isZodError(error)) {
+            badRequestResponse(res, formatZodError(error));
+            return;
+          }
+          throw error;
+        }
+      }
+      if (transformUpdate) {
+        input = transformUpdate(input, req);
+      }
+      const query = {
+        _id: new Types.ObjectId(id),
+        ...buildOrgFilter(req, { ...config, withOrganization, orgField })
+      };
+      const doc = await model.findOneAndUpdate(query, { $set: input }, { new: true });
+      if (!doc) {
+        notFoundResponse(res, `${resourceName} not found`);
+        return;
+      }
+      if (afterUpdate) {
+        await afterUpdate(doc, req);
+      }
+      logger.info(`${resourceName} updated successfully`, { id });
+      successResponse(res, doc, `${resourceName} updated successfully`);
+    } catch (error) {
+      logger.error(`Error in update ${resourceName}`, {
+        error: error instanceof Error ? error.message : "Unknown error",
+        id: req.params.id
+      });
+      errorResponse(res, `Failed to update ${resourceName.toLowerCase()}`);
+    }
+  };
+  const deleteOne = async (req, res, _next) => {
+    try {
+      const { id } = req.params;
+      if (!id || !Types.ObjectId.isValid(id)) {
+        badRequestResponse(res, "Invalid ID format");
+        return;
+      }
+      const query = {
+        _id: new Types.ObjectId(id),
+        ...buildOrgFilter(req, { ...config, withOrganization, orgField })
+      };
+      const result = await model.deleteOne(query);
+      if (result.deletedCount === 0) {
+        notFoundResponse(res, `${resourceName} not found`);
+        return;
+      }
+      if (afterDelete) {
+        await afterDelete(id, req);
+      }
+      logger.info(`${resourceName} deleted successfully`, { id });
+      noContentResponse(res, null, `${resourceName} deleted successfully`);
+    } catch (error) {
+      logger.error(`Error in delete ${resourceName}`, {
+        error: error instanceof Error ? error.message : "Unknown error",
+        id: req.params.id
+      });
+      errorResponse(res, `Failed to delete ${resourceName.toLowerCase()}`);
+    }
+  };
+  const bulkDelete = async (req, res, _next) => {
+    try {
+      const bulkReq = req;
+      const { deleteIds = [], deleteAll = false } = bulkReq;
+      const baseFilter = buildOrgFilter(req, { ...config, withOrganization, orgField });
+      let filter;
+      if (deleteAll) {
+        filter = baseFilter;
+      } else if (deleteIds.length > 0) {
+        filter = {
+          ...baseFilter,
+          _id: { $in: deleteIds.map((id) => new Types.ObjectId(id)) }
+        };
+      } else {
+        badRequestResponse(res, "No IDs provided for deletion");
+        return;
+      }
+      const result = await model.deleteMany(filter);
+      if (afterDelete && deleteIds.length > 0) {
+        await Promise.all(deleteIds.map((id) => afterDelete(id, req)));
+      }
+      logger.info(`${resourceName}(s) bulk deleted successfully`, {
+        deletedCount: result.deletedCount,
+        deleteAll
+      });
+      successResponse(
+        res,
+        { deletedCount: result.deletedCount },
+        `${result.deletedCount} ${resourceName.toLowerCase()}(s) deleted successfully`
+      );
+    } catch (error) {
+      logger.error(`Error in bulkDelete ${resourceName}`, {
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+      errorResponse(res, `Failed to delete ${resourceName.toLowerCase()}(s)`);
+    }
+  };
+  return {
+    getAll,
+    getById,
+    create,
+    update,
+    deleteOne,
+    bulkDelete
+  };
+}
+function createPaginationMiddleware(model, config = {}) {
+  const {
+    searchFields = [],
+    regexFilterFields = [],
+    withOrganization = true,
+    orgField = "organizationId"
+  } = config;
+  return async (req, res, next) => {
+    try {
+      const page = parseInt(req.query.page) || 1;
+      const limit = parseInt(req.query.limit) || 10;
+      const sortField = req.query.sortBy || "createdAt";
+      const sortOrder = req.query.sortOrder || "desc";
+      const search = req.query.search;
+      const query = {};
+      if (withOrganization) {
+        const orgId = getOrgId(req, orgField);
+        if (orgId) {
+          query[orgField] = orgId;
+        }
+      }
+      if (search && searchFields.length > 0) {
+        query.$or = searchFields.map((field) => ({
+          [field]: { $regex: search, $options: "i" }
+        }));
+      }
+      const filterableParams = Object.keys(req.query).filter(
+        (key) => !["page", "limit", "sortBy", "sortOrder", "search"].includes(key)
+      );
+      filterableParams.forEach((key) => {
+        const value = req.query[key];
+        if (value !== void 0 && value !== "" && value !== "all") {
+          if (regexFilterFields.includes(key)) {
+            query[key] = { $regex: value, $options: "i" };
+          } else {
+            query[key] = value;
+          }
+        }
+      });
+      const sortQuery = { [sortField]: sortOrder };
+      const skip = (page - 1) * limit;
+      const [data, total] = await Promise.all([
+        model.find(query).sort(sortQuery).skip(skip).limit(limit),
+        model.countDocuments(query)
+      ]);
+      const paginatedRes = res;
+      paginatedRes.paginatedResult = {
+        data,
+        meta: {
+          page,
+          limit,
+          total,
+          totalPages: Math.ceil(total / limit)
+        },
+        columns: extractSchemaMeta(model, config.createSchema)
+      };
+      next();
+    } catch (error) {
+      next(error);
+    }
+  };
+}
+var parseBulkDelete = (req, res, next) => {
+  try {
+    const bulkReq = req;
+    let ids = [];
+    if (Array.isArray(req.body)) {
+      ids = req.body;
+    } else if (req.body && Array.isArray(req.body.ids)) {
+      ids = req.body.ids;
+    } else if (req.body && typeof req.body === "object") {
+      if (Array.isArray(req.body.data)) {
+        ids = req.body.data;
+      }
+    }
+    if (ids.length === 0) {
+      return badRequestResponse(
+        res,
+        'Request body must contain an array of IDs. Use ["*"] to delete all records or ["id1", "id2"] to delete specific records.'
+      );
+    }
+    if (ids.length === 1 && ids[0] === "*") {
+      bulkReq.deleteAll = true;
+      bulkReq.deleteIds = [];
+      logger.info("Bulk delete: Deleting all records");
+      return next();
+    }
+    const validIds = [];
+    const invalidIds = [];
+    for (const id of ids) {
+      if (typeof id === "string" && Types.ObjectId.isValid(id)) {
+        validIds.push(id);
+      } else {
+        invalidIds.push(id);
+      }
+    }
+    if (invalidIds.length > 0) {
+      return badRequestResponse(
+        res,
+        `Invalid ID format(s): ${invalidIds.slice(0, 5).join(", ")}${invalidIds.length > 5 ? "..." : ""}. All IDs must be valid MongoDB ObjectIds.`
+      );
+    }
+    if (validIds.length === 0) {
+      return badRequestResponse(res, "No valid IDs provided for deletion.");
+    }
+    bulkReq.deleteAll = false;
+    bulkReq.deleteIds = validIds;
+    logger.info(`Bulk delete: Deleting ${validIds.length} record(s)`);
+    next();
+  } catch (error) {
+    logger.error("Error in parseBulkDelete middleware", error);
+    return badRequestResponse(res, "Failed to parse delete request");
+  }
+};
+var buildDeleteFilter = (req, organizationId) => {
+  const filter = {
+    organizationId: new Types.ObjectId(organizationId)
+  };
+  if (!req.deleteAll && req.deleteIds && req.deleteIds.length > 0) {
+    filter._id = {
+      $in: req.deleteIds.map((id) => new Types.ObjectId(id))
+    };
+  }
+  return filter;
+};
+var createBulkDeleteHandler = (Model2, modelName) => {
+  return async (req, res) => {
+    const bulkReq = req;
+    const organizationId = req.headers["x-organization-id"];
+    if (!organizationId) {
+      return badRequestResponse(res, "Organization ID is required");
+    }
+    try {
+      const filter = buildDeleteFilter(bulkReq, organizationId);
+      const result = await Model2.deleteMany(filter);
+      const deletedCount = result.deletedCount || 0;
+      logger.info(`Bulk delete completed: ${deletedCount} ${modelName}(s) deleted`, {
+        organizationId,
+        deleteAll: bulkReq.deleteAll,
+        requestedIds: bulkReq.deleteIds?.length || "all",
+        deletedCount
+      });
+      return res.status(200).json({
+        message: `Successfully deleted ${deletedCount} ${modelName}(s)`,
+        data: {
+          deletedCount,
+          deleteAll: bulkReq.deleteAll
+        },
+        status: "success",
+        statusCode: 200
+      });
+    } catch (error) {
+      logger.error(`Error in bulk delete ${modelName}`, error);
+      return res.status(500).json({
+        message: `Failed to delete ${modelName}(s)`,
+        data: null,
+        status: "error",
+        statusCode: 500
+      });
+    }
+  };
+};
+
 // src/server/utils/filter-builder.ts
 var buildFilter = (options) => {
   const {
@@ -770,45 +1439,704 @@ var packageCheckServer = {
   print: printPackageCheckSummary
 };
 
+// src/server/configs/cors.config.ts
+var DEFAULT_CORS_CONFIG = {
+  productionOrigins: [],
+  developmentOrigins: [
+    "http://localhost:3000",
+    "http://localhost:4000",
+    "http://localhost:5000",
+    "http://localhost:5173",
+    "http://localhost:8080",
+    "http://127.0.0.1:3000",
+    "http://127.0.0.1:4000",
+    "http://127.0.0.1:5000",
+    "http://127.0.0.1:5173",
+    "http://127.0.0.1:8080"
+  ],
+  allowedSubdomains: [],
+  originPatterns: [],
+  allowNoOrigin: true,
+  allowAllInDev: true,
+  credentials: true,
+  methods: ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD"],
+  allowedHeaders: [
+    "Content-Type",
+    "Authorization",
+    "X-Requested-With",
+    "Accept",
+    "Origin",
+    "X-API-Key",
+    "X-Organization-Id",
+    "X-Request-Id"
+  ],
+  exposedHeaders: [
+    "Content-Range",
+    "X-Content-Range",
+    "X-Total-Count",
+    "X-Request-Id"
+  ],
+  maxAge: 86400
+  // 24 hours
+};
+var createCorsOptions = (config = {}) => {
+  const finalConfig = { ...DEFAULT_CORS_CONFIG, ...config };
+  const {
+    productionOrigins,
+    developmentOrigins,
+    allowedSubdomains,
+    originPatterns,
+    allowNoOrigin,
+    allowAllInDev,
+    customValidator,
+    credentials,
+    methods,
+    allowedHeaders,
+    exposedHeaders,
+    maxAge
+  } = finalConfig;
+  const allOrigins = /* @__PURE__ */ new Set([...productionOrigins, ...developmentOrigins]);
+  const originHandler = (origin, callback) => {
+    if (!origin) {
+      callback(null, allowNoOrigin);
+      return;
+    }
+    if (allOrigins.has(origin)) {
+      callback(null, true);
+      return;
+    }
+    if (allowedSubdomains.some((subdomain) => origin.endsWith(subdomain))) {
+      callback(null, true);
+      return;
+    }
+    if (originPatterns.some((pattern) => pattern.test(origin))) {
+      callback(null, true);
+      return;
+    }
+    if (customValidator && customValidator(origin)) {
+      callback(null, true);
+      return;
+    }
+    if (process.env.NODE_ENV !== "production" && allowAllInDev) {
+      callback(null, true);
+      return;
+    }
+    if (process.env.NODE_ENV === "production") {
+      callback(new Error(`Origin ${origin} not allowed by CORS`));
+      return;
+    }
+    callback(null, true);
+  };
+  return {
+    origin: originHandler,
+    credentials,
+    methods,
+    allowedHeaders,
+    exposedHeaders,
+    maxAge
+  };
+};
+var createBrandCorsOptions = (brandDomain, additionalConfig = {}) => {
+  const productionOrigins = [
+    `https://${brandDomain}`,
+    `https://www.${brandDomain}`
+  ];
+  const allowedSubdomains = [`.${brandDomain}`];
+  return createCorsOptions({
+    productionOrigins,
+    allowedSubdomains,
+    ...additionalConfig
+  });
+};
+var createMultiBrandCorsOptions = (domains, additionalConfig = {}) => {
+  const productionOrigins = domains.flatMap((domain) => [
+    `https://${domain}`,
+    `https://www.${domain}`
+  ]);
+  const allowedSubdomains = domains.map((domain) => `.${domain}`);
+  return createCorsOptions({
+    productionOrigins,
+    allowedSubdomains,
+    ...additionalConfig
+  });
+};
+var EXYCONN_CORS_CONFIG = {
+  productionOrigins: [
+    "https://exyconn.com",
+    "https://www.exyconn.com",
+    "https://botify.life",
+    "https://www.botify.life",
+    "https://partywings.fun",
+    "https://www.partywings.fun",
+    "https://sibera.work",
+    "https://www.sibera.work",
+    "https://spentiva.com",
+    "https://www.spentiva.com"
+  ],
+  allowedSubdomains: [
+    ".exyconn.com",
+    ".botify.life",
+    ".partywings.fun",
+    ".sibera.work",
+    ".spentiva.com"
+  ],
+  developmentOrigins: [
+    "http://localhost:3000",
+    "http://localhost:4000",
+    "http://localhost:4001",
+    "http://localhost:4002",
+    "http://localhost:4003",
+    "http://localhost:4004",
+    "http://localhost:4005",
+    "http://localhost:5173",
+    "http://127.0.0.1:3000",
+    "http://127.0.0.1:4000",
+    "http://127.0.0.1:5173"
+  ]
+};
+var STRICT_CORS_CONFIG = {
+  allowNoOrigin: false,
+  allowAllInDev: false,
+  methods: ["GET", "POST", "PUT", "DELETE"]
+};
+var PERMISSIVE_CORS_CONFIG = {
+  allowNoOrigin: true,
+  allowAllInDev: true,
+  originPatterns: [/localhost/, /127\.0\.0\.1/]
+};
+var corsOptions = createCorsOptions(EXYCONN_CORS_CONFIG);
+var DEFAULT_RATE_LIMIT_TIERS = {
+  STANDARD: {
+    windowMs: 15 * 60 * 1e3,
+    // 15 minutes
+    maxRequests: 100,
+    message: "Too many requests, please try again later.",
+    skipSuccessfulRequests: false,
+    skipFailedRequests: false
+  },
+  STRICT: {
+    windowMs: 15 * 60 * 1e3,
+    // 15 minutes
+    maxRequests: 20,
+    message: "Too many requests, please try again later.",
+    skipSuccessfulRequests: false,
+    skipFailedRequests: false
+  },
+  DDOS: {
+    windowMs: 60 * 1e3,
+    // 1 minute
+    maxRequests: 60,
+    message: "Rate limit exceeded. Please slow down.",
+    skipSuccessfulRequests: false,
+    skipFailedRequests: false
+  },
+  // Additional presets
+  VERY_STRICT: {
+    windowMs: 60 * 60 * 1e3,
+    // 1 hour
+    maxRequests: 5,
+    message: "Too many attempts. Please try again in an hour.",
+    skipSuccessfulRequests: false,
+    skipFailedRequests: false
+  },
+  RELAXED: {
+    windowMs: 15 * 60 * 1e3,
+    // 15 minutes
+    maxRequests: 500,
+    message: "Rate limit exceeded.",
+    skipSuccessfulRequests: false,
+    skipFailedRequests: false
+  },
+  API: {
+    windowMs: 60 * 1e3,
+    // 1 minute
+    maxRequests: 30,
+    message: "API rate limit exceeded.",
+    skipSuccessfulRequests: false,
+    skipFailedRequests: false
+  }
+};
+var defaultKeyGenerator = (req) => {
+  const forwarded = req.headers["x-forwarded-for"];
+  const ip = forwarded ? Array.isArray(forwarded) ? forwarded[0] : forwarded.split(",")[0].trim() : req.ip || req.socket.remoteAddress || "unknown";
+  return ip;
+};
+var createPrefixedKeyGenerator = (prefix) => (req) => {
+  return `${prefix}:${defaultKeyGenerator(req)}`;
+};
+var createUserKeyGenerator = (getUserId) => (req) => {
+  const userId = getUserId(req);
+  return userId || defaultKeyGenerator(req);
+};
+var createApiKeyGenerator = (headerName = "x-api-key") => (req) => {
+  const apiKey = req.headers[headerName.toLowerCase()];
+  return apiKey || defaultKeyGenerator(req);
+};
+var createRateLimitResponse = (message, retryAfter) => ({
+  status: "error",
+  statusCode: 429,
+  message,
+  ...retryAfter
+});
+var createRateLimiter = (tierConfig, options = {}) => {
+  const {
+    standardHeaders = true,
+    legacyHeaders = false,
+    keyGenerator = defaultKeyGenerator,
+    skip,
+    handler
+  } = options;
+  return rateLimit({
+    windowMs: tierConfig.windowMs,
+    max: tierConfig.maxRequests,
+    message: createRateLimitResponse(tierConfig.message),
+    standardHeaders,
+    legacyHeaders,
+    keyGenerator,
+    skip,
+    handler,
+    skipSuccessfulRequests: tierConfig.skipSuccessfulRequests,
+    skipFailedRequests: tierConfig.skipFailedRequests
+  });
+};
+var createStandardRateLimiter = (config = {}, options = {}) => {
+  const tierConfig = { ...DEFAULT_RATE_LIMIT_TIERS.STANDARD, ...config };
+  return createRateLimiter(tierConfig, options);
+};
+var createStrictRateLimiter = (config = {}, options = {}) => {
+  const tierConfig = { ...DEFAULT_RATE_LIMIT_TIERS.STRICT, ...config };
+  return createRateLimiter(tierConfig, options);
+};
+var createDdosRateLimiter = (config = {}, options = {}) => {
+  const tierConfig = { ...DEFAULT_RATE_LIMIT_TIERS.DDOS, ...config };
+  return createRateLimiter(tierConfig, options);
+};
+var createApiRateLimiter = (config = {}, options = {}) => {
+  const tierConfig = { ...DEFAULT_RATE_LIMIT_TIERS.API, ...config };
+  return createRateLimiter(tierConfig, {
+    keyGenerator: createApiKeyGenerator(),
+    ...options
+  });
+};
+var RateLimiterBuilder = class {
+  constructor(preset = "STANDARD") {
+    const presetConfig = DEFAULT_RATE_LIMIT_TIERS[preset];
+    this.config = {
+      windowMs: presetConfig.windowMs,
+      maxRequests: presetConfig.maxRequests,
+      message: presetConfig.message,
+      skipSuccessfulRequests: presetConfig.skipSuccessfulRequests ?? false,
+      skipFailedRequests: presetConfig.skipFailedRequests ?? false
+    };
+    this.options = {};
+  }
+  /**
+   * Set window duration
+   */
+  windowMs(ms) {
+    this.config.windowMs = ms;
+    return this;
+  }
+  /**
+   * Set window duration in minutes
+   */
+  windowMinutes(minutes) {
+    this.config.windowMs = minutes * 60 * 1e3;
+    return this;
+  }
+  /**
+   * Set window duration in hours
+   */
+  windowHours(hours) {
+    this.config.windowMs = hours * 60 * 60 * 1e3;
+    return this;
+  }
+  /**
+   * Set maximum requests
+   */
+  max(requests) {
+    this.config.maxRequests = requests;
+    return this;
+  }
+  /**
+   * Set error message
+   */
+  message(msg) {
+    this.config.message = msg;
+    return this;
+  }
+  /**
+   * Skip successful requests
+   */
+  skipSuccessful(skip = true) {
+    this.config.skipSuccessfulRequests = skip;
+    return this;
+  }
+  /**
+   * Skip failed requests
+   */
+  skipFailed(skip = true) {
+    this.config.skipFailedRequests = skip;
+    return this;
+  }
+  /**
+   * Set key generator
+   */
+  keyBy(generator) {
+    this.options.keyGenerator = generator;
+    return this;
+  }
+  /**
+   * Key by IP (default)
+   */
+  keyByIp() {
+    this.options.keyGenerator = defaultKeyGenerator;
+    return this;
+  }
+  /**
+   * Key by API key
+   */
+  keyByApiKey(headerName) {
+    this.options.keyGenerator = createApiKeyGenerator(headerName);
+    return this;
+  }
+  /**
+   * Skip certain requests
+   */
+  skipWhen(predicate) {
+    this.options.skip = predicate;
+    return this;
+  }
+  /**
+   * Build the rate limiter
+   */
+  build() {
+    return createRateLimiter(this.config, this.options);
+  }
+};
+var rateLimiter = (preset) => {
+  return new RateLimiterBuilder(preset);
+};
+var RATE_LIMIT_CONFIG = {
+  STANDARD: DEFAULT_RATE_LIMIT_TIERS.STANDARD,
+  STRICT: DEFAULT_RATE_LIMIT_TIERS.STRICT,
+  DDOS: DEFAULT_RATE_LIMIT_TIERS.DDOS
+};
+var standardRateLimiter = createStandardRateLimiter();
+var strictRateLimiter = createStrictRateLimiter();
+var ddosProtectionLimiter = createDdosRateLimiter();
+
+// src/server/configs/server.config.ts
+var DEFAULT_SERVER_CONFIG = {
+  name: "app-server",
+  version: "1.0.0",
+  environment: process.env.NODE_ENV || "development",
+  port: parseInt(process.env.PORT || "3000", 10),
+  host: process.env.HOST || "0.0.0.0",
+  basePath: "/api",
+  debug: process.env.DEBUG === "true",
+  trustProxy: true
+};
+var DEFAULT_DATABASE_CONFIG = {
+  uri: process.env.DATABASE_URL || process.env.MONGODB_URI || "",
+  name: process.env.DATABASE_NAME || "app_db",
+  maxPoolSize: process.env.NODE_ENV === "production" ? 50 : 10,
+  minPoolSize: process.env.NODE_ENV === "production" ? 10 : 5,
+  socketTimeoutMS: 45e3,
+  serverSelectionTimeoutMS: 1e4,
+  maxIdleTimeMS: 1e4,
+  retryWrites: true,
+  retryReads: true,
+  writeConcern: "majority"
+};
+var DEFAULT_AUTH_CONFIG = {
+  jwtSecret: process.env.JWT_SECRET || "",
+  jwtExpiresIn: process.env.JWT_EXPIRES_IN || "7d",
+  refreshTokenExpiresIn: process.env.REFRESH_TOKEN_EXPIRES_IN || "30d",
+  enableRefreshTokens: true,
+  apiKeyHeader: "x-api-key",
+  orgHeader: "x-organization-id"
+};
+var DEFAULT_LOGGING_CONFIG = {
+  level: process.env.LOG_LEVEL || "info",
+  logsDir: process.env.LOGS_DIR || "logs",
+  maxSize: "20m",
+  maxFiles: "14d",
+  errorMaxFiles: "30d",
+  console: true,
+  file: process.env.NODE_ENV === "production",
+  json: process.env.NODE_ENV === "production"
+};
+var DEFAULT_CORS_ORIGINS = {
+  production: [],
+  development: [
+    "http://localhost:3000",
+    "http://localhost:4000",
+    "http://localhost:5173",
+    "http://127.0.0.1:3000",
+    "http://127.0.0.1:4000",
+    "http://127.0.0.1:5173"
+  ],
+  patterns: []
+};
+var DEFAULT_RATE_LIMIT_CONFIG = {
+  enabled: true,
+  standard: {
+    windowMs: 15 * 60 * 1e3,
+    // 15 minutes
+    maxRequests: 100,
+    message: "Too many requests, please try again later."
+  },
+  strict: {
+    windowMs: 15 * 60 * 1e3,
+    // 15 minutes
+    maxRequests: 20,
+    message: "Too many requests, please try again later."
+  },
+  ddos: {
+    windowMs: 60 * 1e3,
+    // 1 minute
+    maxRequests: 60,
+    message: "Rate limit exceeded. Please slow down.",
+    skipSuccessfulRequests: false
+  }
+};
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key in source) {
+    if (Object.prototype.hasOwnProperty.call(source, key)) {
+      const sourceValue = source[key];
+      const targetValue = target[key];
+      if (sourceValue !== void 0 && typeof sourceValue === "object" && sourceValue !== null && !Array.isArray(sourceValue) && typeof targetValue === "object" && targetValue !== null && !Array.isArray(targetValue)) {
+        result[key] = deepMerge(
+          targetValue,
+          sourceValue
+        );
+      } else if (sourceValue !== void 0) {
+        result[key] = sourceValue;
+      }
+    }
+  }
+  return result;
+}
+var ConfigBuilder = class {
+  constructor() {
+    this.config = {
+      server: { ...DEFAULT_SERVER_CONFIG },
+      database: { ...DEFAULT_DATABASE_CONFIG },
+      auth: { ...DEFAULT_AUTH_CONFIG },
+      logging: { ...DEFAULT_LOGGING_CONFIG },
+      cors: { ...DEFAULT_CORS_ORIGINS },
+      rateLimit: { ...DEFAULT_RATE_LIMIT_CONFIG }
+    };
+  }
+  /**
+   * Set server configuration
+   */
+  setServer(config) {
+    this.config.server = deepMerge(this.config.server, config);
+    return this;
+  }
+  /**
+   * Set database configuration
+   */
+  setDatabase(config) {
+    this.config.database = deepMerge(this.config.database, config);
+    return this;
+  }
+  /**
+   * Set auth configuration
+   */
+  setAuth(config) {
+    this.config.auth = deepMerge(this.config.auth, config);
+    return this;
+  }
+  /**
+   * Set logging configuration
+   */
+  setLogging(config) {
+    this.config.logging = deepMerge(this.config.logging, config);
+    return this;
+  }
+  /**
+   * Set CORS origins
+   */
+  setCorsOrigins(config) {
+    this.config.cors = deepMerge(this.config.cors, config);
+    return this;
+  }
+  /**
+   * Add CORS production origin
+   */
+  addProductionOrigin(origin) {
+    if (!this.config.cors.production.includes(origin)) {
+      this.config.cors.production.push(origin);
+    }
+    return this;
+  }
+  /**
+   * Add CORS development origin
+   */
+  addDevelopmentOrigin(origin) {
+    if (!this.config.cors.development.includes(origin)) {
+      this.config.cors.development.push(origin);
+    }
+    return this;
+  }
+  /**
+   * Add CORS pattern
+   */
+  addCorsPattern(pattern) {
+    if (!this.config.cors.patterns.includes(pattern)) {
+      this.config.cors.patterns.push(pattern);
+    }
+    return this;
+  }
+  /**
+   * Set rate limit configuration
+   */
+  setRateLimit(config) {
+    this.config.rateLimit = deepMerge(this.config.rateLimit, config);
+    return this;
+  }
+  /**
+   * Add custom rate limit tier
+   */
+  addRateLimitTier(name, tier) {
+    if (!this.config.rateLimit.custom) {
+      this.config.rateLimit.custom = {};
+    }
+    this.config.rateLimit.custom[name] = tier;
+    return this;
+  }
+  /**
+   * Set custom configuration
+   */
+  setCustom(key, value) {
+    if (!this.config.custom) {
+      this.config.custom = {};
+    }
+    this.config.custom[key] = value;
+    return this;
+  }
+  /**
+   * Load configuration from environment variables
+   */
+  loadFromEnv() {
+    if (process.env.SERVER_NAME) this.config.server.name = process.env.SERVER_NAME;
+    if (process.env.SERVER_VERSION) this.config.server.version = process.env.SERVER_VERSION;
+    if (process.env.PORT) this.config.server.port = parseInt(process.env.PORT, 10);
+    if (process.env.HOST) this.config.server.host = process.env.HOST;
+    if (process.env.BASE_PATH) this.config.server.basePath = process.env.BASE_PATH;
+    if (process.env.DATABASE_URL) this.config.database.uri = process.env.DATABASE_URL;
+    if (process.env.MONGODB_URI) this.config.database.uri = process.env.MONGODB_URI;
+    if (process.env.DATABASE_NAME) this.config.database.name = process.env.DATABASE_NAME;
+    if (process.env.JWT_SECRET) this.config.auth.jwtSecret = process.env.JWT_SECRET;
+    if (process.env.JWT_EXPIRES_IN) this.config.auth.jwtExpiresIn = process.env.JWT_EXPIRES_IN;
+    if (process.env.LOG_LEVEL) this.config.logging.level = process.env.LOG_LEVEL;
+    if (process.env.LOGS_DIR) this.config.logging.logsDir = process.env.LOGS_DIR;
+    if (process.env.CORS_ORIGINS) {
+      const origins = process.env.CORS_ORIGINS.split(",").map((o) => o.trim());
+      this.config.cors.production.push(...origins);
+    }
+    return this;
+  }
+  /**
+   * Validate configuration
+   */
+  validate() {
+    const errors = [];
+    if (!this.config.server.name) errors.push("Server name is required");
+    if (this.config.server.port < 1 || this.config.server.port > 65535) {
+      errors.push("Server port must be between 1 and 65535");
+    }
+    if (this.config.server.environment === "production") {
+      if (!this.config.auth.jwtSecret || this.config.auth.jwtSecret.length < 32) {
+        errors.push("JWT secret must be at least 32 characters in production");
+      }
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  /**
+   * Build the final configuration
+   */
+  build() {
+    return { ...this.config };
+  }
+};
+var createConfig = () => {
+  return new ConfigBuilder();
+};
+var buildConfig = (partial = {}) => {
+  const builder = createConfig().loadFromEnv();
+  if (partial.server) builder.setServer(partial.server);
+  if (partial.database) builder.setDatabase(partial.database);
+  if (partial.auth) builder.setAuth(partial.auth);
+  if (partial.logging) builder.setLogging(partial.logging);
+  if (partial.cors) builder.setCorsOrigins(partial.cors);
+  if (partial.rateLimit) builder.setRateLimit(partial.rateLimit);
+  return builder.build();
+};
+var isProduction = (config) => {
+  return (config?.environment || process.env.NODE_ENV) === "production";
+};
+var isDevelopment = (config) => {
+  return (config?.environment || process.env.NODE_ENV) === "development";
+};
+var isTest = (config) => {
+  return (config?.environment || process.env.NODE_ENV) === "test";
+};
+var getDatabaseOptions = (config) => {
+  return {
+    maxPoolSize: config.maxPoolSize,
+    minPoolSize: config.minPoolSize,
+    socketTimeoutMS: config.socketTimeoutMS,
+    serverSelectionTimeoutMS: config.serverSelectionTimeoutMS,
+    maxIdleTimeMS: config.maxIdleTimeMS,
+    retryWrites: config.retryWrites,
+    retryReads: config.retryReads,
+    w: config.writeConcern
+  };
+};
+
 // src/client/index.ts
 var client_exports = {};
 __export(client_exports, {
-  ApiUrlBuilder: () => ApiUrlBuilder,
+  API_BASE_URL: () => API_BASE_URL,
+  API_PREFIX: () => API_PREFIX,
   ClientLogger: () => ClientLogger,
   ContactForm: () => ContactForm,
-  EventEmitter: () => EventEmitter,
+  ERROR_CODES: () => ERROR_CODES,
   LoginForm: () => LoginForm,
   NewsletterForm: () => NewsletterForm,
   RegisterForm: () => RegisterForm,
+  STATUS_CODES: () => STATUS_CODES,
+  STATUS_MESSAGES: () => STATUS_MESSAGES,
+  SUCCESS_CODES: () => SUCCESS_CODES,
   ThemeContext: () => ThemeContext,
   ThemeProvider: () => ThemeProvider,
   ThemeToggle: () => ThemeToggle,
   VALIDATION_MESSAGES: () => VALIDATION_MESSAGES,
-  addDays: () => addDays,
   adjustColor: () => adjustColor,
-  appEvents: () => appEvents,
+  axios: () => axiosInstance,
   camelToKebab: () => camelToKebab,
   capitalize: () => capitalize,
   capitalizeWords: () => capitalizeWords,
-  checkPackage: () => checkPackage,
   clientLogger: () => clientLogger,
   contactFormSchema: () => contactFormSchema,
   copyToClipboard: () => copyToClipboard,
-  createApiEndpoints: () => createApiEndpoints,
-  createApiUrlBuilder: () => createApiUrlBuilder,
   createClientLogger: () => createClientLogger,
   createEmptyPaginationMeta: () => createEmptyPaginationMeta,
   createErrorResponse: () => createErrorResponse,
-  createEventEmitter: () => createEventEmitter,
-  createHttpClient: () => createHttpClient,
   createRegisterFormSchema: () => createRegisterFormSchema,
   createSuccessResponse: () => createSuccessResponse,
   createTheme: () => createTheme,
   createThemeFromBrand: () => createThemeFromBrand,
   cssVar: () => cssVar,
-  deepMerge: () => deepMerge,
+  deepMerge: () => deepMerge2,
   defaultDarkTheme: () => defaultDarkTheme,
   defaultLightTheme: () => defaultLightTheme,
+  deleteRequest: () => deleteRequest,
   dummyBannerData: () => dummyBannerData,
   dummyFaqItems: () => dummyFaqItems,
   dummyFeatures: () => dummyFeatures,
@@ -817,59 +2145,66 @@ __export(client_exports, {
   dummyImage: () => dummyImage,
   dummyPricingPlans: () => dummyPricingPlans,
   dummyTestimonials: () => dummyTestimonials,
-  endOfDay: () => endOfDay,
+  extractData: () => extractData,
+  extractMessage: () => extractMessage,
+  extractNestedData: () => extractNestedData,
+  extractPaginatedData: () => extractPaginatedData,
   flattenToCssVars: () => flattenToCssVars,
   formatDate: () => formatDate,
-  formatDateForInput: () => formatDateForInput,
   formatDateTime: () => formatDateTime,
-  formatDateTimeForInput: () => formatDateTimeForInput,
-  formatPackageCheckResult: () => formatPackageCheckResult2,
   formatRelativeTime: () => formatRelativeTime,
   generateCssVars: () => generateCssVars,
-  generateNcuCommand: () => generateNcuCommand2,
+  generateSlug: () => generateSlug,
+  generateSnakeSlug: () => generateSnakeSlug,
+  generateUrlSlug: () => generateUrlSlug,
   getContrastColor: () => getContrastColor,
   getErrorMessage: () => getErrorMessage,
   getNextPage: () => getNextPage,
   getPrevPage: () => getPrevPage,
+  getRequest: () => getRequest,
   getResponseData: () => getResponseData,
   getSystemColorScheme: () => getSystemColorScheme,
   hasData: () => hasData,
   hasMorePages: () => hasMorePages,
   hexToRgba: () => hexToRgba,
   injectCssVars: () => injectCssVars,
-  isClipboardAvailable: () => isClipboardAvailable,
   isErrorResponse: () => isErrorResponse,
-  isForbidden: () => isForbidden,
-  isFuture: () => isFuture,
-  isNotFound: () => isNotFound,
-  isPast: () => isPast,
-  isServerError: () => isServerError,
-  isStatusError: () => isStatusError,
   isSuccess: () => isSuccess,
   isSuccessResponse: () => isSuccessResponse,
-  isToday: () => isToday,
-  isUnauthorized: () => isUnauthorized,
+  isUtilErrorResponse: () => isErrorResponse2,
+  isUtilSuccessResponse: () => isSuccessResponse2,
   kebabToCamel: () => kebabToCamel,
   loadThemeFromUrl: () => loadThemeFromUrl,
   loadThemeMode: () => loadThemeMode,
+  logger: () => logger2,
   loginFormSchema: () => loginFormSchema,
   loremIpsum: () => loremIpsum,
   newsletterFormSchema: () => newsletterFormSchema,
   packageCheck: () => packageCheck,
+  parseAxiosErrorMessage: () => parseAxiosErrorMessage,
   parseError: () => parseError,
-  parseFullResponse: () => parseFullResponse,
-  parseResponse: () => parseResponse,
-  readFromClipboard: () => readFromClipboard,
+  parsePaginatedResponse: () => parsePaginatedResponse,
+  parseResponseData: () => parseResponseData,
+  parseResponseMessage: () => parseResponseMessage,
+  parseResponseStatus: () => parseResponseStatus,
+  parseResponseStatusMessage: () => parseResponseStatusMessage,
+  patchRequest: () => patchRequest,
+  postRequest: () => postRequest,
+  putRequest: () => putRequest,
   registerFormSchema: () => registerFormSchema,
   removeCssVars: () => removeCssVars,
   resolveThemeMode: () => resolveThemeMode,
+  safeJsonParse: () => safeJsonParse,
   saveThemeMode: () => saveThemeMode,
+  simpleMetaParseResponse: () => simpleMetaParseResponse,
+  simpleParseDualDataResponse: () => simpleParseDualDataResponse,
+  simpleParseResponse: () => simpleParseResponse,
   slugify: () => slugify,
   slugifyUnique: () => slugifyUnique,
-  startOfDay: () => startOfDay,
   truncate: () => truncate,
   truncateWords: () => truncateWords,
   unslugify: () => unslugify,
+  uploadFile: () => uploadFile,
   useBattery: () => useBattery_default,
   useClickAway: () => useClickAway_default,
   useContinuousRetry: () => useContinuousRetry_default,
@@ -929,112 +2264,466 @@ __export(client_exports, {
   useToggle: () => useToggle_default,
   useVisibilityChange: () => useVisibilityChange_default,
   useWindowScroll: () => useWindowScroll_default,
-  useWindowSize: () => useWindowSize_default,
-  withAbortSignal: () => withAbortSignal,
-  withFormData: () => withFormData,
-  withTimeout: () => withTimeout
+  useWindowSize: () => useWindowSize_default
 });
-var createHttpClient = (options) => {
-  const {
-    baseURL,
-    timeout = 3e4,
-    withCredentials = true,
-    getAuthToken,
-    onUnauthorized,
-    onServerError
-  } = options;
-  const instance = axios.create({
-    baseURL,
-    timeout,
-    withCredentials,
-    headers: {
-      "Content-Type": "application/json"
+
+// src/client/http/logger.ts
+var Logger = class {
+  constructor() {
+    this.isDevelopment = typeof window !== "undefined" && window.location.hostname === "localhost";
+  }
+  /**
+   * Log informational messages
+   */
+  info(message, data, options) {
+    if (this.isDevelopment) {
+      const prefix = options?.context ? `[${options.context}]` : "";
+      console.log(`${prefix} ${message}`, data ?? "");
+    }
+  }
+  /**
+   * Log warning messages
+   */
+  warn(message, data, options) {
+    if (this.isDevelopment) {
+      const prefix = options?.context ? `[${options.context}]` : "";
+      console.warn(`${prefix} ${message}`, data ?? "");
     }
-  });
-  instance.interceptors.request.use(
-    (config) => {
-      if (getAuthToken) {
-        const token = getAuthToken();
-        if (token && config.headers) {
-          config.headers.Authorization = `Bearer ${token}`;
-        }
+  }
+  /**
+   * Log error messages
+   */
+  error(message, error, options) {
+    const prefix = options?.context ? `[${options.context}]` : "";
+    if (this.isDevelopment) {
+      console.error(`${prefix} ${message}`, error, options?.metadata || "");
+    }
+  }
+  /**
+   * Log debug messages (only in development)
+   */
+  debug(message, data, options) {
+    if (this.isDevelopment) {
+      const prefix = options?.context ? `[${options.context}]` : "";
+      console.debug(`${prefix} ${message}`, data || "");
+    }
+  }
+  /**
+   * Log API errors with structured information
+   */
+  apiError(endpoint, error, metadata) {
+    this.error(`API Error: ${endpoint}`, error, {
+      context: "API",
+      metadata: {
+        endpoint,
+        ...metadata
       }
-      return config;
-    },
-    (error) => Promise.reject(error)
-  );
-  instance.interceptors.response.use(
-    (response) => response,
-    (error) => {
-      if (error.response) {
-        const status = error.response.status;
-        if (status === 401 && onUnauthorized) {
-          onUnauthorized();
-        }
-        if (status >= 500 && onServerError) {
-          onServerError(error);
-        }
+    });
+  }
+};
+var logger2 = new Logger();
+
+// src/client/http/response-parser.ts
+var STATUS_CODES = {
+  SUCCESS: 200,
+  CREATED: 201,
+  NO_CONTENT: 204,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  CONFLICT: 409,
+  ERROR: 500
+};
+var STATUS_MESSAGES = {
+  SUCCESS: "success",
+  CREATED: "created",
+  NO_CONTENT: "no_content",
+  BAD_REQUEST: "bad_request",
+  UNAUTHORIZED: "unauthorized",
+  FORBIDDEN: "forbidden",
+  NOT_FOUND: "not_found",
+  CONFLICT: "conflict",
+  ERROR: "error"
+};
+var SUCCESS_CODES = [200, 201, 204];
+var ERROR_CODES = [400, 401, 403, 404, 409, 500];
+var parseResponseData = (response, fallback = null) => {
+  try {
+    if (!response || typeof response !== "object") {
+      return fallback;
+    }
+    const resp = response;
+    if ("data" in resp) {
+      return resp["data"] ?? fallback;
+    }
+    return response;
+  } catch (error) {
+    logger2.error("Error parsing response data", error);
+    return fallback;
+  }
+};
+var parseResponseMessage = (response, fallback = "") => {
+  try {
+    if (!response || typeof response !== "object") {
+      return fallback;
+    }
+    const resp = response;
+    if ("message" in resp && typeof resp["message"] === "string") {
+      return resp["message"];
+    }
+    return fallback;
+  } catch (error) {
+    logger2.error("Error parsing response message", error);
+    return fallback;
+  }
+};
+var parseResponseStatus = (response) => {
+  try {
+    if (!response || typeof response !== "object") {
+      return null;
+    }
+    const resp = response;
+    if ("statusCode" in resp && typeof resp["statusCode"] === "number") {
+      return resp["statusCode"];
+    }
+    if ("status" in resp && typeof resp["status"] === "number") {
+      return resp["status"];
+    }
+    return null;
+  } catch (error) {
+    logger2.error("Error parsing response status", error);
+    return null;
+  }
+};
+var parseResponseStatusMessage = (response, fallback = "") => {
+  try {
+    if (!response || typeof response !== "object") {
+      return fallback;
+    }
+    const resp = response;
+    if ("status" in resp && typeof resp["status"] === "string") {
+      return resp["status"];
+    }
+    return fallback;
+  } catch (error) {
+    logger2.error("Error parsing response status message", error);
+    return fallback;
+  }
+};
+var isSuccessResponse = (response) => {
+  try {
+    const statusCode2 = parseResponseStatus(response);
+    if (statusCode2 !== null) {
+      return SUCCESS_CODES.includes(statusCode2);
+    }
+    const status = parseResponseStatusMessage(response);
+    return [STATUS_MESSAGES.SUCCESS, STATUS_MESSAGES.CREATED, STATUS_MESSAGES.NO_CONTENT].includes(
+      status
+    );
+  } catch (error) {
+    logger2.error("Error checking response success", error);
+    return false;
+  }
+};
+var isErrorResponse = (response) => {
+  try {
+    const statusCode2 = parseResponseStatus(response);
+    if (statusCode2 !== null) {
+      return ERROR_CODES.includes(statusCode2);
+    }
+    return false;
+  } catch (error) {
+    logger2.error("Error checking response error", error);
+    return false;
+  }
+};
+var parsePaginatedResponse = (response) => {
+  try {
+    if (!response || typeof response !== "object") {
+      return { items: [], total: 0, page: 1, limit: 10 };
+    }
+    const resp = response;
+    let items = [];
+    if ("data" in resp && Array.isArray(resp["data"])) {
+      items = resp["data"];
+    }
+    let total = items.length;
+    let page = 1;
+    let limit = 10;
+    let totalPages;
+    if ("paginationData" in resp && resp["paginationData"] && typeof resp["paginationData"] === "object") {
+      const paginationData = resp["paginationData"];
+      if ("total" in paginationData && typeof paginationData["total"] === "number") {
+        total = paginationData["total"];
+      }
+      if ("page" in paginationData && typeof paginationData["page"] === "number") {
+        page = paginationData["page"];
+      }
+      if ("limit" in paginationData && typeof paginationData["limit"] === "number") {
+        limit = paginationData["limit"];
+      }
+      if ("totalPages" in paginationData && typeof paginationData["totalPages"] === "number") {
+        totalPages = paginationData["totalPages"];
       }
-      return Promise.reject(error);
     }
-  );
-  return instance;
+    let columns;
+    if ("columns" in resp && Array.isArray(resp["columns"])) {
+      columns = resp["columns"];
+    }
+    return {
+      items,
+      total,
+      page,
+      limit,
+      ...totalPages !== void 0 && { totalPages },
+      ...columns !== void 0 && { columns }
+    };
+  } catch (error) {
+    logger2.error("Error parsing paginated response", error);
+    return { items: [], total: 0, page: 1, limit: 10 };
+  }
 };
-var withFormData = () => ({
-  headers: {
-    "Content-Type": "multipart/form-data"
+var extractNestedData = (response, path2, fallback = null) => {
+  try {
+    const keys = path2.split(".");
+    let current = response;
+    for (const key of keys) {
+      if (current && typeof current === "object" && key in current) {
+        current = current[key];
+      } else {
+        return fallback;
+      }
+    }
+    return current;
+  } catch (error) {
+    logger2.error("Error extracting nested data", error);
+    return fallback;
   }
-});
-var withTimeout = (ms) => ({
-  timeout: ms
-});
-var withAbortSignal = (signal) => ({
-  signal
-});
-
-// src/client/http/response-parser.ts
-var parseResponse = (response) => {
-  if (response.data?.success && response.data?.data !== void 0) {
-    return response.data.data;
+};
+var safeJsonParse = (json, fallback = null) => {
+  try {
+    return JSON.parse(json);
+  } catch (error) {
+    logger2.error("Error parsing JSON", error);
+    return fallback;
   }
-  return null;
 };
-var parseFullResponse = (response) => {
-  return response.data;
+var parseAxiosErrorMessage = (error) => {
+  try {
+    if (!error || typeof error !== "object") {
+      return "An unexpected error occurred";
+    }
+    const err = error;
+    if ("response" in err && err["response"] && typeof err["response"] === "object") {
+      const response = err["response"];
+      if ("data" in response && response["data"] && typeof response["data"] === "object") {
+        const data = response["data"];
+        if ("data" in data && data["data"] && typeof data["data"] === "object") {
+          const nestedData = data["data"];
+          if ("message" in nestedData && typeof nestedData["message"] === "string") {
+            return nestedData["message"];
+          }
+        }
+        if ("message" in data && typeof data["message"] === "string") {
+          return data["message"];
+        }
+        if ("error" in data && typeof data["error"] === "string") {
+          return data["error"];
+        }
+      }
+    }
+    if ("message" in err && typeof err["message"] === "string") {
+      return err["message"];
+    }
+    if (typeof error === "string") {
+      return error;
+    }
+    return "An unexpected error occurred";
+  } catch (parseError2) {
+    logger2.error("Error parsing axios error message", parseError2);
+    return "An unexpected error occurred";
+  }
 };
 var parseError = (error) => {
-  if (error.response?.data?.message) {
-    return error.response.data.message;
+  try {
+    if (!error || typeof error !== "object") {
+      return {
+        message: "An unexpected error occurred",
+        statusCode: null,
+        data: null
+      };
+    }
+    const err = error;
+    let statusCode2 = null;
+    let data = null;
+    let status;
+    if ("response" in err && err["response"] && typeof err["response"] === "object") {
+      const response = err["response"];
+      if ("status" in response && typeof response["status"] === "number") {
+        statusCode2 = response["status"];
+      }
+      if ("data" in response && response["data"] !== void 0) {
+        data = response["data"];
+        if (data && typeof data === "object" && "status" in data) {
+          const dataObj = data;
+          if (typeof dataObj["status"] === "string") {
+            status = dataObj["status"];
+          }
+        }
+      }
+    }
+    if (statusCode2 === null && "statusCode" in err && typeof err["statusCode"] === "number") {
+      statusCode2 = err["statusCode"];
+    }
+    if (data === null && "data" in err && err["data"] !== void 0) {
+      data = err["data"];
+    }
+    if (!status && "status" in err && typeof err["status"] === "string") {
+      status = err["status"];
+    }
+    return {
+      message: parseAxiosErrorMessage(error),
+      statusCode: statusCode2,
+      data,
+      ...status !== void 0 && { status }
+    };
+  } catch (err) {
+    logger2.error("Error parsing error object", err);
+    return {
+      message: "An unexpected error occurred",
+      statusCode: null,
+      data: null
+    };
+  }
+};
+var simpleParseResponse = (response) => {
+  return response?.data?.data?.data;
+};
+var simpleMetaParseResponse = (response) => {
+  return response?.data?.data?.meta;
+};
+var simpleParseDualDataResponse = (response) => {
+  return response?.data?.data;
+};
+
+// src/client/http/http.ts
+var isDevelopment2 = typeof window !== "undefined" && window.location.hostname === "localhost";
+var API_BASE_URL = isDevelopment2 ? "http://localhost:4002" : "https://service-api.exyconn.com";
+var API_PREFIX = "/v1/api";
+var axiosInstance = axios.create({
+  baseURL: API_BASE_URL,
+  timeout: 3e4,
+  // 30 seconds
+  headers: {
+    "Content-Type": "application/json"
   }
-  if (error.response?.data?.error) {
-    return error.response.data.error;
+});
+axiosInstance.interceptors.request.use(
+  (config) => {
+    try {
+      if (typeof window !== "undefined" && window.localStorage) {
+        const selectedOrg = localStorage.getItem("selectedOrganization");
+        if (selectedOrg) {
+          const org = JSON.parse(selectedOrg);
+          if (org && org._id) {
+            config.headers["x-organization-id"] = org._id;
+          }
+        }
+      }
+    } catch (error) {
+      logger2.warn("Failed to read organization from localStorage", error);
+    }
+    return config;
+  },
+  (error) => {
+    return Promise.reject(error);
   }
-  if (error.code === "ERR_NETWORK") {
-    return "Network error. Please check your connection.";
+);
+axiosInstance.interceptors.response.use(
+  (response) => response,
+  (error) => {
+    const parsedError = parseError(error);
+    logger2.error("API Error", parsedError);
+    return Promise.reject(parsedError);
   }
-  if (error.code === "ECONNABORTED") {
-    return "Request timed out. Please try again.";
+);
+var buildHeaders = (customHeaders) => {
+  const headers = {
+    "Content-Type": "application/json",
+    ...customHeaders
+  };
+  return headers;
+};
+var buildConfig2 = (params, customHeaders) => {
+  const config = {
+    headers: buildHeaders(customHeaders)
+  };
+  if (params) {
+    config.params = params;
   }
-  return error.message || "An unexpected error occurred.";
+  return config;
 };
-var isSuccess = (response) => {
-  return response.data?.success === true;
+var getRequest = async (url, params, customHeaders) => {
+  const config = buildConfig2(params, customHeaders);
+  return axiosInstance.get(url, config);
+};
+var postRequest = async (url, data, customHeaders) => {
+  const config = buildConfig2(void 0, customHeaders);
+  return axiosInstance.post(url, data, config);
+};
+var putRequest = async (url, data, customHeaders) => {
+  const config = buildConfig2(void 0, customHeaders);
+  return axiosInstance.put(url, data, config);
+};
+var patchRequest = async (url, data, customHeaders) => {
+  const config = buildConfig2(void 0, customHeaders);
+  return axiosInstance.patch(url, data, config);
+};
+var deleteRequest = async (url, params, customHeaders) => {
+  const config = buildConfig2(params, customHeaders);
+  return axiosInstance.delete(url, config);
+};
+var uploadFile = async (url, file, additionalData) => {
+  const formData = new FormData();
+  formData.append("file", file);
+  if (additionalData) {
+    Object.entries(additionalData).forEach(([key, value]) => {
+      formData.append(key, String(value));
+    });
+  }
+  const config = {
+    headers: {
+      "Content-Type": "multipart/form-data"
+    }
+  };
+  return axiosInstance.post(url, formData, config);
+};
+var extractData = (response) => {
+  return parseResponseData(response.data);
+};
+var extractMessage = (response) => {
+  return parseResponseMessage(response, "");
 };
-var isStatusError = (error, statusCode2) => {
-  return error.response?.status === statusCode2;
+var isSuccess = (response) => {
+  return response.status >= 200 && response.status < 300;
 };
-var isUnauthorized = (error) => {
-  return isStatusError(error, 401);
+var extractPaginatedData = (response) => {
+  return parsePaginatedResponse(response.data);
 };
-var isForbidden = (error) => {
-  return isStatusError(error, 403);
+
+// src/client/http/slug.ts
+var generateSlug = (text) => {
+  if (!text) return "";
+  return text.trim().replace(/[^\w\s]/g, "").replace(/\s+(.)/g, (_, char) => char.toUpperCase()).replace(/\s+/g, "").replace(/^(.)/, (_, char) => char.toLowerCase());
 };
-var isNotFound = (error) => {
-  return isStatusError(error, 404);
+var generateUrlSlug = (text) => {
+  if (!text) return "";
+  return text.trim().toLowerCase().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
 };
-var isServerError = (error) => {
-  const status = error.response?.status;
-  return status !== void 0 && status >= 500;
+var generateSnakeSlug = (text) => {
+  if (!text) return "";
+  return text.trim().toLowerCase().replace(/[^\w\s]/g, "").replace(/\s+/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
 };
 
 // src/client/logger/client-logger.ts
@@ -1190,40 +2879,6 @@ var formatRelativeTime = (date) => {
   }
   return "just now";
 };
-var formatDateForInput = (date) => {
-  const dateObj = new Date(date);
-  return dateObj.toISOString().split("T")[0];
-};
-var formatDateTimeForInput = (date) => {
-  const dateObj = new Date(date);
-  return dateObj.toISOString().slice(0, 16);
-};
-var isToday = (date) => {
-  const dateObj = new Date(date);
-  const today = /* @__PURE__ */ new Date();
-  return dateObj.getDate() === today.getDate() && dateObj.getMonth() === today.getMonth() && dateObj.getFullYear() === today.getFullYear();
-};
-var isPast = (date) => {
-  return new Date(date).getTime() < Date.now();
-};
-var isFuture = (date) => {
-  return new Date(date).getTime() > Date.now();
-};
-var addDays = (date, days) => {
-  const dateObj = new Date(date);
-  dateObj.setDate(dateObj.getDate() + days);
-  return dateObj;
-};
-var startOfDay = (date) => {
-  const dateObj = new Date(date);
-  dateObj.setHours(0, 0, 0, 0);
-  return dateObj;
-};
-var endOfDay = (date) => {
-  const dateObj = new Date(date);
-  dateObj.setHours(23, 59, 59, 999);
-  return dateObj;
-};
 
 // src/client/utils/clipboard.ts
 var copyToClipboard = async (text) => {
@@ -1248,20 +2903,6 @@ var copyToClipboard = async (text) => {
     return false;
   }
 };
-var readFromClipboard = async () => {
-  try {
-    if (navigator.clipboard && window.isSecureContext) {
-      return await navigator.clipboard.readText();
-    }
-    return null;
-  } catch (error) {
-    console.error("Failed to read from clipboard:", error);
-    return null;
-  }
-};
-var isClipboardAvailable = () => {
-  return !!(navigator.clipboard && window.isSecureContext);
-};
 
 // src/client/utils/slug.ts
 var slugify = (text) => {
@@ -1298,165 +2939,15 @@ var kebabToCamel = (text) => {
   return text.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
 };
 
-// src/client/utils/events.ts
-var EventEmitter = class {
-  constructor() {
-    this.handlers = /* @__PURE__ */ new Map();
-  }
-  /**
-   * Subscribe to an event
-   * @returns Unsubscribe function
-   */
-  on(event, handler) {
-    if (!this.handlers.has(event)) {
-      this.handlers.set(event, /* @__PURE__ */ new Set());
-    }
-    this.handlers.get(event).add(handler);
-    return () => this.off(event, handler);
-  }
-  /**
-   * Subscribe to an event once
-   */
-  once(event, handler) {
-    const wrappedHandler = (data) => {
-      this.off(event, wrappedHandler);
-      handler(data);
-    };
-    return this.on(event, wrappedHandler);
-  }
-  /**
-   * Unsubscribe from an event
-   */
-  off(event, handler) {
-    const eventHandlers = this.handlers.get(event);
-    if (eventHandlers) {
-      eventHandlers.delete(handler);
-    }
-  }
-  /**
-   * Emit an event
-   */
-  emit(event, data) {
-    const eventHandlers = this.handlers.get(event);
-    if (eventHandlers) {
-      eventHandlers.forEach((handler) => {
-        try {
-          handler(data);
-        } catch (error) {
-          console.error(`Error in event handler for "${String(event)}":`, error);
-        }
-      });
-    }
-  }
-  /**
-   * Remove all handlers for an event (or all events)
-   */
-  removeAllListeners(event) {
-    if (event) {
-      this.handlers.delete(event);
-    } else {
-      this.handlers.clear();
-    }
-  }
-  /**
-   * Get count of listeners for an event
-   */
-  listenerCount(event) {
-    return this.handlers.get(event)?.size ?? 0;
-  }
-};
-var createEventEmitter = () => {
-  return new EventEmitter();
-};
-var appEvents = new EventEmitter();
-
-// src/client/utils/api-urls.ts
-var ApiUrlBuilder = class {
-  constructor(config) {
-    this.baseUrl = config.baseUrl.replace(/\/$/, "");
-    this.version = config.version || "";
-  }
-  /**
-   * Build full URL from path
-   */
-  build(path2) {
-    const normalizedPath = path2.startsWith("/") ? path2 : `/${path2}`;
-    const versionPath = this.version ? `/${this.version}` : "";
-    return `${this.baseUrl}${versionPath}${normalizedPath}`;
-  }
-  /**
-   * Build URL with query parameters
-   */
-  buildWithParams(path2, params) {
-    const url = this.build(path2);
-    const filteredParams = Object.entries(params).filter(([, value]) => value !== void 0).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`).join("&");
-    return filteredParams ? `${url}?${filteredParams}` : url;
-  }
-  /**
-   * Build URL with path parameters
-   */
-  buildWithPathParams(template, params) {
-    let path2 = template;
-    Object.entries(params).forEach(([key, value]) => {
-      path2 = path2.replace(`:${key}`, String(value));
-      path2 = path2.replace(`{${key}}`, String(value));
-    });
-    return this.build(path2);
-  }
-  /**
-   * Get base URL
-   */
-  getBaseUrl() {
-    return this.baseUrl;
-  }
-  /**
-   * Set new base URL
-   */
-  setBaseUrl(baseUrl) {
-    this.baseUrl = baseUrl.replace(/\/$/, "");
-  }
-};
-var createApiUrlBuilder = (config) => {
-  return new ApiUrlBuilder(config);
-};
-var createApiEndpoints = (builder) => ({
-  // Auth endpoints
-  auth: {
-    login: () => builder.build("/auth/login"),
-    register: () => builder.build("/auth/register"),
-    logout: () => builder.build("/auth/logout"),
-    refresh: () => builder.build("/auth/refresh"),
-    me: () => builder.build("/auth/me"),
-    forgotPassword: () => builder.build("/auth/forgot-password"),
-    resetPassword: () => builder.build("/auth/reset-password")
-  },
-  // User endpoints
-  users: {
-    list: () => builder.build("/users"),
-    get: (id) => builder.buildWithPathParams("/users/:id", { id }),
-    create: () => builder.build("/users"),
-    update: (id) => builder.buildWithPathParams("/users/:id", { id }),
-    delete: (id) => builder.buildWithPathParams("/users/:id", { id })
-  },
-  // Generic CRUD factory
-  crud: (resource) => ({
-    list: () => builder.build(`/${resource}`),
-    get: (id) => builder.buildWithPathParams(`/${resource}/:id`, { id }),
-    create: () => builder.build(`/${resource}`),
-    update: (id) => builder.buildWithPathParams(`/${resource}/:id`, { id }),
-    delete: (id) => builder.buildWithPathParams(`/${resource}/:id`, { id })
-  })
-});
-
 // src/client/utils/response-parser.ts
-var isSuccessResponse = (response) => {
+var isSuccessResponse2 = (response) => {
   return response.success === true;
 };
-var isErrorResponse = (response) => {
+var isErrorResponse2 = (response) => {
   return response.success === false;
 };
 var getResponseData = (response, defaultValue) => {
-  if (isSuccessResponse(response) && response.data !== void 0) {
+  if (isSuccessResponse2(response) && response.data !== void 0) {
     return response.data;
   }
   return defaultValue;
@@ -3697,18 +5188,18 @@ function useLogger(componentName, props, options = {}) {
   const {
     logProps = true,
     logLifecycle = true,
-    logger: logger2 = console.log
+    logger: logger3 = console.log
   } = options;
   const previousProps = useRef(props);
   const renderCount = useRef(0);
   renderCount.current++;
   useEffect(() => {
     if (logLifecycle) {
-      logger2(`[${componentName}] Mounted`);
+      logger3(`[${componentName}] Mounted`);
     }
     return () => {
       if (logLifecycle) {
-        logger2(`[${componentName}] Unmounted (rendered ${renderCount.current} times)`);
+        logger3(`[${componentName}] Unmounted (rendered ${renderCount.current} times)`);
       }
     };
   }, []);
@@ -3740,12 +5231,12 @@ function useLogger(componentName, props, options = {}) {
       });
     }
     if (hasChanges) {
-      logger2(`[${componentName}] Props changed:`, changedProps);
+      logger3(`[${componentName}] Props changed:`, changedProps);
     }
     previousProps.current = props;
-  }, [componentName, props, logProps, logger2]);
+  }, [componentName, props, logProps, logger3]);
   if (process.env.NODE_ENV === "development") {
-    logger2(`[${componentName}] Render #${renderCount.current}`);
+    logger3(`[${componentName}] Render #${renderCount.current}`);
   }
 }
 var useLogger_default = useLogger;
@@ -4943,14 +6434,14 @@ var defaultDarkTheme = {
 };
 
 // src/client/web/theme/theme-utils.ts
-function deepMerge(target, source) {
+function deepMerge2(target, source) {
   const output = { ...target };
   for (const key in source) {
     if (Object.prototype.hasOwnProperty.call(source, key)) {
       const sourceValue = source[key];
       const targetValue = target[key];
       if (sourceValue && typeof sourceValue === "object" && !Array.isArray(sourceValue) && targetValue && typeof targetValue === "object" && !Array.isArray(targetValue)) {
-        output[key] = deepMerge(
+        output[key] = deepMerge2(
           targetValue,
           sourceValue
         );
@@ -5016,7 +6507,7 @@ function createThemeFromBrand(brand, baseTheme = defaultLightTheme) {
       }
     }
   };
-  return deepMerge(baseTheme, brandOverrides);
+  return deepMerge2(baseTheme, brandOverrides);
 }
 function adjustColor(hex, percent) {
   hex = hex.replace(/^#/, "");
@@ -5110,8 +6601,8 @@ async function createTheme(config = {}) {
   if (config.themeUrl) {
     const urlTheme = await loadThemeFromUrl(config.themeUrl);
     if (urlTheme) {
-      lightTheme = deepMerge(lightTheme, urlTheme);
-      darkTheme = deepMerge(darkTheme, urlTheme);
+      lightTheme = deepMerge2(lightTheme, urlTheme);
+      darkTheme = deepMerge2(darkTheme, urlTheme);
     }
   }
   if (config.brandIdentity) {
@@ -5119,10 +6610,10 @@ async function createTheme(config = {}) {
     darkTheme = createThemeFromBrand(config.brandIdentity, darkTheme);
   }
   if (config.light) {
-    lightTheme = deepMerge(lightTheme, config.light);
+    lightTheme = deepMerge2(lightTheme, config.light);
   }
   if (config.dark) {
-    darkTheme = deepMerge(darkTheme, config.dark);
+    darkTheme = deepMerge2(darkTheme, config.dark);
   }
   return { light: lightTheme, dark: darkTheme };
 }
@@ -5196,7 +6687,7 @@ function ThemeProvider({
       theme2 = createThemeFromBrand(brandIdentity, theme2);
     }
     if (lightOverrides) {
-      theme2 = deepMerge(theme2, lightOverrides);
+      theme2 = deepMerge2(theme2, lightOverrides);
     }
     return theme2;
   });
@@ -5207,7 +6698,7 @@ function ThemeProvider({
       theme2 = createThemeFromBrand(brandIdentity, theme2);
     }
     if (darkOverrides) {
-      theme2 = deepMerge(theme2, darkOverrides);
+      theme2 = deepMerge2(theme2, darkOverrides);
     }
     return theme2;
   });
@@ -5226,8 +6717,8 @@ function ThemeProvider({
     setError(null);
     loadThemeFromUrl(themeUrl).then((urlTheme) => {
       if (urlTheme) {
-        setLightTheme((prev) => deepMerge(prev, urlTheme));
-        setDarkTheme((prev) => deepMerge(prev, urlTheme));
+        setLightTheme((prev) => deepMerge2(prev, urlTheme));
+        setDarkTheme((prev) => deepMerge2(prev, urlTheme));
       }
     }).catch((err) => {
       setError(err instanceof Error ? err.message : "Failed to load theme");
@@ -5272,8 +6763,8 @@ function ThemeProvider({
     });
   }, []);
   const updateTheme = useCallback((updates) => {
-    setLightTheme((prev) => deepMerge(prev, updates));
-    setDarkTheme((prev) => deepMerge(prev, updates));
+    setLightTheme((prev) => deepMerge2(prev, updates));
+    setDarkTheme((prev) => deepMerge2(prev, updates));
   }, []);
   const resetTheme = useCallback(() => {
     let light = defaultLightTheme;
@@ -5283,10 +6774,10 @@ function ThemeProvider({
       dark = createThemeFromBrand(brandIdentity, dark);
     }
     if (lightOverrides) {
-      light = deepMerge(light, lightOverrides);
+      light = deepMerge2(light, lightOverrides);
     }
     if (darkOverrides) {
-      dark = deepMerge(dark, darkOverrides);
+      dark = deepMerge2(dark, darkOverrides);
     }
     setLightTheme(light);
     setDarkTheme(dark);
@@ -6569,7 +8060,7 @@ __export(shared_exports, {
   VALIDATION_PATTERNS: () => VALIDATION_PATTERNS,
   VALIDATION_RULES: () => VALIDATION_RULES,
   VISIBILITY: () => VISIBILITY,
-  addDays: () => addDays$1,
+  addDays: () => addDays,
   addHours: () => addHours,
   addMinutes: () => addMinutes,
   addMonths: () => addMonths,
@@ -6591,7 +8082,7 @@ __export(shared_exports, {
   eachDayOfInterval: () => eachDayOfInterval,
   eachMonthOfInterval: () => eachMonthOfInterval,
   eachWeekOfInterval: () => eachWeekOfInterval,
-  endOfDay: () => endOfDay$1,
+  endOfDay: () => endOfDay,
   endOfMonth: () => endOfMonth,
   endOfWeek: () => endOfWeek,
   endOfYear: () => endOfYear,
@@ -6634,18 +8125,18 @@ __export(shared_exports, {
   isDateBetween: () => isDateBetween,
   isDev: () => isDev,
   isEqual: () => isEqual,
-  isFuture: () => isFuture$1,
-  isPast: () => isPast$1,
+  isFuture: () => isFuture,
+  isPast: () => isPast,
   isProd: () => isProd,
   isSameDay: () => isSameDay,
   isSameMonth: () => isSameMonth,
   isSameWeek: () => isSameWeek,
   isSameYear: () => isSameYear,
-  isTest: () => isTest,
+  isTest: () => isTest2,
   isThisMonth: () => isThisMonth,
   isThisWeek: () => isThisWeek,
   isThisYear: () => isThisYear,
-  isToday: () => isToday$1,
+  isToday: () => isToday,
   isTomorrow: () => isTomorrow,
   isValid: () => isValid,
   isValidDate: () => isValidDate,
@@ -6665,7 +8156,7 @@ __export(shared_exports, {
   setMinutes: () => setMinutes,
   setSeconds: () => setSeconds,
   setTime: () => setTime,
-  startOfDay: () => startOfDay$1,
+  startOfDay: () => startOfDay,
   startOfMonth: () => startOfMonth,
   startOfWeek: () => startOfWeek,
   startOfYear: () => startOfYear,
@@ -6720,7 +8211,7 @@ var isProd = () => {
 var isDev = () => {
   return process.env.NODE_ENV === "development";
 };
-var isTest = () => {
+var isTest2 = () => {
   return process.env.NODE_ENV === "test";
 };
 var validateEnv = (requiredVars) => {
@@ -7159,7 +8650,7 @@ var formatRelativeTime2 = (date, baseDate) => {
 };
 var formatSmartDate = (date) => {
   const parsed = parseDate(date);
-  if (isToday$1(parsed)) {
+  if (isToday(parsed)) {
     return `Today at ${format(parsed, DATE_FORMATS.TIME_SHORT)}`;
   }
   if (isYesterday(parsed)) {
@@ -7215,7 +8706,7 @@ var addTime = (date, amount, unit) => {
     case "hours":
       return addHours(parsed, amount);
     case "days":
-      return addDays$1(parsed, amount);
+      return addDays(parsed, amount);
     case "weeks":
       return addWeeks(parsed, amount);
     case "months":
@@ -7282,8 +8773,8 @@ var getMonthsInRange = (start, end) => {
 var getDayBoundaries = (date) => {
   const parsed = parseDate(date);
   return {
-    start: startOfDay$1(parsed),
-    end: endOfDay$1(parsed)
+    start: startOfDay(parsed),
+    end: endOfDay(parsed)
   };
 };
 var getWeekBoundaries = (date, weekStartsOn = 0) => {