better-supabase 0.0.0 → 0.1.0

package/dist/sql-M8l3fnS0.js

@@ -0,0 +1,260 @@
+import { a as invalidRequest, n as simplifyOrFalse } from "./simplify-oHiDKRVQ.js";
+//#region src/compile/sql.ts
+const MAX_PAIRS = 50;
+function quoteIdent(name) {
+	return `"${name.replaceAll("\"", "\"\"")}"`;
+}
+function tableRef(table) {
+	return `${quoteIdent(table.schema)}.${quoteIdent(table.name)}`;
+}
+function dbColumn(table, app) {
+	const meta = table.columns[app];
+	if (!meta) invalidRequest(`Unknown column "${app}" on "${table.key}"`, table.key);
+	return meta.db;
+}
+function columnType(table, db) {
+	return Object.values(table.columns).find((meta) => meta.db === db)?.type;
+}
+var SqlCompiler = class {
+	params = [];
+	#aliases = 0;
+	alias() {
+		const alias = `t${this.#aliases}`;
+		this.#aliases += 1;
+		return alias;
+	}
+	param(value, cast) {
+		this.params.push(value);
+		return cast ? `$${this.params.length}::${cast}` : `$${this.params.length}`;
+	}
+	column(alias, name) {
+		return `${alias}.${quoteIdent(name)}`;
+	}
+	condition(condition, table, alias) {
+		switch (condition.kind) {
+			case "and":
+			case "or": {
+				if (condition.items.length === 0) return condition.kind === "and" ? "true" : "false";
+				const joiner = condition.kind === "and" ? " and " : " or ";
+				return `(${condition.items.map((item) => this.condition(item, table, alias)).join(joiner)})`;
+			}
+			case "not": return `not ${this.condition(condition.item, table, alias)}`;
+			case "column": return this.columnCondition(condition, table, alias);
+			case "relation": {
+				const target = this.alias();
+				const join = this.join(condition.relation, table, alias, condition.target, target);
+				const where = condition.quantifier === "every" && condition.where ? `not ${this.condition(condition.where, condition.target, target)}` : condition.where ? this.condition(condition.where, condition.target, target) : void 0;
+				const body = `select 1 from ${tableRef(condition.target)} as ${target} where ${join}${where ? ` and ${where}` : ""}`;
+				return condition.quantifier === "some" ? `exists (${body})` : `not exists (${body})`;
+			}
+			default: return condition;
+		}
+	}
+	columnCondition(condition, table, alias) {
+		const column = this.column(alias, condition.column);
+		const { value } = condition;
+		switch (condition.op) {
+			case "eq": return `${column} = ${this.param(value)}`;
+			case "neq": return `${column} <> ${this.param(value)}`;
+			case "gt": return `${column} > ${this.param(value)}`;
+			case "gte": return `${column} >= ${this.param(value)}`;
+			case "lt": return `${column} < ${this.param(value)}`;
+			case "lte": return `${column} <= ${this.param(value)}`;
+			case "like": return `${column} like ${this.param(value)}`;
+			case "ilike": return `${column} ilike ${this.param(value)}`;
+			case "in":
+				if (!Array.isArray(value)) invalidRequest("\"in\" needs an array");
+				return `${column} = any(${this.param(value)})`;
+			case "is":
+				if (value === null) return `${column} is null`;
+				if (value === true) return `${column} is true`;
+				if (value === false) return `${column} is false`;
+				return invalidRequest("\"is\" needs null, true or false");
+			case "contains":
+			case "containedBy":
+			case "overlaps": {
+				const operator = condition.op === "contains" ? "@>" : condition.op === "containedBy" ? "<@" : "&&";
+				return Array.isArray(value) ? `${column} ${operator} ${this.param(value)}` : `${column} ${operator} ${this.param(JSON.stringify(value), "jsonb")}`;
+			}
+			case "fts": {
+				const config = condition.config ? `${this.param(condition.config, "regconfig")}, ` : "";
+				const query = `websearch_to_tsquery(${config}${this.param(value)})`;
+				return `${columnType(table, condition.column) === "tsvector" ? column : `to_tsvector(${config}${column})`} @@ ${query}`;
+			}
+			default: return condition.op;
+		}
+	}
+	join(relation, source, sourceAlias, target, targetAlias) {
+		return relation.columns.map((column, index) => {
+			const reference = relation.references[index];
+			if (reference === void 0) invalidRequest(`Relation to "${target.key}" has mismatched columns`);
+			return `${this.column(targetAlias, dbColumn(target, reference))} = ${this.column(sourceAlias, dbColumn(source, column))}`;
+		}).join(" and ");
+	}
+	orderBy(terms, alias) {
+		return terms.map((term) => {
+			const nulls = term.nulls ? ` nulls ${term.nulls}` : "";
+			return `${this.column(alias, term.column)} ${term.direction}${nulls}`;
+		}).join(", ");
+	}
+	/** `json_build_object('alias', t0."col", ...)` for a selection. */
+	rowExpression(selection, table, alias) {
+		const pairs = selection.columns.map((entry) => `'${entry.alias.replaceAll("'", "''")}', ${this.column(alias, entry.column)}${entry.cast ? `::${entry.cast}` : ""}`);
+		if (selection.aggregate) {
+			if (selection.aggregate.count) pairs.push(`'_count', count(*)`);
+			for (const measure of selection.aggregate.measures) pairs.push(`'${measure.key.replaceAll("'", "''")}', ${measure.fn}(${this.column(alias, measure.column)})${measure.cast ? `::${measure.cast}` : ""}`);
+		}
+		for (const include of selection.includes) pairs.push(`'${include.alias.replaceAll("'", "''")}', ${this.include(include, table, alias)}`);
+		if (pairs.length <= MAX_PAIRS) return `json_build_object(${pairs.join(", ")})`;
+		const chunks = [];
+		for (let index = 0; index < pairs.length; index += MAX_PAIRS) chunks.push(`jsonb_build_object(${pairs.slice(index, index + MAX_PAIRS).join(", ")})`);
+		return `(${chunks.join(" || ")})::json`;
+	}
+	/** Conditions an include adds to its parent: `required` includes need a match. */
+	requiredIncludes(selection, table, alias) {
+		return selection.includes.filter((include) => include.required).map((include) => {
+			const target = this.alias();
+			const where = this.includeWhere(include, table, alias, target);
+			return `exists (select 1 from ${tableRef(include.target)} as ${target} where ${where})`;
+		});
+	}
+	includeWhere(include, parent, parentAlias, alias) {
+		const parts = [this.join(include.relation, parent, parentAlias, include.target, alias)];
+		const simple = simplifyOrFalse(include.where);
+		if (simple.never) parts.push("false");
+		else if (simple.condition) parts.push(this.condition(simple.condition, include.target, alias));
+		parts.push(...this.requiredIncludes(include.selection, include.target, alias));
+		return parts.join(" and ");
+	}
+	include(include, parent, parentAlias) {
+		const alias = this.alias();
+		const where = this.includeWhere(include, parent, parentAlias, alias);
+		const from = `from ${tableRef(include.target)} as ${alias} where ${where}`;
+		if (include.count !== void 0) return `(select count(*) ${from})`;
+		const row = this.rowExpression(include.selection, include.target, alias);
+		if (include.selection.aggregate) return `(select ${row} ${from})`;
+		if (include.relation.kind === "one") return `(select ${row} ${from} limit 1)`;
+		const order = include.orderBy.length > 0 ? this.orderBy(include.orderBy, alias) : void 0;
+		const limit = include.limit === void 0 ? "" : ` limit ${integer(include.limit)}`;
+		return `(select coalesce(json_agg(s.r order by s.o), '[]'::json) from (${`select ${row} as r, ${`row_number() over (${order ? `order by ${order}` : ""})`} as o ${from}${order ? ` order by ${order}` : ""}${limit}`}) as s)`;
+	}
+};
+function integer(value) {
+	if (!Number.isInteger(value) || value < 0) invalidRequest(`Expected a non-negative integer, got ${value}`);
+	return value;
+}
+function whereClause(parts) {
+	const present = parts.filter((part) => part !== void 0);
+	return present.length > 0 ? ` where ${present.join(" and ")}` : "";
+}
+function insertColumns(op) {
+	const columns = /* @__PURE__ */ new Set();
+	for (const row of op.rows) for (const key of Object.keys(row)) columns.add(key);
+	return [...columns];
+}
+function returningRows(compiler, op, alias) {
+	return op.returning ? ` returning ${compiler.rowExpression(op.returning, op.table, alias)} as row` : " returning 1";
+}
+/** Compiles an operation to parameterized SQL. Rows come back as json. */
+function compileSql(op) {
+	const compiler = new SqlCompiler();
+	const alias = compiler.alias();
+	const source = op.kind === "select" ? op.source : void 0;
+	const from = source ? `${quoteIdent(source.schema)}.${quoteIdent(source.name)}(${Object.entries(source.args).map(([name, value]) => `${quoteIdent(name)} => ${compiler.param(value)}`).join(", ")}) as ${alias}` : `${tableRef(op.table)} as ${alias}`;
+	switch (op.kind) {
+		case "select": {
+			const simple = simplifyOrFalse(op.where);
+			if (simple.never) return {
+				rows: void 0,
+				count: void 0,
+				never: true
+			};
+			const filter = whereClause([simple.condition ? compiler.condition(simple.condition, op.table, alias) : void 0, ...compiler.requiredIncludes(op.selection, op.table, alias)]);
+			const countText = op.count ? `select count(*)::int as count from ${from}${filter}` : void 0;
+			if (op.head) return {
+				rows: void 0,
+				count: {
+					text: countText ?? `select count(*)::int as count from ${from}${filter}`,
+					params: [...compiler.params]
+				},
+				never: false
+			};
+			const countQuery = countText ? {
+				text: countText,
+				params: [...compiler.params]
+			} : void 0;
+			return {
+				rows: {
+					text: `select ${compiler.rowExpression(op.selection, op.table, alias)} as row from ${from}${filter}${op.selection.aggregate && op.selection.columns.length > 0 ? ` group by ${op.selection.columns.map((entry) => compiler.column(alias, entry.column)).join(", ")}` : ""}${op.orderBy.length > 0 ? ` order by ${compiler.orderBy(op.orderBy, alias)}` : ""}${op.limit === void 0 ? "" : ` limit ${integer(op.limit)}`}${op.offset === void 0 ? "" : ` offset ${integer(op.offset)}`}`,
+					params: compiler.params
+				},
+				count: countQuery,
+				never: false
+			};
+		}
+		case "insert": {
+			if (op.rows.length === 0) return {
+				rows: void 0,
+				count: void 0,
+				never: true
+			};
+			const columns = insertColumns(op);
+			let body;
+			if (columns.length === 0) {
+				if (op.rows.length > 1) invalidRequest("Cannot insert several rows without columns");
+				body = "default values";
+			} else {
+				const values = op.rows.map((row) => `(${columns.map((column) => column in row ? compiler.param(row[column]) : op.defaultToNull ? "null" : "default").join(", ")})`);
+				body = `(${columns.map(quoteIdent).join(", ")}) values ${values.join(", ")}`;
+			}
+			let conflict = "";
+			if (op.onConflict) {
+				const target = `(${op.onConflict.columns.map(quoteIdent).join(", ")})`;
+				const updates = columns.map((column) => `${quoteIdent(column)} = excluded.${quoteIdent(column)}`);
+				conflict = op.onConflict.action === "ignore" || updates.length === 0 ? ` on conflict ${target} do nothing` : ` on conflict ${target} do update set ${updates.join(", ")}`;
+			}
+			return mutation(`insert into ${from} ${body}${conflict}${returningRows(compiler, op, alias)}`, op.returning !== void 0, compiler.params);
+		}
+		case "update": {
+			const simple = simplifyOrFalse(op.where);
+			if (simple.never) return {
+				rows: void 0,
+				count: void 0,
+				never: true
+			};
+			const entries = Object.entries(op.set);
+			if (entries.length === 0) invalidRequest(`Update on "${op.table.key}" sets no columns`);
+			return mutation(`update ${from} set ${entries.map(([column, value]) => `${quoteIdent(column)} = ${compiler.param(value)}`).join(", ")}${whereClause([simple.condition ? compiler.condition(simple.condition, op.table, alias) : void 0])}${returningRows(compiler, op, alias)}`, op.returning !== void 0, compiler.params);
+		}
+		case "delete": {
+			const simple = simplifyOrFalse(op.where);
+			if (simple.never) return {
+				rows: void 0,
+				count: void 0,
+				never: true
+			};
+			return mutation(`delete from ${from}${whereClause([simple.condition ? compiler.condition(simple.condition, op.table, alias) : void 0])}${returningRows(compiler, op, alias)}`, op.returning !== void 0, compiler.params);
+		}
+		default: return op;
+	}
+}
+function mutation(statement, returning, params) {
+	if (returning) return {
+		rows: {
+			text: statement,
+			params
+		},
+		count: void 0,
+		never: false
+	};
+	return {
+		rows: void 0,
+		count: {
+			text: `with m as (${statement}) select count(*)::int as count from m`,
+			params
+		},
+		never: false
+	};
+}
+//#endregion
+export { quoteIdent as n, compileSql as t };

package/dist/ssr/index.d.ts

@@ -0,0 +1,5 @@
+import { _ as readSession, a as ResolveAuthOptions, b as writeSession, d as CookieOptions, f as CookieRecord, g as parseCookies, h as applyCookieWrites, l as resolveAuth, m as StoredSession, n as AuthResolver, p as CookieWrite, r as AuthState, s as authContext, t as AuthResolution, u as AUTH_CACHE_HEADERS, v as serializeCookie, y as sessionCookieName } from "../resolve-DW8h9NPm.js";
+import { n as toSession, t as AuthSession } from "../view-B0ltUmTi.js";
+import { n as hasEntitlement, t as EntitlementKey } from "../entitlements-BBg61DQZ.js";
+import { n as RefreshOutcome, r as refreshSession, t as RefreshOptions } from "../index-cEeweTeM.js";
+export { AUTH_CACHE_HEADERS, type AuthResolution, type AuthResolver, type AuthSession, type AuthState, type CookieOptions, type CookieRecord, type CookieWrite, type EntitlementKey, type RefreshOptions, type RefreshOutcome, type ResolveAuthOptions, type StoredSession, applyCookieWrites, authContext, hasEntitlement, parseCookies, readSession, refreshSession, resolveAuth, serializeCookie, sessionCookieName, toSession, writeSession };

package/dist/ssr/index.js

@@ -0,0 +1,4 @@
+import { t as hasEntitlement } from "../entitlements-BC_khwRy.js";
+import { c as applyCookieWrites, d as serializeCookie, f as sessionCookieName, i as authContext, l as parseCookies, m as refreshSession, o as resolveAuth, p as writeSession, s as AUTH_CACHE_HEADERS, u as readSession } from "../mfa-CpogP66z.js";
+import { t as toSession } from "../view-B6F9QbG-.js";
+export { AUTH_CACHE_HEADERS, applyCookieWrites, authContext, hasEntitlement, parseCookies, readSession, refreshSession, resolveAuth, serializeCookie, sessionCookieName, toSession, writeSession };

package/dist/standard-CyhRzctb.d.ts

@@ -0,0 +1,7 @@
+import { o as Result } from "./result-CTkCZ6JA.js";
+import { StandardSchemaV1 as StandardSchemaV1$1 } from "@standard-schema/spec";
+//#region src/core/standard.d.ts
+/** Validates with any Standard Schema (zod, valibot, arktype, ...). */
+declare function validate<S extends StandardSchemaV1$1>(schema: S, value: unknown, label?: string): Promise<Result<StandardSchemaV1$1.InferOutput<S>>>;
+//#endregion
+export { validate as n, StandardSchemaV1$1 as t };

package/dist/standard-FUi3Z3-7.js

@@ -0,0 +1,21 @@
+import { n as dbError } from "./errors-Bl3rkOzo.js";
+import { i as ok, n as err } from "./result-DWXatkd6.js";
+//#region src/core/standard.ts
+/** Validates with any Standard Schema (zod, valibot, arktype, ...). */
+async function validate(schema, value, label = "value") {
+	let outcome = schema["~standard"].validate(value);
+	if (outcome instanceof Promise) outcome = await outcome;
+	if (outcome.issues) return err(dbError("validation", `Invalid ${label}`, { issues: toIssues(outcome.issues) }));
+	return ok(outcome.value);
+}
+function toIssues(issues) {
+	return issues.map((issue) => {
+		const path = issue.path?.map((segment) => typeof segment === "object" ? segment.key : segment);
+		return path && path.length > 0 ? {
+			message: issue.message,
+			path
+		} : { message: issue.message };
+	});
+}
+//#endregion
+export { validate as t };