@tekkare/romulus 0.1.251 → 0.1.253

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

@@ -0,0 +1,658 @@
+// Portage de useElastic de France Augmented Science, pour les fiches du layer
+// (cf. components/oip-science) : memes signatures, mais les requetes passent
+// par le proxy du layer (/api/oip/es, cluster `science`), joignable depuis
+// toutes les apps. Le suivi des listes par `keyName` (resultStore des pages
+// de recherche) n'a pas de sens ici : les resultats reviennent a l'appelant.
+
+import { instrumentSearchClause, searchMatchOf } from "./useOipSearchExplain";
+
+export default function useOipElastic() {
+  const config = useRuntimeConfig();
+  //
+  // const resultsQuery = ref([] as Array<object>);
+  const queryTotalResults = ref(0 as number);
+  // const isLoadingQuery = ref(false as Boolean);
+
+  // MAKE QUEUE
+  const queryQueue = ref<Function[]>([]);
+  let isProcessingQueue = false;
+  let isDisposed = false;
+
+  // Resolvers of the promises handed out by `addToQueue`. Kept so a scope
+  // dispose can settle them instead of leaving awaiting callers hanging on a
+  // queue that will never run.
+  const pendingResolvers = new Set<() => void>();
+
+  // In-flight ES requests, aborted on dispose so navigating away doesn't leave
+  // requests running against a slow connection.
+  const inFlight = new Set<AbortController>();
+
+  // Clean up queue when the calling component/scope is destroyed
+  if (getCurrentScope()) {
+    onScopeDispose(() => {
+      isDisposed = true;
+      queryQueue.value = [];
+      isProcessingQueue = false;
+      for (const resolve of pendingResolvers) resolve();
+      pendingResolvers.clear();
+      for (const controller of inFlight) controller.abort();
+      inFlight.clear();
+    });
+  }
+
+  async function processQueue() {
+    if (isProcessingQueue) return;
+    isProcessingQueue = true;
+
+    while (queryQueue.value.length > 0 && !isDisposed) {
+      const currentQuery = queryQueue.value.shift();
+      if (currentQuery && !isDisposed) {
+        try {
+          await currentQuery();
+        } catch (e) {
+          if (!isDisposed) console.error('Error executing query:', e);
+        }
+      }
+    }
+
+    isProcessingQueue = false;
+  }
+
+  /**
+   * Queue a query and return a promise that settles when it has actually run.
+   *
+   * Callers used to fire-and-forget this, which made their `isLoadingQuery`
+   * flag flip back to `false` in the same tick — the loader never showed and
+   * the "no results" state rendered while the request was still in flight.
+   * The returned promise is what makes `await launchQuery()` meaningful.
+   */
+  function addToQueue(queryFunction: Function): Promise<void> {
+    if (isDisposed) return Promise.resolve();
+
+    return new Promise<void>((resolve) => {
+      const settle = () => {
+        if (pendingResolvers.delete(settle)) resolve();
+      };
+      pendingResolvers.add(settle);
+
+      queryQueue.value.push(async () => {
+        try {
+          await queryFunction();
+        } finally {
+          settle();
+        }
+      });
+
+      if (queryQueue.value.length === 1) {
+        processQueue();
+      }
+    });
+  }
+
+  // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+  const filterResults = ref({} as Object);
+
+  // Last ES failure, so pages can tell "the search failed" from "the search
+  // returned nothing". Without it both render as "0 results" and a network
+  // outage is indistinguishable from an empty result set.
+  const queryError = ref<string | null>(null);
+
+  // Users are regularly on slow hospital networks. A request with no bound
+  // stays in flight for minutes and the page just looks frozen, so every ES
+  // call gets an explicit ceiling.
+  const ES_TIMEOUT = 20000;
+
+  // ES calls go through the app's own server proxy (server/api/es) so the
+  // cluster domain + ApiKey never reach the browser. Auth is injected server-side.
+  const setFetchUrl = (_cluster: string | undefined, index: any) => {
+    return `/api/oip/es?cluster=science&index=${encodeURIComponent(index)}`;
+  };
+
+  const setFetchHeaders = (_cluster?: string) => {
+    return {};
+  };
+
+  /**
+   * Single entry point for every ES request: bounds it in time, aborts it on
+   * dispose, and records failures in `queryError`.
+   *
+   * Returns `null` on failure (never throws) so the ~60 existing call sites
+   * keep their current shape. `retry` is pinned to 0 — ofetch would otherwise
+   * replay these queries, and they are heavy enough that a retry storm is
+   * worse than a clean failure the user can act on.
+   *
+   * `signal` lets a caller cancel its own request — typeahead uses it to drop
+   * the query a previous keystroke started.
+   *
+   * `timeoutMs` raises the ceiling for deliberately heavy, user-initiated work
+   * (an export pulling hundreds of documents). The default suits the
+   * interactive queries a user is sitting in front of.
+   *
+   * Note: ofetch only honours its own `timeout` when no `signal` is passed,
+   * so the deadline is enforced here rather than delegated.
+   */
+  async function esFetch(
+    cluster: string | undefined,
+    index: string,
+    body: any,
+    signal?: AbortSignal,
+    timeoutMs?: number
+  ): Promise<any | null> {
+    if (signal?.aborted) return null;
+
+    const controller = new AbortController();
+    inFlight.add(controller);
+
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, timeoutMs ?? ES_TIMEOUT);
+
+    const onCallerAbort = () => controller.abort();
+    signal?.addEventListener('abort', onCallerAbort, { once: true });
+
+    try {
+      const res = await $fetch(setFetchUrl(cluster, index), {
+        method: 'POST',
+        headers: setFetchHeaders(cluster),
+        body,
+        signal: controller.signal,
+        retry: 0,
+      });
+      queryError.value = null;
+      return res;
+    } catch (err: any) {
+      // An abort triggered by dispose is expected — the user navigated away.
+      if (isDisposed || (err?.name === 'AbortError' && !timedOut)) return null;
+
+      queryError.value = timedOut
+        ? 'timeout'
+        : err?.statusCode
+        ? `http_${err.statusCode}`
+        : 'network';
+      console.error('[useOipElastic] query failed', {
+        index,
+        reason: queryError.value,
+        message: err?.message,
+      });
+      return null;
+    } finally {
+      clearTimeout(timer);
+      signal?.removeEventListener('abort', onCallerAbort);
+      inFlight.delete(controller);
+    }
+  }
+
+  function removeDuplicateMatchAll(queryArray: any) {
+    const hasOtherQueries = queryArray.some(
+      (item) => JSON.stringify(item) !== JSON.stringify({ match_all: {} })
+    );
+
+    const uniqueQueryArray = [];
+    let matchAllAdded = false;
+
+    for (const item of queryArray) {
+      if (JSON.stringify(item) === JSON.stringify({ match_all: {} })) {
+        if (hasOtherQueries) continue;
+
+        if (!matchAllAdded) {
+          uniqueQueryArray.push(item);
+          matchAllAdded = true;
+        }
+      } else {
+        uniqueQueryArray.push(item);
+      }
+    }
+
+    return uniqueQueryArray;
+  }
+
+  // Helper function to get sort values
+  function getSortValues(sortQuery: any): any[] {
+    if (!sortQuery) return [];
+    return sortQuery.values || [];
+  }
+
+  async function queryElastic({
+    index,
+    take,
+    skip,
+    customQuery,
+    sortQuery,
+    keyName,
+    source,
+    highlight,
+    with_id,
+    cluster,
+    mustNot,
+    timeout,
+    explainFilter,
+  }: {
+    index: string;
+    take: any;
+    skip?: number;
+    customQuery: any;
+    sortQuery?: any;
+    keyName?: any;
+    source?: any;
+    highlight?: any;
+    with_id?: boolean;
+    cluster?: string;
+    mustNot?: any;
+    // Raise the deadline for heavy, user-initiated pulls (exports).
+    timeout?: number;
+    // Filtre de la barre de recherche a instrumenter pour le « Voir pourquoi »
+    // (cf. useSearchExplain). Chaque resultat garde alors son `_match`.
+    explainFilter?: string;
+  }) {
+    let esResults: any = {
+      results: [],
+      total: 0,
+    };
+
+    // isLoadingQuery.value = true;
+
+    // Ensure customQuery is always an array
+    const customQueryArray = Array.isArray(customQuery) ? customQuery : [customQuery];
+
+    let explainHighlight: any;
+    const queryRaw = customQueryArray
+      .map((obj: any) => {
+        if (!explainFilter || obj?.filter !== explainFilter) return obj.values;
+        const { query, highlight } = instrumentSearchClause(obj.values);
+        explainHighlight = highlight;
+        return query;
+      })
+      .filter((item: any) => item && item !== undefined);
+
+    // Sans explication, le resultat reste le `_source` tel quel.
+    const sourceOf = (x: any) => {
+      if (!explainFilter) return x._source;
+      const match = searchMatchOf(x);
+      return match ? { ...x._source, _match: match } : x._source;
+    };
+
+    const queryMustValues = removeDuplicateMatchAll(queryRaw);
+
+    // QUERY
+    let query: any = {
+      from: skip ? skip : 0,
+      _source: source ? source : true,
+      query: {
+        bool: {
+          must: queryMustValues,
+          must_not: mustNot ? mustNot : [],
+        },
+      },
+
+      highlight: highlight ? highlight : explainHighlight ?? {},
+      size: take ? (take.values ? take.values : take) : 10,
+      sort: getSortValues(sortQuery),
+      track_total_hits: true,
+    };
+
+    // FETCH
+    const res: any = await esFetch(cluster, index, query, undefined, timeout);
+
+    if (!isDisposed && res) {
+      {
+        // OTHERWISE USE resultsQuery as result
+
+        if (!with_id) {
+          esResults.results = res.hits.hits.map(sourceOf);
+          esResults.total = res.hits.total.value;
+        }
+
+        if (with_id) {
+          esResults.results = res.hits.hits.map((x: any) => x);
+          esResults.total = res.hits.total.value;
+        }
+      }
+    }
+
+    return esResults;
+  }
+
+  // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+  // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+  // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+
+  async function queryOneElastic({
+    index,
+    path,
+    id,
+    source,
+    cluster,
+  }: {
+    index: string;
+    path: any;
+    id: any;
+    source?: any;
+    cluster?: string;
+  }) {
+    let esResults: object = {};
+
+    // QUERY
+    let query: any = {
+      from: 0,
+      _source: source ? source : [],
+      query: {
+        bool: {
+          must: [{ match: { [`${path}`]: id } }],
+        },
+      },
+
+      size: 1,
+
+      track_total_hits: true,
+    };
+
+    // FETCH
+    const res: any = await esFetch(cluster, index, query);
+
+    if (res) {
+      esResults = res.hits.hits.map((x: any) => x._source)[0];
+    }
+
+    return esResults;
+  }
+  // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+  // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+  // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+
+  async function queryCustomElastic({
+    index,
+    customQuery,
+    onlyOne,
+    cluster,
+
+    allAnswer,
+    with_id,
+    signal,
+    timeout,
+  }: {
+    index: string;
+    customQuery: any;
+    onlyOne?: boolean;
+    cluster?: string;
+    allAnswer?: boolean;
+    with_id?: boolean;
+    // Lets the caller cancel a superseded request (typeahead).
+    signal?: AbortSignal;
+    // Raise the deadline for heavy, user-initiated pulls (exports).
+    timeout?: number;
+  }) {
+    let esResults: any = {
+      results: [],
+      total: 0,
+    };
+
+    // QUERY
+    let query = customQuery;
+
+    // FETCH
+    const res: any = await esFetch(cluster, index, query, signal, timeout);
+
+    if (!isDisposed && res) {
+      if (onlyOne) {
+        esResults = res.hits.hits.map((x: any) => (with_id ? x : x._source))[0];
+      } else if (allAnswer) {
+        esResults = res;
+      } else {
+        esResults.results = res.hits.hits.map((x: any) =>
+          with_id ? x : x._source
+        );
+        // ES drops `hits.total` (or changes its shape) when the caller
+        // sets `track_total_hits: false`. Treat any non-object as the
+        // raw count and fall back to 0 when the field is absent.
+        const t = res.hits.total;
+        esResults.total = typeof t === 'number' ? t : (t?.value ?? 0);
+      }
+    }
+
+    return esResults;
+  }
+  // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+  // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+  // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+
+  async function queryFilter({
+    index,
+    filters,
+    take,
+    customQuery,
+    cluster,
+    mustNot,
+  }: {
+    index: string;
+    filters: any;
+    take: number;
+    customQuery: any;
+    cluster?: string;
+    mustNot?: any;
+  }) {
+    let esResults: object = {};
+
+    // Ensure customQuery is always an array
+    const customQueryArray = Array.isArray(customQuery) ? customQuery : [customQuery];
+    
+    const queryMustValues = customQueryArray
+      .filter((x: any) => x.filter != filters.name)
+      .map((obj: any) => obj.values)
+      .filter((item: any) => item && item !== undefined);
+
+    // QUERY
+    let query = {
+      from: 0,
+      query: {
+        bool: {
+          must: queryMustValues,
+          must_not: mustNot ? mustNot : [],
+        },
+      },
+
+      aggs: filters.agg,
+
+      size: 0,
+      track_total_hits: true,
+    };
+
+    // FETCH. FAS chose the aggregation shape from the current route (/pubmed,
+    // /euct); a layer view has no route of its own, the index says the same.
+    const currentPath = index.includes('pubmed') ? '/pubmed' : index.includes('euct') ? '/euct' : '';
+    const res: any = await esFetch(cluster, index, query);
+
+    if (!isDisposed && res) {
+      try {
+        if(filters.path === 'diseases.icd10.combined_label' && currentPath.includes('pubmed')){
+          esResults = res.aggregations['diseases.icd10'][
+            'diseases.icd10.combined_label'
+          ].buckets.map((x: { key: any }) => x.key);
+          
+        }
+         else if(filters.path === 'diseases.icd10.combined_label' && currentPath.includes('euct')){
+          esResults = res.aggregations['diseases.icd10.combined_label'].buckets.map((x: { key: any }) => x.key);
+
+        }
+         else if(filters.path === 'diseases_nested.icd10_combined_label' && currentPath.includes('euct')){
+          esResults = res.aggregations['diseases_nested']['icd10_combined_label'].buckets.map((x: { key: any }) => x.key);
+          
+        } 
+        else if(filters.path === 'diseases.icd10.combined_label'){
+          esResults = res.aggregations['diseases'][
+            'diseases.icd10.combined_label'
+          ].buckets.map((x: { key: any }) => x.key);
+          
+        } else if(filters.path === 'diseases_nested.icd10_nested.icd10_combined_label'){
+           esResults = res.aggregations['diseases_nested'][
+            'icd10_nested'
+          ].icd10_combined_label.buckets.map((x: { key: any }) => x.key);
+        } else if(filters.path === 'diseases.record_diseases.section_label'){
+          esResults = res.aggregations.diseases.record_diseases.section_label.buckets.map((x: { key: any }) => x.key);
+        } 
+        else if (filters.isNested) {
+          esResults = res.aggregations[filters.path.split('.')[0]][
+            filters.path
+          ].buckets.map((x: { key: any }) => x.key);
+        } else {
+          esResults = res.aggregations[filters.path].buckets.map(
+            (x: { key: any }) => x.key
+          );
+        }
+      } catch (err: any) {
+        // The aggregation came back in a shape this branch didn't expect —
+        // a mapping change, not a network problem. Report it as such rather
+        // than letting it read as an empty filter.
+        queryError.value = 'unexpected_aggregation';
+        console.error('[useOipElastic] queryFilter: unexpected aggregation shape', {
+          index,
+          path: filters.path,
+          message: err?.message,
+        });
+      }
+    }
+
+    return esResults;
+  }
+
+  async function queryAggregations({
+    index,
+    queryFilter,
+    aggs,
+    cluster,
+    isNested,
+    allAnswer,
+  }: {
+    index: string;
+    queryFilter: any;
+    aggs: any;
+    cluster?: string;
+    isNested?: boolean;
+    allAnswer?: boolean;
+  }) {
+    let esResults: object = {};
+
+    // QUERY
+    let query: any = {
+      from: 0,
+      query: queryFilter,
+      aggs: aggs,
+      size: 0,
+      track_total_hits: true,
+    };
+
+    const aggsKey = Object.keys(aggs)[0];
+
+    // FETCH
+    const res: any = await esFetch(cluster, index, query);
+
+    if (!isDisposed && res) {
+      if (allAnswer) {
+        esResults = res.aggregations;
+      } else {
+        if (isNested) {
+          esResults = res.aggregations[aggsKey][aggsKey].buckets.map(
+            (x: { key: any }) => x.key
+          );
+        } else {
+          esResults = res.aggregations[aggsKey].buckets.map(
+            (x: { key: any }) => x.key
+          );
+        }
+      }
+    }
+
+    return esResults;
+  }
+
+  // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+  // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+  // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+
+  async function querySearchFilter({
+    index,
+    filters,
+    take,
+    customQuery,
+    cluster,
+    mustNot,
+  }: {
+    index: string;
+    filters: any;
+    take: number;
+    customQuery: any;
+    cluster?: string;
+    mustNot?: any;
+  }) {
+    let esResults: object = {};
+
+    // Ensure customQuery is always an array
+    const customQueryArray = Array.isArray(customQuery) ? customQuery : [customQuery];
+    
+    const queryMustValues = customQueryArray
+      .filter((x: any) => x.filter != filters.name)
+      .map((obj: any) => obj.values)
+      .filter((item: any) => item !== undefined);
+
+    let query: any = {
+      from: 0,
+      query: {
+        bool: {
+          must: [
+            {
+              bool: {
+                must: queryMustValues,
+              },
+            },
+            filters.searchQuery,
+          ],
+          must_not: mustNot ? mustNot : [],
+        },
+      },
+
+      aggs: filters.agg,
+
+      size: 0,
+
+      track_total_hits: true,
+    };
+
+    // FETCH
+    const res: any = await esFetch(cluster, index, query);
+
+    if (!isDisposed && res) {
+      if (filters.isNested) {
+        esResults = res.aggregations[filters.path][filters.path].buckets.map(
+          (x: { key: any }) => x.key
+        );
+      } else {
+        esResults = res.aggregations[filters.path].buckets.map(
+          (x: { key: any }) => x.key
+        );
+      }
+    }
+
+    return esResults;
+  }
+
+  // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+  // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+  return {
+    queryElastic,
+
+    // isLoadingQuery,
+    queryTotalResults,
+    // resultsQuery,
+    // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+    queryFilter,
+    filterResults,
+    queryCustomElastic,
+    querySearchFilter,
+
+    queryOneElastic,
+    queryAggregations,
+    addToQueue,
+    queryError,
+  };
+}