better-supabase 0.2.0 → 0.4.0

package/dist/{sql-DTjA1LPj.js → sql-B34HU2DI.js}

@@ -1,5 +1,7 @@
-import { a as invalidRequest, n as simplifyOrFalse } from "./simplify-bwJpLnaS.js";
+import { a as invalidRequest, n as simplifyOrFalse } from "./simplify-Cqvfr9dj.js";
+import { t as lookupOf } from "./lookup-BaP5bI27.js";
 //#region src/compile/sql.ts
+const MAX_PARAMS = 65535;
 const MAX_PAIRS = 50;
 function quoteIdent(name) {
 	return `"${name.replaceAll("\"", "\"\"")}"`;
@@ -13,7 +15,34 @@ function dbColumn(table, app) {
 	return meta.db;
 }
 function columnType(table, db) {
-	return Object.values(table.columns).find((meta) => meta.db === db)?.type;
+	return lookupOf(table).byDb.get(db)?.[1].type;
+}
+/**
+* `a > x or (a = x and b > y) or ...` as `(a, b) > (x, y)`, which an index
+* on `(a, b)` serves. Both forms give the same result under SQL's
+* three-valued logic, nulls included.
+*/
+function rowComparison(condition) {
+	const steps = [];
+	for (const [index, item] of condition.items.entries()) {
+		const terms = index === 0 ? [item] : item.kind === "and" ? item.items : [];
+		if (terms.length !== index + 1) return null;
+		const step = terms[index];
+		if (step.kind !== "column" || step.op !== "gt" && step.op !== "lt") return null;
+		for (const [at, term] of terms.slice(0, index).entries()) {
+			const prev = steps[at];
+			if (term.kind !== "column" || term.op !== "eq" || term.column !== prev.column || !Object.is(term.value, prev.value)) return null;
+		}
+		steps.push(step);
+	}
+	const op = steps[0]?.op;
+	if (op !== "gt" && op !== "lt") return null;
+	if (steps.length < 2 || steps.some((step) => step.op !== op)) return null;
+	return {
+		columns: steps.map((step) => step.column),
+		op,
+		values: steps.map((step) => step.value)
+	};
 }
 var SqlCompiler = class {
 	params = [];
@@ -35,6 +64,12 @@ var SqlCompiler = class {
 			case "and":
 			case "or": {
 				if (condition.items.length === 0) return condition.kind === "and" ? "true" : "false";
+				const row = condition.kind === "or" ? rowComparison(condition) : null;
+				if (row) {
+					const columns = row.columns.map((name) => this.column(alias, name));
+					const values = row.values.map((value) => this.param(value));
+					return `(${columns.join(", ")}) ${row.op === "gt" ? ">" : "<"} (${values.join(", ")})`;
+				}
 				const joiner = condition.kind === "and" ? " and " : " or ";
 				return `(${condition.items.map((item) => this.condition(item, table, alias)).join(joiner)})`;
 			}
@@ -85,6 +120,7 @@ var SqlCompiler = class {
 		}
 	}
 	join(relation, source, sourceAlias, target, targetAlias) {
+		if (relation.columns.length !== relation.references.length) invalidRequest(`Relation to "${target.key}" has mismatched columns`);
 		return relation.columns.map((column, index) => {
 			const reference = relation.references[index];
 			if (reference === void 0) invalidRequest(`Relation to "${target.key}" has mismatched columns`);
@@ -199,21 +235,20 @@ function compileSql(op) {
 				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);
+			const perChunk = Math.floor(MAX_PARAMS / Math.max(columns.length, 1));
+			if (op.rows.length <= perChunk) return insertPlan(compiler, from, alias, op, columns);
+			const [first, ...rest] = chunk(op.rows, perChunk).map((rows) => {
+				const own = new SqlCompiler();
+				const ownAlias = own.alias();
+				return insertPlan(own, `${tableRef(op.table)} as ${ownAlias}`, ownAlias, {
+					...op,
+					rows
+				}, columns);
+			});
+			return {
+				...first,
+				chunks: rest
+			};
 		}
 		case "update": {
 			const simple = simplifyOrFalse(op.where);
@@ -238,6 +273,28 @@ function compileSql(op) {
 		default: return op;
 	}
 }
+function chunk(items, size) {
+	const out = [];
+	for (let start = 0; start < items.length; start += size) out.push(items.slice(start, start + size));
+	return out;
+}
+function insertPlan(compiler, from, alias, op, columns) {
+	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);
+}
 function mutation(statement, returning, params) {
 	if (returning) return {
 		rows: {

package/dist/ssr/index.d.ts

@@ -1,5 +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-CjHILk2w.js";
-import { n as toSession, t as AuthSession } from "../view-D1s0wa0T.js";
-import { n as MembershipClaim, r as hasEntitlement, t as EntitlementKey } from "../entitlements-Dng-ctuT.js";
-import { n as RefreshOutcome, r as refreshSession, t as RefreshOptions } from "../index-CG69s15v.js";
+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-BAqQcwMW.js";
+import { n as toSession, t as AuthSession } from "../view-B64o81wp.js";
+import { n as MembershipClaim, r as hasEntitlement, t as EntitlementKey } from "../entitlements-Dm-FHpNH.js";
+import { n as RefreshOutcome, r as refreshSession, t as RefreshOptions } from "../refresh-BwYkyNOQ.js";
 export { AUTH_CACHE_HEADERS, type AuthResolution, type AuthResolver, type AuthSession, type AuthState, type CookieOptions, type CookieRecord, type CookieWrite, type EntitlementKey, type MembershipClaim, type RefreshOptions, type RefreshOutcome, type ResolveAuthOptions, type StoredSession, applyCookieWrites, authContext, hasEntitlement, parseCookies, readSession, refreshSession, resolveAuth, serializeCookie, sessionCookieName, toSession, writeSession };

package/dist/ssr/index.js

@@ -1,4 +1,4 @@
 import { t as hasEntitlement } from "../entitlements-CTEBm7IB.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-CpLfJSde.js";
-import { t as toSession } from "../view-aOYizTeE.js";
+import { c as AUTH_CACHE_HEADERS, d as readSession, f as serializeCookie, h as refreshSession, i as authContext, l as applyCookieWrites, m as writeSession, p as sessionCookieName, s as resolveAuth, u as parseCookies } from "../mfa-byfjruR9.js";
+import { t as toSession } from "../view-BrJI2LKp.js";
 export { AUTH_CACHE_HEADERS, applyCookieWrites, authContext, hasEntitlement, parseCookies, readSession, refreshSession, resolveAuth, serializeCookie, sessionCookieName, toSession, writeSession };

package/dist/{standard-FUi3Z3-7.js → standard-BRyBGTtp.js}

@@ -1,5 +1,5 @@
-import { n as dbError } from "./errors-Bl3rkOzo.js";
-import { i as ok, n as err } from "./result-DWXatkd6.js";
+import { n as dbError } from "./errors-L0xK41y_.js";
+import { i as ok, n as err } from "./result-Bj6yt33D.js";
 //#region src/core/standard.ts
 /** Validates with any Standard Schema (zod, valibot, arktype, ...). */
 async function validate(schema, value, label = "value") {

package/dist/{standard-CyhRzctb.d.ts → standard-BsaCYQJc.d.ts}

@@ -1,4 +1,4 @@
-import { o as Result } from "./result-CTkCZ6JA.js";
+import { o as Result } from "./result-CqEsbgYs.js";
 import { StandardSchemaV1 as StandardSchemaV1$1 } from "@standard-schema/spec";
 //#region src/core/standard.d.ts
 /** Validates with any Standard Schema (zod, valibot, arktype, ...). */

package/dist/{stats-C5W-rBfR.js → stats-C_YxA2r1.js}

@@ -1,17 +1,20 @@
-import { c as mapDbError, n as dbError } from "./errors-Bl3rkOzo.js";
-import { a as invalidRequest, n as simplifyOrFalse } from "./simplify-bwJpLnaS.js";
-import { i as ok, n as err, o as toDbError } from "./result-DWXatkd6.js";
+import { c as mapDbError, n as dbError } from "./errors-L0xK41y_.js";
+import { a as invalidRequest, n as simplifyOrFalse } from "./simplify-Cqvfr9dj.js";
+import { i as temporalText } from "./temporal-BwshQk0W.js";
+import { i as ok, n as err, o as toDbError } from "./result-Bj6yt33D.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 === "boolean") return String(value);
+	const temporalValue = temporalText(value);
+	if (temporalValue !== void 0) return temporalValue;
 	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, "\\\"")}"`;
+	return `"${scalar(value).replaceAll("\\", "\\\\").replaceAll("\"", "\\\"")}"`;
 }
 function list(values, open, close) {
 	return `${open}${values.map(quote).join(",")}${close}`;
@@ -220,8 +223,7 @@ var PostgrestCompiler = class {
 				path: `${aliasPath}.${column}`,
 				operator: "is",
 				value: "null"
-			});
-			this.filters.push({
+			}, {
 				kind: "filter",
 				path: `${aliasPath}.${column}`,
 				operator: "not.is",
@@ -274,11 +276,21 @@ function filterEmbed(alias, condition, inner) {
 		children: []
 	};
 }
+const columnTexts = /* @__PURE__ */ new WeakMap();
+/** The rendered column list, cached per (shared, immutable) column array. */
+function columnText(columns) {
+	let text = columnTexts.get(columns);
+	if (text === void 0) {
+		text = columns.map(({ alias, column, cast }) => {
+			const source = cast ? `${column}::${cast}` : column;
+			return alias === column ? source : `${alias}:${source}`;
+		}).join(",");
+		columnTexts.set(columns, text);
+	}
+	return text;
+}
 function columnList(columns) {
-	return columns.map(({ alias, column, cast }) => {
-		const source = cast ? `${column}::${cast}` : column;
-		return alias === column ? source : `${alias}:${source}`;
-	});
+	return columns.length > 0 ? [columnText(columns)] : [];
 }
 /** `key:column.sum()::text`, PostgREST's aggregate syntax (PostgREST 12+). */
 function measureList(measures) {
@@ -297,6 +309,7 @@ function renderEmbeds(embeds) {
 	});
 }
 function renderSelect(selection, embeds) {
+	if (!selection.aggregate && embeds.length === 0) return selection.columns.length > 0 ? columnText(selection.columns) : "*";
 	const parts = [
 		...columnList(selection.columns),
 		...selection.aggregate ? aggregateList(selection.aggregate) : [],
@@ -349,8 +362,21 @@ function compilePostgrest(op) {
 //#region src/core/postgrest-executor.ts
 function scope(client, schema) {
 	const loose = client;
-	return schema !== "public" && loose.schema ? loose.schema(schema) : loose;
+	if (schema === "public" || !loose.schema) return loose;
+	let schemas = scopedClients.get(client);
+	if (!schemas) {
+		schemas = /* @__PURE__ */ new Map();
+		scopedClients.set(client, schemas);
+	}
+	let scoped = schemas.get(schema);
+	if (!scoped) {
+		scoped = loose.schema(schema);
+		schemas.set(schema, scoped);
+	}
+	return scoped;
 }
+/** `schema()` builds a new client on every call; one per client and schema is enough. */
+const scopedClients = /* @__PURE__ */ new WeakMap();
 function fromTable(client, schema, table) {
 	return scope(client, schema).from(table);
 }
@@ -365,7 +391,7 @@ function applyFilters(builder, plan) {
 	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) {
+function applyOrderAndLimits(builder, plan) {
 	let query = builder;
 	for (const order of plan.orders) {
 		const options = { ascending: order.ascending };
@@ -384,7 +410,7 @@ function build(client, op, plan) {
 			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);
+			let query = applyOrderAndLimits(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;

package/dist/storage/index.d.ts

@@ -1,5 +1,6 @@
-import { b as PermdockBucketPolicy } from "../types-C83v5SQz.js";
+import { b as PermdockBucketPolicy } from "../types-DONv9SHN.js";
 import { n as StoragePath, t as PathIn } from "../path-Cv__-OTj.js";
+import { t as PermdockCatalog } from "../permdock-sql-DImJULY-.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-DuP14VHo.js";
-export { ActualBucket, Bucket, BucketClient, BucketConfig, BucketDrift, BucketPolicy, ObjectTarget, type PathIn, type PermdockBucketPolicy, ReplaceOptions, ReplaceResult, Reservation, StorageClient, type StoragePath, StoredObject, SweepOptions, SweepResult, TTL, type TemplateParams, type TemplateValues, TransformOptions, TtlPreset, UploadBody, UploadOptions, UrlOptions, defineBucket, fromStorageError, parseSize };
+import { C as fromStorageError, S as defineBucket, _ as TransformOptions, a as BucketConnectOptions, b as UploadOptions, c as ObjectTarget, d as Reservation, f as StorageClient, g as TTL, h as SweepResult, i as BucketConfig, l as ReplaceOptions, m as SweepOptions, n as Bucket, o as BucketDrift, p as StoredObject, r as BucketClient, s as BucketPolicy, t as ActualBucket, u as ReplaceResult, v as TtlPreset, w as parseSize, x as UrlOptions, y as UploadBody } from "../index-528Ugmyp.js";
+export { type ActualBucket, type Bucket, type BucketClient, type BucketConfig, type BucketConnectOptions, type BucketDrift, type BucketPolicy, type ObjectTarget, type PathIn, type PermdockBucketPolicy, type PermdockCatalog, type ReplaceOptions, type ReplaceResult, type Reservation, type StorageClient, type StoragePath, type StoredObject, type SweepOptions, type SweepResult, TTL, type TemplateParams, type TemplateValues, type TransformOptions, type TtlPreset, type UploadBody, type UploadOptions, type UrlOptions, defineBucket, fromStorageError, parseSize };