@supabase-kit/react
Version:
> Hooks by management data from supabase and fetch data by react.
852 lines (843 loc) • 30.8 kB
JavaScript
'use strict';
var reactQuery = require('@tanstack/react-query');
var react = require('react');
var supabaseJs = require('@supabase/supabase-js');
function _arrayLikeToArray(r, a) {
(null == a || a > r.length) && (a = r.length);
for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
return n;
}
function asyncGeneratorStep(n, t, e, r, o, a, c) {
try {
var i = n[a](c),
u = i.value;
} catch (n) {
return void e(n);
}
i.done ? t(u) : Promise.resolve(u).then(r, o);
}
function _asyncToGenerator(n) {
return function () {
var t = this,
e = arguments;
return new Promise(function (r, o) {
var a = n.apply(t, e);
function _next(n) {
asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
}
function _throw(n) {
asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
}
_next(void 0);
});
};
}
function _createForOfIteratorHelperLoose(r, e) {
var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
if (t) return (t = t.call(r)).next.bind(t);
if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
t && (r = t);
var o = 0;
return function () {
return o >= r.length ? {
done: !0
} : {
done: !1,
value: r[o++]
};
};
}
throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _extends() {
return _extends = Object.assign ? Object.assign.bind() : function (n) {
for (var e = 1; e < arguments.length; e++) {
var t = arguments[e];
for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
}
return n;
}, _extends.apply(null, arguments);
}
function _objectWithoutPropertiesLoose(r, e) {
if (null == r) return {};
var t = {};
for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
if (-1 !== e.indexOf(n)) continue;
t[n] = r[n];
}
return t;
}
function _regeneratorRuntime() {
_regeneratorRuntime = function () {
return r;
};
var t,
r = {},
e = Object.prototype,
n = e.hasOwnProperty,
o = "function" == typeof Symbol ? Symbol : {},
i = o.iterator || "@@iterator",
a = o.asyncIterator || "@@asyncIterator",
u = o.toStringTag || "@@toStringTag";
function c(t, r, e, n) {
return Object.defineProperty(t, r, {
value: e,
enumerable: !n,
configurable: !n,
writable: !n
});
}
try {
c({}, "");
} catch (t) {
c = function (t, r, e) {
return t[r] = e;
};
}
function h(r, e, n, o) {
var i = e && e.prototype instanceof Generator ? e : Generator,
a = Object.create(i.prototype);
return c(a, "_invoke", function (r, e, n) {
var o = 1;
return function (i, a) {
if (3 === o) throw Error("Generator is already running");
if (4 === o) {
if ("throw" === i) throw a;
return {
value: t,
done: !0
};
}
for (n.method = i, n.arg = a;;) {
var u = n.delegate;
if (u) {
var c = d(u, n);
if (c) {
if (c === f) continue;
return c;
}
}
if ("next" === n.method) n.sent = n._sent = n.arg;else if ("throw" === n.method) {
if (1 === o) throw o = 4, n.arg;
n.dispatchException(n.arg);
} else "return" === n.method && n.abrupt("return", n.arg);
o = 3;
var h = s(r, e, n);
if ("normal" === h.type) {
if (o = n.done ? 4 : 2, h.arg === f) continue;
return {
value: h.arg,
done: n.done
};
}
"throw" === h.type && (o = 4, n.method = "throw", n.arg = h.arg);
}
};
}(r, n, new Context(o || [])), !0), a;
}
function s(t, r, e) {
try {
return {
type: "normal",
arg: t.call(r, e)
};
} catch (t) {
return {
type: "throw",
arg: t
};
}
}
r.wrap = h;
var f = {};
function Generator() {}
function GeneratorFunction() {}
function GeneratorFunctionPrototype() {}
var l = {};
c(l, i, function () {
return this;
});
var p = Object.getPrototypeOf,
y = p && p(p(x([])));
y && y !== e && n.call(y, i) && (l = y);
var v = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(l);
function g(t) {
["next", "throw", "return"].forEach(function (r) {
c(t, r, function (t) {
return this._invoke(r, t);
});
});
}
function AsyncIterator(t, r) {
function e(o, i, a, u) {
var c = s(t[o], t, i);
if ("throw" !== c.type) {
var h = c.arg,
f = h.value;
return f && "object" == typeof f && n.call(f, "__await") ? r.resolve(f.__await).then(function (t) {
e("next", t, a, u);
}, function (t) {
e("throw", t, a, u);
}) : r.resolve(f).then(function (t) {
h.value = t, a(h);
}, function (t) {
return e("throw", t, a, u);
});
}
u(c.arg);
}
var o;
c(this, "_invoke", function (t, n) {
function i() {
return new r(function (r, o) {
e(t, n, r, o);
});
}
return o = o ? o.then(i, i) : i();
}, !0);
}
function d(r, e) {
var n = e.method,
o = r.i[n];
if (o === t) return e.delegate = null, "throw" === n && r.i.return && (e.method = "return", e.arg = t, d(r, e), "throw" === e.method) || "return" !== n && (e.method = "throw", e.arg = new TypeError("The iterator does not provide a '" + n + "' method")), f;
var i = s(o, r.i, e.arg);
if ("throw" === i.type) return e.method = "throw", e.arg = i.arg, e.delegate = null, f;
var a = i.arg;
return a ? a.done ? (e[r.r] = a.value, e.next = r.n, "return" !== e.method && (e.method = "next", e.arg = t), e.delegate = null, f) : a : (e.method = "throw", e.arg = new TypeError("iterator result is not an object"), e.delegate = null, f);
}
function w(t) {
this.tryEntries.push(t);
}
function m(r) {
var e = r[4] || {};
e.type = "normal", e.arg = t, r[4] = e;
}
function Context(t) {
this.tryEntries = [[-1]], t.forEach(w, this), this.reset(!0);
}
function x(r) {
if (null != r) {
var e = r[i];
if (e) return e.call(r);
if ("function" == typeof r.next) return r;
if (!isNaN(r.length)) {
var o = -1,
a = function e() {
for (; ++o < r.length;) if (n.call(r, o)) return e.value = r[o], e.done = !1, e;
return e.value = t, e.done = !0, e;
};
return a.next = a;
}
}
throw new TypeError(typeof r + " is not iterable");
}
return GeneratorFunction.prototype = GeneratorFunctionPrototype, c(v, "constructor", GeneratorFunctionPrototype), c(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = c(GeneratorFunctionPrototype, u, "GeneratorFunction"), r.isGeneratorFunction = function (t) {
var r = "function" == typeof t && t.constructor;
return !!r && (r === GeneratorFunction || "GeneratorFunction" === (r.displayName || r.name));
}, r.mark = function (t) {
return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, c(t, u, "GeneratorFunction")), t.prototype = Object.create(v), t;
}, r.awrap = function (t) {
return {
__await: t
};
}, g(AsyncIterator.prototype), c(AsyncIterator.prototype, a, function () {
return this;
}), r.AsyncIterator = AsyncIterator, r.async = function (t, e, n, o, i) {
void 0 === i && (i = Promise);
var a = new AsyncIterator(h(t, e, n, o), i);
return r.isGeneratorFunction(e) ? a : a.next().then(function (t) {
return t.done ? t.value : a.next();
});
}, g(v), c(v, u, "Generator"), c(v, i, function () {
return this;
}), c(v, "toString", function () {
return "[object Generator]";
}), r.keys = function (t) {
var r = Object(t),
e = [];
for (var n in r) e.unshift(n);
return function t() {
for (; e.length;) if ((n = e.pop()) in r) return t.value = n, t.done = !1, t;
return t.done = !0, t;
};
}, r.values = x, Context.prototype = {
constructor: Context,
reset: function (r) {
if (this.prev = this.next = 0, this.sent = this._sent = t, this.done = !1, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(m), !r) for (var e in this) "t" === e.charAt(0) && n.call(this, e) && !isNaN(+e.slice(1)) && (this[e] = t);
},
stop: function () {
this.done = !0;
var t = this.tryEntries[0][4];
if ("throw" === t.type) throw t.arg;
return this.rval;
},
dispatchException: function (r) {
if (this.done) throw r;
var e = this;
function n(t) {
a.type = "throw", a.arg = r, e.next = t;
}
for (var o = e.tryEntries.length - 1; o >= 0; --o) {
var i = this.tryEntries[o],
a = i[4],
u = this.prev,
c = i[1],
h = i[2];
if (-1 === i[0]) return n("end"), !1;
if (!c && !h) throw Error("try statement without catch or finally");
if (null != i[0] && i[0] <= u) {
if (u < c) return this.method = "next", this.arg = t, n(c), !0;
if (u < h) return n(h), !1;
}
}
},
abrupt: function (t, r) {
for (var e = this.tryEntries.length - 1; e >= 0; --e) {
var n = this.tryEntries[e];
if (n[0] > -1 && n[0] <= this.prev && this.prev < n[2]) {
var o = n;
break;
}
}
o && ("break" === t || "continue" === t) && o[0] <= r && r <= o[2] && (o = null);
var i = o ? o[4] : {};
return i.type = t, i.arg = r, o ? (this.method = "next", this.next = o[2], f) : this.complete(i);
},
complete: function (t, r) {
if ("throw" === t.type) throw t.arg;
return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg, this.method = "return", this.next = "end") : "normal" === t.type && r && (this.next = r), f;
},
finish: function (t) {
for (var r = this.tryEntries.length - 1; r >= 0; --r) {
var e = this.tryEntries[r];
if (e[2] === t) return this.complete(e[4], e[3]), m(e), f;
}
},
catch: function (t) {
for (var r = this.tryEntries.length - 1; r >= 0; --r) {
var e = this.tryEntries[r];
if (e[0] === t) {
var n = e[4];
if ("throw" === n.type) {
var o = n.arg;
m(e);
}
return o;
}
}
throw Error("illegal catch attempt");
},
delegateYield: function (r, e, n) {
return this.delegate = {
i: x(r),
r: e,
n: n
}, "next" === this.method && (this.arg = t), f;
}
}, r;
}
function _unsupportedIterableToArray(r, a) {
if (r) {
if ("string" == typeof r) return _arrayLikeToArray(r, a);
var t = {}.toString.call(r).slice(8, -1);
return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
}
}
var GetSupaQueryName = function GetSupaQueryName(_ref) {
var table = _ref.table,
queryKey = _ref.queryKey;
return [table].concat(queryKey).join('_');
};
var _excluded$1 = ["where"];
var objMatchBuild = {
match: function match(Query, _match) {
if (_match === void 0) {
_match = {};
}
return Query.match(_match);
},
or: function or(Query, ors) {
if (ors === void 0) {
ors = [];
}
for (var _iterator = _createForOfIteratorHelperLoose(ors), _step; !(_step = _iterator()).done;) {
var _or = _step.value;
Query = Query.or(_or);
}
return Query;
},
filter: function filter(Query, _filter) {
if (_filter === void 0) {
_filter = {};
}
for (var _i = 0, _Object$entries = Object.entries(_filter); _i < _Object$entries.length; _i++) {
var _Object$entries$_i = _Object$entries[_i],
k = _Object$entries$_i[0],
v = _Object$entries$_i[1];
Query.filter.apply(Query, [k].concat(v));
}
return Query;
},
not: function not(Query, textSearch) {
if (textSearch === void 0) {
textSearch = {};
}
for (var _i2 = 0, _Object$keys = Object.keys(textSearch); _i2 < _Object$keys.length; _i2++) {
var k = _Object$keys[_i2];
var _textSearch$k =
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
textSearch[k],
text = _textSearch$k.text,
options = _textSearch$k.options;
Query = Query.textSearch(k, text, options);
}
return Query;
},
limit: function limit(Query, _limit) {
return Query.limit(_limit);
},
single: function single(Query) {
return Query = Query.single();
},
maybeSingle: function maybeSingle(Query) {
return Query.maybeSingle();
},
csv: function csv(Query) {
return Query.csv();
},
explain: function explain(Query, _explain) {
if (_explain === void 0) {
_explain = {};
}
return Query.explain(_explain);
},
order: function order(Query, _order) {
for (var _i3 = 0, _Object$entries2 = Object.entries(_order); _i3 < _Object$entries2.length; _i3++) {
var _Object$entries2$_i = _Object$entries2[_i3],
k = _Object$entries2$_i[0],
v = _Object$entries2$_i[1];
Query = Query.order(k, v);
}
return Query;
},
range: function range(Query, ranges) {
var onRange = function onRange(range) {
return Query.range(range.from, range.to, range.options);
};
if (!Array.isArray(ranges)) return onRange(ranges);
for (var _iterator2 = _createForOfIteratorHelperLoose(ranges), _step2; !(_step2 = _iterator2()).done;) {
var range = _step2.value;
Query = onRange(range);
}
return Query;
}
};
/**
* Enhances a Supabase query with various filtering, ordering, and formatting options.
*
* @template D - The database schema type.
* @template S - The schema key within the database.
*
* @param {ConfigObj<D, S>} param0 - Configuration object containing filtering and other options.
* @param {PostgrestFilterBuilder<any, any, any>} Query - The initial Postgrest query builder object.
*
* @returns {PostgrestFilterBuilder<any, any, any>} - The enhanced Postgrest query builder object with applied configurations.
*/
var QueryBuilder = function QueryBuilder(_ref, Query) {
var _ref$where = _ref.where,
where = _ref$where === void 0 ? {} : _ref$where,
options = _objectWithoutPropertiesLoose(_ref, _excluded$1);
var base = _extends({}, where, options);
var where_keys = ['eq', 'neq', 'in', 'is', 'lt', 'lte', 'gt', 'gte', 'like', 'ilike', 'contains', 'containedBy', 'rangeGt', 'rangeGte', 'rangeLt', 'rangeLte', 'rangeAdjacent', 'contains', 'containedBy', 'rangeGt', 'rangeGte', 'rangeLt', 'rangeLte', 'rangeAdjacent', 'overlaps'];
for (var _i4 = 0, _Object$entries3 = Object.entries(base); _i4 < _Object$entries3.length; _i4++) {
var _Object$entries3$_i = _Object$entries3[_i4],
kp = _Object$entries3$_i[0],
vQ = _Object$entries3$_i[1];
var k = kp;
var method = objMatchBuild[k];
if (method) {
Query = method(Query, vQ);
continue;
}
if (!where_keys.includes(k)) continue;
for (var _i5 = 0, _Object$entries4 = Object.entries(vQ); _i5 < _Object$entries4.length; _i5++) {
var _Object$entries4$_i = _Object$entries4[_i5],
K = _Object$entries4$_i[0],
v = _Object$entries4$_i[1];
Query = Query[k](K, v);
}
}
return Query;
};
var _excluded = ["table", "schema", "column", "count", "options", "single", "enabled"],
_excluded2 = ["queryKey"],
_excluded3 = ["table", "schema", "column", "options", "enabled", "count"],
_excluded4 = ["initialData", "queryKey"];
// Sobrecargas de la función useSupaQuery
var createSupabaseQuery = function createSupabaseQuery(client) {
function useSupaQuery(_ref) {
var table = _ref.table,
_ref$schema = _ref.schema,
schema = _ref$schema === void 0 ? 'public' : _ref$schema,
_ref$column = _ref.column,
column = _ref$column === void 0 ? '*' : _ref$column,
count = _ref.count,
_ref$options = _ref.options,
options = _ref$options === void 0 ? {} : _ref$options,
single = _ref.single,
enabled = _ref.enabled,
configObj = _objectWithoutPropertiesLoose(_ref, _excluded);
var fetchData = /*#__PURE__*/function () {
var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(signal) {
var localClient, QueryBase, QueryFn, _yield$QueryFn$abortS, data, error, rowCount;
return _regeneratorRuntime().wrap(function _callee$(_context) {
while (1) switch (_context.prev = _context.next) {
case 0:
localClient = !schema ? client : client.schema(schema);
QueryBase = localClient.from(table).select(column, {
count: count
});
QueryFn = QueryBuilder(configObj, QueryBase);
_context.next = 5;
return QueryFn.abortSignal(signal);
case 5:
_yield$QueryFn$abortS = _context.sent;
data = _yield$QueryFn$abortS.data;
error = _yield$QueryFn$abortS.error;
rowCount = _yield$QueryFn$abortS.count;
if (!error) {
_context.next = 11;
break;
}
throw error;
case 11:
return _context.abrupt("return", {
count: rowCount != null ? rowCount : 0,
payload: single ? data != null ? data : {} : data != null ? data : []
});
case 12:
case "end":
return _context.stop();
}
}, _callee);
}));
return function fetchData(_x) {
return _ref2.apply(this, arguments);
};
}();
var _options$queryKey = options.queryKey,
queryKey = _options$queryKey === void 0 ? [] : _options$queryKey,
optionsHooks = _objectWithoutPropertiesLoose(options, _excluded2);
var initQueryKey = GetSupaQueryName({
table: table,
queryKey: queryKey
});
return reactQuery.useQuery(_extends({
queryKey: [initQueryKey, configObj.where, configObj.limit, single, count, table, column, count, options, single, enabled],
queryFn: function queryFn(_ref3) {
var signal = _ref3.signal;
return fetchData(signal);
},
enabled: enabled
}, optionsHooks));
}
/**
* React Query hook for fetching data from a Supabase table with infinite scroll.
*
* @param {string} table - The table to fetch data from.
* @param {string} [column='*'] - The column(s) to fetch. Defaults to '*'.
* @param {Object} [options={}] - Options for the hook. See {@link https://react-query.tanstack.com/docs/api#useinfinitequery}
* @param {boolean} [enabled=true] - Whether the hook is enabled.
* @param {'exact'|'planned'|'estimated'} [count='exact'] - The type of count to fetch. See {@link https://supabase.io/docs/reference/postgrest/count}
* @param {Object} [configObj={}] - Additional configuration options for the query. See {@link https://supabase.io/docs/reference/postgrest/filters}
* @returns {UseInfiniteQueryResult<SupabaseQueryResult<V>, PostgrestError>} - The result of the query.
*/
var useSupaInfiniteQuery = function useSupaInfiniteQuery(_ref4) {
var table = _ref4.table,
_ref4$schema = _ref4.schema,
schema = _ref4$schema === void 0 ? 'public' : _ref4$schema,
_ref4$column = _ref4.column,
column = _ref4$column === void 0 ? '*' : _ref4$column,
options = _ref4.options,
enabled = _ref4.enabled,
_ref4$count = _ref4.count,
count = _ref4$count === void 0 ? 'exact' : _ref4$count,
configObj = _objectWithoutPropertiesLoose(_ref4, _excluded3);
var fetchData = /*#__PURE__*/function () {
var _ref5 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(signal) {
var localClient, QueryBase, QueryFn, _yield$QueryFn$abortS2, data, error, rowCount;
return _regeneratorRuntime().wrap(function _callee2$(_context2) {
while (1) switch (_context2.prev = _context2.next) {
case 0:
localClient = !schema ? client : client.schema(schema);
QueryBase = localClient.from(table).select(column, {
count: count
});
QueryFn = QueryBuilder(configObj, QueryBase);
_context2.next = 5;
return QueryFn.abortSignal(signal);
case 5:
_yield$QueryFn$abortS2 = _context2.sent;
data = _yield$QueryFn$abortS2.data;
error = _yield$QueryFn$abortS2.error;
rowCount = _yield$QueryFn$abortS2.count;
if (!error) {
_context2.next = 11;
break;
}
throw error;
case 11:
return _context2.abrupt("return", {
count: rowCount != null ? rowCount : 0,
payload: data != null ? data : []
});
case 12:
case "end":
return _context2.stop();
}
}, _callee2);
}));
return function fetchData(_x2) {
return _ref5.apply(this, arguments);
};
}();
var _options$queryKey2 = options.queryKey,
queryKey = _options$queryKey2 === void 0 ? [] : _options$queryKey2,
optionsHook = _objectWithoutPropertiesLoose(options, _excluded4);
var initQueryKey = GetSupaQueryName({
table: table,
queryKey: ['infinite'].concat(queryKey)
});
return reactQuery.useInfiniteQuery(_extends({
queryKey: [initQueryKey, configObj.where, configObj.limit],
queryFn: function queryFn(_ref6) {
var signal = _ref6.signal;
return fetchData(signal);
},
enabled: enabled
}, optionsHook));
};
return {
useSupaInfiniteQuery: useSupaInfiniteQuery,
useSupaQuery: useSupaQuery,
QueryBuilder: QueryBuilder
};
};
var createSupabaseSubscription = function createSupabaseSubscription(client, useQuery) {
/**
* Custom hook to create a Supabase subscription with specified configurations.
*
* @template D - Database schema type.
* @template SchemaKey - Database schema type.
*
* @param {Object} config - Configuration object for the subscription.
* @param {string} config.table - The name of the table to subscribe to.
* @param {string} [config.schema='public'] - The database schema to use.
* @param {string} [config.event='*'] - Event type to listen for (e.g., INSERT, UPDATE, DELETE).
* @param {Object} [config.where] - Filter object to specify conditions for events.
* @param {string} [config.type='postgres_changes'] - Type of event to listen for.
* @param {string} [config.channel='general'] - Channel name for the subscription.
* @param {Function} [config.callback=(payload) => console.log(payload)] - Callback function to handle subscription payloads.
*
* @returns {void}
*
* This hook sets up a Supabase subscription based on the provided configuration.
* It automatically unsubscribes when the component is unmounted or the dependencies change.
*/
var useSupaSubscription = function useSupaSubscription(_ref) {
var table = _ref.table,
schema = _ref.schema,
_ref$event = _ref.event,
event = _ref$event === void 0 ? '*' : _ref$event,
where = _ref.where,
_ref$type = _ref.type,
type = _ref$type === void 0 ? 'postgres_changes' : _ref$type,
_ref$channel = _ref.channel,
channel = _ref$channel === void 0 ? 'general' : _ref$channel,
_ref$callback = _ref.callback,
callback = _ref$callback === void 0 ? function (payload) {
return console.log(payload);
} : _ref$callback;
var filter = react.useMemo(function () {
if (!where) return '';
var base = (where == null ? void 0 : where.key) + "=" + (where == null ? void 0 : where.operator);
if ((where == null ? void 0 : where.operator) === 'in') return base + ".(" + (where == null ? void 0 : where.value.toString()) + ")";
return base + "." + (where == null ? void 0 : where.value);
}, [where]);
var configQuery = react.useMemo(function () {
if (!filter) return {
event: event,
schema: schema,
table: table
};
return {
event: event,
schema: schema,
table: table,
filter: filter
};
}, [event, schema, table, filter]);
react.useEffect(function () {
var subscription = client.channel(channel).on(type, configQuery, callback).subscribe();
return function () {
subscription.unsubscribe();
};
}, [callback, configQuery, type, channel]);
};
/**
* Use a subscription to listen to a table in real time.
* @param {Object} props - Options for the subscription.
* @param {string} props.table - The table to listen to.
* @param {Object} props.where - A filter to apply to the subscription.
* @param {string} [props.channel=general] - The channel to subscribe to.
* @returns {UseQueryResult} The result of the subscription.
*/
var useSupaRealtime = function useSupaRealtime(_ref2) {
var table = _ref2.table,
where = _ref2.where,
_ref2$channel = _ref2.channel,
channel = _ref2$channel === void 0 ? 'general' : _ref2$channel,
_ref2$schema = _ref2.schema,
schema = _ref2$schema === void 0 ? 'public' : _ref2$schema;
var queryClient = reactQuery.useQueryClient();
var queryConfig = react.useMemo(function () {
var _where$operator, _ref3;
return where ? (_ref3 = {}, _ref3[where.operator] = (_where$operator = {}, _where$operator[where.key] = where.value, _where$operator), _ref3) : {};
}, [where]);
var QueryKey = [[table, 'subscription'].join('_'), queryConfig, null,
// limit
null,
// single
'estimated' // count
];
var query = useQuery({
table: table,
schema: schema,
where: queryConfig,
options: {
queryKey: ['subscription']
},
count: 'estimated'
});
useSupaSubscription({
table: table,
schema: schema,
event: '*',
where: where,
type: 'postgres_changes',
channel: channel,
callback: function callback(payload) {
var _eventMatch;
var eventMatch = (_eventMatch = {}, _eventMatch[supabaseJs.REALTIME_POSTGRES_CHANGES_LISTEN_EVENT.DELETE] = function () {
queryClient.setQueryData(QueryKey, function (oldData) {
var payload = oldData.payload.filter(function (d) {
return d.id !== payload.old.id;
});
var count = payload.length;
return {
count: count,
payload: payload
};
});
}, _eventMatch[supabaseJs.REALTIME_POSTGRES_CHANGES_LISTEN_EVENT.INSERT] = function () {
queryClient.setQueryData(QueryKey, function (oldData) {
var newPayload = [].concat(oldData.payload, [payload["new"]]);
var count = newPayload.length;
return {
count: count,
payload: newPayload
};
});
}, _eventMatch[supabaseJs.REALTIME_POSTGRES_CHANGES_LISTEN_EVENT.UPDATE] = function () {
queryClient.setQueryData(QueryKey, function (oldData) {
var payload = oldData.payload.map(function (d) {
if (d.id === payload.old.id) return payload["new"];
return d;
});
var count = payload.length;
return {
count: count,
payload: payload
};
});
}, _eventMatch);
eventMatch[payload.eventType]();
}
});
return query;
};
return {
useSupaSubscription: useSupaSubscription,
useSupaRealtime: useSupaRealtime
};
};
var createSupabaseTools = function createSupabaseTools(client) {
var useSupabase = function useSupabase() {
return react.useMemo(function () {
return client;
}, []);
};
/**
* Hook to get the user session.
* @returns The user session.
*
* The query key is `['session', client]`.
* The query function is `async () => client.auth.getSession()`.
* The initial data is `null`.
*/
var useSupaSession = function useSupaSession() {
return reactQuery.useQuery({
queryKey: ['supa_session', client],
initialData: null,
queryFn: function () {
var _queryFn = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
var _yield$client$auth$ge, data, error;
return _regeneratorRuntime().wrap(function _callee$(_context) {
while (1) switch (_context.prev = _context.next) {
case 0:
_context.next = 2;
return client.auth.getSession();
case 2:
_yield$client$auth$ge = _context.sent;
data = _yield$client$auth$ge.data;
error = _yield$client$auth$ge.error;
if (!error) {
_context.next = 7;
break;
}
throw error;
case 7:
return _context.abrupt("return", data.session);
case 8:
case "end":
return _context.stop();
}
}, _callee);
}));
function queryFn() {
return _queryFn.apply(this, arguments);
}
return queryFn;
}()
});
};
var SupabaseQuery = createSupabaseQuery(client);
var SupabaseSubscription = createSupabaseSubscription(client, SupabaseQuery.useSupaQuery);
var getSupaQueryName = function getSupaQueryName(_ref) {
var table = _ref.table,
queryKey = _ref.queryKey;
return GetSupaQueryName({
table: table,
queryKey: queryKey
});
};
return _extends({
useSupabase: useSupabase,
useSupaSession: useSupaSession,
getSupaQueryName: getSupaQueryName
}, SupabaseQuery, SupabaseSubscription);
};
exports.QueryBuilder = QueryBuilder;
exports.createSupabaseQuery = createSupabaseQuery;
exports.createSupabaseTools = createSupabaseTools;
//# sourceMappingURL=react.cjs.development.js.map