@tekkare/romulus 0.1.250 → 0.1.252

package/layer/app/oip-science/composables/useOipSearchExplain.ts

@@ -0,0 +1,166 @@
+/**
+ * « Voir pourquoi » : ou les termes de la recherche ont ete trouves.
+ *
+ * L'explication vient d'Elasticsearch, pas d'une reconstitution cote client.
+ * La clause de la barre de recherche est instrumentee au moment ou la page
+ * lance sa liste : chaque clause nested recoit des `inner_hits` nommes
+ * `search:<famille>` (qui comptent les objets matches et surlignent l'extrait),
+ * et les champs plats un `highlight` a la racine. Le magasin de requetes, les
+ * agregations, les alertes et les suggestions gardent la clause nue.
+ */
+
+import { bareSearchField, searchFieldGroup, searchFieldGroupByKey } from "./useSearchFields";
+
+export const SEARCH_EXPLAIN_PREFIX = "search:";
+
+export type SearchMatchField = {
+  key: string;
+  label: string;
+  /** Objets nested matches (conditions, auteurs...) ; 0 sur un champ plat. */
+  count: number;
+  /** Extraits surlignes en `<mark>`, tels que renvoyes par le moteur. */
+  fragments: string[];
+};
+
+/** Ce qu'un hit porte d'explication, garde a cote de son `_source`. */
+export type SearchMatch = { highlight?: Record<string, string[]>; inner_hits?: Record<string, any> };
+
+const highlightBlock = (fields: string[]) => ({
+  pre_tags: ["<mark>"],
+  post_tags: ["</mark>"],
+  fields: Object.fromEntries(
+    [...new Set(fields.map(bareSearchField))].map((field) => [field, { number_of_fragments: 2, fragment_size: 180 }]),
+  ),
+});
+
+/** Les champs interroges par une clause (`query_string` / `multi_match`), a toute profondeur. */
+function fieldsIn(node: any): string[] {
+  if (!node || typeof node !== "object") return [];
+  if (Array.isArray(node)) return node.flatMap(fieldsIn);
+  return Object.entries(node).flatMap(([key, value]) =>
+    key === "fields" && Array.isArray(value) ? (value as string[]) : fieldsIn(value),
+  );
+}
+
+/**
+ * Pose les inner hits sur une chaine de `nested`. Sur un nested imbrique
+ * (`diseases` > `diseases.icd10`), ES ne remonte les inner hits du niveau
+ * interne que si le niveau externe en demande aussi : chaque niveau en porte,
+ * le surlignage n'est demande qu'au plus profond.
+ */
+function withInnerHits(node: any, name: string, fields: string[]): any {
+  const inner = node.nested.query;
+  const deepest = !inner?.nested;
+  return {
+    nested: {
+      ...node.nested,
+      query: deepest ? inner : withInnerHits(inner, `${name}>`, fields),
+      inner_hits: {
+        name,
+        size: 3,
+        _source: false,
+        ...(deepest ? { highlight: highlightBlock(fields) } : {}),
+      },
+    },
+  };
+}
+
+/**
+ * Instrumente la clause de la barre (`{ bool: { should: [...] } }`) : inner
+ * hits sur ses clauses nested, liste des champs plats pour le highlight
+ * racine. Un `match_all` (barre vide) repart tel quel.
+ */
+export function instrumentSearchClause(values: any): { query: any; highlight?: Record<string, any> } {
+  const should = values?.bool?.should;
+  if (!Array.isArray(should)) return { query: values };
+
+  const flatFields: string[] = [];
+  const used = new Map<string, number>();
+  const instrumented = should.map((clause: any) => {
+    const fields = fieldsIn(clause);
+    if (!clause?.nested) {
+      flatFields.push(...fields);
+      return clause;
+    }
+    // Une meme famille peut partir sur deux chemins nested (CIM-10 et
+    // sections) : ES refuse deux inner hits du meme nom.
+    const key = fields.length ? searchFieldGroup(fields[0]!).key : "other";
+    const n = used.get(key) ?? 0;
+    used.set(key, n + 1);
+    return withInnerHits(clause, `${SEARCH_EXPLAIN_PREFIX}${key}${n ? `#${n}` : ""}`, fields);
+  });
+
+  return {
+    query: { ...values, bool: { ...values.bool, should: instrumented } },
+    highlight: flatFields.length ? highlightBlock(flatFields) : undefined,
+  };
+}
+
+/** Garde d'un hit ce qui l'explique, ou `undefined` s'il n'y a rien. */
+export function searchMatchOf(hit: any): SearchMatch | undefined {
+  const inner = Object.fromEntries(
+    Object.entries<any>(hit?.inner_hits ?? {}).filter(([name]) => name.startsWith(SEARCH_EXPLAIN_PREFIX)),
+  );
+  const hasHighlight = hit?.highlight && Object.keys(hit.highlight).length > 0;
+  const hasInner = Object.keys(inner).length > 0;
+  if (!hasHighlight && !hasInner) return undefined;
+  return {
+    ...(hasHighlight ? { highlight: hit.highlight } : {}),
+    ...(hasInner ? { inner_hits: inner } : {}),
+  };
+}
+
+/**
+ * Surlignage d'un champ `keyword` (ou d'un identifiant) : le moteur renvoie la
+ * valeur entiere enveloppee. L'extrait ne montre rien de plus que la pastille,
+ * il tombe ; la famille garde sa pastille.
+ */
+const WHOLE_VALUE = /^<mark>[^<]*<\/mark>$/;
+
+/** Extraits d'un inner hit, en descendant dans ses inner hits imbriques. */
+function fragmentsOf(innerHit: any): string[] {
+  return (innerHit?.hits?.hits ?? []).flatMap((hit: any) => [
+    ...(Object.values(hit?.highlight ?? {}).flat() as string[]),
+    ...Object.values<any>(hit?.inner_hits ?? {}).flatMap(fragmentsOf),
+  ]);
+}
+
+/**
+ * Familles ou les termes ont ete trouves, la plus fournie d'abord. `null`
+ * quand le resultat ne porte aucune explication (barre vide).
+ */
+export function explainSearchMatch(match: SearchMatch | undefined, locale: string): SearchMatchField[] | null {
+  if (!match) return null;
+  const byKey = new Map<string, SearchMatchField>();
+  const entry = (key: string) => {
+    if (!byKey.has(key)) {
+      const group = searchFieldGroupByKey(key);
+      byKey.set(key, { key, label: searchGroupLabel(group, locale), count: 0, fragments: [] });
+    }
+    return byKey.get(key)!;
+  };
+  const push = (field: SearchMatchField, html: unknown) => {
+    if (typeof html !== "string" || !html || WHOLE_VALUE.test(html)) return;
+    if (!field.fragments.includes(html)) field.fragments.push(html);
+  };
+
+  for (const [name, innerHit] of Object.entries<any>(match.inner_hits ?? {})) {
+    const count = innerHit?.hits?.total?.value ?? 0;
+    if (!count) continue;
+    const field = entry(name.slice(SEARCH_EXPLAIN_PREFIX.length).replace(/#\d+$/, ""));
+    field.count += count;
+    fragmentsOf(innerHit).forEach((html) => push(field, html));
+  }
+
+  for (const [name, fragments] of Object.entries(match.highlight ?? {})) {
+    const field = entry(searchFieldGroup(name).key);
+    (Array.isArray(fragments) ? fragments : []).forEach((html) => push(field, html));
+  }
+
+  // `search_text` concatene tout le document : a cote d'une famille precise,
+  // il ne fait que repeter le meme passage. Il ne parle que seul.
+  let fields = [...byKey.values()];
+  if (fields.length > 1) fields = fields.filter((field) => field.key !== "full_text");
+  if (!fields.length) return null;
+  return fields.sort((a, b) => b.count - a.count || b.fragments.length - a.fragments.length);
+}

package/layer/app/oip-science/composables/usePubmed.ts

@@ -0,0 +1,487 @@
+import indexConfig from '../indexConfig.json';
+import useOipElastic from './useOipElastic';
+import { dateFormat } from '../utils/styleAndFormat';
+
+// Types de France Augmented Science (types/Pubmed) : pas portes, le document reste libre.
+type Pubmed = any;
+
+export default function usePubmed() {
+  // Dans FAS, queryElastic / queryCustomElastic etaient pris au niveau du
+  // module : ici dans la fonction, useOipElastic lit la config Nuxt.
+  const { queryElastic, queryCustomElastic } = useOipElastic();
+  const isLoadingPubmedList = ref(false);
+
+  const indexQuery = ref(indexConfig.pubmed.index);
+  const cluster = ref(indexConfig.pubmed.cluster);
+  const { queryOneElastic } = useOipElastic();
+
+  const resultsQueryPubmed = ref(null as Pubmed | null);
+  const pubmedListResult = ref(null as Pubmed[] | null);
+  const isLoadingQueryPubmed = ref(false);
+
+  const findPubmedById = ({
+    id,
+    source,
+  }: {
+    id: string;
+    source?: string[];
+  }): Promise<Pubmed> => {
+    isLoadingQueryPubmed.value = true;
+    return new Promise<Pubmed>(async (resolve, reject) => {
+      try {
+        const res = await queryOneElastic({
+          index: indexQuery.value,
+          path: '_id',
+          source: source,
+          cluster: cluster.value,
+          id,
+        });
+        if (res) {
+          resultsQueryPubmed.value = res as Pubmed;
+          resolve(res as Pubmed);
+        } else {
+          // Document absent de l'index : la fiche montre son etat vide.
+          resolve(null as any);
+        }
+      } catch (error) {
+        reject(error);
+      } finally {
+        isLoadingQueryPubmed.value = false;
+      }
+    });
+  };
+
+  const findManyPubmedById = async ({
+    ids,
+    source,
+  }: {
+    ids: string[];
+    source?: string[];
+  }): Promise<Pubmed[]> => {
+    isLoadingQueryPubmed.value = true;
+
+    try {
+      const query = {
+        from: 0,
+        query: {
+          bool: {
+            must: [
+              {
+                terms: {
+                  _id: ids,
+                },
+              },
+            ],
+          },
+        },
+        size: 1000,
+        track_total_hits: true,
+        _source: {
+          include: source || [],
+          exclude: [],
+        },
+      };
+
+      const res = await queryCustomElastic({
+        index: indexQuery.value,
+        customQuery: query,
+        cluster: cluster.value,
+      });
+
+      if (res && res.results) {
+        pubmedListResult.value = res.results as Pubmed[];
+        return res.results as Pubmed[];
+      } else {
+        throw new Error('Aucun résultat trouvé');
+      }
+    } catch (error) {
+      throw error;
+    } finally {
+      isLoadingQueryPubmed.value = false;
+    }
+  };
+
+  async function searchPubmedFromIds(array: any[]) {
+    try {
+      const response = await $fetch(
+        `https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esummary.fcgi?&db=pubmed&id=${array.join(
+          ','
+        )}&retmode=json&retstart=0`
+      );
+      // @ts-ignore
+      if (response && response.result) {
+        // @ts-ignore
+        const uids = response.result.uids;
+
+        const results = uids.map((uid: any) => {
+          // @ts-ignore
+          const { uids, ...filtered } = response.result[uid];
+          return filtered;
+        });
+
+        return results;
+      }
+
+      return [];
+    } catch (error) {
+      console.error('Error in searchPubmedFromIds:', error);
+      throw error;
+    }
+  }
+
+  async function searchPubmeds(array: any[]) {
+    try {
+      const response = await $fetch(
+        `https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi?retmode=json&retmax=5000&db=pubmed&sort=pub+date&term=%20%22last%20555%20years%22[dp]`
+      );
+      // @ts-ignore
+      if (response && response.result) {
+        // @ts-ignore
+        const uids = response.result.uids;
+
+        const results = uids.map((uid: any) => {
+          // @ts-ignore
+          const { uids, ...filtered } = response.result[uid];
+          return filtered;
+        });
+
+        return results;
+      }
+
+      return [];
+    } catch (error) {
+      console.error('Error in searchPubmedFromIds:', error);
+      throw error;
+    }
+  }
+
+  const reconstructPubmed = async (pubMedIds: any[]) => {
+    const pubmedContent = [];
+
+    const chunkSize = 400;
+    const chunks = [];
+    for (let i = 0; i < pubMedIds.length; i += chunkSize) {
+      chunks.push(pubMedIds.slice(i, i + chunkSize));
+    }
+
+    // Traitement de chaque tranche
+    for (const chunk of chunks) {
+      try {
+        const res = await searchPubmedFromIds(chunk);
+        if (res) {
+          pubmedContent.push(res);
+        }
+      } catch (error) {
+        console.error('Error processing PubMed chunk:', error);
+      }
+    }
+
+    return pubmedContent;
+  };
+
+  const lastUpdatedData = async () => {
+    let lastUpdate = null;
+    await queryCustomElastic({
+      index: 'oip-discovery-pubmed',
+      customQuery: {
+        from: 0,
+
+        query: {
+          match_all: {},
+        },
+        sort: [
+          {
+            revised_date: {
+              order: 'desc',
+            },
+          },
+        ],
+        size: 1,
+        track_total_hits: true,
+      },
+      onlyOne: true,
+      cluster: 'pubmed',
+    }).then((res) => {
+      if (res) {
+        lastUpdate = dateFormat(res.revised_date);
+      }
+    });
+
+    return lastUpdate;
+  };
+
+  async function pubmedContentFromIds({
+    ids,
+    customQuery,
+  }: {
+    ids?: any;
+    customQuery?: any;
+  }): Promise<any> {
+    isLoadingPubmedList.value = true;
+    return new Promise((resolve, reject) => {
+      let query = {
+        _source: {
+          exclude: ['embedding', 'embeddings_small', 'med_embeddings'],
+        },
+        from: 0,
+        query: {
+          bool: {
+            must: [
+              {
+                terms: {
+                  _id: ids,
+                },
+              },
+            ],
+          },
+        },
+        size: 1000,
+        track_total_hits: true,
+        sort: [{ article_date: { order: 'desc' } }],
+      };
+
+      queryCustomElastic({
+        index: 'oip-discovery-pubmed',
+        cluster: 'pubmed',
+        customQuery: customQuery ? customQuery : query,
+      })
+        .then((res) => {
+          if (res) {
+            pubmedListResult.value = res?.results;
+            resolve(res);
+          } else {
+            reject('Aucun résultat trouvé');
+          }
+        })
+        .catch((error) => {
+          reject(error);
+        })
+        .finally(() => {
+          isLoadingPubmedList.value = false;
+        });
+    });
+  }
+
+  // SPECIAL QUERY
+  // ::::::::::::::::::::::::::::::::::::::::::::::::::
+
+  const pubmedDiseaseQuery = (name: string, synonymes?: string[]) => {
+    if (synonymes && synonymes.length) {
+      const mergeResult = synonymes.concat(name);
+      const query = {
+        bool: {
+          should: [] as any[],
+        },
+      };
+
+      mergeResult.forEach((name) => {
+        query.bool.should.push(
+          {
+            query_string: {
+              query: `(\"${name}\")`,
+              fields: ['title', 'mesh_terms', 'keywords', 'chemical_list'],
+              default_operator: 'AND',
+              analyze_wildcard: true,
+              allow_leading_wildcard: false,
+              phrase_slop: 0,
+              auto_generate_synonyms_phrase_query: true,
+              fuzziness: 'AUTO',
+            },
+          },
+          {
+            nested: {
+              path: 'sections',
+              query: {
+                query_string: {
+                  query: `(\"${name}\")`,
+                  fields: ['sections.label'],
+                  default_operator: 'AND',
+                  analyze_wildcard: true,
+                  allow_leading_wildcard: false,
+                  phrase_slop: 0,
+                  auto_generate_synonyms_phrase_query: true,
+                  fuzziness: 'AUTO',
+                },
+              },
+            },
+          },
+          {
+            nested: {
+              path: 'sections',
+              query: {
+                query_string: {
+                  query: `(\"${name}\")`,
+                  fields: ['sections.text'],
+                  default_operator: 'AND',
+                  analyze_wildcard: true,
+                  allow_leading_wildcard: false,
+                  phrase_slop: 0,
+                  auto_generate_synonyms_phrase_query: true,
+                  fuzziness: 'AUTO',
+                },
+              },
+            },
+          },
+          {
+            nested: {
+              path: 'rare_diseases',
+              query: {
+                query_string: {
+                  query: `(\"${name}\")`,
+                  fields: ['rare_diseases.concat_disease_name_orpha_code'],
+                  default_operator: 'AND',
+                  analyze_wildcard: true,
+                  allow_leading_wildcard: false,
+                  phrase_slop: 0,
+                  auto_generate_synonyms_phrase_query: true,
+                  fuzziness: 'AUTO',
+                },
+              },
+            },
+          },
+          {
+            nested: {
+              path: 'rare_diseases',
+              query: {
+                query_string: {
+                  query: `(\"${name}\")`,
+                  fields: ['rare_diseases.disease_synonyms'],
+                  default_operator: 'AND',
+                  analyze_wildcard: true,
+                  allow_leading_wildcard: false,
+                  phrase_slop: 0,
+                  auto_generate_synonyms_phrase_query: true,
+                  fuzziness: 'AUTO',
+                },
+              },
+            },
+          }
+        );
+      });
+      return query;
+    }
+
+    return {
+      bool: {
+        should: [
+          {
+            nested: {
+              path: 'rare_diseases',
+              query: {
+                query_string: {
+                  query: `(\"${name}\")`,
+                  fields: ['rare_diseases.concat_disease_name_orpha_code'],
+                  default_operator: 'AND',
+                  analyze_wildcard: true,
+                  allow_leading_wildcard: false,
+                  phrase_slop: 0,
+                  auto_generate_synonyms_phrase_query: true,
+                  fuzziness: 'AUTO',
+                },
+              },
+            },
+          },
+          {
+            nested: {
+              path: 'rare_diseases',
+              query: {
+                query_string: {
+                  query: `(\"${name}\")`,
+                  fields: ['rare_diseases.disease_synonyms'],
+                  default_operator: 'AND',
+                  analyze_wildcard: true,
+                  allow_leading_wildcard: false,
+                  phrase_slop: 0,
+                  auto_generate_synonyms_phrase_query: true,
+                  fuzziness: 'AUTO',
+                },
+              },
+            },
+          },
+        ],
+      },
+    };
+  };
+
+  const pubmedFromIdsQuery = (ids: string[]) => ({
+    terms: {
+      PubMed_ID: ids,
+    },
+  });
+
+  const pubmedFromGeneSymbolQuery = (geneSymbol: any) => ({
+    bool: {
+      must: [
+        {
+          nested: {
+            path: 'genomics',
+            query: {
+              terms: {
+                'genomics.gene_symbol.keyword': geneSymbol,
+              },
+            },
+          },
+        },
+        {
+          term: {
+            delete: false,
+          },
+        },
+      ],
+    },
+  });
+
+  const pubmedFromMoleculeQuery = (molecule: any) => {
+    const query: any = {
+      bool: {
+        should: [
+          {
+            nested: {
+              path: 'molecules',
+              query: {
+                bool: {
+                  should: [
+                    {
+                      match: {
+                        'molecules.label.keyword': molecule.label,
+                      },
+                    },
+                  ],
+                },
+              },
+            },
+          },
+        ],
+      },
+    };
+
+    if (molecule.atc_code) {
+      query.bool.should[0].nested.query.bool.should.push({
+        terms: {
+          'molecules.atc5.keyword': molecule.atc_code,
+        },
+      });
+    }
+
+    return query;
+  };
+  return {
+    searchPubmeds,
+    searchPubmedFromIds,
+    reconstructPubmed,
+    lastUpdatedData,
+    // :::::::::::::::::::
+    pubmedContentFromIds,
+    pubmedListResult,
+    isLoadingPubmedList,
+    pubmedFromIdsQuery,
+    pubmedDiseaseQuery,
+    pubmedFromGeneSymbolQuery,
+    pubmedFromMoleculeQuery,
+
+    findPubmedById,
+    resultsQueryPubmed,
+    isLoadingQueryPubmed,
+    findManyPubmedById,
+  };
+}