@pol-studios/db 1.0.8 → 1.0.10

package/dist/chunk-7HG6G25H.js

@@ -0,0 +1,710 @@
+import {
+  getSupabaseUrl
+} from "./chunk-Y3INY2CS.js";
+import {
+  PostgrestParser
+} from "./chunk-JUVE3DWY.js";
+import {
+  isNullOrWhitespace,
+  isUsable,
+  omit
+} from "./chunk-O3K7R32P.js";
+import {
+  encode
+} from "./chunk-H6365JPC.js";
+import {
+  generateUUID,
+  useSupabase
+} from "./chunk-AWFMICFV.js";
+
+// src/database.types.ts
+var Constants = {
+  core: {
+    Enums: {
+      AdvanceQueryChangeType: [
+        "Removed",
+        "Deleted",
+        "Created",
+        "Updated",
+        "Added"
+      ],
+      NotificationType: ["App", "Email", "Push"],
+      OperationType: ["Insert", "Update", "Delete"],
+      PriorityLevel: ["Lowest", "Low", "Medium", "High", "Highest"],
+      ProcessStatus: ["Pending", "Executing", "Completed", "Failed"],
+      PropertyType: ["String", "Number", "Options", "Date", "Boolean"]
+    }
+  },
+  public: {
+    Enums: {
+      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"
+      ],
+      HighlightStatus: ["Queued", "Executed", "Failed", "Cleared"],
+      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"
+      ],
+      Platform: ["Web", "Mobile"],
+      pricing_plan_interval: ["day", "week", "month", "year"],
+      pricing_type: ["one_time", "recurring"],
+      PriorityLevel: ["Lowest", "Low", "Medium", "High", "Highest"],
+      ProcessingStatus: ["None", "Processing", "Error"],
+      ProjectDocumentType: ["Proposal", "Directive", "Contract"],
+      ProjectStatus: ["Active", "Inactive", "Archived"],
+      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"
+      ],
+      TicketCommentParentType: ["Ticket", "TicketComment"],
+      TicketStatus: ["Open", "Closed"],
+      TicketType: ["Issue", "Feedback"],
+      TimeBankEffect: ["Accrues", "Consumes", "Neutral"],
+      UnitMediaType: ["FocusPhoto", "Attachment"],
+      UnitOfMass: ["Pounds", "Kilograms"],
+      UnitOfMeasurement: ["Inches", "Millimeters"],
+      UserAccess: ["ReadOnly", "ReadWrite", "Admin"],
+      WorkingPhaseStatus: ["Pending", "Active", "Closed"]
+    }
+  }
+};
+
+// src/useDbAdvanceQuery.ts
+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;
+  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,
+      field: filter.propertyName,
+      op: operator,
+      value: filter.value,
+      not: shouldNegate,
+      display: filter.display || filter.propertyName
+    };
+  }
+  return {
+    id: filter.id,
+    field: filter.field,
+    op: operator,
+    value: filter.value,
+    not: shouldNegate,
+    similarity: filter.similarity,
+    where: filter.where,
+    display: filter.display || filter.field
+  };
+};
+function useDbAdvanceFilterQuery(query, config) {
+  const filterKey = useMemo(
+    () => config?.filterKey ?? window.location?.pathname,
+    [
+      config?.filterKey
+    ]
+  );
+  const [filterLayer, setFilterLayer] = useSessionStorageState(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 = 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"]
+    ),
+    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 result2 = await executeSupabaseQuery(
+            supabase,
+            body,
+            parser,
+            extraData,
+            props.signal,
+            config?.count
+          );
+          setExtraData((pre) => ({
+            ...omit(result2, "data"),
+            count: result2.count ? result2.count : pre.count,
+            key: currentKey
+          }));
+          return result2;
+        }
+        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 = v.split(".");
+          const column = k;
+          let rawCondition = values[0];
+          let condition = "";
+          let value = values[1];
+          const inverted = values[0] === "not";
+          if (column == "select") return;
+          if (rawCondition === "not") {
+            rawCondition = values[1];
+            value = values[2];
+          }
+          switch (rawCondition) {
+            case "eq":
+              condition = "=";
+              break;
+            case "in":
+              condition = "in";
+              value = value.slice(1, value.length - 1).split(",").filter((x) => isNullOrWhitespace(x) === false);
+              break;
+            case "lt":
+              condition = "<";
+              break;
+            case "gt":
+              condition = ">";
+              break;
+            case "lte":
+              condition = "<=";
+              break;
+            case "gte":
+              condition = ">=";
+              break;
+            case "is":
+              condition = "is";
+              if (value == "null") {
+                value = null;
+              }
+              break;
+          }
+          body.filters = [{
+            id: `filter_${column}_${Date.now()}`,
+            field: column,
+            op: condition,
+            value,
+            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 = null;
+        let response2 = { 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)) {
+              return void 0;
+            }
+            return value;
+          }));
+          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(/^(.+?)\.([^.]+)\.(.+)$/);
+              if (match) {
+                const [_, field, rawOp, value] = 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.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 = typeof errorData?.error === "string" ? errorData.error : errorData?.error?.message || errorData?.message || "An error occurred while processing your request";
+            throw new Error(errorMessage);
+          }
+          const data = await res.json();
+          if (data.clarification) {
+            return {
+              data: [],
+              // Empty data array
+              count: 0,
+              clarification: data.clarification,
+              error: void 0
+            };
+          }
+          result = data;
+          response2 = { 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 };
+          } else if (err instanceof Error) {
+            response2 = { error: err, data: null };
+          } else {
+            const errorMessage = err?.error || err?.message || String(err);
+            response2 = { 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 (result.clarification) {
+          return {
+            data: [],
+            count: 0,
+            clarification: result.clarification,
+            error: void 0
+          };
+        }
+        setExtraData((pre) => ({
+          ...omit(result, "data"),
+          count: pre.key === currentKey ? pre.count : result.count,
+          key: currentKey
+        }));
+        return {
+          ...result,
+          statusText: "",
+          status: result.data?.length > result.count ? 206 : 200,
+          error: response2.data?.error ?? null,
+          hasMore: result.data?.length < result.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 = {
+    ...queryResponse,
+    data: queryResponse.data?.data,
+    count: extraData.count,
+    clarification: queryResponse.data?.clarification
+  };
+  useEffect(() => {
+    if (queryResponse.isFetched && response.count == null) {
+      queryResponse.refetch();
+    }
+  }, [response.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, 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 - 2));
+      return;
+    }
+    const values = v.split(".");
+    const column = k;
+    let rawCondition = values[0];
+    let value = values[1];
+    if (column == "select") 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
+  };
+}
+
+export {
+  Constants,
+  normalizeFilter,
+  useDbAdvanceFilterQuery
+};
+//# sourceMappingURL=chunk-7HG6G25H.js.map