Tengo diferentes métodos en mi aplicación para buscar usuarios:
1. Fetch international users 2. Fetch users from same region 3. Fetch users from same cityActualmente, he implementado 1 método para cada uno:
const fetchIntenationalUsers = async (limit = 10) => { const result = await db.collection("users").limit(limit).get(); ... return parseUsers(result); } const fetchSameRegionUsers = async (region, limit = 10) => { const result = await db.collection("users").where("region", "==", region).limit(limit).get(); ... return parseUsers(result); } const fetchSameCityUsers = async (city, limit = 10) => { const result = await db.collection("users").where("city", "==", city).limit(limit).get(); ... return parseUsers(result); }He pensado en crear un método generalizado como:
const fetchUsers = (queryType = "international", location = {}, limit = 10) => { const queries = { "international": db.collection("users"), "region": db.collection("users").where("region", "==", location.region), "city": db.collection("users").where("city", "==", location.city), }; const result = await queries[queryType].limit(limit).get(); ... return parseUsers(result); }Pero no estoy seguro de si se trata de un antipatrón o de un patrón de diseño. ¿Algún otro enfoque?
La idea general me parece bien, pero hay un problema: con esta línea:
const queries = { "international": db.collection("users"), "region": db.collection("users").where("region", "==", location.region), "city": db.collection("users").where("city", "==", location.city), };Está llamando a todos esos métodos de base de datos cuando se crea el objeto, no solo al que necesita. (Tampoco está manejando posibles errores generados por los métodos no utilizados).
Para una ligera modificación, considere funciones que devuelvan las consultas en su lugar. También puede hacer db.collection('users') por adelantado.
const users = db.collection("users"); const queries = { international: () => users, region: () => users.where("region", "==", location.region), city: () => users.where("city", "==", location.city), }; const result = await queries[queryType]().limit(limit).get();Sí, creo que es un antipatrón juntarlos a todos en un solo método "generalizado" e introducir esa queryType . Obtendrá más y más tipos de consulta en el futuro, y creará un gran lío en ese método dios . (Además, tiene las desventajas mencionadas en la respuesta de @CertainPerformance).
En cambio, recomiendo mantener las funciones separadas (que se pueden llamar por separado), pero abstraer las partes duplicadas del código en una función auxiliar abstracta:
async function fetchUsers(addCondition, limit = 10) { const query = addCondition(db.collection("users")).limit(limit); const result = await query.get(); … return parseUsers(result); } export const fetchInternationalUsers = (limit) => fetchUsers(q => q, limit); export const fetchSameRegionUsers = (region, limit) => fetchUsers(q => q.where("region", "==", region), limit); export const fetchSameCityUsers = async (city, limit) => fetchUsers(q => q.where("city", "==", city), limit);