@pol-studios/db 1.0.10 → 1.0.11

package/dist/{chunk-7HG6G25H.js → chunk-H3LNH2NT.js}

@@ -1,33 +1,40 @@
 import {
   getSupabaseUrl
-} from "./chunk-Y3INY2CS.js";
+} from "./chunk-GC3TBUWE.js";
 import {
   PostgrestParser
-} from "./chunk-JUVE3DWY.js";
+} from "./chunk-TKWR5AAY.js";
 import {
   isNullOrWhitespace,
   isUsable,
   omit
-} from "./chunk-O3K7R32P.js";
+} from "./chunk-OQ7U6EQ3.js";
 import {
   encode
 } from "./chunk-H6365JPC.js";
 import {
   generateUUID,
   useSupabase
-} from "./chunk-AWFMICFV.js";
+} from "./chunk-5EFDS7SR.js";
+
+// src/types/powersync-integration.ts
+function createCombinedStatus(dataLayerStatus, powerSyncStatus) {
+  return {
+    dataLayer: dataLayerStatus,
+    powerSync: powerSyncStatus,
+    overall: {
+      isReady: dataLayerStatus.isInitialized && powerSyncStatus.isReady,
+      isInitializing: !dataLayerStatus.isInitialized || powerSyncStatus.isInitializing,
+      error: dataLayerStatus.error || powerSyncStatus.error
+    }
+  };
+}
 
 // src/database.types.ts
 var Constants = {
   core: {
     Enums: {
-      AdvanceQueryChangeType: [
-        "Removed",
-        "Deleted",
-        "Created",
-        "Updated",
-        "Added"
-      ],
+      AdvanceQueryChangeType: ["Removed", "Deleted", "Created", "Updated", "Added"],
       NotificationType: ["App", "Email", "Push"],
       OperationType: ["Insert", "Update", "Delete"],
       PriorityLevel: ["Lowest", "Low", "Medium", "High", "Highest"],
@@ -37,71 +44,17 @@ var Constants = {
   },
   public: {
     Enums: {
-      AdvanceQueryChangeType: [
-        "Removed",
-        "Deleted",
-        "Created",
-        "Updated",
-        "Added"
-      ],
+      AdvanceQueryChangeType: ["Removed", "Deleted", "Created", "Updated", "Added"],
       BillableItemType: ["TimeActivity", "Expense", "Service", "Retainage"],
-      BillingStatus: [
-        "Unknown",
-        "NotBillable",
-        "Billable",
-        "AddedToInvoice",
-        "HasBeenBilled",
-        "BilledElsewhere",
-        "LumpSum"
-      ],
-      ControlType: [
-        "Unknown",
-        "DMX",
-        "ACN",
-        "ArtNet",
-        "None",
-        "DMXPT",
-        "PWR",
-        "SA",
-        "KiNET",
-        "ZTTV"
-      ],
-      ExpenseReportStatus: [
-        "Pending",
-        "Open",
-        "Submitted",
-        "UnderReview",
-        "Approved",
-        "Reimbursed",
-        "Closed"
-      ],
+      BillingStatus: ["Unknown", "NotBillable", "Billable", "AddedToInvoice", "HasBeenBilled", "BilledElsewhere", "LumpSum"],
+      ControlType: ["Unknown", "DMX", "ACN", "ArtNet", "None", "DMXPT", "PWR", "SA", "KiNET", "ZTTV"],
+      ExpenseReportStatus: ["Pending", "Open", "Submitted", "UnderReview", "Approved", "Reimbursed", "Closed"],
       HighlightStatus: ["Queued", "Executed", "Failed", "Cleared"],
-      InvoiceStatus: [
-        "Created",
-        "ReadyToReview",
-        "Reviewed",
-        "ReadyToSend",
-        "Sent",
-        "Rejected",
-        "Paid"
-      ],
-      MediaContentStatus: [
-        "Unknown",
-        "Required",
-        "Preferred",
-        "NotRequired",
-        "Retake",
-        "Taken"
-      ],
+      InvoiceStatus: ["Created", "ReadyToReview", "Reviewed", "ReadyToSend", "Sent", "Rejected", "Paid"],
+      MediaContentStatus: ["Unknown", "Required", "Preferred", "NotRequired", "Retake", "Taken"],
       NotificationType: ["App", "Email", "Push"],
       OperationType: ["Insert", "Update", "Delete"],
-      PhaseBillingType: [
-        "TBD",
-        "NotBillable",
-        "LumpSum",
-        "TimeAndMaterials",
-        "Expenses"
-      ],
+      PhaseBillingType: ["TBD", "NotBillable", "LumpSum", "TimeAndMaterials", "Expenses"],
       Platform: ["Web", "Mobile"],
       pricing_plan_interval: ["day", "week", "month", "year"],
       pricing_type: ["one_time", "recurring"],
@@ -109,40 +62,11 @@ var Constants = {
       ProcessingStatus: ["None", "Processing", "Error"],
       ProjectDocumentType: ["Proposal", "Directive", "Contract"],
       ProjectStatus: ["Active", "Inactive", "Archived"],
-      PublicAccessType: [
-        "Public",
-        "Unlisted",
-        "InviteOnly",
-        "Private",
-        "Internal"
-      ],
+      PublicAccessType: ["Public", "Unlisted", "InviteOnly", "Private", "Internal"],
       PunchListItemStatus: ["NotStarted", "InProgress", "Finished"],
       RevitChangeType: ["Unknown", "Added", "Modified", "Deleted"],
-      subscription_status: [
-        "trialing",
-        "active",
-        "canceled",
-        "incomplete",
-        "incomplete_expired",
-        "past_due",
-        "unpaid"
-      ],
-      TaskRunStatus: [
-        "PENDING",
-        "EXECUTING",
-        "WAITING_TO_RESUME",
-        "RETRYING_AFTER_FAILURE",
-        "PAUSED",
-        "CANCELED",
-        "COMPLETED_SUCCESSFULLY",
-        "COMPLETED_WITH_ERRORS",
-        "INTERRUPTED",
-        "SYSTEM_FAILURE",
-        "CRASHED",
-        "WAITING_FOR_DEPLOY",
-        "DELAYED",
-        "EXPIRED"
-      ],
+      subscription_status: ["trialing", "active", "canceled", "incomplete", "incomplete_expired", "past_due", "unpaid"],
+      TaskRunStatus: ["PENDING", "EXECUTING", "WAITING_TO_RESUME", "RETRYING_AFTER_FAILURE", "PAUSED", "CANCELED", "COMPLETED_SUCCESSFULLY", "COMPLETED_WITH_ERRORS", "INTERRUPTED", "SYSTEM_FAILURE", "CRASHED", "WAITING_FOR_DEPLOY", "DELAYED", "EXPIRED"],
       TicketCommentParentType: ["Ticket", "TicketComment"],
       TicketStatus: ["Open", "Closed"],
       TicketType: ["Issue", "Feedback"],
@@ -157,15 +81,8 @@ var Constants = {
 };
 
 // src/useDbAdvanceQuery.ts
-import {
-  useEffect,
-  useMemo,
-  useRef,
-  useState
-} from "react";
-import {
-  useQuery
-} from "@tanstack/react-query";
+import { useEffect, useMemo, useRef, useState } from "react";
+import { useQuery } from "@tanstack/react-query";
 import { useSessionStorageState } from "@pol-studios/hooks/storage";
 var normalizeFilter = (filter) => {
   const groupOp = filter.op || filter.operator;
@@ -175,9 +92,7 @@ var normalizeFilter = (filter) => {
       op: groupOp,
       not: filter.not || filter.inverted,
       // Support both 'not' and legacy 'inverted' for groups
-      filters: filter.filters.map(normalizeFilter).filter(
-        Boolean
-      )
+      filters: filter.filters.map(normalizeFilter).filter(Boolean)
     };
   }
   let operator = filter.op || filter.condition;
@@ -192,10 +107,7 @@ var normalizeFilter = (filter) => {
     operator = "contains";
   }
   if (!operator) {
-    console.error(
-      "Filter has undefined operator:",
-      JSON.stringify(filter, null, 2)
-    );
+    console.error("Filter has undefined operator:", JSON.stringify(filter, null, 2));
     return null;
   }
   if (filter.propertyName) {
@@ -220,12 +132,7 @@ var normalizeFilter = (filter) => {
   };
 };
 function useDbAdvanceFilterQuery(query, config) {
-  const filterKey = useMemo(
-    () => config?.filterKey ?? window.location?.pathname,
-    [
-      config?.filterKey
-    ]
-  );
+  const filterKey = useMemo(() => config?.filterKey ?? window.location?.pathname, [config?.filterKey]);
   const [filterLayer, setFilterLayer] = useSessionStorageState(filterKey, {
     id: "root",
     op: "AND",
@@ -234,10 +141,7 @@ function useDbAdvanceFilterQuery(query, config) {
     sort: [],
     isReady: isUsable(config?.searchByDefault) ? config.searchByDefault ? false : true : true
   });
-  const parser = useMemo(
-    () => new PostgrestParser(query),
-    [query, config?.key]
-  );
+  const parser = useMemo(() => new PostgrestParser(query), [query, config?.key]);
   useEffect(() => {
     const searchParam = parser.searchParams.get("order");
     if (searchParam) {
@@ -266,12 +170,7 @@ function useDbAdvanceFilterQuery(query, config) {
           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
-          ]
+          sort: [...(pre.sort || []).filter((old) => orders.some((o) => o.field === old.field) === false), ...orders]
         };
       });
     }
@@ -292,18 +191,7 @@ function useDbAdvanceFilterQuery(query, config) {
     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 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) {
@@ -321,20 +209,17 @@ function useDbAdvanceFilterQuery(query, config) {
   const isEnabled = config?.enabled == null || config?.enabled === void 0 ? true : config.enabled;
   const [extraData, setExtraData] = useState({});
   const queryResponse = useQuery({
-    ...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"]
-    ),
+    ...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) {
@@ -345,27 +230,22 @@ function useDbAdvanceFilterQuery(query, config) {
         const body = {
           ...filterLayer,
           filters: [...filterLayer.filters],
-          pagination: { ...filterLayer.pagination },
+          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 result2 = await executeSupabaseQuery(
-            supabase,
-            body,
-            parser,
-            extraData,
-            props.signal,
-            config?.count
-          );
-          setExtraData((pre) => ({
-            ...omit(result2, "data"),
-            count: result2.count ? result2.count : pre.count,
+          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 result2;
+          return result;
         }
         searchParams.forEach(([k, v]) => {
           if (k.includes("offset")) {
@@ -383,16 +263,16 @@ function useDbAdvanceFilterQuery(query, config) {
             return;
           }
           if (v.includes(".") === false) return;
-          const values = v.split(".");
+          const values_0 = v.split(".");
           const column = k;
-          let rawCondition = values[0];
+          let rawCondition = values_0[0];
           let condition = "";
-          let value = values[1];
-          const inverted = values[0] === "not";
+          let value_0 = values_0[1];
+          const inverted = values_0[0] === "not";
           if (column == "select") return;
           if (rawCondition === "not") {
-            rawCondition = values[1];
-            value = values[2];
+            rawCondition = values_0[1];
+            value_0 = values_0[2];
           }
           switch (rawCondition) {
             case "eq":
@@ -400,7 +280,7 @@ function useDbAdvanceFilterQuery(query, config) {
               break;
             case "in":
               condition = "in";
-              value = value.slice(1, value.length - 1).split(",").filter((x) => isNullOrWhitespace(x) === false);
+              value_0 = value_0.slice(1, value_0.length - 1).split(",").filter((x_0) => isNullOrWhitespace(x_0) === false);
               break;
             case "lt":
               condition = "<";
@@ -416,8 +296,8 @@ function useDbAdvanceFilterQuery(query, config) {
               break;
             case "is":
               condition = "is";
-              if (value == "null") {
-                value = null;
+              if (value_0 == "null") {
+                value_0 = null;
               }
               break;
           }
@@ -425,16 +305,27 @@ function useDbAdvanceFilterQuery(query, config) {
             id: `filter_${column}_${Date.now()}`,
             field: column,
             op: condition,
-            value,
+            value: value_0,
             not: inverted,
             display: column
-          }, { filters: [...body.filters], op: body.op ?? "AND", id: "filterstate" }];
+          }, {
+            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.pagination = {
+            page: 0,
+            pageSize: 50
+          };
           bodyCopy.isReady = true;
         });
-        const { data: { session } } = await supabase.auth.getSession();
+        const {
+          data: {
+            session
+          }
+        } = await supabase.auth.getSession();
         if (!session?.access_token) {
           throw new Error("No active session");
         }
@@ -442,29 +333,29 @@ function useDbAdvanceFilterQuery(query, config) {
         props.signal.addEventListener("abort", () => {
           controller.abort();
         });
-        const timeout = setTimeout(
-          () => controller.abort(),
-          config?.timeout ?? 15e3
-        );
-        let result = null;
-        let response2 = { error: null, data: null };
+        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, value) => {
-            if (UI_ONLY_KEYS.has(key)) {
+          const filteredBody = JSON.parse(JSON.stringify(body, (key_0, value_1) => {
+            if (UI_ONLY_KEYS.has(key_0)) {
               return void 0;
             }
-            return value;
+            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, idx) => {
-              const match = condition.match(/^(.+?)\.([^.]+)\.(.+)$/);
+            const orFilters = orConditions.map((condition_0, idx) => {
+              const match = condition_0.match(/^(.+?)\.([^.]+)\.(.+)$/);
               if (match) {
-                const [_, field, rawOp, value] = match;
+                const [_, field, rawOp, value_2] = match;
                 let op = rawOp.trim();
                 switch (op) {
                   case "eq":
@@ -499,58 +390,52 @@ function useDbAdvanceFilterQuery(query, config) {
                   id: `or-${idx}`,
                   field: field.trim(),
                   op,
-                  value: value.trim()
+                  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
-                }
-              ];
+              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}`
+          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 || []
               },
-              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
-            }
-          );
+              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 = typeof errorData?.error === "string" ? errorData.error : errorData?.error?.message || errorData?.message || "An error occurred while processing your request";
-            throw new Error(errorMessage);
+            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) {
@@ -562,45 +447,57 @@ function useDbAdvanceFilterQuery(query, config) {
               error: void 0
             };
           }
-          result = data;
-          response2 = { error: null, data };
+          result_0 = data;
+          response = {
+            error: null,
+            data
+          };
         } catch (err) {
           if (err.name === "AbortError") {
             console.error("Fetch aborted/time-out");
-            response2 = { error: new Error("This query timed out"), data: null };
+            response = {
+              error: new Error("This query timed out"),
+              data: null
+            };
           } else if (err instanceof Error) {
-            response2 = { error: err, data: null };
+            response = {
+              error: err,
+              data: null
+            };
           } else {
             const errorMessage = err?.error || err?.message || String(err);
-            response2 = { error: new Error(errorMessage), data: null };
+            response = {
+              error: new Error(errorMessage),
+              data: null
+            };
           }
         } finally {
           clearTimeout(timeout);
         }
-        if (response2.error) {
-          throw response2.error;
-        } else if (response2.data?.error) {
-          throw new Error(response2.data.error);
+        if (response.error) {
+          throw response.error;
+        } else if (response.data?.error) {
+          throw new Error(response.data.error);
         }
-        if (result.clarification) {
+        if (result_0.clarification) {
           return {
             data: [],
             count: 0,
-            clarification: result.clarification,
+            clarification: result_0.clarification,
             error: void 0
           };
         }
-        setExtraData((pre) => ({
-          ...omit(result, "data"),
-          count: pre.key === currentKey ? pre.count : result.count,
+        setExtraData((pre_1) => ({
+          ...omit(result_0, "data"),
+          count: pre_1.key === currentKey ? pre_1.count : result_0.count,
           key: currentKey
         }));
         return {
-          ...result,
+          ...result_0,
           statusText: "",
-          status: result.data?.length > result.count ? 206 : 200,
-          error: response2.data?.error ?? null,
-          hasMore: result.data?.length < result.count ? true : false
+          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") {
@@ -615,17 +512,17 @@ function useDbAdvanceFilterQuery(query, config) {
       }
     }
   });
-  const response = {
+  const response_0 = {
     ...queryResponse,
     data: queryResponse.data?.data,
     count: extraData.count,
     clarification: queryResponse.data?.clarification
   };
   useEffect(() => {
-    if (queryResponse.isFetched && response.count == null) {
+    if (queryResponse.isFetched && response_0.count == null) {
       queryResponse.refetch();
     }
-  }, [response.count]);
+  }, [response_0.count]);
   useEffect(() => {
     if (queryResponse.data?.error == null) return;
     if (queryResponse.data?.error?.message?.includes(" does not exist")) {
@@ -639,7 +536,7 @@ function useDbAdvanceFilterQuery(query, config) {
       });
     }
   }, [queryResponse.data?.error]);
-  return [response, filterLayer, setFilterLayer];
+  return [response_0, filterLayer, setFilterLayer];
 }
 function isSearchableColumn(columnName) {
   return true;
@@ -652,7 +549,9 @@ async function executeSupabaseQuery(supabase, body, parser, extraData, signal, c
   });
   if (body.sort && Array.isArray(body.sort)) {
     body.sort.forEach((s) => {
-      query.order(s.field, { ascending: s.direction === "asc" });
+      query.order(s.field, {
+        ascending: s.direction === "asc"
+      });
     });
   }
   const from = searchParams.find((x) => x[0].includes("offset"))?.[1];
@@ -667,7 +566,7 @@ async function executeSupabaseQuery(supabase, body, parser, extraData, signal, c
       return;
     }
     if (k === "or") {
-      query.or(v.slice(1, v.length - 2));
+      query.or(v.slice(1, v.length - 1));
       return;
     }
     const values = v.split(".");
@@ -675,6 +574,7 @@ async function executeSupabaseQuery(supabase, body, parser, extraData, signal, c
     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;
@@ -705,6 +605,7 @@ async function executeSupabaseQuery(supabase, body, parser, extraData, signal, c
 export {
   Constants,
   normalizeFilter,
-  useDbAdvanceFilterQuery
+  useDbAdvanceFilterQuery,
+  createCombinedStatus
 };
-//# sourceMappingURL=chunk-7HG6G25H.js.map
+//# sourceMappingURL=chunk-H3LNH2NT.js.map