@pol-studios/db 1.0.21 → 1.0.23

package/dist/{chunk-X3HZLNBV.js → chunk-BXSOHOQ2.js}

@@ -1,23 +1,3 @@
-import {
-  getSupabaseUrl
-} from "./chunk-GC3TBUWE.js";
-import {
-  PostgrestParser
-} from "./chunk-TKWR5AAY.js";
-import {
-  isNullOrWhitespace,
-  isUsable,
-  omit
-} from "./chunk-OQ7U6EQ3.js";
-import {
-  encode,
-  useQuery
-} from "./chunk-H6365JPC.js";
-import {
-  generateUUID,
-  useSupabase
-} from "./chunk-5EFDS7SR.js";
-
 // src/query/select-parser.ts
 function tokenizeTopLevel(input) {
   const tokens = [];
@@ -690,14 +670,17 @@ var ResultJoiner = class {
       return baseRecords;
     }
     if (relationship.type === "one-to-many") {
-      return baseRecords.map((base) => {
+      const groupedByFK = /* @__PURE__ */ new Map();
+      for (const r of relatedRecords) {
+        const fkValue = r[relationship.foreignKey];
+        if (!groupedByFK.has(fkValue)) groupedByFK.set(fkValue, []);
+        groupedByFK.get(fkValue).push(r);
+      }
+      for (const base of baseRecords) {
         const baseId = base[relationship.referencedColumn];
-        const related = relatedRecords.filter((r) => r[relationship.foreignKey] === baseId);
-        return {
-          ...base,
-          [relationName]: related
-        };
-      });
+        base[relationName] = groupedByFK.get(baseId) ?? [];
+      }
+      return baseRecords;
     } else {
       const relatedMap = /* @__PURE__ */ new Map();
       for (const r of relatedRecords) {
@@ -706,14 +689,11 @@ var ResultJoiner = class {
           relatedMap.set(refValue, r);
         }
       }
-      return baseRecords.map((base) => {
+      for (const base of baseRecords) {
         const fkValue = base[relationship.foreignKey];
-        const related = fkValue != null ? relatedMap.get(fkValue) ?? null : null;
-        return {
-          ...base,
-          [relationName]: related
-        };
-      });
+        base[relationName] = fkValue != null ? relatedMap.get(fkValue) ?? null : null;
+      }
+      return baseRecords;
     }
   }
   /**
@@ -1102,27 +1082,56 @@ var QueryExecutor = class {
    * @returns Parent records with relations attached
    */
   async queryAndJoinRelations(parentTable, parentRecords, relations) {
-    let result = [...parentRecords];
-    for (const relation of relations) {
+    const relationResults = await Promise.all(relations.map(async (relation) => {
       const resolved = this.resolver.resolve(parentTable, relation.name);
       if (!resolved) {
         console.warn(`Could not resolve relationship: ${parentTable} -> ${relation.name}`);
-        continue;
+        return {
+          relation,
+          resolved: null,
+          records: []
+        };
       }
       const parentIds = this.getParentIdsForRelation(parentRecords, resolved);
       if (parentIds.length === 0) {
+        return {
+          relation,
+          resolved,
+          records: []
+        };
+      }
+      const relQuery = this.buildRelatedQuery(relation, resolved, parentIds);
+      let records = await this.db.getAll(relQuery.sql, relQuery.params);
+      if (relation.relations.length > 0 && records.length > 0) {
+        records = await this.queryAndJoinRelations(relation.name, records, relation.relations);
+      }
+      return {
+        relation,
+        resolved,
+        records
+      };
+    }));
+    let result = [...parentRecords];
+    for (const {
+      relation,
+      resolved,
+      records
+    } of relationResults) {
+      if (!resolved) {
         result = result.map((r) => ({
           ...r,
-          [relation.alias ?? relation.name]: resolved.type === "one-to-many" ? [] : null
+          [relation.alias ?? relation.name]: null
         }));
         continue;
       }
-      const relQuery = this.buildRelatedQuery(relation, resolved, parentIds);
-      let relatedRecords = await this.db.getAll(relQuery.sql, relQuery.params);
-      if (relation.relations.length > 0 && relatedRecords.length > 0) {
-        relatedRecords = await this.queryAndJoinRelations(relation.name, relatedRecords, relation.relations);
+      if (records.length === 0) {
+        result = result.map((r) => ({
+          ...r,
+          [relation.alias ?? relation.name]: resolved.type === "one-to-many" ? [] : null
+        }));
+        continue;
       }
-      result = this.joiner.join(result, relatedRecords, resolved, relation.alias ?? relation.name);
+      result = this.joiner.join(result, records, resolved, relation.alias ?? relation.name);
     }
     return result;
   }
@@ -1169,940 +1178,6 @@ function createQueryExecutor(db, schema) {
   return new QueryExecutor(db, schema);
 }
 
-// src/query/useQuery.ts
-import { c as _c } from "react/compiler-runtime";
-import { useDelayedValue } from "@pol-studios/hooks/state";
-function useQuery2(query, config) {
-  const $ = _c(5);
-  let t0;
-  if ($[0] !== query) {
-    const queryKey = encode(query, false);
-    t0 = queryKey.join("-");
-    $[0] = query;
-    $[1] = t0;
-  } else {
-    t0 = $[1];
-  }
-  const queryKeyString = t0;
-  const debouncedKeyString = useDelayedValue(queryKeyString, 50);
-  const isKeyStable = queryKeyString === debouncedKeyString;
-  const effectiveEnabled = config?.enabled !== false && isKeyStable;
-  let t1;
-  if ($[2] !== config || $[3] !== effectiveEnabled) {
-    t1 = omit({
-      retry: 1,
-      ...config,
-      enabled: effectiveEnabled
-    }, ["queryKey"]);
-    $[2] = config;
-    $[3] = effectiveEnabled;
-    $[4] = t1;
-  } else {
-    t1 = $[4];
-  }
-  const request = useQuery(query, t1);
-  return request;
-}
-
-// src/query/usePartialQuery.ts
-import { c as _c2 } from "react/compiler-runtime";
-import { useSessionStorageState } from "@pol-studios/hooks/storage";
-function usePartialQuery(query, itemCountPerPage, config) {
-  const $ = _c2(28);
-  let t0;
-  if ($[0] !== query) {
-    t0 = encode(query, false);
-    $[0] = query;
-    $[1] = t0;
-  } else {
-    t0 = $[1];
-  }
-  const initialQuery = t0;
-  let t1;
-  if ($[2] !== initialQuery[7] || $[3] !== initialQuery[8]) {
-    t1 = [initialQuery[7], initialQuery[8]];
-    $[2] = initialQuery[7];
-    $[3] = initialQuery[8];
-    $[4] = t1;
-  } else {
-    t1 = $[4];
-  }
-  const id = t1.join("-");
-  const [currentPage, setCurrentPage] = useSessionStorageState(id, 1);
-  const page = currentPage ?? 1;
-  const t2 = query;
-  let t3;
-  if ($[5] !== itemCountPerPage || $[6] !== page || $[7] !== t2) {
-    t3 = t2.range((page - 1) * itemCountPerPage, page * itemCountPerPage - 1);
-    $[5] = itemCountPerPage;
-    $[6] = page;
-    $[7] = t2;
-    $[8] = t3;
-  } else {
-    t3 = $[8];
-  }
-  const rangedQuery = t3;
-  const baseQuery = useQuery2(rangedQuery, config);
-  let t4;
-  if ($[9] !== setCurrentPage) {
-    t4 = () => {
-      setCurrentPage(_temp);
-    };
-    $[9] = setCurrentPage;
-    $[10] = t4;
-  } else {
-    t4 = $[10];
-  }
-  const safeFetchNextPage = t4;
-  let t5;
-  if ($[11] !== setCurrentPage) {
-    t5 = () => {
-      setCurrentPage(_temp2);
-    };
-    $[11] = setCurrentPage;
-    $[12] = t5;
-  } else {
-    t5 = $[12];
-  }
-  const fetchPreviousPage = t5;
-  const pageCount = Math.max(Math.ceil((baseQuery.count ?? 0) / itemCountPerPage), 1);
-  let t6;
-  if ($[13] !== baseQuery.count || $[14] !== baseQuery.data || $[15] !== currentPage || $[16] !== itemCountPerPage) {
-    t6 = baseQuery.data ? toPagedResponse(baseQuery.data, currentPage, baseQuery.count ?? baseQuery.data.length, itemCountPerPage) : null;
-    $[13] = baseQuery.count;
-    $[14] = baseQuery.data;
-    $[15] = currentPage;
-    $[16] = itemCountPerPage;
-    $[17] = t6;
-  } else {
-    t6 = $[17];
-  }
-  const t7 = currentPage < pageCount;
-  const t8 = currentPage > 1;
-  let t9;
-  if ($[18] !== baseQuery || $[19] !== currentPage || $[20] !== fetchPreviousPage || $[21] !== pageCount || $[22] !== safeFetchNextPage || $[23] !== setCurrentPage || $[24] !== t6 || $[25] !== t7 || $[26] !== t8) {
-    t9 = {
-      ...baseQuery,
-      fetchPreviousPage,
-      fetchNextPage: safeFetchNextPage,
-      currentPage,
-      setCurrentPage,
-      data: t6,
-      pageCount,
-      hasNextPage: t7,
-      hasPreviousPage: t8
-    };
-    $[18] = baseQuery;
-    $[19] = currentPage;
-    $[20] = fetchPreviousPage;
-    $[21] = pageCount;
-    $[22] = safeFetchNextPage;
-    $[23] = setCurrentPage;
-    $[24] = t6;
-    $[25] = t7;
-    $[26] = t8;
-    $[27] = t9;
-  } else {
-    t9 = $[27];
-  }
-  return t9;
-}
-function _temp2(currentPage_1) {
-  return currentPage_1 - 1;
-}
-function _temp(currentPage_0) {
-  return currentPage_0 + 1;
-}
-function toPagedResponse(results, currentPage, totalCount, itemPerPage) {
-  const newPage = {
-    Items: results,
-    CurrentPage: currentPage,
-    ItemCount: totalCount,
-    MaxCountPerPage: itemPerPage,
-    PageCount: Math.max(Math.ceil(totalCount / itemPerPage), 1)
-  };
-  return newPage;
-}
-
-// src/query/useAdvancedQuery.ts
-import { useEffect, useMemo, useRef, useState } from "react";
-import { useQuery as useQuery3 } from "@tanstack/react-query";
-import { useSessionStorageState as useSessionStorageState2 } from "@pol-studios/hooks/storage";
-var normalizeFilter = (filter) => {
-  const groupOp = filter.op || filter.operator;
-  if (groupOp && (groupOp === "AND" || groupOp === "OR") && filter.filters) {
-    return {
-      id: filter.id || generateUUID(),
-      op: groupOp,
-      not: filter.not || filter.inverted,
-      // Support both 'not' and legacy 'inverted' for groups
-      filters: filter.filters.map(normalizeFilter).filter(Boolean)
-    };
-  }
-  let operator = filter.op || filter.condition;
-  let shouldNegate = filter.not || filter.inverted || false;
-  if (operator === "\u220B") operator = "in";
-  if (operator === "\u2260" || operator === "!=") {
-    operator = "=";
-    shouldNegate = true;
-  }
-  if (operator === "like") operator = "contains";
-  if (operator === "regex" || operator === "regex_i" || operator === "similar_to") {
-    operator = "contains";
-  }
-  if (!operator) {
-    console.error("Filter has undefined operator:", JSON.stringify(filter, null, 2));
-    return null;
-  }
-  if (filter.propertyName) {
-    return {
-      id: filter.id || generateUUID(),
-      field: filter.propertyName,
-      op: operator,
-      value: filter.value,
-      not: shouldNegate,
-      display: filter.display || filter.propertyName
-    };
-  }
-  return {
-    id: filter.id || generateUUID(),
-    field: filter.field || "",
-    op: operator,
-    value: filter.value,
-    not: shouldNegate,
-    similarity: filter.similarity,
-    where: filter.where,
-    display: filter.display || filter.field || ""
-  };
-};
-function useAdvancedFilterQuery(query, config) {
-  const filterKey = useMemo(() => config?.filterKey ?? window.location?.pathname, [config?.filterKey]);
-  const [filterLayer, setFilterLayer] = useSessionStorageState2(filterKey, {
-    id: "root",
-    op: "AND",
-    filters: [],
-    pagination: void 0,
-    sort: [],
-    isReady: isUsable(config?.searchByDefault) ? config.searchByDefault ? false : true : true
-  });
-  const parser = useMemo(() => new PostgrestParser(query), [query, config?.key]);
-  useEffect(() => {
-    const searchParam = parser.searchParams.get("order");
-    if (searchParam) {
-      const orderColumns = searchParam.split(",");
-      const orders = [];
-      orderColumns.forEach((x) => {
-        const values = x.split(".");
-        orders.push({
-          field: values[0],
-          direction: values[1] === "asc" ? "asc" : "desc"
-        });
-      });
-      setFilterLayer((pre) => {
-        if (!pre) {
-          return {
-            id: "root",
-            op: "AND",
-            filters: [],
-            isReady: true,
-            sort: orders
-          };
-        }
-        return {
-          ...pre,
-          id: pre.id || "root",
-          op: pre.op || "AND",
-          filters: pre.filters || [],
-          isReady: pre.isReady ?? true,
-          sort: [...(pre.sort || []).filter((old) => orders.some((o) => o.field === old.field) === false), ...orders]
-        };
-      });
-    }
-  }, [JSON.stringify(parser.searchParams), config?.key]);
-  const encodedQueryKeyRef = useRef([]);
-  const encodedQueryKey = useMemo(() => {
-    const newEncoded = encode(query, false);
-    const newEncodedString = JSON.stringify(newEncoded);
-    const oldEncodedString = JSON.stringify(encodedQueryKeyRef.current);
-    if (newEncodedString !== oldEncodedString) {
-      encodedQueryKeyRef.current = newEncoded;
-    }
-    return encodedQueryKeyRef.current;
-  }, [query, parser.offset, parser.limit]);
-  const filterLayerStringRef = useRef("");
-  const currentFilterString = JSON.stringify(filterLayer, (key, value) => key === "id" ? "redacted" : value);
-  if (filterLayerStringRef.current !== currentFilterString) {
-    filterLayerStringRef.current = currentFilterString;
-  }
-  const queryKeyRef = useRef([]);
-  const newKey = [encodedQueryKey[0], encodedQueryKey[1], encodedQueryKey[2], encodedQueryKey[3], encodedQueryKey[4], encodedQueryKey[5], "count=" + (config?.count ?? ""), encodedQueryKey[7], encodedQueryKey[8], filterLayerStringRef.current];
-  const newKeyString = JSON.stringify(newKey);
-  const oldKeyString = JSON.stringify(queryKeyRef.current);
-  if (oldKeyString !== newKeyString) {
-    queryKeyRef.current = newKey;
-  }
-  const queryKey = queryKeyRef.current;
-  const [previousKey, setPreviousKey] = useState(queryKey);
-  useEffect(() => {
-    if (filterLayer?.isReady) {
-      setPreviousKey(queryKey);
-    }
-  }, [...queryKey]);
-  const loadingKey = filterLayer?.isReady ? queryKey : previousKey ?? queryKey;
-  const supabase = useSupabase();
-  const isEnabled = config?.enabled == null || config?.enabled === void 0 ? true : config.enabled;
-  const [extraData, setExtraData] = useState({});
-  const queryResponse = useQuery3({
-    ...omit({
-      retry: 0,
-      // Changed from 1 to 0 to prevent retries
-      ...config ?? {},
-      // Override any config settings to prevent multiple executions
-      refetchOnMount: false,
-      refetchOnWindowFocus: false,
-      refetchOnReconnect: false,
-      structuralSharing: false,
-      enabled: filterLayer?.isReady && isEnabled
-    }, ["queryKey", "persister", "initialData"]),
-    queryKey: loadingKey,
-    queryFn: async (props) => {
-      if (!filterLayer) {
-        throw new Error("Filter layer is not initialized");
-      }
-      try {
-        const searchParams = Array.from(parser.searchParams.entries());
-        const body = {
-          ...filterLayer,
-          filters: [...filterLayer.filters],
-          pagination: {
-            ...filterLayer.pagination
-          },
-          sort: [...filterLayer.sort || []]
-        };
-        const currentKey = `${parser.schema}${parser.table}${parser.select}${JSON.stringify(omit(body, "pagination"))}`;
-        const requiresEdgeForOrdering = false;
-        const hasNaturalLanguageQuery = !!filterLayer.naturalLanguageQuery;
-        if (filterLayer.filters.length == 0 && requiresEdgeForOrdering === false && !hasNaturalLanguageQuery) {
-          const result = await executeSupabaseQuery(supabase, body, parser, extraData, props.signal, config?.count);
-          setExtraData((pre_0) => ({
-            ...omit(result, "data"),
-            count: result.count ? result.count : pre_0.count,
-            key: currentKey
-          }));
-          return result;
-        }
-        searchParams.forEach(([k, v]) => {
-          if (k.includes("offset")) {
-            body.pagination.offset = Number(v);
-            return;
-          }
-          if (k.includes("limit")) {
-            body.pagination.limit = Number(v);
-            return;
-          }
-          if (k.includes("order")) {
-            return;
-          }
-          if (k === "or") {
-            return;
-          }
-          if (v.includes(".") === false) return;
-          const values_0 = v.split(".");
-          const column = k;
-          let rawCondition = values_0[0];
-          let condition = "";
-          let value_0 = values_0[1];
-          const inverted = values_0[0] === "not";
-          if (column == "select") return;
-          if (rawCondition === "not") {
-            rawCondition = values_0[1];
-            value_0 = values_0[2];
-          }
-          switch (rawCondition) {
-            case "eq":
-              condition = "=";
-              break;
-            case "in":
-              condition = "in";
-              value_0 = value_0.slice(1, value_0.length - 1).split(",").filter((x_0) => isNullOrWhitespace(x_0) === false);
-              break;
-            case "lt":
-              condition = "<";
-              break;
-            case "gt":
-              condition = ">";
-              break;
-            case "lte":
-              condition = "<=";
-              break;
-            case "gte":
-              condition = ">=";
-              break;
-            case "is":
-              condition = "is";
-              if (value_0 == "null") {
-                value_0 = null;
-              }
-              break;
-          }
-          body.filters = [{
-            id: `filter_${column}_${Date.now()}`,
-            field: column,
-            op: condition,
-            value: value_0,
-            not: inverted,
-            display: column
-          }, {
-            filters: [...body.filters],
-            op: body.op ?? "AND",
-            id: "filterstate"
-          }];
-          body.op = "AND";
-          const bodyCopy = JSON.parse(JSON.stringify(body));
-          bodyCopy.pagination = {
-            page: 0,
-            pageSize: 50
-          };
-          bodyCopy.isReady = true;
-        });
-        const {
-          data: {
-            session
-          }
-        } = await supabase.auth.getSession();
-        if (!session?.access_token) {
-          throw new Error("No active session");
-        }
-        const controller = new AbortController();
-        props.signal.addEventListener("abort", () => {
-          controller.abort();
-        });
-        const timeout = setTimeout(() => controller.abort(), config?.timeout ?? 15e3);
-        let result_0 = null;
-        let response = {
-          error: null,
-          data: null
-        };
-        try {
-          const UI_ONLY_KEYS = /* @__PURE__ */ new Set(["info", "options", "display"]);
-          const filteredBody = JSON.parse(JSON.stringify(body, (key_0, value_1) => {
-            if (UI_ONLY_KEYS.has(key_0)) {
-              return void 0;
-            }
-            return value_1;
-          }));
-          filteredBody.filters = filteredBody.filters.map(normalizeFilter).filter(Boolean);
-          const orParam = parser.searchParams.get("or");
-          if (orParam) {
-            const cleanedOrParam = orParam.replace(/^\(|\)$/g, "");
-            const orConditions = cleanedOrParam.split(",");
-            const orFilters = orConditions.map((condition_0, idx) => {
-              const match = condition_0.match(/^(.+?)\.([^.]+)\.(.+)$/);
-              if (match) {
-                const [_, field, rawOp, value_2] = match;
-                let op = rawOp.trim();
-                switch (op) {
-                  case "eq":
-                    op = "=";
-                    break;
-                  case "neq":
-                    op = "!=";
-                    break;
-                  case "gt":
-                    op = ">";
-                    break;
-                  case "gte":
-                    op = ">=";
-                    break;
-                  case "lt":
-                    op = "<";
-                    break;
-                  case "lte":
-                    op = "<=";
-                    break;
-                  case "like":
-                    op = "contains";
-                    break;
-                  case "ilike":
-                    op = "contains";
-                    break;
-                  case "in":
-                    op = "in";
-                    break;
-                }
-                return {
-                  id: `or-${idx}`,
-                  field: field.trim(),
-                  op,
-                  value: value_2.trim()
-                };
-              }
-              return null;
-            }).filter(Boolean);
-            if (orFilters.length > 0) {
-              filteredBody.filters = [...filteredBody.filters, {
-                id: "base-or-group",
-                op: "OR",
-                filters: orFilters,
-                pagination: void 0,
-                sort: void 0,
-                isReady: true
-              }];
-            }
-          }
-          const res = await fetch(`${getSupabaseUrl()}/functions/v1/query?forceDenoVersion=2`, {
-            method: "POST",
-            headers: {
-              "Content-Type": "application/json",
-              "Authorization": `Bearer ${session.access_token}`
-            },
-            body: JSON.stringify({
-              table: parser.table,
-              schema: parser.schema,
-              select: parser.select,
-              filters: {
-                id: filteredBody.id || "root",
-                op: filteredBody.op || filteredBody.operator || "AND",
-                not: filteredBody.not || filteredBody.inverted,
-                // Support both 'not' and legacy 'inverted'
-                filters: filteredBody.filters || []
-              },
-              pagination: filteredBody.pagination,
-              sort: filteredBody.sort,
-              distinctOn: filteredBody.distinctOn,
-              naturalLanguageQuery: filteredBody.naturalLanguageQuery,
-              count: currentKey === extraData.key ? "" : config?.count ?? "",
-              debug: true
-            }),
-            signal: controller.signal
-          });
-          if (!res.ok) {
-            const errorData = await res.json();
-            const errorMessage_0 = typeof errorData?.error === "string" ? errorData.error : errorData?.error?.message || errorData?.message || "An error occurred while processing your request";
-            throw new Error(errorMessage_0);
-          }
-          const data = await res.json();
-          if (data.clarification) {
-            return {
-              data: [],
-              // Empty data array
-              count: 0,
-              clarification: data.clarification,
-              error: void 0
-            };
-          }
-          result_0 = data;
-          response = {
-            error: null,
-            data
-          };
-        } catch (err) {
-          if (err.name === "AbortError") {
-            console.error("Fetch aborted/time-out");
-            response = {
-              error: new Error("This query timed out"),
-              data: null
-            };
-          } else if (err instanceof Error) {
-            response = {
-              error: err,
-              data: null
-            };
-          } else {
-            const errorMessage = err?.error || err?.message || String(err);
-            response = {
-              error: new Error(errorMessage),
-              data: null
-            };
-          }
-        } finally {
-          clearTimeout(timeout);
-        }
-        if (response.error) {
-          throw response.error;
-        } else if (response.data?.error) {
-          throw new Error(response.data.error);
-        }
-        if (result_0.clarification) {
-          return {
-            data: [],
-            count: 0,
-            clarification: result_0.clarification,
-            error: void 0
-          };
-        }
-        setExtraData((pre_1) => ({
-          ...omit(result_0, "data"),
-          count: pre_1.key === currentKey ? pre_1.count : result_0.count,
-          key: currentKey
-        }));
-        return {
-          ...result_0,
-          statusText: "",
-          status: result_0.data?.length > result_0.count ? 206 : 200,
-          error: response.data?.error ?? null,
-          hasMore: result_0.data?.length < result_0.count ? true : false
-        };
-      } catch (error) {
-        if (error instanceof Error && error.name === "AbortError") {
-          console.log("Fetch aborted");
-        } else {
-          console.error("Error fetching data:", error);
-        }
-        if (error instanceof Error && error.message === "Failed to send a request to the Edge Function") {
-          throw new Error("Could not contact query server");
-        }
-        throw error;
-      }
-    }
-  });
-  const response_0 = {
-    ...queryResponse,
-    data: queryResponse.data?.data,
-    count: extraData.count,
-    clarification: queryResponse.data?.clarification
-  };
-  useEffect(() => {
-    if (queryResponse.isFetched && response_0.count == null) {
-      queryResponse.refetch();
-    }
-  }, [response_0.count]);
-  useEffect(() => {
-    if (queryResponse.data?.error == null) return;
-    if (queryResponse.data?.error?.message?.includes(" does not exist")) {
-      setFilterLayer({
-        id: "root",
-        op: "AND",
-        filters: [],
-        pagination: void 0,
-        sort: [],
-        isReady: isUsable(config?.searchByDefault) ? config.searchByDefault ? false : true : true
-      });
-    }
-  }, [queryResponse.data?.error]);
-  return [response_0, filterLayer, setFilterLayer];
-}
-function isSearchableColumn(columnName) {
-  return true;
-}
-async function executeSupabaseQuery(supabase, body, parser, extraData, signal, count) {
-  const searchParams = Array.from(parser.searchParams.entries());
-  const currentKey = `${parser.schema}${parser.table}${parser.select}${JSON.stringify(omit(body, "pagination"))}`;
-  const query = supabase.schema(parser.schema).from(parser.table).select(parser.select, {
-    count: currentKey === extraData.key ? void 0 : count || void 0
-  });
-  if (body.sort && Array.isArray(body.sort)) {
-    body.sort.forEach((s) => {
-      query.order(s.field, {
-        ascending: s.direction === "asc"
-      });
-    });
-  }
-  const from = searchParams.find((x) => x[0].includes("offset"))?.[1];
-  const to = searchParams.find((x) => x[0].includes("limit"))?.[1];
-  searchParams.forEach(([k, v]) => {
-    if (k.includes("offset") && isUsable(v)) {
-      body.pagination.from = Number(v);
-      return;
-    }
-    if (k.includes("limit") && isUsable(v)) {
-      body.pagination.to = Number(from) + Number(v) - 1;
-      return;
-    }
-    if (k === "or") {
-      query.or(v.slice(1, v.length - 1));
-      return;
-    }
-    const values = v.split(".");
-    const column = k;
-    let rawCondition = values[0];
-    let value = values[1];
-    if (column == "select") return;
-    if (column == "order") return;
-    if (v.includes(".") === false) return;
-    if (rawCondition === "ilike" && !isSearchableColumn(column)) {
-      return;
-    }
-    if (rawCondition === "not") {
-      rawCondition = values[1];
-      value = values[2];
-      query.not(column, rawCondition, value);
-    } else {
-      query.filter(column, rawCondition, value);
-    }
-  });
-  if (body.pagination.from !== null && body.pagination.from !== void 0 && body.pagination.to !== null && body.pagination.to !== void 0 && isNaN(body.pagination.from) === false && isNaN(body.pagination.to) === false) {
-    query.range(body.pagination.from, body.pagination.to);
-  }
-  const result = await query.abortSignal(signal);
-  const dataLength = result.data?.length ?? 0;
-  const totalCount = result.count ?? 0;
-  return {
-    ...result,
-    statusText: "",
-    status: dataLength > totalCount ? 206 : 200,
-    error: result.error,
-    hasMore: dataLength < totalCount
-  };
-}
-var useAdvancedQuery = useAdvancedFilterQuery;
-
-// src/query/useInfiniteQuery.ts
-import { useInfiniteQuery as useTanstackInfiniteQuery } from "@tanstack/react-query";
-import { useMemo as useMemo2, useRef as useRef2 } from "react";
-function useInfiniteQuery(query, countPerLoad, config) {
-  const initialQueryKey = encode(query, false).join("-");
-  const lastKnownQuery = useRef2(initialQueryKey);
-  const currentPageNumber = useRef2(1);
-  if (lastKnownQuery.current != initialQueryKey) {
-    lastKnownQuery.current = initialQueryKey;
-    currentPageNumber.current = 1;
-  }
-  const isFetching = useRef2(false);
-  const queryKey = useMemo2(() => encode(query, false), [initialQueryKey, config?.crossOrganization]);
-  const getQuery = useTanstackInfiniteQuery({
-    ...config,
-    queryKey,
-    queryFn: async ({
-      pageParam,
-      signal
-    }) => {
-      let adjustableQuery = query;
-      const pageNumber = pageParam;
-      if (config?.onQuery && config?.enableOnQuery) {
-        config?.onQuery({
-          query: adjustableQuery,
-          pageParam: pageNumber
-        });
-      } else {
-        adjustableQuery = adjustableQuery.range((pageNumber - 1) * countPerLoad, pageNumber * countPerLoad - 1);
-      }
-      adjustableQuery = adjustableQuery.abortSignal(signal);
-      updatedCache.current = false;
-      const response = await adjustableQuery;
-      currentPageNumber.current = pageNumber;
-      if (response.error) {
-        throw response.error;
-      } else {
-        return response;
-      }
-    },
-    initialPageParam: 1,
-    getNextPageParam: (response_0, allResponses, lastParam) => {
-      const pageParam_0 = lastParam;
-      const resp = response_0;
-      if (allResponses.length * countPerLoad >= (resp?.count ?? 0)) {
-        return void 0;
-      }
-      return pageParam_0 + 1;
-    }
-  });
-  const updatedCache = useRef2(true);
-  return useMemo2(() => {
-    const pages = getQuery.data?.pages;
-    return {
-      ...getQuery,
-      count: pages?.[pages.length - 1]?.count,
-      data: pages?.flatMap((x) => x.data ?? [])
-    };
-  }, [getQuery.data, currentPageNumber.current]);
-}
-
-// src/query/usePartialAdvancedQuery.ts
-import { c as _c3 } from "react/compiler-runtime";
-import { useLayoutEffect, useState as useState2 } from "react";
-import { useSessionStorageState as useSessionStorageState3 } from "@pol-studios/hooks/storage";
-function usePartialAdvancedQuery(query, itemCountPerPage, config) {
-  const $ = _c3(54);
-  const initialQuery = encode(query, false);
-  const [id, setId] = useState2(window.location.pathname);
-  const [currentPage, setCurrentPage] = useSessionStorageState3(`${id}-currentPage`, 1);
-  const page = currentPage ?? 1;
-  const t0 = query;
-  let t1;
-  if ($[0] !== itemCountPerPage || $[1] !== page || $[2] !== t0) {
-    t1 = t0.range((page - 1) * itemCountPerPage, page * itemCountPerPage - 1);
-    $[0] = itemCountPerPage;
-    $[1] = page;
-    $[2] = t0;
-    $[3] = t1;
-  } else {
-    t1 = $[3];
-  }
-  const rangedQuery = t1;
-  const t2 = config?.filterKey;
-  const t3 = currentPage ?? 1;
-  let t4;
-  if ($[4] !== t3) {
-    t4 = t3.toString();
-    $[4] = t3;
-    $[5] = t4;
-  } else {
-    t4 = $[5];
-  }
-  let t5;
-  if ($[6] !== config || $[7] !== t2 || $[8] !== t4) {
-    t5 = {
-      ...config,
-      filterKey: t2,
-      count: "exact",
-      key: t4
-    };
-    $[6] = config;
-    $[7] = t2;
-    $[8] = t4;
-    $[9] = t5;
-  } else {
-    t5 = $[9];
-  }
-  const [baseQuery, filter, setFilters] = useAdvancedFilterQuery(rangedQuery, t5);
-  let t6;
-  if ($[10] !== filter) {
-    t6 = JSON.stringify(omit(filter, ["pagination"]));
-    $[10] = filter;
-    $[11] = t6;
-  } else {
-    t6 = $[11];
-  }
-  const filterKey = t6;
-  const select = initialQuery[4].split("&").find(_temp4);
-  let t7;
-  if ($[12] !== filterKey || $[13] !== id || $[14] !== initialQuery[3] || $[15] !== initialQuery[5] || $[16] !== initialQuery[6] || $[17] !== initialQuery[7] || $[18] !== initialQuery[8] || $[19] !== select || $[20] !== setId) {
-    t7 = () => {
-      const newId = [initialQuery[3], select, initialQuery[5], initialQuery[6], initialQuery[7], initialQuery[8], filterKey].join("-");
-      console.log({
-        newId,
-        id
-      });
-      setId(newId);
-    };
-    $[12] = filterKey;
-    $[13] = id;
-    $[14] = initialQuery[3];
-    $[15] = initialQuery[5];
-    $[16] = initialQuery[6];
-    $[17] = initialQuery[7];
-    $[18] = initialQuery[8];
-    $[19] = select;
-    $[20] = setId;
-    $[21] = t7;
-  } else {
-    t7 = $[21];
-  }
-  let t8;
-  if ($[22] !== filterKey || $[23] !== initialQuery[3] || $[24] !== initialQuery[5] || $[25] !== initialQuery[6] || $[26] !== initialQuery[7] || $[27] !== initialQuery[8] || $[28] !== select) {
-    t8 = [initialQuery[3], select, initialQuery[5], initialQuery[6], initialQuery[7], initialQuery[8], filterKey];
-    $[22] = filterKey;
-    $[23] = initialQuery[3];
-    $[24] = initialQuery[5];
-    $[25] = initialQuery[6];
-    $[26] = initialQuery[7];
-    $[27] = initialQuery[8];
-    $[28] = select;
-    $[29] = t8;
-  } else {
-    t8 = $[29];
-  }
-  useLayoutEffect(t7, t8);
-  let t9;
-  if ($[30] !== setCurrentPage) {
-    t9 = () => {
-      setCurrentPage(_temp22);
-    };
-    $[30] = setCurrentPage;
-    $[31] = t9;
-  } else {
-    t9 = $[31];
-  }
-  const safeFetchNextPage = t9;
-  let t10;
-  if ($[32] !== setCurrentPage) {
-    t10 = () => {
-      setCurrentPage(_temp3);
-    };
-    $[32] = setCurrentPage;
-    $[33] = t10;
-  } else {
-    t10 = $[33];
-  }
-  const fetchPreviousPage = t10;
-  const pageCount = Math.max(Math.ceil((baseQuery.count ?? 0) / itemCountPerPage), 1);
-  let t11;
-  if ($[34] !== baseQuery.count || $[35] !== baseQuery.data || $[36] !== currentPage || $[37] !== itemCountPerPage) {
-    t11 = baseQuery.data ? toPagedResponse2(baseQuery.data, currentPage ?? 1, baseQuery.count ?? baseQuery.data.length, itemCountPerPage) : null;
-    $[34] = baseQuery.count;
-    $[35] = baseQuery.data;
-    $[36] = currentPage;
-    $[37] = itemCountPerPage;
-    $[38] = t11;
-  } else {
-    t11 = $[38];
-  }
-  const t12 = (currentPage ?? 1) < pageCount;
-  const t13 = (currentPage ?? 1) > 1;
-  const t14 = baseQuery.count ?? baseQuery.data?.length;
-  let t15;
-  if ($[39] !== baseQuery || $[40] !== currentPage || $[41] !== fetchPreviousPage || $[42] !== pageCount || $[43] !== safeFetchNextPage || $[44] !== setCurrentPage || $[45] !== t11 || $[46] !== t12 || $[47] !== t13 || $[48] !== t14) {
-    t15 = {
-      ...baseQuery,
-      clarification: baseQuery.clarification,
-      fetchPreviousPage,
-      fetchNextPage: safeFetchNextPage,
-      currentPage,
-      setCurrentPage,
-      data: t11,
-      pageCount,
-      hasNextPage: t12,
-      hasPreviousPage: t13,
-      count: t14
-    };
-    $[39] = baseQuery;
-    $[40] = currentPage;
-    $[41] = fetchPreviousPage;
-    $[42] = pageCount;
-    $[43] = safeFetchNextPage;
-    $[44] = setCurrentPage;
-    $[45] = t11;
-    $[46] = t12;
-    $[47] = t13;
-    $[48] = t14;
-    $[49] = t15;
-  } else {
-    t15 = $[49];
-  }
-  const request = t15;
-  let t16;
-  if ($[50] !== filter || $[51] !== request || $[52] !== setFilters) {
-    t16 = [request, filter, setFilters];
-    $[50] = filter;
-    $[51] = request;
-    $[52] = setFilters;
-    $[53] = t16;
-  } else {
-    t16 = $[53];
-  }
-  return t16;
-}
-function _temp3(currentPage_1) {
-  return (currentPage_1 ?? 1) - 1;
-}
-function _temp22(currentPage_0) {
-  return (currentPage_0 ?? 1) + 1;
-}
-function _temp4(x) {
-  return x.startsWith("select=");
-}
-function toPagedResponse2(results, currentPage, totalCount, itemPerPage) {
-  const newPage = {
-    Items: results,
-    CurrentPage: currentPage,
-    ItemCount: totalCount,
-    MaxCountPerPage: itemPerPage,
-    PageCount: Math.max(Math.ceil(totalCount / itemPerPage), 1)
-  };
-  return newPage;
-}
-
 export {
   tokenizeTopLevel,
   parseSelect,
@@ -2118,12 +1193,6 @@ export {
   ResultJoiner,
   createResultJoiner,
   QueryExecutor,
-  createQueryExecutor,
-  useQuery2 as useQuery,
-  usePartialQuery,
-  useAdvancedFilterQuery,
-  useAdvancedQuery,
-  useInfiniteQuery,
-  usePartialAdvancedQuery
+  createQueryExecutor
 };
-//# sourceMappingURL=chunk-X3HZLNBV.js.map
+//# sourceMappingURL=chunk-BXSOHOQ2.js.map