better-supabase 0.0.0 → 0.1.0

package/dist/stats-3iy8u3_P.js

@@ -0,0 +1,566 @@
+import { c as mapDbError, n as dbError } from "./errors-Bl3rkOzo.js";
+import { a as invalidRequest, n as simplifyOrFalse } from "./simplify-oHiDKRVQ.js";
+import { i as ok, n as err, o as toDbError } from "./result-DWXatkd6.js";
+//#region src/compile/postgrest.ts
+function scalar(value) {
+	if (value instanceof Date) return value.toISOString();
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") return String(value);
+	if (value === null) return "null";
+	return JSON.stringify(value);
+}
+/** Double-quotes a value for PostgREST lists and logic trees. */
+function quote(value) {
+	return `"${scalar(value).replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+}
+function list(values, open, close) {
+	return `${open}${values.map(quote).join(",")}${close}`;
+}
+function isBoolLike(value) {
+	return value === null || typeof value === "boolean";
+}
+function operatorAndValue(condition, inLogic) {
+	const { op, value } = condition;
+	const plain = (text) => inLogic ? quote(text) : scalar(text);
+	switch (op) {
+		case "eq":
+		case "neq":
+		case "gt":
+		case "gte":
+		case "lt":
+		case "lte":
+		case "like":
+		case "ilike": return {
+			operator: op,
+			value: plain(value)
+		};
+		case "in":
+			if (!Array.isArray(value)) invalidRequest("\"in\" needs an array");
+			return {
+				operator: "in",
+				value: list(value, "(", ")")
+			};
+		case "is":
+			if (!isBoolLike(value)) invalidRequest("\"is\" needs null, true or false");
+			return {
+				operator: "is",
+				value: String(value)
+			};
+		case "contains":
+		case "containedBy":
+		case "overlaps": {
+			const operator = op === "contains" ? "cs" : op === "containedBy" ? "cd" : "ov";
+			if (Array.isArray(value)) return {
+				operator,
+				value: list(value, "{", "}")
+			};
+			const json = JSON.stringify(value);
+			return {
+				operator,
+				value: inLogic ? quote(json) : json
+			};
+		}
+		case "fts": return {
+			operator: condition.config ? `wfts(${condition.config})` : "wfts",
+			value: plain(value)
+		};
+		default: return op;
+	}
+}
+var PostgrestCompiler = class {
+	filters = [];
+	orders = [];
+	limits = [];
+	#counter = 0;
+	nextAlias() {
+		this.#counter += 1;
+		return `_bs${this.#counter}`;
+	}
+	/** Compiles a condition at `path` where top-level items are ANDed. */
+	andContext(condition, path, embeds) {
+		switch (condition.kind) {
+			case "and":
+				for (const item of condition.items) this.andContext(item, path, embeds);
+				return;
+			case "column": {
+				const { operator, value } = operatorAndValue(condition, false);
+				this.filters.push({
+					kind: "filter",
+					path: path ? `${path}.${condition.column}` : condition.column,
+					operator,
+					value
+				});
+				return;
+			}
+			case "not": {
+				const inner = condition.item;
+				if (inner.kind === "column") {
+					const { operator, value } = operatorAndValue(inner, false);
+					this.filters.push({
+						kind: "filter",
+						path: path ? `${path}.${inner.column}` : inner.column,
+						operator: `not.${operator}`,
+						value
+					});
+					return;
+				}
+				if (inner.kind === "relation") {
+					this.relationAnd(negateRelation(inner), path, embeds);
+					return;
+				}
+				if (inner.kind === "not") {
+					this.andContext(inner.item, path, embeds);
+					return;
+				}
+				this.filters.push({
+					kind: "or",
+					expression: this.logic(condition, embeds),
+					referencedTable: path
+				});
+				return;
+			}
+			case "or":
+				this.filters.push({
+					kind: "or",
+					expression: this.logic(condition, embeds).replace(/^or\(/, "").replace(/\)$/, ""),
+					referencedTable: path
+				});
+				return;
+			case "relation":
+				this.relationAnd(condition, path, embeds);
+				return;
+			default: return condition;
+		}
+	}
+	relationAnd(condition, path, embeds) {
+		if (condition.quantifier === "every" && !condition.where) return;
+		const alias = this.nextAlias();
+		const aliasPath = path ? `${path}.${alias}` : alias;
+		const node = filterEmbed(alias, condition, condition.quantifier === "some");
+		this.withPath(node.children, aliasPath);
+		embeds.push(node);
+		const where = condition.quantifier === "every" && condition.where ? {
+			kind: "not",
+			item: condition.where
+		} : condition.where;
+		if (where) this.andContext(where, aliasPath, node.children);
+		if (condition.quantifier !== "some") this.filters.push({
+			kind: "filter",
+			path: aliasPath,
+			operator: "is",
+			value: "null"
+		});
+	}
+	/** Compiles a condition into a PostgREST logic-tree term. */
+	logic(condition, embeds) {
+		switch (condition.kind) {
+			case "and":
+			case "or": return `${condition.kind}(${condition.items.map((item) => this.logic(item, embeds)).join(",")})`;
+			case "not": {
+				const inner = condition.item;
+				if (inner.kind === "column") {
+					const { operator, value } = operatorAndValue(inner, true);
+					return `${inner.column}.not.${operator}.${value}`;
+				}
+				if (inner.kind === "relation") return this.logic(negateRelation(inner), embeds);
+				if (inner.kind === "not") return this.logic(inner.item, embeds);
+				return `not.${this.logic(inner, embeds)}`;
+			}
+			case "column": {
+				const { operator, value } = operatorAndValue(condition, true);
+				return `${condition.column}.${operator}.${value}`;
+			}
+			case "relation": {
+				if (condition.quantifier === "every" && !condition.where) invalidRequest("every({}) must be simplified before compiling");
+				const alias = this.nextAlias();
+				const node = filterEmbed(alias, condition, false);
+				const nodePath = this.pathOf(alias, embeds);
+				this.withPath(node.children, nodePath);
+				embeds.push(node);
+				const where = condition.quantifier === "every" && condition.where ? {
+					kind: "not",
+					item: condition.where
+				} : condition.where;
+				if (where) this.andContext(where, nodePath, node.children);
+				return condition.quantifier === "some" ? `${alias}.not.is.null` : `${alias}.is.null`;
+			}
+			default: return condition;
+		}
+	}
+	#paths = /* @__PURE__ */ new WeakMap();
+	withPath(embeds, path) {
+		this.#paths.set(embeds, path);
+		return embeds;
+	}
+	pathOf(alias, embeds) {
+		const parent = this.#paths.get(embeds);
+		return parent ? `${parent}.${alias}` : alias;
+	}
+	include(include, path, embeds) {
+		const aliasPath = path ? `${path}.${include.alias}` : include.alias;
+		const node = {
+			alias: include.alias,
+			target: include.target,
+			relation: include.relation,
+			inner: include.required,
+			columns: include.selection.columns,
+			children: this.withPath([], aliasPath),
+			...include.count === void 0 ? {} : { count: true },
+			...include.selection.aggregate ? { measures: include.selection.aggregate.measures } : {}
+		};
+		embeds.push(node);
+		for (const child of include.selection.includes) this.include(child, aliasPath, node.children);
+		const where = simplifyOrFalse(include.where);
+		if (where.never) {
+			const [first] = include.target.primaryKey;
+			const column = first ? include.target.columns[first]?.db : void 0;
+			if (!column) invalidRequest(`Cannot filter "${include.alias}" to nothing`);
+			this.filters.push({
+				kind: "filter",
+				path: `${aliasPath}.${column}`,
+				operator: "is",
+				value: "null"
+			});
+			this.filters.push({
+				kind: "filter",
+				path: `${aliasPath}.${column}`,
+				operator: "not.is",
+				value: "null"
+			});
+		} else if (where.condition) this.andContext(where.condition, aliasPath, node.children);
+		for (const term of include.orderBy) this.order(term, aliasPath);
+		if (include.limit !== void 0) this.limits.push({
+			count: include.limit,
+			referencedTable: aliasPath
+		});
+	}
+	order(term, referencedTable) {
+		this.orders.push({
+			column: term.column,
+			ascending: term.direction === "asc",
+			nullsFirst: term.nulls === void 0 ? void 0 : term.nulls === "first",
+			referencedTable
+		});
+	}
+};
+function negateRelation(condition) {
+	switch (condition.quantifier) {
+		case "some": return {
+			...condition,
+			quantifier: "none"
+		};
+		case "none": return {
+			...condition,
+			quantifier: "some"
+		};
+		case "every": return {
+			...condition,
+			quantifier: "some",
+			where: condition.where ? {
+				kind: "not",
+				item: condition.where
+			} : void 0
+		};
+		default: return condition.quantifier;
+	}
+}
+function filterEmbed(alias, condition, inner) {
+	return {
+		alias,
+		target: condition.target,
+		relation: condition.relation,
+		inner,
+		columns: [],
+		children: []
+	};
+}
+function columnList(columns) {
+	return columns.map(({ alias, column, cast }) => {
+		const source = cast ? `${column}::${cast}` : column;
+		return alias === column ? source : `${alias}:${source}`;
+	});
+}
+/** `key:column.sum()::text`, PostgREST's aggregate syntax (PostgREST 12+). */
+function measureList(measures) {
+	return measures.map(({ key, column, fn, cast }) => `${key}:${column}.${fn}()${cast ? `::${cast}` : ""}`);
+}
+function aggregateList(aggregate) {
+	return [...aggregate.count ? ["_count:count()"] : [], ...measureList(aggregate.measures)];
+}
+function renderEmbeds(embeds) {
+	return embeds.map((node) => {
+		const hint = `${node.target.name}!${node.relation.foreignKey}${node.inner ? "!inner" : ""}`;
+		if (node.count) return `${node.alias}:${hint}(count)`;
+		if (node.measures) return `${node.alias}:${hint}(${measureList(node.measures).join(",")})`;
+		const inside = [...columnList(node.columns), ...renderEmbeds(node.children)];
+		return `${node.alias}:${hint}(${inside.join(",")})`;
+	});
+}
+function renderSelect(selection, embeds) {
+	const parts = [
+		...columnList(selection.columns),
+		...selection.aggregate ? aggregateList(selection.aggregate) : [],
+		...renderEmbeds(embeds)
+	];
+	return parts.length > 0 ? parts.join(",") : "*";
+}
+function applyWhere(compiler, condition, embeds) {
+	const where = simplifyOrFalse(condition);
+	if (where.never) return false;
+	if (where.condition) compiler.andContext(where.condition, void 0, embeds);
+	return true;
+}
+/** Compiles an operation into a PostgREST plan. */
+function compilePostgrest(op) {
+	const compiler = new PostgrestCompiler();
+	const embeds = compiler.withPath([], void 0);
+	const selection = op.kind === "select" ? op.selection : op.kind === "insert" ? op.returning : op.returning;
+	if (selection) for (const include of selection.includes) compiler.include(include, void 0, embeds);
+	let matches = true;
+	if (op.kind === "select" || op.kind === "update" || op.kind === "delete") {
+		const before = embeds.length;
+		matches = applyWhere(compiler, op.where, embeds);
+		if (op.kind !== "select" && embeds.length > before) invalidRequest(`Relation filters are not supported in ${op.kind} on PostgREST; filter by key instead`, op.table.key);
+	}
+	let range;
+	if (op.kind === "select") {
+		for (const term of op.orderBy) compiler.order(term, void 0);
+		if (op.offset !== void 0) {
+			const from = op.offset;
+			range = {
+				from,
+				to: op.limit === void 0 ? Number.MAX_SAFE_INTEGER : from + op.limit - 1
+			};
+		} else if (op.limit !== void 0) compiler.limits.push({
+			count: op.limit,
+			referencedTable: void 0
+		});
+	}
+	return {
+		select: selection ? renderSelect(selection, embeds) : void 0,
+		filters: compiler.filters,
+		orders: compiler.orders,
+		limits: compiler.limits,
+		range,
+		never: !matches
+	};
+}
+//#endregion
+//#region src/core/postgrest-executor.ts
+function scope(client, schema) {
+	const loose = client;
+	return schema !== "public" && loose.schema ? loose.schema(schema) : loose;
+}
+function fromTable(client, schema, table) {
+	return scope(client, schema).from(table);
+}
+/** A POST to the function: arguments such as query vectors are too long for a URL. */
+function fromFunction(client, source, options) {
+	const scoped = scope(client, source.schema);
+	if (!scoped.rpc) throw new TypeError(`better-supabase: the client has no rpc(), needed to read from ${source.name}`);
+	return scoped.rpc(source.name, source.args, options);
+}
+function applyFilters(builder, plan) {
+	let query = builder;
+	for (const filter of plan.filters) query = filter.kind === "filter" ? query.filter(filter.path, filter.operator, filter.value) : query.or(filter.expression, filter.referencedTable ? { referencedTable: filter.referencedTable } : {});
+	return query;
+}
+function applyShape(builder, plan) {
+	let query = builder;
+	for (const order of plan.orders) {
+		const options = { ascending: order.ascending };
+		if (order.nullsFirst !== void 0) options.nullsFirst = order.nullsFirst;
+		if (order.referencedTable) options.referencedTable = order.referencedTable;
+		query = query.order(order.column, options);
+	}
+	for (const limit of plan.limits) query = query.limit(limit.count, limit.referencedTable ? { referencedTable: limit.referencedTable } : {});
+	if (plan.range) query = query.range(plan.range.from, plan.range.to);
+	return query;
+}
+function build(client, op, plan) {
+	const base = fromTable(client, op.table.schema, op.table.name);
+	switch (op.kind) {
+		case "select": {
+			const options = {};
+			if (op.count) options.count = op.count;
+			if (op.head) options.head = true;
+			let query = applyShape(applyFilters(op.source ? fromFunction(client, op.source, options).select(plan.select) : base.select(plan.select, options), plan), plan);
+			if (op.single === "one") query = query.single();
+			if (op.single === "maybe") query = query.maybeSingle();
+			return query;
+		}
+		case "insert": {
+			const rows = op.rows.length === 1 ? op.rows[0] : op.rows;
+			const count = plan.select === void 0 ? { count: "exact" } : {};
+			let query = op.onConflict ? base.upsert(rows, {
+				onConflict: op.onConflict.columns.join(","),
+				ignoreDuplicates: op.onConflict.action === "ignore",
+				defaultToNull: op.defaultToNull,
+				...count
+			}) : base.insert(rows, {
+				defaultToNull: op.defaultToNull,
+				...count
+			});
+			if (plan.select !== void 0) query = query.select(plan.select);
+			return query;
+		}
+		case "update": {
+			const count = plan.select === void 0 ? { count: "exact" } : {};
+			let query = applyFilters(base.update(op.set, count), plan);
+			if (plan.select !== void 0) query = query.select(plan.select);
+			return query;
+		}
+		case "delete": {
+			const count = plan.select === void 0 ? { count: "exact" } : {};
+			let query = applyFilters(base.delete(count), plan);
+			if (plan.select !== void 0) query = query.select(plan.select);
+			return query;
+		}
+		default: return op;
+	}
+}
+function rowsOf(data) {
+	if (data === null || data === void 0) return [];
+	if (Array.isArray(data)) return data;
+	return [data];
+}
+/** Executes IR operations through a supabase-js client. */
+const aborted = () => dbError("aborted", "The request was aborted");
+function postgrestExecutor(client) {
+	return {
+		name: "postgrest",
+		functionSources: true,
+		async execute(op, context) {
+			let plan;
+			try {
+				plan = compilePostgrest(op);
+			} catch (cause) {
+				return err(toDbError(cause));
+			}
+			if (plan.never) return ok({
+				rows: [],
+				count: 0
+			});
+			if (context.signal?.aborted) return err(aborted());
+			let query = build(client, op, plan);
+			if (context.signal) query = query.abortSignal(context.signal);
+			const response = await query;
+			if (response.error) {
+				if (context.signal?.aborted) return err(aborted());
+				return err(mapDbError(response.error, context.errorMappers));
+			}
+			return ok({
+				rows: rowsOf(response.data),
+				count: response.count ?? null
+			});
+		},
+		async rpc(name, args, context) {
+			const scoped = scope(client, context.schema);
+			if (!scoped.rpc) return err(toDbError(/* @__PURE__ */ new Error("The client does not support rpc()")));
+			if (context.signal?.aborted) return err(aborted());
+			let query = context.get ? scoped.rpc(name, queryArgs(args), { get: true }) : scoped.rpc(name, args);
+			if (context.signal) query = query.abortSignal(context.signal);
+			const response = await query;
+			if (response.error) {
+				if (context.signal?.aborted) return err(aborted());
+				return err(mapDbError(response.error, context.errorMappers));
+			}
+			return ok(response.data);
+		}
+	};
+}
+/**
+* GET arguments travel in the query string, where supabase-js would print an
+* object as `[object Object]`; json and jsonb parameters take it as JSON.
+*/
+function queryArgs(args) {
+	return Object.fromEntries(Object.entries(args).map(([key, value]) => [key, typeof value === "object" && value !== null && !Array.isArray(value) ? JSON.stringify(value) : value]));
+}
+/** The compiled plan for an operation; useful for debugging and tests. */
+function explainPostgrest(op) {
+	return compilePostgrest(op);
+}
+//#endregion
+//#region src/core/stats.ts
+const EMPTY_STATS = {
+	calls: 0,
+	waves: 0,
+	tables: [],
+	ms: 0
+};
+/**
+* Counts calls and waves. A recorder with a `parent` also reports to it, so
+* a request-wide recorder sees every scope's calls.
+*/
+var StatsRecorder = class {
+	#parent;
+	#now;
+	#tables = /* @__PURE__ */ new Set();
+	#calls = 0;
+	#waves = 0;
+	#inFlight = 0;
+	#first;
+	#last;
+	constructor(parent, now = () => performance.now()) {
+		this.#parent = parent;
+		this.#now = now;
+	}
+	/** Records a call to `table`; the returned function ends it. */
+	begin(table) {
+		const end = this.#parent?.begin(table);
+		const started = this.#now();
+		if (this.#inFlight === 0) this.#waves += 1;
+		this.#inFlight += 1;
+		this.#calls += 1;
+		this.#tables.add(table);
+		this.#first ??= started;
+		let ended = false;
+		return () => {
+			if (ended) return;
+			ended = true;
+			this.#inFlight -= 1;
+			this.#last = Math.max(this.#last ?? 0, this.#now());
+			end?.();
+		};
+	}
+	/** The totals so far. */
+	snapshot() {
+		return {
+			calls: this.#calls,
+			waves: this.#waves,
+			tables: [...this.#tables],
+			ms: this.#first === void 0 || this.#last === void 0 ? 0 : Math.round((this.#last - this.#first) * 100) / 100
+		};
+	}
+};
+/** Wraps an executor so every call is recorded. */
+function recordStats(executor, recorder) {
+	const wrapped = {
+		name: executor.name,
+		async execute(op, context) {
+			const end = recorder.begin(op.table.key);
+			try {
+				return await executor.execute(op, context);
+			} finally {
+				end();
+			}
+		}
+	};
+	if (executor.rpc) {
+		const rpc = executor.rpc.bind(executor);
+		return {
+			...wrapped,
+			async rpc(name, args, context) {
+				const end = recorder.begin(`${name}()`);
+				try {
+					return await rpc(name, args, context);
+				} finally {
+					end();
+				}
+			}
+		};
+	}
+	return wrapped;
+}
+//#endregion
+export { postgrestExecutor as a, explainPostgrest as i, StatsRecorder as n, compilePostgrest as o, recordStats as r, EMPTY_STATS as t };

package/dist/storage/index.d.ts

@@ -0,0 +1,4 @@
+import { n as StoragePath, t as PathIn } from "../path-Cv__-OTj.js";
+import { n as TemplateValues, t as TemplateParams } from "../template-mbvlysOo.js";
+import { C as parseSize, S as fromStorageError, _ as TtlPreset, a as BucketDrift, b as UrlOptions, c as ReplaceOptions, d as StorageClient, f as StoredObject, g as TransformOptions, h as TTL, i as BucketConfig, l as ReplaceResult, m as SweepResult, n as Bucket, o as BucketPolicy, p as SweepOptions, r as BucketClient, s as ObjectTarget, t as ActualBucket, u as Reservation, v as UploadBody, x as defineBucket, y as UploadOptions } from "../index-Nxo3TJcm.js";
+export { ActualBucket, Bucket, BucketClient, BucketConfig, BucketDrift, BucketPolicy, ObjectTarget, type PathIn, ReplaceOptions, ReplaceResult, Reservation, StorageClient, type StoragePath, StoredObject, SweepOptions, SweepResult, TTL, type TemplateParams, type TemplateValues, TransformOptions, TtlPreset, UploadBody, UploadOptions, UrlOptions, defineBucket, fromStorageError, parseSize };

package/dist/storage/index.js

@@ -0,0 +1,2 @@
+import { i as parseSize, n as defineBucket, r as fromStorageError, t as TTL } from "../storage-BWXVUXGk.js";
+export { TTL, defineBucket, fromStorageError, parseSize };