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

A collection of SWR utilities for working with Supabase.

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __getProtoOf = Object.getPrototypeOf;
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 __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
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/index.ts
var index_exports = {};
__export(index_exports, {
  INFINITE_KEY_PREFIX: () => INFINITE_KEY_PREFIX,
  INFINITE_PREFIX: () => INFINITE_PREFIX,
  KEY_PREFIX: () => KEY_PREFIX,
  KEY_SEPARATOR: () => KEY_SEPARATOR,
  POSTGREST_FILTER_KEY_PREFIX: () => POSTGREST_FILTER_KEY_PREFIX,
  createCursorKeyGetter: () => createCursorKeyGetter,
  createOffsetKeyGetter: () => createOffsetKeyGetter,
  decode: () => decode,
  encode: () => encode,
  fetchOffsetPaginationFallbackData: () => fetchOffsetPaginationFallbackData,
  fetchOffsetPaginationHasMoreFallbackData: () => fetchOffsetPaginationHasMoreFallbackData,
  fetchQueryFallbackData: () => fetchQueryFallbackData,
  infiniteMiddleware: () => infiniteMiddleware,
  useCursorInfiniteScrollQuery: () => useCursorInfiniteScrollQuery,
  useDeleteItem: () => useDeleteItem,
  useDeleteManyMutation: () => useDeleteManyMutation,
  useDeleteMutation: () => useDeleteMutation,
  useInfiniteOffsetPaginationQuery: () => useInfiniteOffsetPaginationQuery,
  useInsertMutation: () => useInsertMutation,
  useMutateItem: () => useMutateItem,
  useOffsetInfiniteQuery: () => useOffsetInfiniteQuery,
  useOffsetInfiniteScrollQuery: () => useOffsetInfiniteScrollQuery,
  usePostgrestFilterCache: () => usePostgrestFilterCache,
  useQueriesForTableLoader: () => useQueriesForTableLoader,
  useQuery: () => useQuery,
  useRevalidateTables: () => useRevalidateTables,
  useSubscription: () => useSubscription,
  useSubscriptionQuery: () => useSubscriptionQuery,
  useUpdateMutation: () => useUpdateMutation,
  useUpsertItem: () => useUpsertItem,
  useUpsertMutation: () => useUpsertMutation
});
module.exports = __toCommonJS(index_exports);

// src/cache/use-delete-item.ts
var import_postgrest_core5 = require("@supabase-cache-helpers/postgrest-core");
var import_flat = require("flat");
var import_swr3 = require("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
var import_postgrest_core2 = require("@supabase-cache-helpers/postgrest-core");

// src/lib/parse-order-by.ts
var import_postgrest_core = require("@supabase-cache-helpers/postgrest-core");
function parseOrderBy(searchParams, {
  orderByPath,
  uqOrderByPath
}) {
  const orderByDef = (0, import_postgrest_core.parseOrderBy)(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 && ((0, import_postgrest_core2.isPostgrestHasMorePaginationResponse)(previousPageData) && !previousPageData.data.length || (0, import_postgrest_core2.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({}, (0, import_postgrest_core2.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 = (0, import_postgrest_core2.get)(lastItem, orderBy);
    if (!lastValueOrderBy) return query;
    const lastValueUqColumn = uqColumn ? (0, import_postgrest_core2.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({}, (0, import_postgrest_core2.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 (0, import_postgrest_core2.isPostgrestHasMorePaginationResponse)(previousPageData) && !previousPageData.data.length || (0, import_postgrest_core2.isPostgrestPaginationResponse)(previousPageData) && !previousPageData.length;
}
function getLastItem(data) {
  if ((0, import_postgrest_core2.isPostgrestHasMorePaginationResponse)(data)) {
    return data.data.length ? data.data[data.data.length - 1] : null;
  } else if ((0, import_postgrest_core2.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
var import_postgrest_core3 = require("@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 (!(0, import_postgrest_core3.isPostgrestBuilder)(query)) {
          throw new Error("Key is not a PostgrestBuilder");
        }
        return encode(new import_postgrest_core3.PostgrestParser(query), true);
      },
      typeof fetcher === "function" ? (query) => fetcher(query) : fetcher,
      config
    );
  };
};

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

// src/lib/use-queries-for-table-loader.ts
var import_swr2 = require("swr");
var useQueriesForTableLoader = (table) => {
  const { cache } = (0, import_swr2.useSWRConfig)();
  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 } = (0, import_swr3.useSWRConfig)();
  const getPostgrestFilter = usePostgrestFilterCache();
  return (input) => __async(this, null, function* () {
    return yield (0, import_postgrest_core5.deleteItem)(
      __spreadValues({
        input: (0, import_flat.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
var import_postgrest_core6 = require("@supabase-cache-helpers/postgrest-core");
var import_flat2 = require("flat");
var import_swr4 = require("swr");
function useMutateItem(opts) {
  const { mutate, cache } = (0, import_swr4.useSWRConfig)();
  const getPostgrestFilter = usePostgrestFilterCache();
  return (input, mutateFn) => __async(this, null, function* () {
    return yield (0, import_postgrest_core6.mutateItem)(
      __spreadValues({
        input: (0, import_flat2.flatten)(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
var import_postgrest_core7 = require("@supabase-cache-helpers/postgrest-core");
var import_swr5 = require("swr");
function useRevalidateTables(tables) {
  const { mutate, cache } = (0, import_swr5.useSWRConfig)();
  return () => __async(this, null, function* () {
    return yield (0, import_postgrest_core7.revalidateTables)(tables, {
      cacheKeys: getMutableKeys(Array.from(cache.keys())),
      revalidate: (key) => {
        mutate(key);
      },
      decode
    });
  });
}

// src/cache/use-upsert-item.ts
var import_postgrest_core8 = require("@supabase-cache-helpers/postgrest-core");
var import_flat3 = require("flat");
var import_swr6 = require("swr");
function useUpsertItem(opts) {
  const { mutate, cache } = (0, import_swr6.useSWRConfig)();
  const getPostgrestFilter = usePostgrestFilterCache();
  return (input) => __async(this, null, function* () {
    return yield (0, import_postgrest_core8.upsertItem)(
      __spreadValues({
        input: (0, import_flat3.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/mutate/use-delete-many-mutation.ts
var import_postgrest_core9 = require("@supabase-cache-helpers/postgrest-core");
var import_mutation = __toESM(require("swr/mutation"), 1);

// src/mutate/use-random-key.ts
var import_react = require("react");
var PREFIX = "random-mutation-key";
var useRandomKey = () => {
  const key = (0, import_react.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((0, import_postgrest_core9.getTable)(qb));
  const deleteItem2 = useDeleteItem(__spreadProps(__spreadValues({}, opts), {
    primaryKeys,
    table: (0, import_postgrest_core9.getTable)(qb),
    schema: qb.schema
  }));
  return (0, import_mutation.default)(
    key,
    (_0, _1) => __async(this, [_0, _1], function* (_, { arg }) {
      const result = yield (0, import_postgrest_core9.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
var import_postgrest_core10 = require("@supabase-cache-helpers/postgrest-core");
var import_mutation2 = __toESM(require("swr/mutation"), 1);
function useDeleteMutation(qb, primaryKeys, query, opts) {
  const key = useRandomKey();
  const queriesForTable = useQueriesForTableLoader((0, import_postgrest_core10.getTable)(qb));
  const deleteItem2 = useDeleteItem(__spreadProps(__spreadValues({}, opts), {
    primaryKeys,
    table: (0, import_postgrest_core10.getTable)(qb),
    schema: qb.schema
  }));
  return (0, import_mutation2.default)(
    key,
    (_0, _1) => __async(this, [_0, _1], function* (_, { arg }) {
      const r = yield (0, import_postgrest_core10.buildDeleteFetcher)(
        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
var import_postgrest_core11 = require("@supabase-cache-helpers/postgrest-core");
var import_mutation3 = __toESM(require("swr/mutation"), 1);

// 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((0, import_postgrest_core11.getTable)(qb));
  const upsertItem2 = useUpsertItem(__spreadProps(__spreadValues({}, opts), {
    primaryKeys,
    table: (0, import_postgrest_core11.getTable)(qb),
    schema: qb.schema
  }));
  return (0, import_mutation3.default)(
    key,
    (_0, _1) => __async(this, [_0, _1], function* (_, { arg }) {
      const result = yield (0, import_postgrest_core11.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
var import_postgrest_core12 = require("@supabase-cache-helpers/postgrest-core");
var import_mutation4 = __toESM(require("swr/mutation"), 1);
function useUpdateMutation(qb, primaryKeys, query, opts) {
  const key = useRandomKey();
  const queriesForTable = useQueriesForTableLoader((0, import_postgrest_core12.getTable)(qb));
  const upsertItem2 = useUpsertItem(__spreadProps(__spreadValues({}, opts), {
    primaryKeys,
    table: (0, import_postgrest_core12.getTable)(qb),
    schema: qb.schema
  }));
  return (0, import_mutation4.default)(
    key,
    (_0, _1) => __async(this, [_0, _1], function* (_, { arg }) {
      var _a;
      const result = yield (0, import_postgrest_core12.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
var import_postgrest_core13 = require("@supabase-cache-helpers/postgrest-core");
var import_mutation5 = __toESM(require("swr/mutation"), 1);
function useUpsertMutation(qb, primaryKeys, query, opts) {
  const key = useRandomKey();
  const queriesForTable = useQueriesForTableLoader((0, import_postgrest_core13.getTable)(qb));
  const upsertItem2 = useUpsertItem(__spreadProps(__spreadValues({}, opts), {
    primaryKeys,
    table: (0, import_postgrest_core13.getTable)(qb),
    schema: qb.schema
  }));
  return (0, import_mutation5.default)(
    key,
    (_0, _1) => __async(this, [_0, _1], function* (_, { arg }) {
      const result = yield (0, import_postgrest_core13.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
var import_postgrest_core14 = require("@supabase-cache-helpers/postgrest-core");
function fetchQueryFallbackData(query) {
  return __async(this, null, function* () {
    if (!(0, import_postgrest_core14.isPostgrestBuilder)(query)) {
      throw new Error("Query is not a PostgrestBuilder");
    }
    return [
      encode(new import_postgrest_core14.PostgrestParser(query), false),
      yield query.throwOnError()
    ];
  });
}
function fetchOffsetPaginationHasMoreFallbackData(query, pageSize) {
  return __async(this, null, function* () {
    return [
      encode(new import_postgrest_core14.PostgrestParser(query.range(0, pageSize)), true),
      [
        yield (0, import_postgrest_core14.offsetPaginationHasMoreFetcher)(query, {
          offset: 0,
          limit: pageSize,
          pageSize
        })
      ]
    ];
  });
}
var fetchOffsetPaginationFallbackData = (query, pageSize) => __async(void 0, null, function* () {
  return [
    encode(new import_postgrest_core14.PostgrestParser(query.range(0, pageSize)), true),
    [
      yield (0, import_postgrest_core14.offsetPaginationFetcher)(query, {
        offset: 0,
        limit: pageSize
      })
    ]
  ];
});

// src/query/use-cursor-infinite-scroll-query.ts
var import_postgrest_core15 = require("@supabase-cache-helpers/postgrest-core");
var import_react2 = require("react");
var import_infinite = __toESM(require("swr/infinite"), 1);
function useCursorInfiniteScrollQuery(queryFactory, config) {
  var _a;
  const _b = (0, import_infinite.default)(
    createCursorKeyGetter(queryFactory, config),
    (0, import_postgrest_core15.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 = (0, import_postgrest_core15.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 } = (0, import_react2.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 = (0, import_postgrest_core15.isPlainObject)(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 = (0, import_react2.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
var import_postgrest_core16 = require("@supabase-cache-helpers/postgrest-core");
var import_infinite2 = __toESM(require("swr/infinite"), 1);
function useOffsetInfiniteQuery(queryFactory, config) {
  var _a, _b, _c;
  return (0, import_infinite2.default)(
    createOffsetKeyGetter(queryFactory, {
      pageSize: (_a = config == null ? void 0 : config.pageSize) != null ? _a : 20,
      rpcArgs: config == null ? void 0 : config.rpcArgs
    }),
    (0, import_postgrest_core16.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 = (0, import_postgrest_core16.decodeObject)(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
var import_postgrest_core17 = require("@supabase-cache-helpers/postgrest-core");
var import_react3 = require("react");
var import_infinite3 = __toESM(require("swr/infinite"), 1);
function useOffsetInfiniteScrollQuery(queryFactory, config) {
  var _a, _b, _c;
  const _d = (0, import_infinite3.default)(
    createOffsetKeyGetter(queryFactory, {
      pageSize: (_a = config == null ? void 0 : config.pageSize) != null ? _a : 20,
      rpcArgs: config == null ? void 0 : config.rpcArgs
    }),
    (0, import_postgrest_core17.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 = (0, import_postgrest_core17.decodeObject)(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 = (0, import_react3.useCallback)(() => 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
var import_postgrest_core18 = require("@supabase-cache-helpers/postgrest-core");
var import_react4 = require("react");
var import_infinite4 = __toESM(require("swr/infinite"), 1);
function useInfiniteOffsetPaginationQuery(queryFactory, config) {
  var _a, _b, _c, _e;
  const _d = (0, import_infinite4.default)(
    createOffsetKeyGetter(queryFactory, {
      pageSize: (_a = config == null ? void 0 : config.pageSize) != null ? _a : 20,
      rpcArgs: config == null ? void 0 : config.rpcArgs
    }),
    (0, import_postgrest_core18.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 = (0, import_postgrest_core18.decodeObject)(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] = (0, import_react4.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 = (0, import_react4.useCallback)(
    (idx) => {
      if (idx > size - 1) {
        setSize(idx + 1);
      }
      setCurrentPageIndex(idx);
    },
    [size, setSize, setCurrentPageIndex]
  );
  const nextPageFn = (0, import_react4.useCallback)(() => {
    if (currentPageIndex === size - 1) {
      setSize((size2) => size2 + 1);
    }
    setCurrentPageIndex((page) => page + 1);
  }, [currentPageIndex, size, setSize, setCurrentPageIndex]);
  const previousPageFn = (0, import_react4.useCallback)(
    () => 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
var import_postgrest_core19 = require("@supabase-cache-helpers/postgrest-core");
var import_swr7 = __toESM(require("swr"), 1);
function useQuery(query, config) {
  var _a, _c;
  const _b = (0, import_swr7.default)(
    query,
    (q) => __async(this, null, function* () {
      if ((0, import_postgrest_core19.isPostgrestBuilder)(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 && !(0, import_postgrest_core19.isPostgrestBuilder)(key)) {
              throw new Error("Key is not a PostgrestBuilder");
            }
            return useSWRNext(
              key ? encode(new import_postgrest_core19.PostgrestParser(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
var import_postgrest_core20 = require("@supabase-cache-helpers/postgrest-core");
var import_supabase_js = require("@supabase/supabase-js");
var import_react5 = require("react");
function useSubscriptionQuery(client, channelName, filter, primaryKeys, query, opts) {
  const [status, setStatus] = (0, import_react5.useState)({ status: null, error: null });
  const [channel, setChannel] = (0, import_react5.useState)();
  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
  }));
  (0, import_react5.useEffect)(() => {
    if (!client) return;
    const c = client.channel(channelName).on(
      import_supabase_js.REALTIME_LISTEN_TYPES.POSTGRES_CHANGES,
      filter,
      (payload) => __async(this, null, function* () {
        var _a;
        let data = (_a = payload.new) != null ? _a : payload.old;
        const selectQuery = (0, import_postgrest_core20.buildNormalizedQuery)({ queriesForTable, query });
        if (payload.eventType !== import_supabase_js.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 = (0, import_postgrest_core20.normalizeResponse)(selectQuery.groupedPaths, res.data);
          }
        }
        if (payload.eventType === import_supabase_js.REALTIME_POSTGRES_CHANGES_LISTEN_EVENT.INSERT || payload.eventType === import_supabase_js.REALTIME_POSTGRES_CHANGES_LISTEN_EVENT.UPDATE) {
          yield upsertItem2(data);
        } else if (payload.eventType === import_supabase_js.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
var import_supabase_js2 = require("@supabase/supabase-js");
var import_react6 = require("react");
function useSubscription(client, channelName, filter, primaryKeys, opts) {
  const [status, setStatus] = (0, import_react6.useState)({ 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
  }));
  (0, import_react6.useEffect)(() => {
    if (!client) return;
    const c = client.channel(channelName).on(
      import_supabase_js2.REALTIME_LISTEN_TYPES.POSTGRES_CHANGES,
      filter,
      (payload) => __async(this, null, function* () {
        if (payload.eventType === import_supabase_js2.REALTIME_POSTGRES_CHANGES_LISTEN_EVENT.INSERT || payload.eventType === import_supabase_js2.REALTIME_POSTGRES_CHANGES_LISTEN_EVENT.UPDATE) {
          yield upsertItem2(payload.new);
        } else if (payload.eventType === import_supabase_js2.REALTIME_POSTGRES_CHANGES_LISTEN_EVENT.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;
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  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.cjs.map