better-supabase 0.5.1 → 0.6.0

package/dist/{simplify-_0oUKqCd.js → build-BXIzE6Xv.js}

@@ -1,8 +1,10 @@
 import { n as isPlainObject } from "./clone-BfgmLU90.js";
-import { n as dbError, t as DbException } from "./errors-DtwXa6b8.js";
+import { t as DbException } from "./db-exception-CnWcYPxL.js";
+import { n as dbError } from "./errors-B11Duf73.js";
 import { t as lookupOf } from "./lookup-BaP5bI27.js";
+import { t as escapeLike } from "./escape-like-DHfx6jRr.js";
 import { i as or, r as not, t as and } from "./types-6cYK9pbJ.js";
-import { r as encodeValue } from "./wire-D2dT86vi.js";
+import { i as encodeValue } from "./wire-DtZQ4sdE.js";
 //#region src/schema/define.ts
 /**
 * Binds generated model types to runtime metadata. Called from the generated
@@ -53,6 +55,8 @@ const NUMERIC_TYPES = /* @__PURE__ */ new Set([
 function invalidRequest(message, table) {
 	throw new DbException(dbError("invalid_request", message, table ? { table } : {}));
 }
+/** A regconfig name, optionally schema-qualified; PostgREST puts it in the operator unquoted. */
+const TEXT_SEARCH_CONFIG = /^[A-Za-z_]\w*(\.[A-Za-z_]\w*)?$/;
 const FIELD_OPS = /* @__PURE__ */ new Set([
 	"eq",
 	"neq",
@@ -66,6 +70,8 @@ const FIELD_OPS = /* @__PURE__ */ new Set([
 	"lte",
 	"like",
 	"ilike",
+	"match",
+	"imatch",
 	"contains",
 	"startsWith",
 	"endsWith",
@@ -84,11 +90,30 @@ function writable(meta, mode) {
 	if (meta.generated || meta.identity === "always") return false;
 	return mode === "insert" ? meta.insertable !== false : meta.updatable !== false;
 }
-/** Escapes LIKE wildcards so user input matches literally. */
-function escapeLike(value) {
-	return value.replaceAll(/[\\%_]/g, (char) => `\\${char}`);
+/** A json key PostgREST accepts in an arrow path, or an array index. */
+const JSON_KEY = /^[\w$]+$/;
+/** Path filters compare text (`->>`), so numbers and booleans become strings. */
+function text(value) {
+	return typeof value === "number" || typeof value === "boolean" || typeof value === "bigint" ? String(value) : value;
+}
+/**
+* `in` over a list: `null` never equals anything in SQL, so a list with
+* `null` also matches the rows where the column is null.
+*/
+function inList(values, make) {
+	const present = values.filter((value) => value !== null);
+	if (present.length === values.length) return make("in", values);
+	const isNull = make("is", null);
+	return present.length === 0 ? isNull : or(make("in", present), isNull);
+}
+/** A primary key value; `null` and `undefined` match no row, so they are a caller error. */
+function keyValue(table, name, value) {
+	if (value === null || value === void 0) invalidRequest(`"${name}" of a ${table.key} key is ${String(value)}; pass the row's key`, table.key);
+	return value;
 }
 const builders = /* @__PURE__ */ new WeakMap();
+/** Column lists remembered per table; reads with generated lists stay bounded. */
+const SELECTION_CACHE_SIZE = 256;
 /** The shared builder for a schema; a builder holds no per-call state. */
 function builderFor(meta) {
 	let builder = builders.get(meta);
@@ -102,6 +127,7 @@ var IrBuilder = class {
 	meta;
 	/** Every column of a table, the selection of reads without `select`. */
 	#allColumns = /* @__PURE__ */ new WeakMap();
+	#selections = /* @__PURE__ */ new WeakMap();
 	constructor(meta) {
 		this.meta = meta;
 	}
@@ -179,6 +205,7 @@ var IrBuilder = class {
 			op: "is",
 			value: null
 		};
+		if (isPlainObject(value) && Array.isArray(value["path"])) return this.pathFilter(table, name, column, value);
 		if (!isOpsObject(value)) return {
 			kind: "column",
 			column,
@@ -195,6 +222,56 @@ var IrBuilder = class {
 			items: []
 		};
 	}
+	/** `{ path: ["a", "b"], eq: "x" }` on a json column: compares the text at the path. */
+	pathFilter(table, name, column, input) {
+		if (!table.columns[name]?.json) invalidRequest(`"path" needs a json column; "${name}" on "${table.key}" is not one`, table.key);
+		const path = input["path"];
+		if (!Array.isArray(path) || path.length === 0 || !path.every((key) => typeof key === "string" && JSON_KEY.test(key))) invalidRequest(`"path" on "${name}" must be a non-empty list of keys made of letters, digits and _`, table.key);
+		const keys = path;
+		const at = (op, value) => ({
+			kind: "column",
+			column,
+			op,
+			value,
+			path: keys
+		});
+		const items = [];
+		for (const [op, operand] of Object.entries(input)) {
+			if (op === "path" || operand === void 0) continue;
+			switch (op) {
+				case "eq":
+					items.push(operand === null ? at("is", null) : at("eq", text(operand)));
+					break;
+				case "neq":
+					items.push(operand === null ? not(at("is", null)) : at("neq", text(operand)));
+					break;
+				case "in":
+				case "notIn": {
+					if (!Array.isArray(operand)) invalidRequest(`"${op}" on "${name}" needs an array`, table.key);
+					const condition = inList(operand.map(text), at);
+					items.push(op === "in" ? condition : not(condition));
+					break;
+				}
+				case "isNull":
+					items.push(operand ? at("is", null) : not(at("is", null)));
+					break;
+				case "gt":
+				case "gte":
+				case "lt":
+				case "lte":
+				case "like":
+				case "ilike":
+				case "match":
+				case "imatch":
+					items.push(at(op, text(operand)));
+					break;
+				default: invalidRequest(`Unknown operator "${op}" on a path of "${name}"`, table.key);
+			}
+		}
+		const condition = and(...items);
+		if (!condition) invalidRequest(`"path" on "${name}" needs an operator`, table.key);
+		return condition;
+	}
 	fieldOp(table, name, column, op, operand) {
 		const col = (kind, value) => ({
 			kind: "column",
@@ -203,13 +280,20 @@ var IrBuilder = class {
 			value: encodeValue(value)
 		});
 		const meta = table.columns[name];
+		const containment = (kind, value) => meta?.json ? {
+			kind: "column",
+			column,
+			op: kind,
+			value: encodeValue(value),
+			json: true
+		} : col(kind, value);
 		switch (op) {
 			case "eq": return operand === null ? col("is", null) : col("eq", operand);
 			case "neq": return operand === null ? not(col("is", null)) : col("neq", operand);
 			case "in":
 			case "notIn": {
 				if (!Array.isArray(operand)) invalidRequest(`"${op}" on "${name}" needs an array`, table.key);
-				const condition = col("in", operand);
+				const condition = inList(operand, col);
 				return op === "in" ? condition : not(condition);
 			}
 			case "isNull": return operand ? col("is", null) : not(col("is", null));
@@ -222,15 +306,18 @@ var IrBuilder = class {
 			case "lt":
 			case "lte":
 			case "like":
-			case "ilike": return col(op, operand);
+			case "ilike":
+			case "match":
+			case "imatch": return col(op, operand);
 			case "contains":
-				if (meta?.json || meta?.array) return col("contains", operand);
+				if (meta?.json || meta?.array) return containment("contains", operand);
 				return col("ilike", `%${escapeLike(String(operand))}%`);
 			case "startsWith": return col("like", `${escapeLike(String(operand))}%`);
 			case "endsWith": return col("like", `%${escapeLike(String(operand))}`);
 			case "search": {
 				if (typeof operand === "string") return col("fts", operand);
 				const { query, config } = operand;
+				if (config && !TEXT_SEARCH_CONFIG.test(config)) invalidRequest(`"search" on "${name}" needs a text search configuration name, such as "english"`, table.key);
 				return config ? {
 					kind: "column",
 					column,
@@ -239,25 +326,26 @@ var IrBuilder = class {
 					config
 				} : col("fts", query);
 			}
-			case "hasEvery": return col("contains", operand);
-			case "has": return col("contains", [operand]);
-			case "hasSome": return col("overlaps", operand);
-			case "containedBy": return col("containedBy", operand);
+			case "hasEvery": return containment("contains", operand);
+			case "has": return containment("contains", [operand]);
+			case "hasSome":
+				if (meta?.json) invalidRequest(`"hasSome" on json column "${name}" has no PostgREST operator; use OR with "has"`, table.key);
+				return col("overlaps", operand);
+			case "containedBy": return containment("containedBy", operand);
 			default: return invalidRequest(`Unknown operator "${op}" on "${name}"`, table.key);
 		}
 	}
 	selection(table, select, include) {
+		if (include === void 0) return this.#columnsOnly(table, select);
 		const columns = select?.map((alias) => this.selectColumn(table, alias)) ?? this.allColumns(table);
 		const includes = [];
-		if (include !== void 0) {
-			if (!isPlainObject(include)) invalidRequest(`"include" on "${table.key}" must be an object`, table.key);
-			for (const [name, value] of Object.entries(include)) {
-				if (value === void 0 || value === false) continue;
-				const fn = AGGREGATE_KEYS[name];
-				if (name === "_count") includes.push(...this.counts(table, value));
-				else if (fn) includes.push(...this.relationAggregates(table, fn, value));
-				else includes.push(this.include(table, name, value));
-			}
+		if (!isPlainObject(include)) invalidRequest(`"include" on "${table.key}" must be an object`, table.key);
+		for (const [name, value] of Object.entries(include)) {
+			if (value === void 0 || value === false) continue;
+			const fn = AGGREGATE_KEYS[name];
+			if (name === "_count") includes.push(...this.counts(table, value));
+			else if (fn) includes.push(...this.relationAggregates(table, fn, value));
+			else includes.push(this.include(table, name, value));
 		}
 		return {
 			columns,
@@ -265,6 +353,28 @@ var IrBuilder = class {
 		};
 	}
 	/**
+	* A selection without includes, shared per table and column list so the
+	* caches keyed on a selection (decoding, rules) hit across calls.
+	*/
+	#columnsOnly(table, select) {
+		let byList = this.#selections.get(table);
+		if (!byList) {
+			byList = /* @__PURE__ */ new Map();
+			this.#selections.set(table, byList);
+		}
+		const key = select === void 0 ? "*" : `:${select.join(",")}`;
+		let selection = byList.get(key);
+		if (!selection) {
+			selection = {
+				columns: select?.map((alias) => this.selectColumn(table, alias)) ?? this.allColumns(table),
+				includes: []
+			};
+			if (byList.size >= SELECTION_CACHE_SIZE) byList.clear();
+			byList.set(key, selection);
+		}
+		return selection;
+	}
+	/**
 	* `db.x.aggregate(args)`: the grouping columns, `_count` and the measures
 	* of each group.
 	*/
@@ -405,12 +515,16 @@ var IrBuilder = class {
 			target,
 			selection: this.selection(target, args["select"], args["include"]),
 			where: this.where(target, args["where"]),
-			orderBy: this.orderBy(target, args["orderBy"]),
+			orderBy: this.orderBy(target, args["orderBy"], "include"),
 			limit: typeof args["limit"] === "number" ? args["limit"] : void 0,
 			required: args["required"] === true
 		};
 	}
-	orderBy(table, input) {
+	/**
+	* Sort terms. On the root table, a to-one relation key sorts by the related
+	* row's columns: `{ organization: { name: "asc" } }`.
+	*/
+	orderBy(table, input, scope = "root") {
 		if (input === void 0) return [];
 		const list = Array.isArray(input) ? input : [input];
 		const terms = [];
@@ -418,27 +532,93 @@ var IrBuilder = class {
 			if (!isPlainObject(item)) invalidRequest(`"orderBy" on "${table.key}" must be an object`, table.key);
 			for (const [name, spec] of Object.entries(item)) {
 				if (spec === void 0) continue;
-				const column = this.column(table, name);
-				if (spec === "asc" || spec === "desc") terms.push({
-					column,
-					direction: spec
+				if (!(name in table.columns) && name in table.relations) {
+					terms.push(...this.relationOrder(table, name, spec, scope));
+					continue;
+				}
+				terms.push(this.sortTerm(table, name, this.column(table, name), spec));
+			}
+		}
+		return terms;
+	}
+	/**
+	* Sort terms for `db.x.aggregate(args)`: `groupBy` columns of `grouped`,
+	* `{ _count: "desc" }` and measures such as `{ _sum: { amount: "desc" } }`.
+	*/
+	aggregateOrderBy(table, input, grouped) {
+		if (input === void 0) return [];
+		const list = Array.isArray(input) ? input : [input];
+		const columns = new Set(grouped.columns.map((entry) => entry.column));
+		const terms = [];
+		for (const item of list) {
+			if (!isPlainObject(item)) invalidRequest(`"orderBy" on "${table.key}" must be an object`, table.key);
+			for (const [name, spec] of Object.entries(item)) {
+				if (spec === void 0) continue;
+				if (Object.hasOwn(table.columns, name) || Object.hasOwn(table.relations, name)) terms.push(...this.groupOrder(table, name, spec, columns));
+				else if (name === "_count") terms.push({
+					...this.sortTerm(table, name, "*", spec),
+					aggregate: "count"
 				});
-				else if (isPlainObject(spec)) {
-					const direction = spec["direction"] === "desc" ? "desc" : "asc";
-					const nulls = spec["nulls"];
-					terms.push(nulls === "first" || nulls === "last" ? {
-						column,
-						direction,
-						nulls
-					} : {
-						column,
-						direction
-					});
-				} else invalidRequest(`Invalid sort for "${name}" on "${table.key}"`, table.key);
+				else terms.push(...this.measureOrder(table, name, spec));
 			}
 		}
 		return terms;
 	}
+	/** A sort on a column, which an aggregate allows only for `groupBy` columns. */
+	groupOrder(table, name, spec, grouped) {
+		const terms = this.orderBy(table, { [name]: spec });
+		const loose = terms.find((term) => term.relation !== void 0 || !grouped.has(term.column));
+		if (loose) invalidRequest(`aggregate on "${table.key}" can only sort by groupBy columns, _count and measures, not "${loose.column}"`, table.key);
+		return terms;
+	}
+	/** `_sum: { amount: "desc" }` in an aggregate's `orderBy`. */
+	measureOrder(table, key, spec) {
+		const fn = Object.hasOwn(AGGREGATE_KEYS, key) ? AGGREGATE_KEYS[key] : void 0;
+		if (fn === void 0) invalidRequest(`Unknown column "${key}" on "${table.key}"`, table.key);
+		if (!isPlainObject(spec)) invalidRequest(`"orderBy.${key}" on "${table.key}" must map columns to a direction`, table.key);
+		const terms = [];
+		for (const [alias, direction] of Object.entries(spec)) {
+			if (direction === void 0) continue;
+			const { column } = this.measure(table, fn, alias, alias);
+			terms.push({
+				...this.sortTerm(table, `${key}.${alias}`, column, direction),
+				aggregate: fn
+			});
+		}
+		return terms;
+	}
+	/** One sort term from `"asc"`, `"desc"` or `{ direction, nulls }`. */
+	sortTerm(table, name, column, spec) {
+		if (spec === "asc" || spec === "desc") return {
+			column,
+			direction: spec
+		};
+		if (!isPlainObject(spec)) invalidRequest(`Invalid sort for "${name}" on "${table.key}"`, table.key);
+		const direction = spec["direction"] === "desc" ? "desc" : "asc";
+		const nulls = spec["nulls"];
+		return nulls === "first" || nulls === "last" ? {
+			column,
+			direction,
+			nulls
+		} : {
+			column,
+			direction
+		};
+	}
+	relationOrder(table, name, spec, scope) {
+		if (scope !== "root") invalidRequest(scope === "include" ? `"orderBy" inside an include can't sort by the relation "${name}"` : `"orderBy" sorts by one level of relations; "${name}" on "${table.key}" is a second`, table.key);
+		const { relation, target } = relationMeta(this.meta, table, name);
+		if (relation.kind !== "one") invalidRequest(`"orderBy" on "${name}" needs a to-one relation; "${name}" on "${table.key}" is to-many`, table.key);
+		if (!isPlainObject(spec)) invalidRequest(`"orderBy.${name}" on "${table.key}" must map columns of "${target.key}" to a direction`, table.key);
+		return this.orderBy(target, spec, "relation").map((term) => ({
+			...term,
+			relation: {
+				name,
+				relation,
+				target
+			}
+		}));
+	}
 	/**
 	* Maps an app-cased row to database column names. Rejects columns the
 	* database won't accept for `mode`: generated columns, `identity always`
@@ -490,7 +670,7 @@ var IrBuilder = class {
 				kind: "column",
 				column: this.column(table, name),
 				op: "eq",
-				value: encodeValue(value)
+				value: encodeValue(keyValue(table, name, value))
 			};
 		}
 		if (!isPlainObject(id)) invalidRequest(`Table "${table.key}" has a composite key; pass { ${pk.join(", ")} }`, table.key);
@@ -500,92 +680,10 @@ var IrBuilder = class {
 				kind: "column",
 				column: this.column(table, name),
 				op: "eq",
-				value: encodeValue(id[name])
+				value: encodeValue(keyValue(table, name, id[name]))
 			}))
 		};
 	}
 };
 //#endregion
-//#region src/ir/simplify.ts
-/**
-* Folds constant conditions. `true` means "no filter", `false` means "matches
-* nothing", so executors can skip the request entirely.
-*/
-function simplify(condition) {
-	if (condition === void 0) return true;
-	switch (condition.kind) {
-		case "and": {
-			const items = [];
-			for (const item of condition.items) {
-				const simple = simplify(item);
-				if (simple === false) return false;
-				if (simple !== true) items.push(simple);
-			}
-			if (items.length === 0) return true;
-			return items.length === 1 && items[0] ? items[0] : {
-				kind: "and",
-				items
-			};
-		}
-		case "or": {
-			const items = [];
-			for (const item of condition.items) {
-				const simple = simplify(item);
-				if (simple === true) return true;
-				if (simple !== false) items.push(simple);
-			}
-			if (items.length === 0) return false;
-			return items.length === 1 && items[0] ? items[0] : {
-				kind: "or",
-				items
-			};
-		}
-		case "not": {
-			const inner = simplify(condition.item);
-			if (typeof inner === "boolean") return !inner;
-			if (inner.kind === "not") return inner.item;
-			return {
-				kind: "not",
-				item: inner
-			};
-		}
-		case "relation": {
-			const where = simplify(condition.where);
-			if (where === true) {
-				if (condition.quantifier === "every") return true;
-				return {
-					...condition,
-					where: void 0
-				};
-			}
-			if (where === false) {
-				if (condition.quantifier === "some") return false;
-				if (condition.quantifier === "none") return true;
-				return {
-					...condition,
-					quantifier: "none",
-					where: void 0
-				};
-			}
-			return {
-				...condition,
-				where
-			};
-		}
-		case "column":
-			if (condition.op === "in" && Array.isArray(condition.value) && condition.value.length === 0) return false;
-			return condition;
-		default: return condition;
-	}
-}
-/** Returns the condition, or `undefined` when it folds to `true`. */
-function simplifyOrFalse(condition) {
-	const simple = simplify(condition);
-	if (simple === false) return { never: true };
-	return {
-		never: false,
-		condition: simple === true ? void 0 : simple
-	};
-}
-//#endregion
-export { invalidRequest as a, escapeLike as i, simplifyOrFalse as n, defineSchema as o, builderFor as r, tableMeta as s, simplify as t };
+export { tableMeta as i, invalidRequest as n, defineSchema as r, builderFor as t };

package/dist/{channel-FQW-CnGR.d.ts → channel-_2Mx1Oyu.d.ts}

@@ -1,5 +1,5 @@
 /// <reference lib="esnext.temporal" />
-//#region src/notifications/types.d.ts
+//#region src/blocks/notifications/types.d.ts
 /** A subject a notification is about, e.g. `{ type: 'task', id: '42' }`. */
 interface NotificationSubject {
   readonly type: string;
@@ -31,7 +31,7 @@ interface RenderedText {
   readonly body?: string;
 }
 //#endregion
-//#region src/notifications/channel.d.ts
+//#region src/blocks/notifications/channel.d.ts
 /** One pending delivery a channel sends: the notification and who gets it. */
 interface NotificationMessage {
   readonly deliveryId: string;

package/dist/channels-CkgQ_X60.js

@@ -0,0 +1,114 @@
+import { i as refreshRealtimeAuth } from "./live-CTAZQkwl.js";
+import { REALTIME_SUBSCRIBE_STATES } from "@supabase/supabase-js";
+//#region src/realtime/channels.ts
+const topicChannels = /* @__PURE__ */ new WeakMap();
+/**
+* One channel per topic and client, shared by every `subscribe()` on it:
+* supabase-js hands back the open channel for a topic, so a second join or
+* an early `removeChannel` would break the first subscription.
+*/
+function joinTopic(client, topic, isPrivate, self, presence, subscriber) {
+	let byTopic = topicChannels.get(client);
+	if (!byTopic) {
+		byTopic = /* @__PURE__ */ new Map();
+		topicChannels.set(client, byTopic);
+	}
+	const topics = byTopic;
+	let shared = topics.get(topic);
+	if (shared && shared.self !== self) throw new TypeError(`better-supabase: "${topic}" is already subscribed with self: ${String(shared.self)}; every subscription on a topic needs the same \`self\``);
+	if (shared && shared.presence !== presence) throw new TypeError(`better-supabase: "${topic}" is already subscribed ${shared.presence ? "with" : "without"} presence; every topic definition for it needs the same \`presence\``);
+	if (!shared) {
+		const channel = client.channel(topic, { config: {
+			private: isPrivate,
+			broadcast: { self }
+		} });
+		const subscribers = /* @__PURE__ */ new Set();
+		const status = (next, error) => {
+			for (const each of subscribers) each.onStatus?.(next, error);
+		};
+		channel.on("broadcast", { event: "*" }, (raw) => {
+			const message = {
+				event: raw.event,
+				payload: raw["payload"],
+				topic
+			};
+			for (const each of subscribers) each.receive(message);
+		});
+		if (presence) channel.on("presence", { event: "sync" }, () => {
+			entry.synced = true;
+			const state = channel.presenceState();
+			for (const each of subscribers) each.sync?.(state);
+		});
+		const evict = () => {
+			if (topics.get(topic) !== entry) return;
+			topics.delete(topic);
+			client.removeChannel(channel);
+		};
+		const ready = (async () => {
+			await (isPrivate ? refreshRealtimeAuth(client) : void 0);
+			if (subscribers.size === 0) return;
+			await new Promise((resolve, reject) => {
+				channel.subscribe((state, error) => {
+					if (topics.get(topic) !== entry) return;
+					switch (state) {
+						case REALTIME_SUBSCRIBE_STATES.SUBSCRIBED:
+							entry.subscribed = true;
+							status("subscribed");
+							resolve();
+							return;
+						case REALTIME_SUBSCRIBE_STATES.CLOSED:
+							entry.subscribed = false;
+							status("closed");
+							resolve();
+							return;
+						case REALTIME_SUBSCRIBE_STATES.CHANNEL_ERROR:
+						case REALTIME_SUBSCRIBE_STATES.TIMED_OUT: {
+							const failure = error ?? /* @__PURE__ */ new Error(`Realtime ${state.toLowerCase()} on ${topic}`);
+							status("error", failure);
+							reject(failure);
+							if (!entry.subscribed) evict();
+							return;
+						}
+						default: reject(/* @__PURE__ */ new Error(`Unknown realtime status ${String(state)}`));
+					}
+				});
+			});
+		})();
+		ready.catch(() => void 0);
+		const entry = {
+			channel,
+			self,
+			presence,
+			subscribers,
+			ready,
+			subscribed: false,
+			synced: false,
+			tracker: void 0
+		};
+		shared = entry;
+		topics.set(topic, entry);
+	}
+	const current = shared;
+	current.subscribers.add(subscriber);
+	subscriber.onStatus?.("joining");
+	if (current.subscribed) subscriber.onStatus?.("subscribed");
+	if (current.synced) subscriber.sync?.(current.channel.presenceState());
+	return {
+		shared: current,
+		leave: async () => {
+			current.subscribers.delete(subscriber);
+			if (current.subscribers.size > 0) {
+				if (current.tracker === subscriber) {
+					current.tracker = void 0;
+					await current.channel.untrack();
+				}
+				return;
+			}
+			if (topics.get(topic) !== current) return;
+			topics.delete(topic);
+			await client.removeChannel(current.channel);
+		}
+	};
+}
+//#endregion
+export { joinTopic as t };