@pol-studios/db 1.0.54 → 1.0.55

package/dist/chunk-YUX6RGLZ.js

@@ -0,0 +1,1858 @@
+import {
+  deepEqual,
+  flatten,
+  src_default,
+  unflatten
+} from "./chunk-AKIRHA4Q.js";
+
+// ../../../node_modules/.pnpm/is-what@4.1.16/node_modules/is-what/dist/index.js
+function getType(payload) {
+  return Object.prototype.toString.call(payload).slice(8, -1);
+}
+function isPlainObject(payload) {
+  if (getType(payload) !== "Object")
+    return false;
+  const prototype = Object.getPrototypeOf(payload);
+  return !!prototype && prototype.constructor === Object && prototype === Object.prototype;
+}
+function isNull(payload) {
+  return getType(payload) === "Null";
+}
+function isOneOf(a, b, c, d, e) {
+  return (value) => a(value) || b(value) || !!c && c(value) || !!d && d(value) || !!e && e(value);
+}
+function isUndefined(payload) {
+  return getType(payload) === "Undefined";
+}
+var isNullOrUndefined = isOneOf(isNull, isUndefined);
+function isSymbol(payload) {
+  return getType(payload) === "Symbol";
+}
+
+// ../../../node_modules/.pnpm/merge-anything@5.1.7/node_modules/merge-anything/dist/index.js
+function assignProp(carry, key, newVal, originalObject) {
+  const propType = {}.propertyIsEnumerable.call(originalObject, key) ? "enumerable" : "nonenumerable";
+  if (propType === "enumerable")
+    carry[key] = newVal;
+  if (propType === "nonenumerable") {
+    Object.defineProperty(carry, key, {
+      value: newVal,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    });
+  }
+}
+function mergeRecursively(origin, newComer, compareFn) {
+  if (!isPlainObject(newComer))
+    return newComer;
+  let newObject = {};
+  if (isPlainObject(origin)) {
+    const props2 = Object.getOwnPropertyNames(origin);
+    const symbols2 = Object.getOwnPropertySymbols(origin);
+    newObject = [...props2, ...symbols2].reduce((carry, key) => {
+      const targetVal = origin[key];
+      if (!isSymbol(key) && !Object.getOwnPropertyNames(newComer).includes(key) || isSymbol(key) && !Object.getOwnPropertySymbols(newComer).includes(key)) {
+        assignProp(
+          carry,
+          key,
+          targetVal,
+          origin
+        );
+      }
+      return carry;
+    }, {});
+  }
+  const props = Object.getOwnPropertyNames(newComer);
+  const symbols = Object.getOwnPropertySymbols(newComer);
+  const result = [...props, ...symbols].reduce((carry, key) => {
+    let newVal = newComer[key];
+    const targetVal = isPlainObject(origin) ? origin[key] : void 0;
+    if (targetVal !== void 0 && isPlainObject(newVal)) {
+      newVal = mergeRecursively(targetVal, newVal, compareFn);
+    }
+    const propToAssign = compareFn ? compareFn(targetVal, newVal, key) : newVal;
+    assignProp(
+      carry,
+      key,
+      propToAssign,
+      newComer
+    );
+    return carry;
+  }, newObject);
+  return result;
+}
+function merge(object, ...otherObjects) {
+  return otherObjects.reduce((result, newComer) => {
+    return mergeRecursively(result, newComer);
+  }, object);
+}
+
+// ../../../node_modules/.pnpm/@supabase-cache-helpers+postgrest-core@0.12.3_patch_hash=pk7qqc22n5ajzpk5ax7g6nuane_@supabase+postgrest-js@2.81.1/node_modules/@supabase-cache-helpers/postgrest-core/dist/index.js
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var isAndFilter = (f) => Array.isArray(f.and);
+var isOrFilter = (f) => Array.isArray(f.or);
+var isFilterDefinition = (f) => !isAndFilter(f) && !isOrFilter(f);
+var extractPathsFromFilters = (f, p) => {
+  return f.reduce((prev, filter) => {
+    var _a;
+    if (isAndFilter(filter)) {
+      prev.push(...extractPathsFromFilters(filter.and, p));
+    } else if (isOrFilter(filter)) {
+      prev.push(...extractPathsFromFilters(filter.or, p));
+    } else if (isFilterDefinition(filter)) {
+      const relatedPath = p.find((p2) => p2.path === filter.path);
+      const pathElements = filter.path.split(".");
+      const aliasElements = (_a = filter.alias) == null ? void 0 : _a.split(".");
+      const declaration = pathElements.map(
+        (el, idx) => `${aliasElements && aliasElements[idx] !== el ? `${aliasElements[idx]}:` : ""}${el}`
+      ).join(".");
+      prev.push({
+        path: filter.path,
+        alias: filter.alias,
+        declaration: relatedPath ? relatedPath.declaration : declaration
+      });
+    }
+    return prev;
+  }, []);
+};
+var removeFirstPathElement = (p) => {
+  const aliasWithoutFirstElement = p.alias ? p.alias.split(".").slice(1).join(".") : void 0;
+  const pathWithoutFirstEelment = p.path.split(".").slice(1).join(".");
+  return {
+    declaration: p.declaration.split(".").slice(1).join("."),
+    path: pathWithoutFirstEelment,
+    alias: aliasWithoutFirstElement && (aliasWithoutFirstElement.split(".").length > 1 || aliasWithoutFirstElement !== pathWithoutFirstEelment) ? aliasWithoutFirstElement : void 0
+  };
+};
+var isNestedPath = (p) => Array.isArray(p.paths);
+var groupPathsRecursive = (paths) => {
+  const grouped = paths.reduce((prev, curr) => {
+    const levels = curr.path.split(".").length;
+    if (levels === 1) {
+      prev.push(curr);
+      return prev;
+    }
+    const firstLevelDeclaration = curr.declaration.split(".")[0];
+    const indexOfNested = prev.findIndex(
+      (p) => isNestedPath(p) && p.declaration === firstLevelDeclaration
+    );
+    const pathWithoutCurrentLevel = removeFirstPathElement(curr);
+    if (indexOfNested !== -1) {
+      prev[indexOfNested].paths.push(pathWithoutCurrentLevel);
+      return prev;
+    }
+    prev.push(__spreadValues({
+      declaration: firstLevelDeclaration,
+      path: curr.path.split(".")[0],
+      paths: [pathWithoutCurrentLevel]
+    }, curr.alias ? { alias: curr.alias.split(".")[0] } : {}));
+    return prev;
+  }, []);
+  return grouped.map(
+    (p) => isNestedPath(p) ? __spreadProps(__spreadValues({}, p), { paths: groupPathsRecursive(p.paths) }) : p
+  );
+};
+var parseSelectParam = (s, currentPath) => {
+  s = s.replace(/\s/g, "");
+  let result;
+  try {
+    result = src_default.matchRecursive(`,${s}`, "([^,\\(]+)\\(", "\\)", "g", {
+      valueNames: {
+        "0": null,
+        "1": "tableName",
+        "2": "selectedColumns",
+        "3": null
+      }
+    }).map((item) => {
+      if (item.name === "tableName" && item.value && !item.value.startsWith(",")) {
+        item.value = "," + item.value;
+      }
+      return item;
+    });
+  } catch (e) {
+    const path = (currentPath == null ? void 0 : currentPath.path) ? `${currentPath == null ? void 0 : currentPath.declaration} with alias ${currentPath == null ? void 0 : currentPath.alias} at path ${currentPath == null ? void 0 : currentPath.path}` : "root";
+    throw new Error(`Unable to parse ${s} at ${path}`, {
+      cause: e
+    });
+  }
+  const foreignTables = result.reduce((prev, curr, idx, matches) => {
+    if (curr.name === "selectedColumns" && curr.value.length > 0) {
+      const name = matches[idx - 1].value.slice(1, -1);
+      prev = __spreadProps(__spreadValues({}, prev), { [name]: curr.value });
+    }
+    return prev;
+  }, {});
+  const columns = s.replace(
+    new RegExp(
+      `${Object.entries(foreignTables).map(
+        ([table, selectedColumns]) => `${table}(${selectedColumns})`.replace(/\(/g, "\\(").replace(/\)/g, "\\)").replace(/\*/g, "\\*")
+      ).join("|")}`,
+      "g"
+    ),
+    ""
+  ).replace(/(,)\1+/g, ",").split(",").filter((c) => c.length > 0).map((c) => {
+    var _a;
+    const split = c.split(":");
+    const hasAlias = split.length > 1;
+    const aggregateSplit = split[hasAlias ? 1 : 0].split(".");
+    const hasAggregate = aggregateSplit.length > 1 && aggregateSplit[1].endsWith("()");
+    return __spreadValues({
+      declaration: [currentPath == null ? void 0 : currentPath.declaration, c].filter(Boolean).join("."),
+      alias: hasAlias || (currentPath == null ? void 0 : currentPath.alias) ? [(_a = currentPath == null ? void 0 : currentPath.alias) != null ? _a : currentPath == null ? void 0 : currentPath.path, split[0]].filter(Boolean).join(".") : void 0,
+      path: [
+        currentPath == null ? void 0 : currentPath.path,
+        hasAggregate ? aggregateSplit[0] : split[hasAlias ? 1 : 0]
+      ].filter(Boolean).join(".")
+    }, hasAggregate ? { aggregate: aggregateSplit[1].slice(0, -2) } : {});
+  });
+  return [
+    ...columns,
+    ...Object.entries(foreignTables).flatMap(
+      ([currentDeclaration, selectedColumns]) => {
+        var _a;
+        const aliasSplit = currentDeclaration.split(":");
+        const currentAliasElem = aliasSplit.length > 1 ? aliasSplit[0] : void 0;
+        const currentPathDeclaration = aliasSplit[aliasSplit.length - 1];
+        const currentPathElem = currentPathDeclaration.split("!")[0];
+        const path = [currentPath == null ? void 0 : currentPath.path, currentPathElem].filter(Boolean).join(".");
+        const alias = [
+          (_a = currentPath == null ? void 0 : currentPath.alias) != null ? _a : currentPath == null ? void 0 : currentPath.path,
+          currentAliasElem != null ? currentAliasElem : currentPathElem
+        ].filter(Boolean).join(".");
+        const declaration = [currentPath == null ? void 0 : currentPath.declaration, currentDeclaration].filter(Boolean).join(".");
+        return parseSelectParam(`${selectedColumns}`, {
+          path,
+          alias: (currentPath == null ? void 0 : currentPath.alias) || currentAliasElem ? alias : void 0,
+          declaration
+        });
+      }
+    )
+  ];
+};
+var removeAliasFromDeclaration = (d) => d.split(".").map((el) => el.split(":").pop()).join(".");
+var buildSelectStatement = (paths) => {
+  return buildSelectStatementFromGroupedPaths(groupPathsRecursive(paths));
+};
+var buildSelectStatementFromGroupedPaths = (paths) => paths.map((i) => {
+  if (isNestedPath(i)) {
+    return `${i.declaration}(${buildSelectStatement(i.paths)})`;
+  }
+  return `${i.alias ? `${i.alias}:` : ""}${i.path}`;
+}).join(",");
+var DEDUPE_ALIAS_PREFIX = "d";
+var dedupeGroupedPathsRecursive = (grouped) => {
+  const dedupeCounters = /* @__PURE__ */ new Map();
+  return grouped.map((p, idx, a) => {
+    if (!isNestedPath(p)) return p;
+    if (a.some((i, itemIdx) => i.path === p.path && idx !== itemIdx)) {
+      const counter = dedupeCounters.get(p.path) || 0;
+      dedupeCounters.set(p.path, counter + 1);
+      const alias = [DEDUPE_ALIAS_PREFIX, counter, p.path].join("_");
+      return __spreadProps(__spreadValues({}, p), {
+        alias,
+        declaration: `${alias}:${p.declaration}`,
+        paths: dedupeGroupedPathsRecursive(p.paths)
+      });
+    }
+    return __spreadProps(__spreadValues({}, p), {
+      paths: dedupeGroupedPathsRecursive(p.paths)
+    });
+  });
+};
+var buildNormalizedQuery = ({
+  query,
+  disabled,
+  queriesForTable
+}) => {
+  var _a;
+  const userQueryPaths = query ? parseSelectParam(query) : null;
+  const paths = userQueryPaths ? userQueryPaths.map((q) => ({
+    declaration: removeAliasFromDeclaration(q.declaration),
+    path: q.path
+  })) : [];
+  if (!disabled) {
+    for (const tableQuery of queriesForTable()) {
+      for (const filterPath of extractPathsFromFilters(
+        tableQuery.filters,
+        tableQuery.paths
+      )) {
+        const path = (_a = tableQuery.paths.find(
+          (p) => p.path === filterPath.path && p.alias === filterPath.alias
+        )) != null ? _a : {
+          path: filterPath.path,
+          declaration: filterPath.path
+        };
+        if (paths.every(
+          (p) => removeAliasFromDeclaration(p.declaration) !== removeAliasFromDeclaration(path.declaration)
+        )) {
+          paths.push({
+            path: path.path,
+            declaration: removeAliasFromDeclaration(path.declaration)
+          });
+        }
+      }
+      for (const path of tableQuery.paths) {
+        if (paths.every(
+          (p) => removeAliasFromDeclaration(p.declaration) !== removeAliasFromDeclaration(path.declaration)
+        ) && // do not add agg functions
+        !path.declaration.endsWith(".count") && // do not add wildcard queries
+        !path.declaration.endsWith("*")) {
+          paths.push({
+            path: path.path,
+            declaration: removeAliasFromDeclaration(path.declaration)
+          });
+        }
+      }
+    }
+  }
+  const groupedPaths = groupPathsRecursive(paths);
+  const groupedDedupedPaths = dedupeGroupedPathsRecursive(groupedPaths);
+  const selectQuery = buildSelectStatementFromGroupedPaths(groupedDedupedPaths);
+  if (selectQuery.length === 0) return null;
+  return {
+    selectQuery,
+    groupedUserQueryPaths: userQueryPaths ? groupPathsRecursive(userQueryPaths) : null,
+    groupedPaths: groupedDedupedPaths
+  };
+};
+var get = (obj, path, defaultValue = void 0) => {
+  const split = path.split(/((?:\.|,|\[|\]|->>|->)+)/g);
+  let result = obj;
+  for (let i = -1; i < split.length; i += 2) {
+    const separator = split[i];
+    let key = split[i + 1];
+    if (!key) {
+      continue;
+    }
+    if ((separator == null ? void 0 : separator.endsWith("->")) || (separator == null ? void 0 : separator.endsWith("->>"))) {
+      if (/^\d+$/.test(key)) {
+        key = Number.parseInt(key, 10);
+      }
+    }
+    if (separator == null ? void 0 : separator.endsWith("->>")) {
+      result = `${result ? result[key] : result}`;
+    } else {
+      result = result ? result[key] : result;
+    }
+  }
+  return result === void 0 || result === obj ? defaultValue : result;
+};
+function isPlainObject2(value) {
+  return Object.prototype.toString.call(value) === "[object Object]";
+}
+var buildMutationFetcherResponse = (input, {
+  groupedPaths,
+  groupedUserQueryPaths
+}) => {
+  return {
+    normalizedData: normalizeResponse(groupedPaths, input),
+    userQueryData: groupedUserQueryPaths ? buildUserQueryData(groupedUserQueryPaths, groupedPaths, input) : void 0
+  };
+};
+var normalizeResponse = (groups, obj) => {
+  if (groups.some((p) => p.path === "*")) {
+    Object.entries(obj).forEach(([k, v]) => {
+      if (typeof v === "object" || Array.isArray(v)) {
+        if (!groups.some((g) => isNestedPath(g) && g.path === k)) {
+          groups.push({
+            path: k,
+            declaration: k
+          });
+        }
+      } else if (!groups.some((g) => g.path === k)) {
+        groups.push({
+          path: k,
+          declaration: k
+        });
+      }
+    });
+  }
+  return groups.reduce((prev, curr) => {
+    var _a, _b;
+    const value = get(obj, curr.alias || curr.path);
+    if (typeof value === "undefined") return prev;
+    if (value === null) {
+      return __spreadProps(__spreadValues({}, prev), {
+        // add hint to path if it has dedupe alias
+        // can happen if the same relation is queried multiple times via different fkeys
+        [`${curr.path}${((_a = curr.alias) == null ? void 0 : _a.startsWith("d_")) && curr.declaration.split("!").length > 1 ? `!${curr.declaration.split("!")[1]}` : ""}`]: value
+      });
+    }
+    if (!isNestedPath(curr)) {
+      return __spreadValues(__spreadValues({}, prev), flatten({
+        [curr.path]: value !== null && (isPlainObject2(value) || Array.isArray(value) && value.length > 0) ? flatten(value) : value
+      }));
+    }
+    if (Array.isArray(value)) {
+      return __spreadValues(__spreadValues({}, prev), flatten({
+        [curr.path]: value.map((v) => normalizeResponse(curr.paths, v))
+      }));
+    }
+    return __spreadValues(__spreadValues({}, prev), flatten({
+      // add hint to path if it has dedupe alias
+      // can happen if the same relation is queried multiple times via different fkeys
+      [`${curr.path}${((_b = curr.alias) == null ? void 0 : _b.startsWith("d_")) && curr.declaration.split("!").length > 1 ? `!${curr.declaration.split("!")[1]}` : ""}`]: normalizeResponse(curr.paths, value)
+    }));
+  }, {});
+};
+var buildUserQueryData = (userQueryGroups, pathGroups, obj) => {
+  if (pathGroups.some((p) => p.path === "*")) {
+    Object.entries(obj).forEach(([k, v]) => {
+      if (typeof v === "object" || Array.isArray(v)) {
+        if (!pathGroups.some((g) => isNestedPath(g) && g.path === k)) {
+          pathGroups.push({
+            path: k,
+            declaration: k
+          });
+        }
+      } else if (!pathGroups.some((g) => g.path === k)) {
+        pathGroups.push({
+          path: k,
+          declaration: k
+        });
+      }
+    });
+  }
+  if (userQueryGroups.some((p) => p.path === "*")) {
+    Object.entries(obj).forEach(([k, v]) => {
+      if (typeof v === "object" || Array.isArray(v)) {
+        if (!pathGroups.some((g) => isNestedPath(g) && g.path === k)) {
+          userQueryGroups.push({
+            path: k,
+            declaration: k
+          });
+        }
+      } else if (!userQueryGroups.some((g) => g.path === k)) {
+        userQueryGroups.push({
+          path: k,
+          declaration: k
+        });
+      }
+    });
+  }
+  return userQueryGroups.reduce((prev, curr) => {
+    if (curr.path === "*") return prev;
+    const inputPath = pathGroups.find(
+      (p) => p.path === curr.path && isNestedPath(p) === isNestedPath(curr)
+    );
+    if (!inputPath) {
+      throw new Error(`Path ${curr.path} not found in response paths`);
+    }
+    const value = get(obj, inputPath.alias || inputPath.path);
+    if (typeof value === "undefined") return prev;
+    if (value === null || !isNestedPath(curr) || !isNestedPath(inputPath)) {
+      prev[curr.alias ? curr.alias : curr.path] = value;
+    } else if (Array.isArray(value)) {
+      prev[curr.alias ? curr.alias : curr.path] = value.map((v) => buildUserQueryData(curr.paths, inputPath.paths, v));
+    } else {
+      prev[curr.alias ? curr.alias : curr.path] = buildUserQueryData(
+        curr.paths,
+        inputPath.paths,
+        value
+      );
+    }
+    return prev;
+  }, {});
+};
+var getTableFromUrl = (url) => {
+  var _a;
+  const split = url.toString().split("/");
+  const table = (_a = split.pop()) == null ? void 0 : _a.split("?").shift();
+  const maybeRpc = split.pop();
+  return [maybeRpc === "rpc" ? maybeRpc : null, table].filter(Boolean).join("/");
+};
+var isLikeQueryBuilder = (v) => {
+  if (typeof v !== "object" || v === null) return false;
+  const obj = v;
+  return typeof obj["url"] === "object";
+};
+var getTable = (query) => {
+  if (!isLikeQueryBuilder(query)) {
+    throw new Error("Invalid PostgrestBuilder");
+  }
+  return getTableFromUrl(query["url"].pathname);
+};
+var isPostgrestPaginationCacheData = (q) => {
+  if (!Array.isArray(q)) return false;
+  return q.length === 0 || Array.isArray(q[0]);
+};
+var isPostgrestHasMorePaginationCacheData = (q) => {
+  if (!Array.isArray(q)) return false;
+  if (q.length === 0) return true;
+  const firstPage = q[0];
+  return Array.isArray(
+    firstPage.data
+  ) && typeof firstPage.hasMore === "boolean";
+};
+var isAnyPostgrestResponse = (q) => {
+  if (!q) return false;
+  return typeof q.data === "object" || Array.isArray(q.data);
+};
+var sortSearchParams = (params) => new URLSearchParams(
+  Array.from(params.entries()).sort((a, b) => {
+    const x = `${a[0]}${a[1]}`;
+    const y = `${b[0]}${b[1]}`;
+    return x > y ? 1 : -1;
+  })
+);
+var encodeObject = (obj) => {
+  const sortedEntries = Object.entries(
+    flatten(obj)
+  ).sort(([a], [b]) => a.length - b.length);
+  const bodyParams = new URLSearchParams();
+  sortedEntries.forEach(([key, value]) => {
+    bodyParams.append(key, String(value));
+  });
+  return sortSearchParams(bodyParams).toString();
+};
+var isPostgrestBuilder = (q) => {
+  return typeof q.throwOnError === "function";
+};
+var isPostgrestTransformBuilder = (q) => {
+  return typeof q.abortSignal === "function";
+};
+var isISODateString = (v) => typeof v === "string" && /(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))/.test(
+  v
+);
+var parseValue = (v) => {
+  if (isISODateString(v)) return new Date(v);
+  try {
+    return JSON.parse(v);
+  } catch (e) {
+    return v;
+  }
+};
+var parseOrderByKey = (v) => {
+  return v.split("|").map((orderBy) => {
+    const [tableDef, orderDef] = orderBy.split(":");
+    const [foreignTableOrCol, maybeCol] = tableDef.split(".");
+    const [dir, nulls] = orderDef.split(".");
+    return {
+      ascending: dir === "asc",
+      nullsFirst: nulls === "nullsFirst",
+      foreignTable: maybeCol ? foreignTableOrCol : void 0,
+      column: maybeCol ? maybeCol : foreignTableOrCol
+    };
+  });
+};
+var parseOrderBy = (searchParams) => {
+  const orderBy = [];
+  searchParams.forEach((value, key) => {
+    const split = key.split(".");
+    if (split[split.length === 2 ? 1 : 0] === "order") {
+      const orderByDefs = value.split(",");
+      orderByDefs.forEach((def) => {
+        const [column, ascending, nullsFirst] = def.split(".");
+        orderBy.push({
+          ascending: ascending === "asc",
+          column,
+          nullsFirst: nullsFirst === "nullsfirst",
+          foreignTable: split.length === 2 ? split[0] : void 0
+        });
+      });
+    }
+  });
+  return orderBy;
+};
+var buildDeleteFetcher = (qb, primaryKeys, opts) => (input) => __async(void 0, null, function* () {
+  let filterBuilder = qb.delete(opts);
+  if (primaryKeys.length === 1) {
+    const primaryKey = primaryKeys[0];
+    filterBuilder.in(
+      primaryKey,
+      input.map((i) => {
+        const v = i[primaryKey];
+        if (!v) {
+          throw new Error(
+            `Missing value for primary key ${primaryKey}`
+          );
+        }
+        return v;
+      })
+    );
+  } else {
+    filterBuilder = filterBuilder.or(
+      input.map(
+        (i) => `and(${primaryKeys.map((c) => {
+          const v = i[c];
+          if (!v) {
+            throw new Error(
+              `Missing value for primary key ${c}`
+            );
+          }
+          return `${c}.eq.${v}`;
+        })})`
+      ).join(",")
+    );
+  }
+  const primaryKeysData = input.map(
+    (i) => primaryKeys.reduce((prev, key) => {
+      return __spreadProps(__spreadValues({}, prev), {
+        [key]: i[key]
+      });
+    }, {})
+  );
+  const query = buildNormalizedQuery(opts);
+  if (query) {
+    const { selectQuery, groupedUserQueryPaths, groupedPaths } = query;
+    const groupedPathsWithPrimaryKeys = groupedPaths;
+    const addKeys = [];
+    primaryKeys.forEach((key) => {
+      if (!groupedPathsWithPrimaryKeys.find((p) => p.path === key)) {
+        groupedPathsWithPrimaryKeys.push({
+          declaration: key,
+          path: key
+        });
+        addKeys.push(key);
+      }
+    });
+    const { data } = yield filterBuilder.select([selectQuery, ...addKeys].join(",")).throwOnError();
+    return data.map(
+      (d) => buildMutationFetcherResponse(d, {
+        groupedPaths: groupedPathsWithPrimaryKeys,
+        groupedUserQueryPaths
+      })
+    );
+  }
+  yield filterBuilder.throwOnError();
+  if (opts.queriesForTable().length > 0) {
+    return primaryKeysData.map((pk) => ({ normalizedData: pk }));
+  }
+  return null;
+});
+var shouldRevalidateRelation = (relations, {
+  input,
+  getPostgrestFilter,
+  decodedKey: { schema, table, queryKey }
+}) => Boolean(
+  relations.find(
+    (r) => (!r.schema || r.schema === schema) && r.relation === table && typeof input[r.fKeyColumn] !== "undefined" && getPostgrestFilter(queryKey, {
+      exclusivePaths: [r.relationIdColumn]
+    }).applyFilters({
+      [r.relationIdColumn]: input[r.fKeyColumn]
+    })
+  )
+);
+var shouldRevalidateTable = (tables, { decodedKey: { schema, table } }) => Boolean(
+  tables.find((t) => (!t.schema || t.schema === schema) && t.table === table)
+);
+var toHasMorePaginationCacheData = (a, currentData, chunkSize) => {
+  const hasMoreCache = currentData.map((p) => p.hasMore);
+  return a.reduce(
+    (resultArray, item, index) => {
+      var _a, _b;
+      const chunkIndex = Math.floor(index / chunkSize);
+      if (!resultArray[chunkIndex]) {
+        let hasMore = hasMoreCache[chunkIndex];
+        if (!hasMore) {
+          hasMore = hasMoreCache[hasMoreCache.length - 1];
+        }
+        if (chunkIndex > 0) {
+          resultArray[chunkIndex - 1].hasMore = true;
+        }
+        resultArray[chunkIndex] = {
+          data: [],
+          hasMore: (_b = (_a = hasMoreCache[chunkIndex]) != null ? _a : hasMoreCache[hasMoreCache.length - 1]) != null ? _b : false
+        };
+      }
+      resultArray[chunkIndex].data.push(item);
+      return resultArray;
+    },
+    []
+  );
+};
+var toPaginationCacheData = (a, chunkSize) => {
+  return a.reduce(
+    (resultArray, item, index) => {
+      const chunkIndex = Math.floor(index / chunkSize);
+      if (!resultArray[chunkIndex]) {
+        resultArray[chunkIndex] = [];
+      }
+      resultArray[chunkIndex].push(item);
+      return resultArray;
+    },
+    []
+  );
+};
+var filterByPks = (input, currentData, primaryKeys) => {
+  return currentData.filter(
+    (i) => primaryKeys.some((pk) => i[pk] !== input[pk])
+  );
+};
+var deleteItem = (op, cache) => __async(void 0, null, function* () {
+  var _a;
+  const {
+    revalidateRelations: revalidateRelationsOpt,
+    revalidateTables: revalidateTablesOpt,
+    schema,
+    table
+  } = op;
+  const { cacheKeys, decode: decode2, getPostgrestFilter, mutate, revalidate } = cache;
+  const mutations = [];
+  for (const k of cacheKeys) {
+    const key = decode2(k);
+    if (!key) continue;
+    const filter = getPostgrestFilter(key.queryKey);
+    if (key.schema === schema && key.table === table) {
+      if (key.isHead === true) {
+        mutations.push(revalidate(k));
+      } else {
+        const transformedInput = filter.denormalize(op.input);
+        if (
+          // For delete, the input has to have a value for all primary keys
+          op.primaryKeys.every(
+            (pk) => typeof transformedInput[pk] !== "undefined"
+          )
+        ) {
+          const limit = (_a = key.limit) != null ? _a : 1e3;
+          mutations.push(
+            mutate(k, (currentData) => {
+              if (!currentData) return currentData;
+              if (isPostgrestHasMorePaginationCacheData(currentData)) {
+                return toHasMorePaginationCacheData(
+                  filterByPks(
+                    transformedInput,
+                    currentData.flatMap((p) => p.data),
+                    op.primaryKeys
+                  ),
+                  currentData,
+                  limit
+                );
+              } else if (isPostgrestPaginationCacheData(currentData)) {
+                return toPaginationCacheData(
+                  filterByPks(
+                    transformedInput,
+                    currentData.flat(),
+                    op.primaryKeys
+                  ),
+                  limit
+                );
+              } else if (isAnyPostgrestResponse(currentData)) {
+                const { data } = currentData;
+                if (!Array.isArray(data)) {
+                  if (data && op.primaryKeys.some(
+                    (pk) => transformedInput[pk] !== data[pk]
+                  )) {
+                    return currentData;
+                  } else {
+                    return { data: null };
+                  }
+                }
+                const newData = filterByPks(
+                  transformedInput,
+                  data,
+                  op.primaryKeys
+                );
+                return {
+                  data: newData,
+                  count: newData.length
+                };
+              }
+            })
+          );
+        }
+      }
+    }
+    if (revalidateTablesOpt && shouldRevalidateTable(revalidateTablesOpt, { decodedKey: key })) {
+      mutations.push(revalidate(k));
+    }
+    if (revalidateRelationsOpt && shouldRevalidateRelation(revalidateRelationsOpt, {
+      input: op.input,
+      getPostgrestFilter,
+      decodedKey: key
+    })) {
+      mutations.push(revalidate(k));
+    }
+  }
+  yield Promise.all(mutations);
+});
+function buildInsertFetcher(qb, opts) {
+  return (input) => __async(this, null, function* () {
+    const query = buildNormalizedQuery(opts);
+    if (query) {
+      const { selectQuery, groupedUserQueryPaths, groupedPaths } = query;
+      const { data } = yield qb.insert(input, opts).select(selectQuery).throwOnError();
+      return data.map(
+        (d) => buildMutationFetcherResponse(d, {
+          groupedUserQueryPaths,
+          groupedPaths
+        })
+      );
+    }
+    yield qb.insert(input).throwOnError();
+    return input.map((d) => ({ normalizedData: d }));
+  });
+}
+function binarySearch(arr, el, compare) {
+  let m = 0;
+  let n = arr.length - 1;
+  while (m <= n) {
+    const k = n + m >> 1;
+    const cmp = compare(el, arr[k]);
+    if (cmp > 0) {
+      m = k + 1;
+    } else if (cmp < 0) {
+      n = k - 1;
+    } else {
+      return k;
+    }
+  }
+  return m;
+}
+var ifDateGetTime = (v) => {
+  if (v instanceof Date) return v.getTime();
+  if (typeof v === "string") {
+    const t = new Date(v).getTime();
+    if (!isNaN(t)) return t;
+  }
+  return v;
+};
+var buildSortedComparator = (orderBy) => {
+  return (a, b) => {
+    for (const { column, ascending, nullsFirst, foreignTable } of orderBy) {
+      const aValue = ifDateGetTime(
+        get(
+          a,
+          `${foreignTable ? `${foreignTable}.` : ""}${column}`,
+          null
+        )
+      );
+      const bValue = ifDateGetTime(
+        get(
+          b,
+          `${foreignTable ? `${foreignTable}.` : ""}${column}`,
+          null
+        )
+      );
+      if (aValue === bValue) continue;
+      if (aValue === null || aValue === void 0) {
+        return nullsFirst ? -1 : 1;
+      }
+      if (bValue === null || bValue === void 0) {
+        return nullsFirst ? 1 : -1;
+      }
+      if (ascending) {
+        return aValue < bValue ? -1 : 1;
+      }
+      return aValue < bValue ? 1 : -1;
+    }
+    return 0;
+  };
+};
+var findIndexOrdered = (input, currentData, orderBy) => binarySearch(currentData, input, buildSortedComparator(orderBy));
+var denormalize = (paths, obj) => {
+  const groups = groupPathsRecursive(paths);
+  if (groups.some((g) => g.path === "*")) {
+    Object.keys(obj).forEach((k) => {
+      const keyParts = k.split(".");
+      if (keyParts.length > 1 && groups.some((g) => isNestedPath(g) && g.path === keyParts[0])) {
+        return;
+      }
+      if (groups.some((g) => g.path === keyParts[0])) {
+        return;
+      }
+      groups.push({
+        declaration: keyParts[0],
+        path: keyParts[0]
+      });
+    });
+  }
+  return groups.reduce((prev, curr) => {
+    if (curr.path === "*") return prev;
+    let value = obj[curr.path];
+    if (!isNestedPath(curr)) {
+      if (typeof value === "undefined") {
+        const array = Object.entries(obj).reduce((prev2, [k, v]) => {
+          if (new RegExp(`^${curr.path}.\\d+$`).test(k)) {
+            prev2.push(v);
+          }
+          return prev2;
+        }, []);
+        if (array.length > 0) {
+          value = array;
+        }
+      }
+      if (typeof value === "undefined") {
+        let isArray22 = false;
+        const jsonValue = Object.entries(obj).reduce(
+          (prev2, [k, v]) => {
+            if (k.startsWith(`${curr.path}.`)) {
+              const key = k.slice(curr.path.length + 1);
+              const maybeIdx = key.match(/^\b\d+\b/);
+              if (maybeIdx && isFlatNestedArray(prev2)) {
+                isArray22 = true;
+                prev2 = __spreadProps(__spreadValues({}, prev2), {
+                  [maybeIdx[0]]: __spreadProps(__spreadValues({}, prev2[maybeIdx[0]] ? prev2[maybeIdx[0]] : {}), {
+                    [key.slice(maybeIdx[0].length + 1)]: v
+                  })
+                });
+              } else {
+                prev2[maybeIdx ? maybeIdx[0] : key] = v;
+              }
+            }
+            return prev2;
+          },
+          {}
+        );
+        if (Object.keys(jsonValue).length > 0) {
+          if (isArray22) {
+            value = Object.values(jsonValue).map((v) => unflatten(v));
+          } else {
+            value = unflatten(jsonValue);
+          }
+        }
+      }
+      if (typeof value === "undefined") {
+        return prev;
+      }
+      return __spreadProps(__spreadValues({}, prev), {
+        [curr.alias || curr.path]: value
+      });
+    }
+    if (value === null || Array.isArray(value) && value.length === 0) {
+      return __spreadProps(__spreadValues({}, prev), {
+        [curr.alias || curr.path]: value
+      });
+    }
+    let isArray2 = false;
+    const flatNestedObjectOrArray = Object.entries(obj).reduce((prev2, [k, v]) => {
+      const isNested = k.startsWith(`${curr.path}.`) || k.includes("!") && k.startsWith(`${removeFirstAlias(curr.declaration)}.`);
+      if (!isNested) return prev2;
+      const flatKey = k.slice(
+        (k.includes("!") ? removeFirstAlias(curr.declaration) : curr.path).length + 1
+      );
+      const maybeIdx = flatKey.match(/^\b\d+\b/);
+      if (maybeIdx && isFlatNestedArray(prev2)) {
+        isArray2 = true;
+        const key = flatKey.slice(maybeIdx[0].length + 1);
+        return __spreadProps(__spreadValues({}, prev2), {
+          [maybeIdx[0]]: __spreadProps(__spreadValues({}, prev2[maybeIdx[0]] ? prev2[maybeIdx[0]] : {}), {
+            [key]: v
+          })
+        });
+      }
+      return __spreadProps(__spreadValues({}, prev2), {
+        [flatKey]: v
+      });
+    }, {});
+    if (Object.keys(flatNestedObjectOrArray).length === 0) return prev;
+    if (isArray2 && isFlatNestedArray(flatNestedObjectOrArray)) {
+      return __spreadProps(__spreadValues({}, prev), {
+        [curr.alias || curr.path]: Object.values(flatNestedObjectOrArray).map(
+          (v) => denormalize(curr.paths, v)
+        )
+      });
+    }
+    return __spreadProps(__spreadValues({}, prev), {
+      [curr.alias || curr.path]: denormalize(
+        curr.paths,
+        flatNestedObjectOrArray
+      )
+    });
+  }, {});
+};
+var isFlatNestedArray = (obj) => true;
+var removeFirstAlias = (key) => {
+  const split = key.split(":");
+  if (split.length === 1) return key;
+  split.shift();
+  return split.join(":");
+};
+var filterFilterDefinitionsByPaths = (f, paths) => {
+  return f.reduce((prev, filter) => {
+    if (isAndFilter(filter)) {
+      const filters = filterFilterDefinitionsByPaths(filter.and, paths);
+      if (filters.length > 0) {
+        prev.push({ and: filters });
+      }
+    } else if (isOrFilter(filter)) {
+      const filters = filterFilterDefinitionsByPaths(filter.or, paths);
+      if (filters.length > 0) {
+        prev.push({ or: filters });
+      }
+    } else if (isFilterDefinition(filter) && paths.includes(filter.path)) {
+      prev.push(filter);
+    }
+    return prev;
+  }, []);
+};
+var isObject = (v) => typeof v === "object" && !Array.isArray(v) && v !== null;
+var isLikePostgrestBuilder = (v) => {
+  if (typeof v !== "object" || v === null) return false;
+  const obj = v;
+  return typeof obj["url"] === "object" && typeof obj["headers"] === "object" && typeof obj["method"] === "string";
+};
+var buildLikeRegex = (search) => new RegExp(`^${search.replace(/%/g, ".*")}$`);
+var textSearch = (c, v) => {
+  const regExp = `^${v.split("&").map((v2) => v2.trim().toLowerCase()).join("|").replace(/:\*/g, ".*")}$`;
+  const tokens = c.match(/'(.*?)'/g).map((t) => t.replace(/'/g, "").toLowerCase());
+  return tokens.some((t) => new RegExp(regExp).test(t));
+};
+var ifDateGetTime2 = (v) => v instanceof Date ? v.getTime() : v;
+var enclose = (v, char) => {
+  if (!v.startsWith(char)) v = `${char}${v}`;
+  if (!v.endsWith(char)) v = `${v}${char}`;
+  return v;
+};
+var OPERATOR_MAP = {
+  eq: (c, v) => ifDateGetTime2(c) === ifDateGetTime2(v),
+  neq: (c, v) => ifDateGetTime2(c) !== ifDateGetTime2(v),
+  gt: (c, v) => c > v,
+  gte: (c, v) => c >= v,
+  lt: (c, v) => c < v,
+  lte: (c, v) => c <= v,
+  like: (c, v) => buildLikeRegex(v).test(c.toString()),
+  ilike: (c, v) => buildLikeRegex(v.toLowerCase()).test(c.toString().toLowerCase()),
+  is: (c, v) => c === v,
+  in: (c, v) => {
+    const parsedValue = v.slice(1, -1).split(",");
+    return parsedValue.some((i) => i === c);
+  },
+  // contains
+  cs: (c, v) => {
+    if (!Array.isArray(c)) return false;
+    if (!Array.isArray(v)) v = v.slice(1, -1).split(",");
+    return v.every((i) => c.some((colVal) => deepEqual(colVal, i)));
+  },
+  // containedBy
+  cd: (c, v) => {
+    if (!Array.isArray(c)) return false;
+    if (!Array.isArray(v)) v = v.slice(1, -1).split(",");
+    return c.every(
+      (i) => v.some((cmpVal) => deepEqual(cmpVal, i))
+    );
+  },
+  fts: textSearch,
+  plfts: (c, v) => buildLikeRegex(enclose(v.toLowerCase(), "%")).test(
+    c.toString().toLowerCase()
+  )
+};
+function findLastIndex(array, predicate) {
+  let l = array.length;
+  while (l--) {
+    if (predicate(array[l], l, array)) return l;
+  }
+  return -1;
+}
+var isNotNull = (i) => i !== null;
+var SUPPORTED_OPERATORS = ["or", ...Object.keys(OPERATOR_MAP)];
+var PostgrestQueryParser = class {
+  constructor(query, opts) {
+    this.opts = opts;
+    this._params = new URLSearchParams(query);
+  }
+  /**
+   * Getter that returns the paths and their aliases that the query selects. Will do the computation only once.
+   *
+   * ```js
+   * const p = new PostgrestParser(
+   * supabaseClient.from("test")
+   *    .select(
+   *      `name,
+   *       city:cities (
+   *        test:name
+   *      ),
+   *      countries (
+   *        capital,
+   *        population,
+   *        some_ref (
+   *          test:first,
+   *          second
+   *        )
+   *      )`
+   *    );
+   * console.log(p.paths);
+   * //  [
+   * //    { alias: undefined, path: "name" },
+   * //    { alias: "city.test", path: "cities.name" },
+   * //    { alias: undefined, path: "countries.capital" },
+   * //    { alias: undefined, path: "countries.population" },
+   * //    {
+   * //      alias: "countries.some_ref.test",
+   * //      path: "countries.some_ref.first",
+   * //    },
+   * //    { alias: undefined, path: "countries.some_ref.second" },
+   * //  ];
+   * ```
+   *
+   * @returns an array of paths that the query selects, containing the columns and aliases
+   */
+  get paths() {
+    if (!this._paths) {
+      const select = this._params.get("select");
+      this._paths = select ? parseSelectParam(select) : [];
+    }
+    return this._paths;
+  }
+  /**
+   * Getter that returns the filters that this query applies in a json object.
+   *
+   * ```js
+   * const p = new PostgrestParser(
+   * supabaseClient.from("test").select('*')
+   *  .or("full_name.eq.20,test.neq.true,and(full_name.eq.Test Name,email.eq.test@mail.com)")
+   *  .eq("id", "123")
+   *  .contains("id", "456")
+   * );
+   *
+   * console.log(p.filters);
+   *
+   * // [
+   * //   {
+   * //     or: [
+   * //       {
+   * //         path: "full_name",
+   * //         negate: false,
+   * //         operator: "eq",
+   * //         value: 20,
+   * //       },
+   * //       {
+   * //         path: "test",
+   * //         negate: false,
+   * //         operator: "neq",
+   * //         value: true,
+   * //       },
+   * //       {
+   * //         and: [
+   * //           {
+   * //             path: "full_name",
+   * //             negate: false,
+   * //             operator: "eq",
+   * //             value: "Test Name",
+   * //           },
+   * //           {
+   * //             path: "email",
+   * //             negate: false,
+   * //             operator: "eq",
+   * //             value: "test@mail.com",
+   * //           },
+   * //         ],
+   * //       },
+   * //     ],
+   * //   },
+   * //   {
+   * //     path: "id",
+   * //     negate: false,
+   * //     operator: "eq",
+   * //     value: 123,
+   * //   },
+   * //   {
+   * //     path: "id",
+   * //     negate: false,
+   * //     operator: "cs",
+   * //     value: 456,
+   * //   },
+   * // ];
+   * ```
+   *
+   * @returns a FilterDefinitions object
+   */
+  get filters() {
+    if (!this._filters) {
+      const filters = [];
+      this._params.forEach((value, key) => {
+        if (SUPPORTED_OPERATORS.some(
+          (f) => key === f || value.split(".").includes(f)
+        )) {
+          const filter = this.parseFilterString(`${key}.${value}`, void 0);
+          if (filter !== null) filters.push(filter);
+        }
+      });
+      this._filters = filters;
+    }
+    return this._filters;
+  }
+  parseFilterString(filter, prefix) {
+    if (filter.startsWith("and(") && filter.endsWith(")")) {
+      const andFilters = filter.slice(4, -1).split(",").map((s) => this.parseFilterString(s, prefix)).filter(isNotNull);
+      if (andFilters.length === 0) return null;
+      else return { and: andFilters };
+    }
+    const split = filter.split(".");
+    if ([split[0], split[1]].includes("or")) {
+      let foreignTable;
+      if (split[1] === "or") {
+        foreignTable = split[0];
+      }
+      const orFilters = filter.slice(4 + (foreignTable ? foreignTable.length + 1 : 0), -1).split(",").reduce((prev, curr, idx, filters) => {
+        if (curr.startsWith("and(")) {
+          prev = [...prev, [curr, filters[idx + 1]].join()];
+        } else if (!curr.endsWith(")")) {
+          prev = [...prev, curr];
+        }
+        return prev;
+      }, []).map((s) => this.parseFilterString(s, foreignTable)).filter(isNotNull);
+      if (orFilters.length === 0) return null;
+      else return { or: orFilters };
+    }
+    const operatorIdx = findLastIndex(
+      split,
+      (s) => SUPPORTED_OPERATORS.includes(s)
+    );
+    if (operatorIdx === -1)
+      throw new Error(
+        `Could not find a valid operator in ${split.join(".")}. Supported are ${SUPPORTED_OPERATORS.join(",")}.`
+      );
+    const negate = split[operatorIdx - 1] === "not";
+    const pathOrAlias = [
+      prefix,
+      ...split.slice(0, negate ? operatorIdx - 1 : operatorIdx)
+    ].filter(Boolean).join(".").replace(/\s/g, "");
+    let path = pathOrAlias;
+    let alias;
+    for (const p of this.paths) {
+      if (p.path === pathOrAlias) {
+        alias = p.alias;
+        break;
+      }
+      if (p.alias === pathOrAlias) {
+        path = p.path;
+        alias = p.alias;
+        break;
+      }
+    }
+    if (this.opts && Array.isArray(this.opts.exclusivePaths) && !this.opts.exclusivePaths.includes(path)) {
+      return null;
+    }
+    const operator = split[operatorIdx];
+    const value = split.slice(operatorIdx + 1).join(".");
+    return {
+      path,
+      alias,
+      negate,
+      operator,
+      value: parseValue(value)
+    };
+  }
+};
+var PostgrestFilter = class _PostgrestFilter {
+  constructor(params) {
+    this.params = params;
+    this._filterPaths = extractPathsFromFilters(
+      this.params.filters,
+      this.params.paths
+    );
+    this.hasWildcardPath = this.params.paths.some(
+      (p) => p.declaration.endsWith("*")
+    );
+    this.hasAggregatePath = this.params.paths.some((p) => Boolean(p.aggregate));
+  }
+  static fromQuery(query, opts) {
+    const parser = new PostgrestQueryParser(query, opts);
+    return new _PostgrestFilter({
+      filters: parser.filters,
+      paths: parser.paths
+    });
+  }
+  static fromBuilder(fb, opts) {
+    if (!isLikePostgrestBuilder(fb)) {
+      throw new Error("Invalid PostgrestBuilder");
+    }
+    const parser = new PostgrestQueryParser(
+      fb["url"].searchParams.toString(),
+      opts
+    );
+    return new _PostgrestFilter({
+      filters: parser.filters,
+      paths: parser.paths
+    });
+  }
+  denormalize(obj) {
+    return denormalize([...this.params.paths, ...this._filterPaths], obj);
+  }
+  apply(obj) {
+    if (!this._fn) {
+      this._fn = (obj2) => this.applyFilters(obj2) && this.hasPaths(obj2);
+    }
+    return this._fn(obj);
+  }
+  applyFilters(obj) {
+    if (!this._filtersFn) {
+      const filterFns = this.params.filters.map((d) => this.buildFilterFn(d));
+      this._filtersFn = (obj2) => filterFns.every((fn) => isObject(obj2) && fn(obj2));
+    }
+    return this._filtersFn(obj);
+  }
+  hasFiltersOnPaths(paths) {
+    return filterFilterDefinitionsByPaths(this.params.filters, paths).length > 0;
+  }
+  applyFiltersOnPaths(obj, paths) {
+    const filterFns = filterFilterDefinitionsByPaths(
+      this.params.filters,
+      paths
+    ).map((d) => this.buildFilterFn(d));
+    const filtersFn = (obj2) => filterFns.every((fn) => isObject(obj2) && fn(obj2));
+    return filtersFn(obj);
+  }
+  hasPaths(obj) {
+    if (!this._selectFn) {
+      this._selectFn = (obj2) => this.params.paths.every(
+        (p) => {
+          var _a;
+          return this.hasPathRecursive(obj2, (_a = p.alias) != null ? _a : p.path);
+        }
+      );
+    }
+    return this._selectFn(obj);
+  }
+  hasPathRecursive(obj, path) {
+    if (obj === null) return true;
+    const pathElements = path.replace(/->>|->/g, ".").split(".");
+    if (pathElements.length === 1) {
+      return typeof get(obj, pathElements[0]) !== "undefined";
+    }
+    const currentPathElement = pathElements.shift();
+    const v = get(obj, currentPathElement);
+    if (typeof v === "undefined") return false;
+    if (Array.isArray(v)) {
+      return v.every((i) => this.hasPathRecursive(i, pathElements.join(".")));
+    }
+    return this.hasPathRecursive(v, pathElements.join("."));
+  }
+  applyFilterFn(obj, path, {
+    filterFn,
+    value,
+    negate
+  }) {
+    const pathElements = path.replace(/->>|->/g, ".").split(".");
+    const v = get(obj, pathElements[0]);
+    if (typeof v === "undefined") {
+      if (Array.isArray(obj)) {
+        return obj.every(
+          (o) => this.applyFilterFn(o, path, { filterFn, value, negate })
+        );
+      }
+      return false;
+    }
+    if (pathElements.length > 1) {
+      return this.applyFilterFn(
+        v,
+        pathElements.slice(1).join("."),
+        {
+          filterFn,
+          value,
+          negate
+        }
+      );
+    }
+    const res = filterFn(parseValue(v), value);
+    if (negate) return !res;
+    return res;
+  }
+  buildFilterFn(def) {
+    if ("or" in def) {
+      return (obj) => def.or.some((d) => this.buildFilterFn(d)(obj));
+    }
+    if ("and" in def) {
+      return (obj) => def.and.every((d) => this.buildFilterFn(d)(obj));
+    }
+    const { operator, path, value, negate, alias } = def;
+    const filterFn = OPERATOR_MAP[operator];
+    if (!filterFn)
+      throw new Error(
+        `Unable to build filter function for ${JSON.stringify(
+          def
+        )}. Operator ${operator} is not supported.`
+      );
+    return (obj) => this.applyFilterFn(obj, alias != null ? alias : path, { filterFn, value, negate });
+  }
+};
+var PostgrestParser = class extends PostgrestQueryParser {
+  constructor(fb, opts) {
+    var _a;
+    if (!isLikePostgrestBuilder(fb)) {
+      throw new Error("Invalid PostgrestBuilder");
+    }
+    super(new URL(fb["url"]).searchParams.toString(), opts);
+    this.opts = opts;
+    this.orderBy = [];
+    this._url = new URL(fb["url"]);
+    this._headers = fb["headers"];
+    this._body = isObject(fb["body"]) ? __spreadValues({}, fb["body"]) : void 0;
+    this._method = fb["method"];
+    this.queryKey = sortSearchParams(this._url.searchParams).toString();
+    this.table = getTableFromUrl(this._url.toString());
+    if (this._body) {
+      this.bodyKey = encodeObject(this._body);
+    }
+    const preferHeaders = (this._headers["Prefer"] ?? "").split(",").reduce((prev, curr) => {
+      const s = curr.split("=");
+      return __spreadProps(__spreadValues({}, prev), {
+        [s[0]]: s[1]
+      });
+    }, {});
+    this.count = (_a = preferHeaders["count"]) != null ? _a : null;
+    this.schema = fb["schema"];
+    this.isHead = this._method === "HEAD";
+    const limit = this._url.searchParams.get("limit");
+    this.limit = limit ? Number(limit) : void 0;
+    const offset = this._url.searchParams.get("offset");
+    this.offset = offset ? Number(offset) : void 0;
+    this.orderBy = parseOrderBy(this._url.searchParams);
+    this.orderByKey = this.orderBy.map(
+      ({ column, ascending, nullsFirst, foreignTable }) => `${foreignTable ? `${foreignTable}.` : ""}${column}:${ascending ? "asc" : "desc"}.${nullsFirst ? "nullsFirst" : "nullsLast"}`
+    ).join("|");
+  }
+};
+var upsert = (input, currentData, primaryKeys, filter, mergeFn, orderBy) => {
+  const merge2 = mergeFn != null ? mergeFn : merge;
+  const itemIdx = currentData.findIndex(
+    (oldItem) => primaryKeys.every((pk) => oldItem[pk] === input[pk])
+  );
+  let newItem = input;
+  let newItemIdx = itemIdx;
+  if (itemIdx !== -1) {
+    newItem = merge2(currentData[itemIdx], input);
+    currentData.splice(itemIdx, 1);
+  }
+  if (orderBy && Array.isArray(orderBy) && orderBy.length > 0) {
+    newItemIdx = findIndexOrdered(newItem, currentData, orderBy);
+  }
+  if (newItemIdx === -1) {
+    newItemIdx = 0;
+  }
+  if (filter.apply(newItem)) {
+    currentData.splice(newItemIdx, 0, newItem);
+  }
+  return currentData;
+};
+var upsertItem = (op, cache) => __async(void 0, null, function* () {
+  var _a, _b;
+  const {
+    revalidateRelations: revalidateRelationsOpt,
+    revalidateTables: revalidateTablesOpt,
+    schema,
+    table,
+    primaryKeys
+  } = op;
+  const { cacheKeys, decode: decode2, getPostgrestFilter, mutate, revalidate } = cache;
+  const mutations = [];
+  for (const k of cacheKeys) {
+    const key = decode2(k);
+    if (!key) continue;
+    const filter = getPostgrestFilter(key.queryKey);
+    if (key.schema === schema && key.table === table) {
+      const transformedInput = filter.denormalize(op.input);
+      if (filter.applyFilters(transformedInput) || // also allow upsert if either the filter does not apply eq filters on any pk
+      !filter.hasFiltersOnPaths(op.primaryKeys) || // or input matches all pk filters
+      filter.applyFiltersOnPaths(transformedInput, op.primaryKeys)) {
+        const merge2 = (_a = op.merge) != null ? _a : merge;
+        const limit = (_b = key.limit) != null ? _b : 1e3;
+        const orderBy = key.orderByKey ? parseOrderByKey(key.orderByKey) : void 0;
+        if (key.isHead === true || filter.hasWildcardPath || filter.hasAggregatePath) {
+          mutations.push(revalidate(k));
+        } else {
+          mutations.push(
+            mutate(k, (currentData) => {
+              if (!currentData) return currentData;
+              if (isPostgrestHasMorePaginationCacheData(currentData)) {
+                return toHasMorePaginationCacheData(
+                  upsert(
+                    transformedInput,
+                    currentData.flatMap((p) => p.data),
+                    primaryKeys,
+                    filter,
+                    merge2,
+                    orderBy
+                  ),
+                  currentData,
+                  limit
+                );
+              } else if (isPostgrestPaginationCacheData(currentData)) {
+                return toPaginationCacheData(
+                  upsert(
+                    transformedInput,
+                    currentData.flat(),
+                    primaryKeys,
+                    filter,
+                    merge2,
+                    orderBy
+                  ),
+                  limit
+                );
+              } else if (isAnyPostgrestResponse(currentData)) {
+                const { data } = currentData;
+                if (!Array.isArray(data)) {
+                  if (data === null) {
+                    return {
+                      data,
+                      count: currentData.count
+                    };
+                  }
+                  const newData2 = merge2(data, transformedInput);
+                  return {
+                    // Check if the new data is still valid given the key
+                    data: filter.apply(newData2) ? newData2 : null,
+                    count: currentData.count
+                  };
+                }
+                const newData = upsert(
+                  transformedInput,
+                  // deep copy data to avoid mutating the original
+                  JSON.parse(JSON.stringify(data)),
+                  primaryKeys,
+                  filter,
+                  merge2,
+                  orderBy
+                );
+                return {
+                  data: newData,
+                  count: newData.length
+                };
+              }
+              return currentData;
+            })
+          );
+        }
+      }
+    }
+    if (revalidateTablesOpt && shouldRevalidateTable(revalidateTablesOpt, { decodedKey: key })) {
+      mutations.push(revalidate(k));
+    }
+    if (revalidateRelationsOpt && shouldRevalidateRelation(revalidateRelationsOpt, {
+      input: op.input,
+      getPostgrestFilter,
+      decodedKey: key
+    })) {
+      mutations.push(revalidate(k));
+    }
+  }
+  yield Promise.all(mutations);
+});
+
+// ../../../node_modules/.pnpm/@supabase-cache-helpers+postgrest-react-query@1.13.6_@supabase+postgrest-js@2.81.1_@tanstack+_yc5q7qvczk7zvppefoodrwog4i/node_modules/@supabase-cache-helpers/postgrest-react-query/dist/index.js
+import { useQueryClient as useQueryClient3 } from "@tanstack/react-query";
+import { useQueryClient } from "@tanstack/react-query";
+import { useQueryClient as useQueryClient2 } from "@tanstack/react-query";
+import { useQueryClient as useQueryClient4 } from "@tanstack/react-query";
+import { useQueryClient as useQueryClient5 } from "@tanstack/react-query";
+import { useQueryClient as useQueryClient6 } from "@tanstack/react-query";
+import { useMutation } from "@tanstack/react-query";
+import { useMutation as useMutation2 } from "@tanstack/react-query";
+import { useMutation as useMutation3 } from "@tanstack/react-query";
+import { useMutation as useMutation4 } from "@tanstack/react-query";
+import { useMutation as useMutation5 } from "@tanstack/react-query";
+import {
+  useQuery as useReactQuery
+} from "@tanstack/react-query";
+import {
+  REALTIME_LISTEN_TYPES,
+  REALTIME_POSTGRES_CHANGES_LISTEN_EVENT
+} from "@supabase/supabase-js";
+import { useEffect, useState } from "react";
+import {
+  REALTIME_LISTEN_TYPES as REALTIME_LISTEN_TYPES2,
+  REALTIME_POSTGRES_CHANGES_LISTEN_EVENT as REALTIME_POSTGRES_CHANGES_LISTEN_EVENT2
+} from "@supabase/supabase-js";
+import { useEffect as useEffect2, useState as useState2 } from "react";
+var __defProp2 = Object.defineProperty;
+var __defProps2 = Object.defineProperties;
+var __getOwnPropDescs2 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols2 = Object.getOwnPropertySymbols;
+var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+var __propIsEnum2 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues2 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp2.call(b, prop))
+      __defNormalProp2(a, prop, b[prop]);
+  if (__getOwnPropSymbols2)
+    for (var prop of __getOwnPropSymbols2(b)) {
+      if (__propIsEnum2.call(b, prop))
+        __defNormalProp2(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps2 = (a, b) => __defProps2(a, __getOwnPropDescs2(b));
+var __async2 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var POSTGREST_FILTER_KEY_PREFIX = "postgrest-filter";
+var usePostgrestFilterCache = () => {
+  const queryClient = useQueryClient();
+  return (query, opts) => {
+    const key = [
+      POSTGREST_FILTER_KEY_PREFIX,
+      query,
+      opts ? encodeObject(opts) : null
+    ];
+    const cacheData = queryClient.getQueryData(key);
+    if (cacheData instanceof PostgrestFilter) {
+      return cacheData;
+    }
+    const filter = PostgrestFilter.fromQuery(query, opts);
+    queryClient.setQueryData(key, filter);
+    return filter;
+  };
+};
+var KEY_PREFIX = "postgrest";
+var INFINITE_KEY_PREFIX = "page";
+var encode = (key, isInfinite) => {
+  var _a;
+  if (!isPostgrestBuilder(key)) {
+    throw new Error("Key is not a PostgrestBuilder");
+  }
+  const parser = new PostgrestParser(key);
+  return [
+    KEY_PREFIX,
+    isInfinite ? INFINITE_KEY_PREFIX : "null",
+    parser.schema,
+    parser.table,
+    parser.queryKey,
+    (_a = parser.bodyKey) != null ? _a : "null",
+    `count=${parser.count}`,
+    `head=${parser.isHead}`,
+    parser.orderByKey
+  ];
+};
+var decode = (key) => {
+  if (!Array.isArray(key)) return null;
+  const [
+    prefix,
+    infinitePrefix,
+    schema,
+    table,
+    queryKey,
+    bodyKey,
+    count,
+    head,
+    orderByKey
+  ] = key;
+  if (prefix !== KEY_PREFIX) return null;
+  const params = new URLSearchParams(queryKey);
+  const limit = params.get("limit");
+  const offset = params.get("offset");
+  const countValue = count.replace("count=", "");
+  return {
+    limit: limit ? Number(limit) : void 0,
+    offset: offset ? Number(offset) : void 0,
+    bodyKey,
+    count: countValue === "null" ? null : countValue,
+    isHead: head === "head=true",
+    isInfinite: infinitePrefix === INFINITE_KEY_PREFIX,
+    key,
+    queryKey,
+    schema,
+    table,
+    orderByKey
+  };
+};
+var useQueriesForTableLoader = (table) => {
+  const queryClient = useQueryClient2();
+  const getPostgrestFilter = usePostgrestFilterCache();
+  return () => queryClient.getQueryCache().getAll().map((c) => c.queryKey).reduce(
+    (prev, curr) => {
+      const decodedKey = decode(curr);
+      if ((decodedKey == null ? void 0 : decodedKey.table) === table) {
+        prev.push(getPostgrestFilter(decodedKey.queryKey).params);
+      }
+      return prev;
+    },
+    []
+  );
+};
+function useDeleteItem(opts) {
+  const queryClient = useQueryClient3();
+  const getPostgrestFilter = usePostgrestFilterCache();
+  return (input) => __async2(this, null, function* () {
+    return yield deleteItem(
+      __spreadValues2({
+        input: flatten(input)
+      }, opts),
+      {
+        cacheKeys: queryClient.getQueryCache().getAll().map((c) => c.queryKey),
+        getPostgrestFilter,
+        revalidate: (key) => queryClient.invalidateQueries({ queryKey: key }),
+        mutate: (key, fn) => {
+          queryClient.setQueriesData({ queryKey: key }, fn);
+        },
+        decode
+      }
+    );
+  });
+}
+function useUpsertItem(opts) {
+  const queryClient = useQueryClient6();
+  const getPostgrestFilter = usePostgrestFilterCache();
+  return (input) => __async2(this, null, function* () {
+    return yield upsertItem(
+      __spreadValues2({
+        input: flatten(input)
+      }, opts),
+      {
+        cacheKeys: queryClient.getQueryCache().getAll().map((c) => c.queryKey),
+        getPostgrestFilter,
+        revalidate: (key) => queryClient.invalidateQueries({ queryKey: key }),
+        mutate: (key, fn) => {
+          queryClient.setQueriesData({ queryKey: key }, fn);
+        },
+        decode
+      }
+    );
+  });
+}
+function useDeleteManyMutation(qb, primaryKeys, query, opts) {
+  const queriesForTable = useQueriesForTableLoader(getTable(qb));
+  const deleteItem2 = useDeleteItem(__spreadProps2(__spreadValues2({}, opts), {
+    primaryKeys,
+    table: getTable(qb),
+    schema: qb.schema
+  }));
+  return useMutation(__spreadValues2({
+    mutationFn: (input) => __async2(this, null, function* () {
+      const result = yield buildDeleteFetcher(
+        qb,
+        primaryKeys,
+        __spreadValues2({
+          query: query != null ? query : void 0,
+          queriesForTable,
+          disabled: opts == null ? void 0 : opts.disableAutoQuery
+        }, opts)
+      )(input);
+      if (result) {
+        for (const r of result) {
+          deleteItem2(r.normalizedData);
+        }
+      }
+      if (!result || result.every((r) => !r.userQueryData)) return null;
+      return result.map((r) => r.userQueryData);
+    })
+  }, opts));
+}
+function truthy(value) {
+  return !!value;
+}
+var getUserResponse = (d) => {
+  if (!d) return d;
+  return d.map((r) => r.userQueryData).filter(truthy);
+};
+function useInsertMutation(qb, primaryKeys, query, opts) {
+  const queriesForTable = useQueriesForTableLoader(getTable(qb));
+  const upsertItem2 = useUpsertItem(__spreadProps2(__spreadValues2({}, opts), {
+    primaryKeys,
+    table: getTable(qb),
+    schema: qb.schema
+  }));
+  return useMutation3(__spreadValues2({
+    mutationFn: (input) => __async2(this, null, function* () {
+      var _a;
+      const result = yield buildInsertFetcher(
+        qb,
+        __spreadValues2({
+          query: query != null ? query : void 0,
+          queriesForTable,
+          disabled: opts == null ? void 0 : opts.disableAutoQuery
+        }, opts)
+      )(input);
+      if (result) {
+        yield Promise.all(
+          result.map(
+            (d) => __async2(this, null, function* () {
+              return yield upsertItem2(d.normalizedData);
+            })
+          )
+        );
+      }
+      return (_a = getUserResponse(result)) != null ? _a : null;
+    })
+  }, opts));
+}
+function buildQueryOpts(query, config) {
+  return __spreadValues2({
+    queryKey: encode(query, false),
+    queryFn: (_0) => __async2(this, [_0], function* ({ signal }) {
+      if (isPostgrestTransformBuilder(query)) {
+        query = query.abortSignal(signal);
+      }
+      if (isPostgrestBuilder(query)) {
+        query = query.throwOnError();
+      }
+      return yield query;
+    })
+  }, config);
+}
+function useQuery(query, config) {
+  var _a, _b;
+  const result = useReactQuery(
+    buildQueryOpts(query, config)
+  );
+  if (result.isPending || result.isLoadingError) {
+    return __spreadProps2(__spreadValues2({}, result), {
+      data: void 0,
+      count: null
+    });
+  }
+  return __spreadProps2(__spreadValues2({}, result), {
+    data: (_a = result.data) == null ? void 0 : _a.data,
+    count: (_b = result.data) == null ? void 0 : _b.count
+  });
+}
+
+export {
+  buildNormalizedQuery,
+  normalizeResponse,
+  encode,
+  useQueriesForTableLoader,
+  useDeleteItem,
+  useUpsertItem,
+  useDeleteManyMutation,
+  useInsertMutation,
+  useQuery
+};
+//# sourceMappingURL=chunk-YUX6RGLZ.js.map