@exyconn/common 2.3.2 → 2.3.4

package/dist/server/index.js

@@ -428,6 +428,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 || !mongoose.Types.ObjectId.isValid(id)) {
+        badRequestResponse(res, "Invalid ID format");
+        return;
+      }
+      const query = {
+        _id: new mongoose.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 || !mongoose.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 mongoose.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 || !mongoose.Types.ObjectId.isValid(id)) {
+        badRequestResponse(res, "Invalid ID format");
+        return;
+      }
+      const query = {
+        _id: new mongoose.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 mongoose.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" && mongoose.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 mongoose.Types.ObjectId(organizationId)
+  };
+  if (!req.deleteAll && req.deleteIds && req.deleteIds.length > 0) {
+    filter._id = {
+      $in: req.deleteIds.map((id) => new mongoose.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 {
@@ -1402,6 +2025,7 @@ exports.authenticateApiKey = authenticateApiKey;
 exports.authenticateJWT = authenticateJWT;
 exports.badRequestResponse = badRequestResponse;
 exports.buildConfig = buildConfig;
+exports.buildDeleteFilter = buildDeleteFilter;
 exports.buildFilter = buildFilter;
 exports.buildPagination = buildPagination;
 exports.buildPaginationMeta = buildPaginationMeta;
@@ -1412,12 +2036,15 @@ exports.corsOptions = corsOptions;
 exports.createApiKeyGenerator = createApiKeyGenerator;
 exports.createApiRateLimiter = createApiRateLimiter;
 exports.createBrandCorsOptions = createBrandCorsOptions;
+exports.createBulkDeleteHandler = createBulkDeleteHandler;
 exports.createConfig = createConfig;
 exports.createCorsOptions = createCorsOptions;
+exports.createCrudControllers = createCrudControllers;
 exports.createDdosRateLimiter = createDdosRateLimiter;
 exports.createLogger = createLogger;
 exports.createMorganStream = createMorganStream;
 exports.createMultiBrandCorsOptions = createMultiBrandCorsOptions;
+exports.createPaginationMiddleware = createPaginationMiddleware;
 exports.createPrefixedKeyGenerator = createPrefixedKeyGenerator;
 exports.createRateLimiter = createRateLimiter;
 exports.createStandardRateLimiter = createStandardRateLimiter;
@@ -1430,6 +2057,7 @@ exports.disconnectDB = disconnectDB;
 exports.errorResponse = errorResponse;
 exports.extractColumns = extractColumns;
 exports.extractOrganization = extractOrganization;
+exports.extractSchemaMeta = extractSchemaMeta;
 exports.forbiddenResponse = forbiddenResponse;
 exports.formatPackageCheckResult = formatPackageCheckResult;
 exports.generateNcuCommand = generateNcuCommand;
@@ -1444,8 +2072,11 @@ exports.notFoundResponse = notFoundResponse;
 exports.omitFields = omitFields;
 exports.optionalAuthenticateJWT = optionalAuthenticateJWT;
 exports.packageCheckServer = packageCheckServer;
+exports.parseBulkDelete = parseBulkDelete;
 exports.pickFields = pickFields;
 exports.printPackageCheckSummary = printPackageCheckSummary;
+exports.queryPagination = queryPagination;
+exports.queryParser = queryParser;
 exports.rateLimitResponse = rateLimitResponse;
 exports.rateLimiter = rateLimiter;
 exports.requireOrganization = requireOrganization;