Skip to content
TheChatArchiveThe Chat Archive
Claudeclaude-opus-4-20250514· AnthropicHugging Face LMArena Human Preference 140K

refactor the funtion keep comments add new if needed // Combined API for nearby,…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Metallama-4-scout-17b-16e-instruct’s answer.
  1. User

    refactor the funtion keep comments add new if needed

    // Combined API for nearby, preference and filter based school search const getSchoolsByMode = async (req, res) => { const mode = req.query.mode || "filter"; // default to filter if (mode === "nearby") { // --- getNearBySchools logic --- try { const { rootUserId } = req; if (!rootUserId) { return res.status(401).json({ status: 401, message: "Token is missing", success: false, }); } const foundProfile = await studentProfile.findOne({ userId: rootUserId, isDeleted: false }).lean(); if (!foundProfile) { return res.status(404).json({ status: 404, message: "Student profile not found", success: false, }); } const { schoolPreferences } = foundProfile; const { location, radius: studentRadius } = schoolPreferences || {}; if (!location || !studentRadius) { return res.status(400).json({ status: 400, message: "Location and radius are required", success: false, }); } const limit = parseInt(req.query.limit) || 10; const page = parseInt(req.query.page) || 1; const skip = (page - 1) * limit; const search = req.query.search || ""; const sortField = req.query.sortField || "distanceInMeters"; const sortOrder = req.query.sortOrder === "desc" ? -1 : 1; const searchQuery = search ? { or: [ { schoolName: { regex: search, options: "i" } }, { religion: { regex: search, options: "i" } }, { region: { regex: search, options: "i" } }, { district: { regex: search, options: "i" } }, { subCounty: { regex: search, options: "i" } }, { description: { regex: search, options: "i" } }, { affiliation: { regex: search, options: "i" } }, { referral_code: { regex: search, options: "i" } }, { schoolCategory: { regex: search, options: "i" } }, ], } : {}; const combinedQuery = { isDeleted: false, ...searchQuery }; const maxSchoolRadius = await schoolProfile.findOne({ isDeleted: false }, { "targetArea.radius": 1 }).sort({ "targetArea.radius": -1 }).lean(); const maxPossibleDistance = studentRadius + (maxSchoolRadius?.targetArea?.radius || 100000); const results = await schoolProfile.aggregate([ { geoNear: { near: location, distanceField: "distanceInMeters", maxDistance: maxPossibleDistance, spherical: true, query: combinedQuery, }, }, { addFields: { combinedRadius: { add: [studentRadius, { ifNull:["ifNull: ["targetArea.radius", 100000] }], }, studentRadius, schoolRadius: { ifNull:["ifNull: ["targetArea.radius", 100000] }, distanceInKm: { round: [{ divide: ["distanceInMeters", 1000] }, 2], }, }, }, { match: { expr: { lte: ["distanceInMeters","distanceInMeters", "combinedRadius"], }, }, }, { lookup: { from: "users", localField: "userId", foreignField: "_id", as: "user", // Ensure user is not deleted, isActive and is verified pipeline: [ { match: { expr: { and: [{ eq:["eq: ["isDeleted", false] }, { eq:["eq: ["isVerified", true] }, { eq:["eq: ["isActive", true] }], }, }, }, ], }, }, { unwind: { path: "user", preserveNullAndEmptyArrays: true } }, { project: { "user.password": 0, "user.otp": 0, "user.otpExpiration": 0, "user.otpGenerationTime": 0, "user.otpUsed": 0, "user.deviceTokens": 0, "user.blockAllEmails": 0, "user.isTwoFactorAuthentication": 0, "user.deviceTokens": 0, "user.isDeleted": 0, "user.__v": 0, isDeleted: 0, __v: 0, }, }, { sort: { [sortField]: sortOrder, }, }, { facet: { paginatedResults: [{ skip: skip }, { limit: limit }], totalCount: [{ count: "count" }], }, }, ]); const paginatedResults = results[0].paginatedResults; const totalCount = results[0].totalCount[0]?.count || 0; return res.status(200).json({ status: 200, message: "Nearby schools retrieved successfully", success: true, data: paginatedResults, totalCount, currentPage: page, limit, totalPages: Math.ceil(totalCount / limit), }); } catch (error) { console.error("Error in getSchools (nearby):", error); return res.status(500).json({ status: 500, message: "Internal server error", success: false, }); } } else if (mode === "filter") { // --- filter mode logic --- try { // Accept filters from req.body let filters = req.body.filters; if (!filters || typeof filters !== "object" || Array.isArray(filters)) { return res.status(400).json({ status: 400, message: "Filters object is required", success: false, }); } // Pagination and sorting const limit = parseInt(req.query.limit) || 10; const page = parseInt(req.query.page) || 1; const skip = (page - 1) * limit; const sortField = req.query.sortField || "createdAt"; const sortOrder = req.query.sortOrder === "desc" ? -1 : 1; // Build query, supporting dot notation for nested fields and elemMatch for arrays function buildQuery(obj, prefix = "") { let query = {}; for (const key in obj) { const value = obj[key]; if (value !== undefined && value !== null && value !== "") { if (Array.isArray(value) && value.length > 0 && typeof value[0] === "object" && !Array.isArray(value[0])) { // Array of objects: use elemMatch query[prefix ? ${prefix}.${key} : key] = { elemMatch: buildQuery(value[0]) }; } else if (typeof value === "object" && !Array.isArray(value)) { // Nested object Object.assign(query, buildQuery(value, prefix ? `{prefix}.{key}` : key)); } else { // Primitive value query[prefix ? `{prefix}.{key}` : key] = value; } } } return query; } const filterQuery = buildQuery(filters); filterQuery.isDeleted = false; const results = await schoolProfile.aggregate([ { match: filterQuery }, { sort: { [sortField]: sortOrder } }, { lookup: { from: "users", localField: "userId", foreignField: "_id", as: "user", // Ensure user is not deleted, isActive and is verified pipeline: [ { match: { expr: { and: [{ eq: ["isDeleted", false] }, { eq: ["isVerified", true] }, { eq: ["isActive", true] }], }, }, }, ], }, }, { unwind: { path: "user", preserveNullAndEmptyArrays: true } }, { project: { "user.password": 0, "user.otp": 0, "user.otpExpiration": 0, "user.otpGenerationTime": 0, "user.otpUsed": 0, "user.deviceTokens": 0, "user.blockAllEmails": 0, "user.isTwoFactorAuthentication": 0, "user.deviceTokens": 0, "user.isDeleted": 0, "user.__v": 0, isDeleted: 0, __v: 0, }, }, { facet: { paginatedResults: [{ skip: skip }, { limit: limit }], totalCount: [{ count: "count" }], }, }, ]); const paginatedResults = results[0].paginatedResults; const totalCount = results[0].totalCount[0]?.count || 0; return res.status(200).json({ status: 200, message: "Schools retrieved successfully by filter", success: true, data: paginatedResults, totalCount, currentPage: page, limit, totalPages: Math.ceil(totalCount / limit), }); } catch (error) { console.error("Error in getSchools (filter):", error); return res.status(500).json({ status: 500, message: "Internal server error", success: false, }); } } else if (mode === "preference") { // --- getSchoolsByStudentPreference logic --- try { const { rootUserId } = req; if (!rootUserId) { return res.status(401).json({ status: 401, message: "Token is missing", success: false, }); } const foundProfile = await studentProfile.findOne({ userId: rootUserId }).lean(); if (!foundProfile) { return res.status(404).json({ status: 404, message: "Student profile not found", success: false, }); } const { schoolPreferences } = foundProfile; const { wholeNation, categories, regions, districts, subCounties } = schoolPreferences || {}; if (!wholeNation && !categories && !regions && !districts && !subCounties) { return res.status(400).json({ status: 400, message: "At least one preference or wholeNation must be provided", success: false, }); } const limit = parseInt(req.query.limit) || 10; const page = parseInt(req.query.page) || 1; const skip = (page - 1) * limit; const search = req.query.search || ""; const sortField = req.query.sortField || "createdAt"; const sortOrder = req.query.sortOrder === "desc" ? -1 : 1; const preferenceQuery = { isDeleted: false, ...(categories?.length && { schoolCategory: { in: categories.map((c) => c.toLowerCase()) } }), ...(regions && { "targetArea.regions": { in: regions.map((r) => r.toLowerCase()) } }), ...(districts?.length && { "targetArea.districts": { in: districts.map((d) => d.toLowerCase()) } }), ...(subCounties?.length && { "targetArea.subCounties": { in: subCounties.map((s) => s.toLowerCase()) } }), }; const searchQuery = search ? { or: [ { schoolName: { regex: search, options: "i" } }, { religion: { regex: search, options: "i" } }, { region: { regex: search, options: "i" } }, { district: { regex: search, options: "i" } }, { subCounty: { regex: search, options: "i" } }, { description: { regex: search, options: "i" } }, { affiliation: { regex: search, options: "i" } }, { referral_code: { regex: search, options: "i" } }, { schoolCategory: { regex: search, options: "i" } }, ], } : {}; const combinedQuery = search ? { and: [preferenceQuery, searchQuery] } : preferenceQuery; if (wholeNation) { const results = await schoolProfile.aggregate([ { match: combinedQuery }, { sort: { [sortField]: sortOrder } }, { lookup: { from: "users", localField: "userId", foreignField: "_id", as: "user", // Ensure user is not deleted, isActive and is verified pipeline: [ { match: { expr: { and: [{ eq:["eq: ["isDeleted", false] }, { eq:["eq: ["isVerified", true] }, { eq:["eq: ["isActive", true] }], }, }, }, ], }, }, { unwind: { path: "user", preserveNullAndEmptyArrays: true } }, { project: { "user.password": 0, "user.otp": 0, "user.otpExpiration": 0, "user.otpGenerationTime": 0, "user.otpUsed": 0, "user.deviceTokens": 0, "user.blockAllEmails": 0, "user.isTwoFactorAuthentication": 0, "user.deviceTokens": 0, "user.isDeleted": 0, "user.__v": 0, isDeleted: 0, __v: 0, }, }, { facet: { paginatedResults: [{ skip: skip }, { limit: limit }], totalCount: [{ count: "count" }], }, }, ]); const paginatedResults = results[0].paginatedResults; const totalCount = results[0].totalCount[0]?.count || 0; return res.status(200).json({ status: 200, message: "Nationwide schools retrieved successfully", success: true, data: paginatedResults, totalCount, currentPage: page, limit, totalPages: Math.ceil(totalCount / limit), }); } const results = await schoolProfile.aggregate([ { match: combinedQuery }, { sort: { [sortField]: sortOrder } }, { lookup: { from: "users", localField: "userId", foreignField: "_id", as: "user", // Ensure user is not deleted, isActive and is verified pipeline: [ { match: { expr: { and: [{ eq: ["isDeleted", false] }, { eq: ["isVerified", true] }, { eq: ["isActive", true] }], }, }, }, ], }, }, { facet: { paginatedResults: [{ skip: skip }, { limit: limit }], totalCount: [{ $count: "count" }], }, }, ]); const paginatedResults = results[0].paginatedResults; const totalCount = results[0].totalCount[0]?.count || 0; return res.status(200).json({ status: 200, message: "Schools retrieved successfully", success: true, data: paginatedResults, totalCount, currentPage: page, limit, totalPages: Math.ceil(totalCount / limit), }); } catch (error) { console.error("Error in getSchools (preference):", error); return res.status(500).json({ status: 500, message: "Internal server error", success: false, }); } } else { return res.status(400).json({ status: 400, message: "Invalid mode. Use 'nearby', 'filter', or 'preference'.", success: false, }); } };

  2. Claude Assistant

    Here's a refactored version of the function with improved structure, reduced duplication, and better maintainability:

    // Combined API for nearby, preference and filter based school search
    const getSchoolsByMode = async (req, res) => {
      try {
        const mode = req.query.mode || "filter"; // default to filter
        
        // Validate mode
        if (!["nearby", "filter", "preference"].includes(mode)) {
          return res.status(400).json({
            status: 400,
            message: "Invalid mode. Use 'nearby', 'filter', or 'preference'.",
            success: false,
          });
        }
    
        // Extract common pagination and sorting parameters
        const paginationParams = extractPaginationParams(req);
        
        // Route to appropriate handler based on mode
        let result;
        switch (mode) {
          case "nearby":
            result = await handleNearbySearch(req, paginationParams);
            break;
          case "filter":
            result = await handleFilterSearch(req, paginationParams);
            break;
          case "preference":
            result = await handlePreferenceSearch(req, paginationParams);
            break;
        }
    
        // Check if handler returned an error response
        if (result.error) {
          return res.status(result.status).json(result);
        }
    
        // Return successful response
        return res.status(200).json({
          status: 200,
          message: result.message,
          success: true,
          data: result.data,
          totalCount: result.totalCount,
          currentPage: paginationParams.page,
          limit: paginationParams.limit,
          totalPages: Math.ceil(result.totalCount / paginationParams.limit),
        });
    
      } catch (error) {
        console.error("Error in getSchoolsByMode:", error);
        return res.status(500).json({
          status: 500,
          message: "Internal server error",
          success: false,
        });
      }
    };
    
    // Helper function to extract pagination parameters
    const extractPaginationParams = (req) => {
      return {
        limit: parseInt(req.query.limit) || 10,
        page: parseInt(req.query.page) || 1,
        skip: ((parseInt(req.query.page) || 1) - 1) * (parseInt(req.query.limit) || 10),
        search: req.query.search || "",
        sortField: req.query.sortField || "createdAt",
        sortOrder: req.query.sortOrder === "desc" ? -1 : 1,
      };
    };
    
    // Helper function to build search query for text search
    const buildSearchQuery = (search) => {
      if (!search) return {};
      
      const searchFields = [
        "schoolName", "religion", "region", "district", 
        "subCounty", "description", "affiliation", 
        "referral_code", "schoolCategory"
      ];
      
      return {
        $or: searchFields.map(field => ({
          [field]: { $regex: search, $options: "i" }
        }))
      };
    };
    
    // Common aggregation pipeline stages
    const commonPipelineStages = {
      // Lookup user with validation
      userLookup: {
        $lookup: {
          from: "users",
          localField: "userId",
          foreignField: "_id",
          as: "user",
          pipeline: [
            {
              $match: {
                $expr: {
                  $and: [
                    { $eq: ["$isDeleted", false] },
                    { $eq: ["$isVerified", true] },
                    { $eq: ["$isActive", true] }
                  ],
                },
              },
            },
          ],
        },
      },
      
      // Unwind user array
      userUnwind: {
        $unwind: { path: "$user", preserveNullAndEmptyArrays: true }
      },
      
      // Project to exclude sensitive fields
      projection: {
        $project: {
          "user.password": 0,
          "user.otp": 0,
          "user.otpExpiration": 0,
          "user.otpGenerationTime": 0,
          "user.otpUsed": 0,
          "user.deviceTokens": 0,
          "user.blockAllEmails": 0,
          "user.isTwoFactorAuthentication": 0,
          "user.isDeleted": 0,
          "user.__v": 0,
          isDeleted: 0,
          __v: 0,
        },
      },
    };
    
    // Helper function to execute aggregation with pagination
    const executeAggregation = async (pipeline, paginationParams) => {
      // Add pagination facet
      pipeline.push({
        $facet: {
          paginatedResults: [
            { $skip: paginationParams.skip },
            { $limit: paginationParams.limit }
          ],
          totalCount: [{ $count: "count" }],
        },
      });
    
      const results = await schoolProfile.aggregate(pipeline);
      
      return {
        data: results[0].paginatedResults,
        totalCount: results[0].totalCount[0]?.count || 0,
      };
    };
    
    // Handler for nearby schools search
    const handleNearbySearch = async (req, paginationParams) => {
      const { rootUserId } = req;
      
      // Validate authentication
      if (!rootUserId) {
        return {
          error: true,
          status: 401,
          message: "Token is missing",
          success: false,
        };
      }
    
      // Get student profile
      const foundProfile = await studentProfile.findOne({ 
        userId: rootUserId, 
        isDeleted: false 
      }).lean();
      
      if (!foundProfile) {
        return {
          error: true,
          status: 404,
          message: "Student profile not found",
          success: false,
        };
      }
    
      // Validate location preferences
      const { location, radius: studentRadius } = foundProfile.schoolPreferences || {};
      if (!location || !studentRadius) {
        return {
          error: true,
          status: 400,
          message: "Location and radius are required",
          success: false,
        };
      }
    
      // Build search query
      const searchQuery = buildSearchQuery(paginationParams.search);
      const combinedQuery = { isDeleted: false, ...searchQuery };
    
      // Get maximum school radius for distance calculation
      const maxSchoolRadius = await schoolProfile.findOne(
        { isDeleted: false },
        { "targetArea.radius": 1 }
      ).sort({ "targetArea.radius": -1 }).lean();
      
      const maxPossibleDistance = studentRadius + (maxSchoolRadius?.targetArea?.radius || 100000);
    
      // Build aggregation pipeline for nearby search
      const pipeline = [
        {
          $geoNear: {
            near: location,
            distanceField: "distanceInMeters",
            maxDistance: maxPossibleDistance,
            spherical: true,
            query: combinedQuery,
          },
        },
        {
          $addFields: {
            combinedRadius: {
              $add: [studentRadius, { $ifNull: ["$targetArea.radius", 100000] }],
            },
            studentRadius,
            schoolRadius: { $ifNull: ["$targetArea.radius", 100000] },
            distanceInKm: {
              $round: [{ $divide: ["$distanceInMeters", 1000] }, 2],
            },
          },
        },
        {
          $match: {
            $expr: {
              $lte: ["$distanceInMeters", "$combinedRadius"],
            },
          },
        },
        commonPipelineStages.userLookup,
        commonPipelineStages.userUnwind,
        commonPipelineStages.projection,
        {
          $sort: {
            [paginationParams.sortField === "createdAt" ? "distanceInMeters" : paginationParams.sortField]: 
              paginationParams.sortOrder,
          },
        },
      ];
    
      const result = await executeAggregation(pipeline, paginationParams);
      
      return {
        ...result,
        message: "Nearby schools retrieved successfully",
      };
    };
    
    // Handler for filter-based search
    const handleFilterSearch = async (req, paginationParams) => {
      // Validate filters
      const filters = req.body.filters;
      if (!filters || typeof filters !== "object" || Array.isArray(filters)) {
        return {
          error: true,
          status: 400,
          message: "Filters object is required",
          success: false,
        };
      }
    
      // Build filter query
      const filterQuery = buildQuery(filters);
      filterQuery.isDeleted = false;
    
      // Build aggregation pipeline
      const pipeline = [
        { $match: filterQuery },
        { $sort: { [paginationParams.sortField]: paginationParams.sortOrder } },
        commonPipelineStages.userLookup,
        commonPipelineStages.userUnwind,
        commonPipelineStages.projection,
      ];
    
      const result = await executeAggregation(pipeline, paginationParams);
      
      return {
        ...result,
        message: "Schools retrieved successfully by filter",
      };
    };
    
    // Helper function to build query from filters object
    const buildQuery = (obj, prefix = "") => {
      let query = {};
      
      for (const key in obj) {
        const value = obj[key];
        
        // Skip undefined, null, or empty values
        if (value === undefined || value === null || value === "") continue;
        
        const fullKey = prefix ? `${prefix}.${key}` : key;
        
        if (Array.isArray(value) && value.length > 0) {
          // Handle array of objects with $elemMatch
          if (typeof value[0] === "object" && !Array.isArray(value[0])) {
            query[fullKey] = { $elemMatch: buildQuery(value[0]) };
          } else {
            // Simple array values
            query[fullKey] = value;
          }
        } else if (typeof value === "object" && !Array.isArray(value)) {
          // Recursively handle nested objects
          Object.assign(query, buildQuery(value, fullKey));
        } else {
          // Primitive values
          query[fullKey] = value;
        }
      }
      
      return query;
    };
    
    // Handler for preference-based search
    const handlePreferenceSearch = async (req, paginationParams) => {
      const { rootUserId } = req;
      
      // Validate authentication
      if (!rootUserId) {
        return {
          error: true,
          status: 401,
          message: "Token is missing",
          success: false,
        };
      }
    
      // Get student profile
      const foundProfile = await studentProfile.findOne({ 
        userId: rootUserId,
        isDeleted: false 
      }).lean();
      
      if (!foundProfile) {
        return {
          error: true,
          status: 404,
          message: "Student profile not found",
          success: false,
        };
      }
    
      // Extract preferences
      const { wholeNation, categories, regions, districts, subCounties } = 
        foundProfile.schoolPreferences || {};
    
      // Validate preferences
      if (!wholeNation && !categories && !regions && !districts && !subCounties) {
        return {
          error: true,
          status: 400,
          message: "At least one preference or wholeNation must be provided",
          success: false,
        };
      }
    
      // Build preference query
      const preferenceQuery = buildPreferenceQuery({
        categories,
        regions,
        districts,
        subCounties,
      });
    
      // Build search query
      const searchQuery = buildSearchQuery(paginationParams.search);
      
      // Combine queries
      const combinedQuery = paginationParams.search 
        ? { $and: [preferenceQuery, searchQuery] } 
        : preferenceQuery;
    
      // Build aggregation pipeline
      const pipeline = [
        { $match: combinedQuery },
        { $sort: { [paginationParams.sortField]: paginationParams.sortOrder } },
        commonPipelineStages.userLookup,
        commonPipelineStages.userUnwind,
        commonPipelineStages.projection,
      ];
    
      const result = await executeAggregation(pipeline, paginationParams);
      
      return {
        ...result,
        message: wholeNation 
          ? "Nationwide schools retrieved successfully" 
          : "Schools retrieved successfully",
      };
    };
    
    // Helper function to build preference query
    const buildPreferenceQuery = ({ categories, regions, districts, subCounties }) => {
      const query = { isDeleted: false };
      
      // Add category filter
      if (categories?.length) {
        query.schoolCategory = { $in: categories.map(c => c.toLowerCase()) };
      }
      
      // Add location filters
      if (regions?.length) {
        query["targetArea.regions"] = { $in: regions.map(r => r.toLowerCase()) };
      }
      
      if (districts?.length) {
        query["targetArea.districts"] = { $in: districts.map(d => d.toLowerCase()) };
      }
      
      if (subCounties?.length) {
        query["targetArea.subCounties"] = { $in: subCounties.map(s => s.toLowerCase()) };
      }
      
      return query;
    };
    

    Key improvements made:

    1. Separation of Concerns: Split the large function into smaller, focused handlers for each mode
    2. Reduced Duplication: Extracted common logic into reusable functions and objects
    3. Better Error Handling: Centralized error handling with consistent response structure
    4. Improved Readability: Clear function names and logical flow
    5. Reusable Components: Common pipeline stages, query builders, and pagination logic
    6. Maintainability: Each handler can be modified independently without affecting others
    7. Consistent Patterns: All handlers follow similar structure and return format
    8. Better Comments: Added descriptive comments for complex logic
    9. Validation: Early validation with clear error messages
    10. Performance: Removed duplicate user field exclusion in projection

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.