nuxt-kql/dist/runtime/composables/useKql.js

Kirby's Query Language API for Nuxt

import { useAsyncData, useRequestFetch, useRuntimeConfig } from "#imports";
import { hash } from "ohash";
import { computed, toValue } from "vue";
import { createAuthHeader, getProxyPath, headersToObject } from "../utils.js";
export function useKql(query, opts = {}) {
  const {
    server,
    lazy,
    default: defaultFn,
    transform,
    pick,
    watch: watchSources,
    immediate,
    headers,
    language,
    cache = true,
    ...fetchOptions
  } = opts;
  const kql = useRuntimeConfig().public.kql;
  const _query = computed(() => toValue(query));
  const _language = computed(() => toValue(language));
  const key = computed(() => `$kql${hash([_query.value, _language.value])}`);
  if (Object.keys(_query.value).length === 0 || !_query.value.query)
    console.error("[useKql] Empty KQL query");
  const asyncDataOptions = {
    server,
    lazy,
    default: defaultFn,
    transform,
    pick,
    watch: watchSources === false ? [] : [...watchSources || [], key],
    immediate
  };
  let controller;
  return useAsyncData(
    watchSources === false ? key.value : key,
    async (nuxt) => {
      controller?.abort?.();
      if (nuxt && (nuxt.isHydrating || cache) && nuxt.payload.data[key.value])
        return nuxt.payload.data[key.value];
      controller = new AbortController();
      try {
        let result;
        if (kql.client) {
          result = await useRequestFetch()(kql.prefix, {
            ...fetchOptions,
            signal: controller.signal,
            baseURL: kql.url,
            method: "POST",
            body: _query.value,
            headers: {
              ...headersToObject(headers),
              ...createAuthHeader(kql),
              ..._language.value && { "X-Language": _language.value }
            }
          });
        } else {
          result = await useRequestFetch()(getProxyPath(key.value), {
            ...fetchOptions,
            signal: controller.signal,
            method: "POST",
            body: {
              query: _query.value,
              cache,
              headers: {
                ...headersToObject(headers),
                ..._language.value && { "X-Language": _language.value }
              }
            }
          });
        }
        if (nuxt && cache)
          nuxt.payload.data[key.value] = result;
        return result;
      } catch (error) {
        if (nuxt)
          nuxt.payload.data[key.value] = void 0;
        throw error;
      }
    },
    asyncDataOptions
  );
}