@supabase-cache-helpers/postgrest-swr/dist/index.js

A collection of SWR utilities for working with Supabase.

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 __objRest = (source, exclude) => {
  var target = {};
  for (var prop in source)
    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
      target[prop] = source[prop];
  if (source != null && __getOwnPropSymbols)
    for (var prop of __getOwnPropSymbols(source)) {
      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
        target[prop] = source[prop];
    }
  return target;
};
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());
  });
};

// src/cache/use-delete-item.ts
import {
  deleteItem
} from "@supabase-cache-helpers/postgrest-core";
import { flatten } from "flat";
import { useSWRConfig as useSWRConfig3 } from "swr";

// src/lib/constants.ts
var KEY_PREFIX = "postgrest";
var POSTGREST_FILTER_KEY_PREFIX = "postgrest-filter";
var KEY_SEPARATOR = "$";
var INFINITE_PREFIX = "$inf$";
var INFINITE_KEY_PREFIX = "page";

// src/lib/create-key-getter.ts
import {
  get,
  isPlainObject,
  isPostgrestHasMorePaginationResponse,
  isPostgrestPaginationResponse
} from "@supabase-cache-helpers/postgrest-core";

// src/lib/parse-order-by.ts
import { parseOrderBy as core } from "@supabase-cache-helpers/postgrest-core";
function parseOrderBy(searchParams, {
  orderByPath,
  uqOrderByPath
}) {
  const orderByDef = core(searchParams);
  const orderBy = orderByDef.find((o) => o.column === orderByPath);
  if (!orderBy) {
    throw new Error(`No ordering key found for path ${orderByPath}`);
  }
  const uqOrderBy = uqOrderByPath ? orderByDef.find((o) => o.column === uqOrderByPath) : null;
  return {
    orderBy,
    uqOrderBy
  };
}

// src/lib/create-key-getter.ts
var createOffsetKeyGetter = (queryFactory, {
  pageSize,
  rpcArgs
}) => {
  if (!queryFactory) return () => null;
  return (pageIndex, previousPageData) => {
    if (previousPageData && (isPostgrestHasMorePaginationResponse(previousPageData) && !previousPageData.data.length || isPostgrestPaginationResponse(previousPageData) && !previousPageData.length)) {
      return null;
    }
    const cursor = pageIndex * pageSize;
    const query = queryFactory();
    if (rpcArgs) {
      if (query["method"] === "GET") {
        query["url"].searchParams.set(rpcArgs.limit, String(pageSize));
        query["url"].searchParams.set(rpcArgs.offset, String(cursor));
      } else {
        query["body"] = __spreadProps(__spreadValues({}, isPlainObject(query["body"]) ? query["body"] : {}), {
          [rpcArgs.limit]: pageSize,
          [rpcArgs.offset]: cursor
        });
      }
      return query;
    }
    return query.range(cursor, cursor + pageSize - 1);
  };
};
var createCursorKeyGetter = (queryFactory, {
  orderBy,
  uqOrderBy: uqColumn,
  rpcArgs
}) => {
  if (!queryFactory) return () => null;
  return (_pageIndex, previousPageData) => {
    if (previousPageData && isEmptyPreviousPage(previousPageData)) {
      return null;
    }
    const query = queryFactory();
    if (!previousPageData) return query;
    const lastItem = getLastItem(previousPageData);
    if (!lastItem) return query;
    const lastValueOrderBy = get(lastItem, orderBy);
    if (!lastValueOrderBy) return query;
    const lastValueUqColumn = uqColumn ? get(lastItem, uqColumn) : null;
    if (rpcArgs) {
      if (query["method"] === "GET") {
        if (lastValueOrderBy) {
          query["url"].searchParams.set(rpcArgs.orderBy, lastValueOrderBy);
        }
        if (lastValueUqColumn && rpcArgs.uqOrderBy) {
          query["url"].searchParams.set(rpcArgs.uqOrderBy, lastValueUqColumn);
        }
      } else {
        query["body"] = __spreadValues(__spreadProps(__spreadValues({}, isPlainObject(query["body"]) ? query["body"] : {}), {
          [rpcArgs.orderBy]: lastValueOrderBy
        }), lastValueUqColumn && rpcArgs.uqOrderBy ? { [rpcArgs.uqOrderBy]: lastValueUqColumn } : {});
      }
      return query;
    }
    const { orderBy: mainOrderBy, uqOrderBy } = parseOrderBy(
      query["url"].searchParams,
      { orderByPath: orderBy, uqOrderByPath: uqColumn }
    );
    if (uqColumn && uqOrderBy && lastValueOrderBy && lastValueUqColumn) {
      const operator = mainOrderBy.ascending ? "gt" : "lt";
      const uqOperator = uqOrderBy.ascending ? "gt" : "lt";
      query["url"].searchParams.append(
        "or",
        `(${orderBy}.${operator}.${lastValueOrderBy},and(${orderBy}.eq.${lastValueOrderBy},${uqColumn}.${uqOperator}.${lastValueUqColumn}))`
      );
    } else if (lastValueOrderBy) {
      const operator = mainOrderBy.ascending ? "gt" : "lt";
      query["url"].searchParams.append(
        orderBy,
        `${operator}.${lastValueOrderBy}`
      );
    }
    return query;
  };
};
function isEmptyPreviousPage(previousPageData) {
  return isPostgrestHasMorePaginationResponse(previousPageData) && !previousPageData.data.length || isPostgrestPaginationResponse(previousPageData) && !previousPageData.length;
}
function getLastItem(data) {
  if (isPostgrestHasMorePaginationResponse(data)) {
    return data.data.length ? data.data[data.data.length - 1] : null;
  } else if (isPostgrestPaginationResponse(data)) {
    return data.length ? data[data.length - 1] : null;
  }
  return null;
}

// src/lib/decode.ts
var decode = (key) => {
  if (typeof key !== "string") return null;
  const isInfinite = key.startsWith(INFINITE_PREFIX);
  let parsedKey = key.replace(INFINITE_PREFIX, "");
  const isPostgrestKey = parsedKey.startsWith(`${KEY_PREFIX}${KEY_SEPARATOR}`);
  if (!isPostgrestKey) {
    return null;
  }
  parsedKey = parsedKey.replace(`${KEY_PREFIX}${KEY_SEPARATOR}`, "");
  const [
    pagePrefix,
    schema,
    table,
    queryKey,
    bodyKey,
    count,
    head,
    orderByKey
  ] = parsedKey.split(KEY_SEPARATOR);
  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,
    key,
    isInfiniteKey: pagePrefix === INFINITE_KEY_PREFIX,
    queryKey,
    schema,
    table,
    orderByKey
  };
};

// src/lib/encode.ts
var encode = (parser, isInfinite) => {
  var _a;
  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
  ].join(KEY_SEPARATOR);
};

// src/lib/middleware.ts
import {
  PostgrestParser,
  isPostgrestBuilder
} from "@supabase-cache-helpers/postgrest-core";
var infiniteMiddleware = (useSWRInfiniteNext) => {
  return (keyFn, fetcher, config) => {
    return useSWRInfiniteNext(
      (index, previousPageData) => {
        const query = keyFn(index, previousPageData);
        if (!query) return null;
        if (!isPostgrestBuilder(query)) {
          throw new Error("Key is not a PostgrestBuilder");
        }
        return encode(new PostgrestParser(query), true);
      },
      typeof fetcher === "function" ? (query) => fetcher(query) : fetcher,
      config
    );
  };
};

// src/lib/use-postgrest-filter-cache.ts
import {
  PostgrestFilter,
  encodeObject
} from "@supabase-cache-helpers/postgrest-core";
import { useSWRConfig } from "swr";
var usePostgrestFilterCache = () => {
  const { cache } = useSWRConfig();
  return (query, opts) => {
    const key = [
      POSTGREST_FILTER_KEY_PREFIX,
      query,
      opts ? encodeObject(opts) : null
    ].filter(Boolean).join(KEY_SEPARATOR);
    const cacheData = cache.get(key);
    if (cacheData && cacheData.data instanceof PostgrestFilter) {
      return cacheData.data;
    }
    const filter = PostgrestFilter.fromQuery(query, opts);
    cache.set(key, { data: filter });
    return filter;
  };
};

// src/lib/use-queries-for-table-loader.ts
import { useSWRConfig as useSWRConfig2 } from "swr";
var useQueriesForTableLoader = (table) => {
  const { cache } = useSWRConfig2();
  const getPostgrestFilter = usePostgrestFilterCache();
  return () => Array.from(cache.keys()).reduce((prev, curr) => {
    const decodedKey = decode(curr);
    if ((decodedKey == null ? void 0 : decodedKey.table) === table) {
      prev.push(getPostgrestFilter(decodedKey.queryKey).params);
    }
    return prev;
  }, []);
};

// src/lib/mutable-keys.ts
var getMutableKeys = (keys) => {
  return keys.filter((k) => {
    const decoded = decode(k);
    return decoded && (decoded.isInfinite || !decoded.isInfiniteKey);
  });
};

// src/cache/use-delete-item.ts
function useDeleteItem(opts) {
  const { mutate, cache } = useSWRConfig3();
  const getPostgrestFilter = usePostgrestFilterCache();
  return (input) => __async(this, null, function* () {
    return yield deleteItem(
      __spreadValues({
        input: flatten(input)
      }, opts),
      {
        cacheKeys: getMutableKeys(Array.from(cache.keys())),
        getPostgrestFilter,
        revalidate: (key) => {
          mutate(key);
        },
        mutate: (key, data) => {
          var _a;
          mutate(key, data, __spreadProps(__spreadValues({}, opts), { revalidate: (_a = opts == null ? void 0 : opts.revalidate) != null ? _a : false }));
        },
        decode
      }
    );
  });
}

// src/cache/use-mutate-item.ts
import {
  mutateItem
} from "@supabase-cache-helpers/postgrest-core";
import { flatten as flatten2 } from "flat";
import { useSWRConfig as useSWRConfig4 } from "swr";
function useMutateItem(opts) {
  const { mutate, cache } = useSWRConfig4();
  const getPostgrestFilter = usePostgrestFilterCache();
  return (input, mutateFn) => __async(this, null, function* () {
    return yield mutateItem(
      __spreadValues({
        input: flatten2(input),
        mutate: mutateFn
      }, opts),
      {
        cacheKeys: getMutableKeys(Array.from(cache.keys())),
        getPostgrestFilter,
        revalidate: (key) => {
          mutate(key);
        },
        mutate: (key, data) => {
          var _a;
          mutate(key, data, __spreadProps(__spreadValues({}, opts), {
            revalidate: (_a = opts == null ? void 0 : opts.revalidate) != null ? _a : false
          }));
        },
        decode
      }
    );
  });
}

// src/cache/use-revalidate-tables.ts
import {
  revalidateTables
} from "@supabase-cache-helpers/postgrest-core";
import { useSWRConfig as useSWRConfig5 } from "swr";
function useRevalidateTables(tables) {
  const { mutate, cache } = useSWRConfig5();
  return () => __async(this, null, function* () {
    return yield revalidateTables(tables, {
      cacheKeys: getMutableKeys(Array.from(cache.keys())),
      revalidate: (key) => {
        mutate(key);
      },
      decode
    });
  });
}

// src/cache/use-upsert-item.ts
import {
  upsertItem
} from "@supabase-cache-helpers/postgrest-core";
import { flatten as flatten3 } from "flat";
import { useSWRConfig as useSWRConfig6 } from "swr";
function useUpsertItem(opts) {
  const { mutate, cache } = useSWRConfig6();
  const getPostgrestFilter = usePostgrestFilterCache();
  return (input) => __async(this, null, function* () {
    return yield upsertItem(
      __spreadValues({
        input: flatten3(input)
      }, opts),
      {
        cacheKeys: getMutableKeys(Array.from(cache.keys())),
        getPostgrestFilter,
        revalidate: (key) => {
          mutate(key);
        },
        mutate: (key, data) => {
          var _a;
          mutate(key, data, __spreadProps(__spreadValues({}, opts), {
            revalidate: (_a = opts == null ? void 0 : opts.revalidate) != null ? _a : false
          }));
        },
        decode
      }
    );
  });
}

// src/mutate/use-delete-many-mutation.ts
import {
  buildDeleteFetcher,
  getTable
} from "@supabase-cache-helpers/postgrest-core";
import useMutation from "swr/mutation";

// src/mutate/use-random-key.ts
import { useId } from "react";
var PREFIX = "random-mutation-key";
var useRandomKey = () => {
  const key = useId();
  return [PREFIX, key].join(KEY_SEPARATOR);
};

// src/mutate/use-delete-many-mutation.ts
function useDeleteManyMutation(qb, primaryKeys, query, opts) {
  const key = useRandomKey();
  const queriesForTable = useQueriesForTableLoader(getTable(qb));
  const deleteItem2 = useDeleteItem(__spreadProps(__spreadValues({}, opts), {
    primaryKeys,
    table: getTable(qb),
    schema: qb.schema
  }));
  return useMutation(
    key,
    (_0, _1) => __async(this, [_0, _1], function* (_, { arg }) {
      const result = yield buildDeleteFetcher(
        qb,
        primaryKeys,
        __spreadValues({
          query: query != null ? query : void 0,
          queriesForTable,
          disabled: opts == null ? void 0 : opts.disableAutoQuery
        }, opts)
      )(arg);
      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
  );
}

// src/mutate/use-delete-mutation.ts
import {
  buildDeleteFetcher as buildDeleteFetcher2,
  getTable as getTable2
} from "@supabase-cache-helpers/postgrest-core";
import useMutation2 from "swr/mutation";
function useDeleteMutation(qb, primaryKeys, query, opts) {
  const key = useRandomKey();
  const queriesForTable = useQueriesForTableLoader(getTable2(qb));
  const deleteItem2 = useDeleteItem(__spreadProps(__spreadValues({}, opts), {
    primaryKeys,
    table: getTable2(qb),
    schema: qb.schema
  }));
  return useMutation2(
    key,
    (_0, _1) => __async(this, [_0, _1], function* (_, { arg }) {
      const r = yield buildDeleteFetcher2(
        qb,
        primaryKeys,
        __spreadValues({
          query: query != null ? query : void 0,
          queriesForTable,
          disabled: opts == null ? void 0 : opts.disableAutoQuery
        }, opts)
      )([arg]);
      if (!r || r.length === 0) return null;
      const result = r[0];
      if (result) {
        deleteItem2(result.normalizedData);
      }
      return result.userQueryData;
    }),
    opts
  );
}

// src/mutate/use-insert-mutation.ts
import {
  buildInsertFetcher,
  getTable as getTable3
} from "@supabase-cache-helpers/postgrest-core";
import useMutation3 from "swr/mutation";

// src/mutate/get-user-response.ts
function truthy(value) {
  return !!value;
}
var getUserResponse = (d) => {
  if (!d) return d;
  return d.map((r) => r.userQueryData).filter(truthy);
};

// src/mutate/use-insert-mutation.ts
function useInsertMutation(qb, primaryKeys, query, opts) {
  const key = useRandomKey();
  const queriesForTable = useQueriesForTableLoader(getTable3(qb));
  const upsertItem2 = useUpsertItem(__spreadProps(__spreadValues({}, opts), {
    primaryKeys,
    table: getTable3(qb),
    schema: qb.schema
  }));
  return useMutation3(
    key,
    (_0, _1) => __async(this, [_0, _1], function* (_, { arg }) {
      const result = yield buildInsertFetcher(
        qb,
        __spreadValues({
          query: query != null ? query : void 0,
          queriesForTable,
          disabled: opts == null ? void 0 : opts.disableAutoQuery
        }, opts)
      )(arg);
      if (result) {
        Promise.all(
          (result != null ? result : []).map(
            (d) => __async(this, null, function* () {
              return yield upsertItem2(d.normalizedData);
            })
          )
        );
      }
      return getUserResponse(result);
    }),
    opts
  );
}

// src/mutate/use-update-mutation.ts
import {
  buildUpdateFetcher,
  getTable as getTable4
} from "@supabase-cache-helpers/postgrest-core";
import useSWRMutation from "swr/mutation";
function useUpdateMutation(qb, primaryKeys, query, opts) {
  const key = useRandomKey();
  const queriesForTable = useQueriesForTableLoader(getTable4(qb));
  const upsertItem2 = useUpsertItem(__spreadProps(__spreadValues({}, opts), {
    primaryKeys,
    table: getTable4(qb),
    schema: qb.schema
  }));
  return useSWRMutation(
    key,
    (_0, _1) => __async(this, [_0, _1], function* (_, { arg }) {
      var _a;
      const result = yield buildUpdateFetcher(
        qb,
        primaryKeys,
        __spreadValues({
          query: query != null ? query : void 0,
          queriesForTable,
          disabled: opts == null ? void 0 : opts.disableAutoQuery
        }, opts)
      )(arg);
      if (result == null ? void 0 : result.normalizedData) {
        upsertItem2(result == null ? void 0 : result.normalizedData);
      }
      return (_a = result == null ? void 0 : result.userQueryData) != null ? _a : null;
    }),
    opts
  );
}

// src/mutate/use-upsert-mutation.ts
import {
  buildUpsertFetcher,
  getTable as getTable5
} from "@supabase-cache-helpers/postgrest-core";
import useMutation4 from "swr/mutation";
function useUpsertMutation(qb, primaryKeys, query, opts) {
  const key = useRandomKey();
  const queriesForTable = useQueriesForTableLoader(getTable5(qb));
  const upsertItem2 = useUpsertItem(__spreadProps(__spreadValues({}, opts), {
    primaryKeys,
    table: getTable5(qb),
    schema: qb.schema
  }));
  return useMutation4(
    key,
    (_0, _1) => __async(this, [_0, _1], function* (_, { arg }) {
      const result = yield buildUpsertFetcher(
        qb,
        __spreadValues({
          query: query != null ? query : void 0,
          queriesForTable,
          disabled: opts == null ? void 0 : opts.disableAutoQuery
        }, opts)
      )(arg);
      if (result) {
        Promise.all(
          result.map(
            (d) => __async(this, null, function* () {
              return yield upsertItem2(d.normalizedData);
            })
          )
        );
      }
      return getUserResponse(result);
    }),
    opts
  );
}

// src/query/prefetch.ts
import {
  PostgrestParser as PostgrestParser2,
  isPostgrestBuilder as isPostgrestBuilder2,
  offsetPaginationFetcher,
  offsetPaginationHasMoreFetcher
} from "@supabase-cache-helpers/postgrest-core";
function fetchQueryFallbackData(query) {
  return __async(this, null, function* () {
    if (!isPostgrestBuilder2(query)) {
      throw new Error("Query is not a PostgrestBuilder");
    }
    return [
      encode(new PostgrestParser2(query), false),
      yield query.throwOnError()
    ];
  });
}
function fetchOffsetPaginationHasMoreFallbackData(query, pageSize) {
  return __async(this, null, function* () {
    return [
      encode(new PostgrestParser2(query.range(0, pageSize)), true),
      [
        yield offsetPaginationHasMoreFetcher(query, {
          offset: 0,
          limit: pageSize,
          pageSize
        })
      ]
    ];
  });
}
var fetchOffsetPaginationFallbackData = (query, pageSize) => __async(void 0, null, function* () {
  return [
    encode(new PostgrestParser2(query.range(0, pageSize)), true),
    [
      yield offsetPaginationFetcher(query, {
        offset: 0,
        limit: pageSize
      })
    ]
  ];
});

// src/query/use-cursor-infinite-scroll-query.ts
import {
  createCursorPaginationFetcher,
  decodeObject,
  isPlainObject as isPlainObject2
} from "@supabase-cache-helpers/postgrest-core";
import { useCallback, useMemo } from "react";
import useSWRInfinite from "swr/infinite";
function useCursorInfiniteScrollQuery(queryFactory, config) {
  var _a;
  const _b = useSWRInfinite(
    createCursorKeyGetter(queryFactory, config),
    createCursorPaginationFetcher(
      queryFactory,
      {
        decode: (key) => {
          if (!queryFactory) {
            throw new Error("No query provided");
          }
          const decodedKey = decode(key);
          if (!decodedKey) {
            throw new Error("Not a SWRPostgrest key");
          }
          if (config.rpcArgs) {
            if (decodedKey.bodyKey && decodedKey.bodyKey !== "null") {
              const body = decodeObject(decodedKey.bodyKey);
              const orderBy = body[config.rpcArgs.orderBy];
              const uqOrderBy = config.rpcArgs.uqOrderBy ? body[config.rpcArgs.uqOrderBy] : void 0;
              return {
                orderBy: typeof orderBy === "string" ? orderBy : void 0,
                uqOrderBy: typeof uqOrderBy === "string" ? uqOrderBy : void 0
              };
            } else {
              const sp = new URLSearchParams(decodedKey.queryKey);
              const orderByValue = sp.get(config.rpcArgs.orderBy);
              const uqOrderByValue = config.rpcArgs.uqOrderBy ? sp.get(config.rpcArgs.uqOrderBy) : void 0;
              return {
                orderBy: orderByValue || void 0,
                uqOrderBy: uqOrderByValue || void 0
              };
            }
          }
          const query = queryFactory();
          const { orderBy: mainOrderBy } = parseOrderBy(
            query["url"].searchParams,
            { orderByPath: config.orderBy, uqOrderByPath: config.uqOrderBy }
          );
          const searchParams = new URLSearchParams(decodedKey.queryKey);
          if (config.uqOrderBy) {
            const possibleFilters = searchParams.getAll("or");
            const filter = possibleFilters.find(
              (f) => f.includes(`${config.orderBy}.`) && f.includes(`${config.uqOrderBy}.`)
            );
            if (!filter) {
              return {};
            }
            const bracketsPart = filter.split("and").pop().match(/\((.*)\)\)/)[1].replace(/\s+/g, "");
            const filterParts = bracketsPart.split(",");
            const cursorValue = filterParts[0].split(".").pop();
            const uqCursorValue = filterParts[1].split(".").pop();
            return {
              orderBy: cursorValue,
              uqOrderBy: uqCursorValue
            };
          } else {
            const filters = searchParams.getAll(config.orderBy);
            const filter = filters.find(
              (f) => f.startsWith(
                `${config.orderBy}.${mainOrderBy.ascending ? "gt" : "lt"}`
              )
            );
            if (!filter) {
              return {};
            }
            const cursorValue = filter.split(".").pop();
            return {
              orderBy: cursorValue
            };
          }
        },
        orderBy: config.orderBy,
        uqOrderBy: config.uqOrderBy,
        rpcArgs: config.rpcArgs
      }
    ),
    __spreadProps(__spreadValues({}, config), {
      use: [
        ...(_a = config == null ? void 0 : config.use) != null ? _a : [],
        infiniteMiddleware
      ]
    })
  ), { data, setSize, size, isValidating } = _b, rest = __objRest(_b, ["data", "setSize", "size", "isValidating"]);
  const { flatData, hasLoadMore } = useMemo(() => {
    if (!queryFactory) {
      return { flatData: void 0, hasLoadMore: false };
    }
    const query = queryFactory();
    const flatData2 = (data != null ? data : []).flat();
    let pageSize;
    if (config.rpcArgs) {
      if (query["method"] === "GET") {
        pageSize = query["url"].searchParams.get(config.rpcArgs.limit);
      } else {
        pageSize = isPlainObject2(query["body"]) ? query["body"][config.rpcArgs.limit] : null;
      }
    } else {
      pageSize = query ? query["url"].searchParams.get("limit") : null;
    }
    if (!pageSize) {
      return { flatData: void 0, hasLoadMore: false };
    }
    let hasLoadMore2 = !data || (pageSize ? data[data.length - 1].length === Number(pageSize) : true);
    return {
      flatData: flatData2,
      hasLoadMore: hasLoadMore2
    };
  }, [data, config]);
  const loadMoreFn = useCallback(() => setSize(size + 1), [size, setSize]);
  return __spreadValues({
    data: flatData,
    size,
    setSize,
    loadMore: hasLoadMore && !isValidating ? loadMoreFn : null,
    isValidating
  }, rest);
}

// src/query/use-offset-infinite-query.ts
import {
  createOffsetPaginationFetcher,
  decodeObject as decodeObject2
} from "@supabase-cache-helpers/postgrest-core";
import useSWRInfinite2 from "swr/infinite";
function useOffsetInfiniteQuery(queryFactory, config) {
  var _a, _b, _c;
  return useSWRInfinite2(
    createOffsetKeyGetter(queryFactory, {
      pageSize: (_a = config == null ? void 0 : config.pageSize) != null ? _a : 20,
      rpcArgs: config == null ? void 0 : config.rpcArgs
    }),
    createOffsetPaginationFetcher(queryFactory, {
      decode: (key) => {
        const decodedKey = decode(key);
        if (!decodedKey) {
          throw new Error("Not a SWRPostgrest key");
        }
        if (config == null ? void 0 : config.rpcArgs) {
          if (decodedKey.bodyKey && decodedKey.bodyKey !== "null") {
            const body = decodeObject2(decodedKey.bodyKey);
            const limit = body[config.rpcArgs.limit];
            const offset = body[config.rpcArgs.offset];
            return {
              limit: typeof limit === "number" ? limit : void 0,
              offset: typeof offset === "number" ? offset : void 0
            };
          } else {
            const sp = new URLSearchParams(decodedKey.queryKey);
            const limitValue = sp.get(config.rpcArgs.limit);
            const offsetValue = sp.get(config.rpcArgs.offset);
            return {
              limit: limitValue ? parseInt(limitValue, 10) : void 0,
              offset: offsetValue ? parseInt(offsetValue, 10) : void 0
            };
          }
        }
        return {
          limit: decodedKey.limit,
          offset: decodedKey.offset
        };
      },
      pageSize: (_b = config == null ? void 0 : config.pageSize) != null ? _b : 20,
      rpcArgs: config == null ? void 0 : config.rpcArgs
    }),
    __spreadProps(__spreadValues({}, config), {
      use: [
        ...(_c = config == null ? void 0 : config.use) != null ? _c : [],
        infiniteMiddleware
      ]
    })
  );
}

// src/query/use-offset-infinite-scroll-query.ts
import {
  createOffsetPaginationHasMoreFetcher,
  decodeObject as decodeObject3
} from "@supabase-cache-helpers/postgrest-core";
import { useCallback as useCallback2 } from "react";
import useSWRInfinite3 from "swr/infinite";
function useOffsetInfiniteScrollQuery(queryFactory, config) {
  var _a, _b, _c;
  const _d = useSWRInfinite3(
    createOffsetKeyGetter(queryFactory, {
      pageSize: (_a = config == null ? void 0 : config.pageSize) != null ? _a : 20,
      rpcArgs: config == null ? void 0 : config.rpcArgs
    }),
    createOffsetPaginationHasMoreFetcher(queryFactory, {
      decode: (key) => {
        const decodedKey = decode(key);
        if (!decodedKey) {
          throw new Error("Not a SWRPostgrest key");
        }
        if (config == null ? void 0 : config.rpcArgs) {
          if (decodedKey.bodyKey && decodedKey.bodyKey !== "null") {
            const body = decodeObject3(decodedKey.bodyKey);
            const limit = body[config.rpcArgs.limit];
            const offset = body[config.rpcArgs.offset];
            return {
              limit: typeof limit === "number" ? limit : void 0,
              offset: typeof offset === "number" ? offset : void 0
            };
          } else {
            const sp = new URLSearchParams(decodedKey.queryKey);
            const limitValue = sp.get(config.rpcArgs.limit);
            const offsetValue = sp.get(config.rpcArgs.offset);
            return {
              limit: limitValue ? parseInt(limitValue, 10) : void 0,
              offset: offsetValue ? parseInt(offsetValue, 10) : void 0
            };
          }
        }
        return {
          limit: decodedKey.limit,
          offset: decodedKey.offset
        };
      },
      pageSize: (_b = config == null ? void 0 : config.pageSize) != null ? _b : 20,
      rpcArgs: config == null ? void 0 : config.rpcArgs
    }),
    __spreadProps(__spreadValues({}, config), {
      use: [
        ...(_c = config == null ? void 0 : config.use) != null ? _c : [],
        infiniteMiddleware
      ]
    })
  ), { data, setSize, size, isValidating } = _d, rest = __objRest(_d, ["data", "setSize", "size", "isValidating"]);
  const hasMore = Array.isArray(data) && data.length > 0 && data[data.length - 1].hasMore;
  const loadMoreFn = useCallback2(() => setSize(size + 1), [size, setSize]);
  return __spreadValues({
    data: (Array.isArray(data) ? data : []).flatMap((p) => p.data),
    size,
    setSize,
    loadMore: hasMore ? loadMoreFn : null,
    isValidating
  }, rest);
}

// src/query/use-infinite-offset-pagination-query.ts
import {
  createOffsetPaginationHasMoreFetcher as createOffsetPaginationHasMoreFetcher2,
  decodeObject as decodeObject4
} from "@supabase-cache-helpers/postgrest-core";
import { useCallback as useCallback3, useState } from "react";
import useSWRInfinite4 from "swr/infinite";
function useInfiniteOffsetPaginationQuery(queryFactory, config) {
  var _a, _b, _c, _e;
  const _d = useSWRInfinite4(
    createOffsetKeyGetter(queryFactory, {
      pageSize: (_a = config == null ? void 0 : config.pageSize) != null ? _a : 20,
      rpcArgs: config == null ? void 0 : config.rpcArgs
    }),
    createOffsetPaginationHasMoreFetcher2(queryFactory, {
      decode: (key) => {
        const decodedKey = decode(key);
        if (!decodedKey) {
          throw new Error("Not a SWRPostgrest key");
        }
        if (config == null ? void 0 : config.rpcArgs) {
          if (decodedKey.bodyKey && decodedKey.bodyKey !== "null") {
            const body = decodeObject4(decodedKey.bodyKey);
            const limit = body[config.rpcArgs.limit];
            const offset = body[config.rpcArgs.offset];
            return {
              limit: typeof limit === "number" ? limit : void 0,
              offset: typeof offset === "number" ? offset : void 0
            };
          } else {
            const sp = new URLSearchParams(decodedKey.queryKey);
            const limitValue = sp.get(config.rpcArgs.limit);
            const offsetValue = sp.get(config.rpcArgs.offset);
            return {
              limit: limitValue ? parseInt(limitValue, 10) : void 0,
              offset: offsetValue ? parseInt(offsetValue, 10) : void 0
            };
          }
        }
        return {
          limit: decodedKey.limit,
          offset: decodedKey.offset
        };
      },
      pageSize: (_b = config == null ? void 0 : config.pageSize) != null ? _b : 20,
      rpcArgs: config == null ? void 0 : config.rpcArgs
    }),
    __spreadProps(__spreadValues({}, config), {
      use: [
        ...(_c = config == null ? void 0 : config.use) != null ? _c : [],
        infiniteMiddleware
      ]
    })
  ), { data, setSize, size, isValidating } = _d, rest = __objRest(_d, ["data", "setSize", "size", "isValidating"]);
  const [currentPageIndex, setCurrentPageIndex] = useState(0);
  const parsedData = (data != null ? data : []).map((p) => p.data);
  const hasMore = Array.isArray(data) && data.length > 0 && data[data.length - 1].hasMore;
  const setPage = useCallback3(
    (idx) => {
      if (idx > size - 1) {
        setSize(idx + 1);
      }
      setCurrentPageIndex(idx);
    },
    [size, setSize, setCurrentPageIndex]
  );
  const nextPageFn = useCallback3(() => {
    if (currentPageIndex === size - 1) {
      setSize((size2) => size2 + 1);
    }
    setCurrentPageIndex((page) => page + 1);
  }, [currentPageIndex, size, setSize, setCurrentPageIndex]);
  const previousPageFn = useCallback3(
    () => setCurrentPageIndex((current) => current - 1),
    [setCurrentPageIndex]
  );
  return __spreadValues({
    pages: parsedData,
    currentPage: parsedData ? (_e = parsedData[currentPageIndex]) != null ? _e : [] : [],
    pageIndex: currentPageIndex,
    setPage,
    nextPage: !isValidating && (hasMore || currentPageIndex < size - 1) ? nextPageFn : null,
    previousPage: !isValidating && currentPageIndex > 0 ? previousPageFn : null,
    isValidating
  }, rest);
}

// src/query/use-query.ts
import {
  PostgrestParser as PostgrestParser3,
  isPostgrestBuilder as isPostgrestBuilder3
} from "@supabase-cache-helpers/postgrest-core";
import useSWR from "swr";
function useQuery(query, config) {
  var _a, _c;
  const _b = useSWR(
    query,
    (q) => __async(this, null, function* () {
      if (isPostgrestBuilder3(q)) {
        q = q.throwOnError();
      }
      return yield q;
    }),
    __spreadProps(__spreadValues({}, config), {
      use: [
        ...(_a = config == null ? void 0 : config.use) != null ? _a : [],
        (useSWRNext) => {
          return (key, fetcher, config2) => {
            if (!fetcher) throw new Error("No fetcher provided");
            if (key !== null && !isPostgrestBuilder3(key)) {
              throw new Error("Key is not a PostgrestBuilder");
            }
            return useSWRNext(
              key ? encode(new PostgrestParser3(key), false) : null,
              () => fetcher(key),
              config2
            );
          };
        }
      ]
    })
  ), { data } = _b, rest = __objRest(_b, ["data"]);
  return __spreadValues({ data: data == null ? void 0 : data.data, count: (_c = data == null ? void 0 : data.count) != null ? _c : null }, rest);
}

// src/subscribe/use-subscription-query.ts
import {
  buildNormalizedQuery,
  normalizeResponse
} from "@supabase-cache-helpers/postgrest-core";
import {
  REALTIME_LISTEN_TYPES,
  REALTIME_POSTGRES_CHANGES_LISTEN_EVENT
} from "@supabase/supabase-js";
import { useEffect, useState as useState2 } from "react";
function useSubscriptionQuery(client, channelName, filter, primaryKeys, query, opts) {
  const [status, setStatus] = useState2({ status: null, error: null });
  const [channel, setChannel] = useState2();
  const queriesForTable = useQueriesForTableLoader(filter.table);
  const deleteItem2 = useDeleteItem(__spreadProps(__spreadValues({}, opts), {
    primaryKeys,
    table: filter.table,
    schema: filter.schema
  }));
  const upsertItem2 = useUpsertItem(__spreadProps(__spreadValues({}, opts), {
    primaryKeys,
    table: filter.table,
    schema: filter.schema
  }));
  useEffect(() => {
    if (!client) return;
    const c = client.channel(channelName).on(
      REALTIME_LISTEN_TYPES.POSTGRES_CHANGES,
      filter,
      (payload) => __async(this, null, function* () {
        var _a;
        let data = (_a = payload.new) != null ? _a : payload.old;
        const selectQuery = buildNormalizedQuery({ queriesForTable, query });
        if (payload.eventType !== REALTIME_POSTGRES_CHANGES_LISTEN_EVENT.DELETE && selectQuery) {
          const qb = client.from(payload.table).select(selectQuery.selectQuery);
          for (const pk of primaryKeys) {
            qb.eq(pk.toString(), data[pk]);
          }
          const res = yield qb.single();
          if (res.data) {
            data = normalizeResponse(selectQuery.groupedPaths, res.data);
          }
        }
        if (payload.eventType === REALTIME_POSTGRES_CHANGES_LISTEN_EVENT.INSERT || payload.eventType === REALTIME_POSTGRES_CHANGES_LISTEN_EVENT.UPDATE) {
          yield upsertItem2(data);
        } else if (payload.eventType === REALTIME_POSTGRES_CHANGES_LISTEN_EVENT.DELETE) {
          yield deleteItem2(payload.old);
        }
        if (opts == null ? void 0 : opts.callback) {
          opts.callback(__spreadProps(__spreadValues({}, payload), {
            data
          }));
        }
      })
    ).subscribe(
      (status2, error) => setStatus({ status: status2, error: error || null })
    );
    setChannel(c);
    return () => {
      if (c) c.unsubscribe();
    };
  }, []);
  return __spreadValues({ channel }, status);
}

// src/subscribe/use-subscription.ts
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 useState3 } from "react";
function useSubscription(client, channelName, filter, primaryKeys, opts) {
  const [status, setStatus] = useState3({ status: null, error: null });
  const deleteItem2 = useDeleteItem(__spreadProps(__spreadValues({}, opts), {
    primaryKeys,
    table: filter.table,
    schema: filter.schema
  }));
  const upsertItem2 = useUpsertItem(__spreadProps(__spreadValues({}, opts), {
    primaryKeys,
    table: filter.table,
    schema: filter.schema
  }));
  useEffect2(() => {
    if (!client) return;
    const c = client.channel(channelName).on(
      REALTIME_LISTEN_TYPES2.POSTGRES_CHANGES,
      filter,
      (payload) => __async(this, null, function* () {
        if (payload.eventType === REALTIME_POSTGRES_CHANGES_LISTEN_EVENT2.INSERT || payload.eventType === REALTIME_POSTGRES_CHANGES_LISTEN_EVENT2.UPDATE) {
          yield upsertItem2(payload.new);
        } else if (payload.eventType === REALTIME_POSTGRES_CHANGES_LISTEN_EVENT2.DELETE) {
          yield deleteItem2(payload.old);
        }
        if (opts == null ? void 0 : opts.callback) {
          opts.callback(__spreadValues({}, payload));
        }
      })
    ).subscribe(
      (status2, error) => setStatus({ status: status2, error: error || null })
    );
    return () => {
      if (c) c.unsubscribe();
    };
  }, []);
  return status;
}
export {
  INFINITE_KEY_PREFIX,
  INFINITE_PREFIX,
  KEY_PREFIX,
  KEY_SEPARATOR,
  POSTGREST_FILTER_KEY_PREFIX,
  createCursorKeyGetter,
  createOffsetKeyGetter,
  decode,
  encode,
  fetchOffsetPaginationFallbackData,
  fetchOffsetPaginationHasMoreFallbackData,
  fetchQueryFallbackData,
  infiniteMiddleware,
  useCursorInfiniteScrollQuery,
  useDeleteItem,
  useDeleteManyMutation,
  useDeleteMutation,
  useInfiniteOffsetPaginationQuery,
  useInsertMutation,
  useMutateItem,
  useOffsetInfiniteQuery,
  useOffsetInfiniteScrollQuery,
  usePostgrestFilterCache,
  useQueriesForTableLoader,
  useQuery,
  useRevalidateTables,
  useSubscription,
  useSubscriptionQuery,
  useUpdateMutation,
  useUpsertItem,
  useUpsertMutation
};
//# sourceMappingURL=index.js.map