Merge pull request #189 from CodeForPhilly/feat/zbl-day6-updates

Feat/zbl day6 updates

Author: ZacharyLeahan

lib/server.js

@@ -147,6 +147,202 @@ module.exports = async function ({ plants, nurseries }) {
 
   app.use(express.json());
 
+  // Resolve a pasted block of text into plant IDs by exact match on:
+  // - _id
+  // - Common Name
+  // - Scientific Name
+  //
+  // Notes:
+  // - Matching is case-insensitive.
+  // - Input may contain extra text; we split into chunks and also extract binomial
+  //   scientific names (e.g. "Acer rubrum") from longer lines.
+  app.post("/api/v1/plants/resolve-names", async (req, res) => {
+    try {
+      const text = typeof req.body?.text === "string" ? req.body.text : "";
+      if (!text.trim()) {
+        return res.status(400).json({ error: "text is required" });
+      }
+
+      const MAX_TOKENS = 1000;
+      const HEADER_TOKENS = new Set(
+        [
+          "common name",
+          "scientific name",
+          "bloom",
+          "bloom time",
+          "sun",
+          "soil",
+          "life",
+          "life cycle",
+          "form",
+          "height",
+          "spread",
+          "notes",
+          "additional details",
+        ].map((s) => s.toLowerCase())
+      );
+
+      const normalize = (s) =>
+        String(s || "")
+          .trim()
+          .replace(/\s+/g, " ")
+          .replace(/^[•*\-–—\u2022]+/g, "")
+          .replace(/^\(?\s*(?:plant|common name|scientific name)\s*[:\-–—]\s*/i, "")
+          .replace(/^["']|["']$/g, "")
+          .trim()
+          .replace(/\s+/g, " ");
+
+      // Split into chunks by common separators.
+      const chunks = text
+        .split(/[\n\r\t,;]+/g)
+        .map(normalize)
+        .filter((s) => s.length > 0);
+
+      // Extract scientific binomials from longer chunks (helps when extra text surrounds names).
+      /** @type {string[]} */
+      const extractedBinomials = [];
+      for (const chunk of chunks) {
+        // Match "Genus species" (species can include hyphen).
+        const re = /\b([A-Z][a-z]+)\s+([a-z][a-z-]{1,})\b/g;
+        let m;
+        while ((m = re.exec(chunk)) !== null) {
+          extractedBinomials.push(`${m[1]} ${m[2]}`);
+        }
+      }
+
+      // De-dupe while preserving original casing for UI, but match on normalized form.
+      const normalizedToOriginal = new Map();
+      for (const raw of [...chunks, ...extractedBinomials]) {
+        if (normalizedToOriginal.size >= MAX_TOKENS) break;
+        const n = normalize(raw).toLowerCase();
+        if (!n) continue;
+        if (HEADER_TOKENS.has(n)) continue;
+        if (!normalizedToOriginal.has(n)) {
+          normalizedToOriginal.set(n, normalize(raw));
+        }
+      }
+
+      const tokens = Array.from(normalizedToOriginal.values());
+      const tokensLower = Array.from(normalizedToOriginal.keys());
+
+      if (!tokens.length) {
+        return res.json({
+          tokensUsed: 0,
+          matchedIds: [],
+          matched: [],
+          notFound: [],
+        });
+      }
+
+      // Query candidates in one go.
+      const docs = await plants
+        .find(
+          {
+            $or: [
+              { _id: { $in: tokens } },
+              { "Scientific Name": { $in: tokens } },
+              { "Common Name": { $in: tokens } },
+            ],
+          },
+          {
+            projection: { _id: 1, "Common Name": 1, "Scientific Name": 1 },
+          }
+        )
+        .collation({ locale: "en", strength: 2 })
+        .toArray();
+
+      // Build lookup maps (normalized -> docs).
+      const byId = new Map();
+      const bySci = new Map();
+      const byCommon = new Map();
+
+      const pushMap = (map, key, doc) => {
+        if (!key) return;
+        const k = normalize(key).toLowerCase();
+        if (!k) return;
+        const arr = map.get(k) || [];
+        arr.push(doc);
+        map.set(k, arr);
+      };
+
+      for (const d of docs) {
+        pushMap(byId, d._id, d);
+        pushMap(bySci, d["Scientific Name"], d);
+        pushMap(byCommon, d["Common Name"], d);
+      }
+
+      /** @type {Set<string>} */
+      const matchedIdsSet = new Set();
+      /** @type {{_id: string, commonName: string, scientificName: string}[]} */
+      const matched = [];
+      /** @type {string[]} */
+      const notFound = [];
+      /** @type {Record<string, string[]>} */
+      const ambiguous = {};
+
+      const chooseDeterministic = (arr) => {
+        if (!arr || !arr.length) return null;
+        // Stable deterministic selection: lowest _id lexicographically
+        const sorted = [...arr].sort((a, b) => String(a._id).localeCompare(String(b._id)));
+        return sorted[0];
+      };
+
+      for (let i = 0; i < tokensLower.length; i++) {
+        const tokenKey = tokensLower[i];
+        const tokenDisplay = tokens[i];
+
+        const idMatches = byId.get(tokenKey) || [];
+        const sciMatches = bySci.get(tokenKey) || [];
+        const commonMatches = byCommon.get(tokenKey) || [];
+
+        const candidates = idMatches.length ? idMatches : sciMatches.length ? sciMatches : commonMatches;
+        if (!candidates || !candidates.length) {
+          notFound.push(tokenDisplay);
+          continue;
+        }
+
+        if (candidates.length > 1) {
+          ambiguous[tokenDisplay] = candidates.map((d) => String(d._id));
+        }
+
+        const chosen = chooseDeterministic(candidates);
+        if (!chosen) {
+          notFound.push(tokenDisplay);
+          continue;
+        }
+
+        const id = String(chosen._id);
+        if (!matchedIdsSet.has(id)) {
+          matchedIdsSet.add(id);
+          matched.push({
+            _id: id,
+            commonName: chosen["Common Name"] || "",
+            scientificName: chosen["Scientific Name"] || "",
+          });
+        }
+      }
+
+      const response = {
+        tokensUsed: tokens.length,
+        matchedIds: Array.from(matchedIdsSet),
+        matched,
+        notFound,
+      };
+
+      if (Object.keys(ambiguous).length) {
+        response.ambiguous = ambiguous;
+      }
+
+      return res.json(response);
+    } catch (e) {
+      console.error("error in /api/v1/plants/resolve-names:", e);
+      return res.status(500).json({
+        error: e.message || "Internal server error",
+        details: process.env.NODE_ENV === "development" ? e.stack : undefined,
+      });
+    }
+  });
+
   app.post("/get-vendors", async (req, res) => {
     try {
       if (!req.body.zipCode) {
@@ -731,12 +927,18 @@ module.exports = async function ({ plants, nurseries }) {
           });
         });
       }
-      if (Array.isArray(req.query.favorites)) {
+      // Favorites can arrive as a string when there's only one (?favorites=ID),
+      // or as an array when repeated (?favorites=ID1&favorites=ID2).
+      const favoritesParam = req.query.favorites;
+      const favoritesList = Array.isArray(favoritesParam)
+        ? favoritesParam
+        : typeof favoritesParam === "string"
+          ? [favoritesParam]
+          : [];
+      if (favoritesList.length) {
         $and.push({
           _id: {
-            $in: req.query.favorites.map((v) =>
-              typeof v == "string" ? v : ""
-            ),
+            $in: favoritesList.map((v) => (typeof v == "string" ? v : "")).filter(Boolean),
           },
         });
       }