better-supabase 0.2.0 → 0.4.0

package/dist/cli/jsonc-BUniUpOk.js

@@ -0,0 +1,2 @@
+import { t as i } from "./jsonc-D5Fu67jw.js";
+export { i as parseJSONC };

package/dist/cli/jsonc-D5Fu67jw.js

@@ -0,0 +1,45 @@
+import { n as o, t as i$2 } from "./_format-Cax5EsM9.js";
+//#region ../../node_modules/.pnpm/confbox@0.3.1/node_modules/confbox/dist/_chunks/libs/strip-json-comments.mjs
+const e = Symbol(`singleComment`);
+const t = Symbol(`multiComment`);
+const n = () => ``;
+const r = (e, t, n) => e.slice(t, n).replace(/[^ \t\r\n]/g, ` `);
+const i$1 = (e, t) => {
+	let n = t - 1, r = 0;
+	for (; e[n] === `\\`;) --n, r += 1;
+	return !!(r % 2);
+};
+function a(a, { whitespace: o = !0, trailingCommas: s = !1 } = {}) {
+	if (typeof a != `string`) throw TypeError(`Expected argument \`jsonString\` to be a \`string\`, got \`${typeof a}\``);
+	let c = o ? r : n, l = !1, u = !1, d = 0, f = ``, p = ``, m = -1;
+	for (let n = 0; n < a.length; n++) {
+		let r = a[n], o = a[n + 1];
+		if (!u && r === `"` && (i$1(a, n) || (l = !l)), !l) {
+			if (!u && r + o === `//`) f += a.slice(d, n), d = n, u = e, n++;
+			else if (u === e && r + o === `\r
+`) {
+				n++, u = !1, f += c(a, d, n), d = n;
+				continue;
+			} else if (u === e && r === `
+`) u = !1, f += c(a, d, n), d = n;
+			else if (!u && r + o === `/*`) {
+				f += a.slice(d, n), d = n, u = t, n++;
+				continue;
+			} else if (u === t && r + o === `*/`) {
+				n++, u = !1, f += c(a, d, n + 1), d = n + 1;
+				continue;
+			} else s && !u && (m === -1 ? r === `,` && (p += f + a.slice(d, n), f = ``, d = n, m = n) : r === `}` || r === `]` ? (f += a.slice(d, n), p += c(f, 0, 1) + f.slice(1), f = ``, d = n, m = -1) : r !== ` ` && r !== `	` && r !== `\r` && r !== `
+` && (f += a.slice(d, n), d = n, m = -1));
+		}
+	}
+	let h = u === e ? c(a, d) : a.slice(d);
+	return p + f + h;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/confbox@0.3.1/node_modules/confbox/dist/jsonc.mjs
+function i(r, i) {
+	let a$1 = JSON.parse(a(i$2(r), { trailingCommas: i?.allowTrailingComma }));
+	return o(r, a$1, i), a$1;
+}
+//#endregion
+export { i as t };

package/dist/cli/keys-ByKHnvP9.js

@@ -0,0 +1,83 @@
+import { r as defineCliCommand } from "./command-CK14fP91.js";
+import { t as display } from "./io-k41_z-jT.js";
+import { dirname, resolve } from "node:path";
+import { existsSync } from "node:fs";
+import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
+//#region src/cli/commands/keys.ts
+const ARGS = {
+	out: {
+		type: "string",
+		description: "Defaults to supabase/signing_keys.json",
+		valueHint: "file"
+	},
+	rotate: {
+		type: "boolean",
+		description: "Put a new key first (it signs) and keep the old ones (they still verify)"
+	},
+	force: {
+		type: "boolean",
+		description: "Replace the file"
+	}
+};
+async function createSigningKey() {
+	const pair = await crypto.subtle.generateKey({
+		name: "ECDSA",
+		namedCurve: "P-256"
+	}, true, ["sign", "verify"]);
+	const jwk = await crypto.subtle.exportKey("jwk", pair.privateKey);
+	return {
+		kty: "EC",
+		kid: crypto.randomUUID(),
+		use: "sig",
+		key_ops: ["sign", "verify"],
+		alg: "ES256",
+		ext: true,
+		crv: jwk.crv,
+		x: jwk.x,
+		y: jwk.y,
+		d: jwk.d
+	};
+}
+async function runKeys(config, args) {
+	const out = args.out ?? "supabase/signing_keys.json";
+	const path = resolve(config.root, out);
+	const rotate = args.rotate === true;
+	const exists = existsSync(path);
+	if (exists && !rotate && args.force !== true) return {
+		code: 1,
+		error: `${display(config.root, out)} exists. Use --rotate to add a key or --force to replace it.`
+	};
+	const previous = exists && rotate ? JSON.parse(await readFile(path, "utf8")) : [];
+	if (!Array.isArray(previous)) return {
+		code: 1,
+		error: `${display(config.root, out)} is not a JSON array of keys.`
+	};
+	const key = await createSigningKey();
+	await mkdir(dirname(path), { recursive: true });
+	await writeFile(path, `${JSON.stringify([key, ...previous], null, 2)}\n`, { mode: 384 });
+	await chmod(path, 384);
+	const lines = [`Wrote ${display(config.root, out)} with key ${key.kid}${previous.length > 0 ? ` (${previous.length} older key${previous.length === 1 ? "" : "s"} kept for verification)` : ""}.`];
+	const toml = resolve(config.root, "supabase/config.toml");
+	if (!(existsSync(toml) && /^\s*signing_keys_path\s*=/m.test(await readFile(toml, "utf8")))) {
+		const relativeToSupabase = out.startsWith("supabase/") ? `./${out.slice(9)}` : out;
+		lines.push("", "Add it to supabase/config.toml and restart the stack:", "  [auth]", `  signing_keys_path = "${relativeToSupabase}"`);
+	}
+	const gitignored = [resolve(config.root, ".gitignore"), resolve(config.root, "supabase/.gitignore")];
+	let ignored = false;
+	for (const file of gitignored) if (existsSync(file) && (await readFile(file, "utf8")).includes("signing_keys")) ignored = true;
+	if (!ignored) lines.push("", `Warning: add ${out} to .gitignore; it holds a private key.`);
+	return {
+		code: 0,
+		output: lines.join("\n")
+	};
+}
+const keysCommand = defineCliCommand({
+	meta: {
+		name: "keys",
+		description: "Creates an ES256 signing key for the local stack, so local tokens verify through JWKS like hosted ones"
+	},
+	args: ARGS,
+	run: (args, { config }) => runKeys(config, args)
+});
+//#endregion
+export { keysCommand };

package/dist/cli/ohash-D7bG_EOb.js

@@ -0,0 +1,277 @@
+import { createHash } from "node:crypto";
+//#region ../../node_modules/.pnpm/c12@4.0.0-rc.2_dotenv@17.4.2_jiti@2.7.0_magicast@0.5.5/node_modules/c12/dist/_chunks/libs/ohash.mjs
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+function serialize(input) {
+	if (typeof input === "string") return `'${input}'`;
+	return new Serializer().serialize(input);
+}
+const asciiOrder = " _-,;:!?.'\"()[]{}@*/\\&#%`^+<=>|~$0123456789abcdefghijklmnopqrstuvwxyz";
+const asciiWeights = /*@__PURE__*/ (function() {
+	const weights = /* @__PURE__ */ new Uint8Array(128);
+	for (let i = 0; i < 69; i++) weights[asciiOrder.charCodeAt(i)] = i + 1;
+	for (let code = 65; code <= 90; code++) weights[code] = weights[code + 32];
+	return weights;
+})();
+function compareStrings(a, b) {
+	if (a === b) return 0;
+	const length = Math.min(a.length, b.length);
+	let tieBreaker = 0;
+	for (let i = 0; i < length; i++) {
+		const codeA = a.charCodeAt(i);
+		const codeB = b.charCodeAt(i);
+		if (codeA === codeB) continue;
+		const weightA = codeA < 128 && asciiWeights[codeA] ? asciiWeights[codeA] : codeA + 128;
+		const weightB = codeB < 128 && asciiWeights[codeB] ? asciiWeights[codeB] : codeB + 128;
+		if (weightA !== weightB) return weightA < weightB ? -1 : 1;
+		if (tieBreaker === 0) tieBreaker = codeA > codeB ? -1 : 1;
+	}
+	if (a.length !== b.length) return a.length < b.length ? -1 : 1;
+	return tieBreaker;
+}
+const Serializer = /*@__PURE__*/ (function() {
+	class Serializer {
+		#context = /* @__PURE__ */ new Map();
+		compare(a, b) {
+			const typeA = typeof a;
+			const typeB = typeof b;
+			if (typeA === "string" && typeB === "string") return compareStrings(a, b);
+			if (typeA === "number" && typeB === "number") return a - b;
+			return compareStrings(this.serialize(a, true), this.serialize(b, true));
+		}
+		serialize(value, noQuotes) {
+			if (value === null) return "null";
+			switch (typeof value) {
+				case "string": return noQuotes ? value : `'${value}'`;
+				case "bigint": return `${value}n`;
+				case "object": return this.$object(value);
+				case "function": return this.$function(value);
+			}
+			return String(value);
+		}
+		serializeObject(object) {
+			const objString = Object.prototype.toString.call(object);
+			if (objString !== "[object Object]") return this.serializeBuiltInType(objString.length < 10 ? `unknown:${objString}` : objString.slice(8, -1), object);
+			const constructor = object.constructor;
+			const objName = constructor === Object || constructor === void 0 ? "" : constructor.name;
+			if (objName !== "" && globalThis[objName] === constructor) return this.serializeBuiltInType(objName, object);
+			if ("toJSON" in object && typeof object.toJSON === "function") {
+				const json = object.toJSON();
+				return objName + (json !== null && typeof json === "object" ? this.$object(json) : `(${this.serialize(json)})`);
+			}
+			const keys = Object.keys(object).sort(compareStrings);
+			let content = `${objName}{`;
+			for (let i = 0; i < keys.length; i++) {
+				const key = keys[i];
+				content += `${key}:${this.serialize(object[key])}`;
+				if (i < keys.length - 1) content += ",";
+			}
+			return content + "}";
+		}
+		serializeBuiltInType(type, object) {
+			const handler = this["$" + type];
+			if (handler) return handler.call(this, object);
+			if (typeof object.entries === "function") return this.serializeObjectEntries(type, object.entries());
+			throw new Error(`Cannot serialize ${type}`);
+		}
+		serializeObjectEntries(type, entries) {
+			const sortedEntries = Array.from(entries).sort((a, b) => this.compare(a[0], b[0]));
+			let content = `${type}{`;
+			for (let i = 0; i < sortedEntries.length; i++) {
+				const [key, value] = sortedEntries[i];
+				content += `${this.serialize(key, true)}:${this.serialize(value)}`;
+				if (i < sortedEntries.length - 1) content += ",";
+			}
+			return content + "}";
+		}
+		$object(object) {
+			let content = this.#context.get(object);
+			if (content === void 0) {
+				this.#context.set(object, `#${this.#context.size}`);
+				content = this.serializeObject(object);
+				this.#context.set(object, content);
+			}
+			return content;
+		}
+		$function(fn) {
+			const fnStr = Function.prototype.toString.call(fn);
+			if (fnStr.slice(-15) === "[native code] }") return `${fn.name || ""}()[native]`;
+			return `${fn.name}(${fn.length})${fnStr.replace(/\s*\n\s*/g, "")}`;
+		}
+		$Array(arr) {
+			let content = "[";
+			for (let i = 0; i < arr.length; i++) {
+				content += this.serialize(arr[i]);
+				if (i < arr.length - 1) content += ",";
+			}
+			return content + "]";
+		}
+		$Date(date) {
+			try {
+				return `Date(${date.toISOString()})`;
+			} catch {
+				return `Date(null)`;
+			}
+		}
+		$ArrayBuffer(arr) {
+			return `ArrayBuffer[${new Uint8Array(arr).join(",")}]`;
+		}
+		$Set(set) {
+			return `Set${this.$Array(Array.from(set).sort((a, b) => this.compare(a, b)))}`;
+		}
+		$Map(map) {
+			return this.serializeObjectEntries("Map", map.entries());
+		}
+	}
+	for (const type of [
+		"Error",
+		"RegExp",
+		"URL"
+	]) Serializer.prototype["$" + type] = function(val) {
+		return `${type}(${val})`;
+	};
+	for (const type of [
+		"Int8Array",
+		"Uint8Array",
+		"Uint8ClampedArray",
+		"Int16Array",
+		"Uint16Array",
+		"Int32Array",
+		"Uint32Array",
+		"Float32Array",
+		"Float64Array"
+	]) Serializer.prototype["$" + type] = function(arr) {
+		return `${type}[${arr.join(",")}]`;
+	};
+	for (const type of ["BigInt64Array", "BigUint64Array"]) Serializer.prototype["$" + type] = function(arr) {
+		return `${type}[${arr.join("n,")}${arr.length > 0 ? "n" : ""}]`;
+	};
+	return Serializer;
+})();
+const fastHash = /*@__PURE__*/ (() => globalThis.process?.getBuiltinModule?.("crypto")?.hash)();
+const algorithm = "sha256";
+const encoding = "base64url";
+function digest(data) {
+	if (fastHash) return fastHash(algorithm, data, encoding);
+	const h = createHash(algorithm).update(data);
+	return globalThis.process?.versions?.webcontainer ? h.digest().toString(encoding) : h.digest(encoding);
+}
+var dist_exports = /* @__PURE__ */ __exportAll({ digest: () => digest });
+var utils_exports = /* @__PURE__ */ __exportAll({ diff: () => diff });
+const PROTO_KEY = "__proto__";
+function diff(obj1, obj2) {
+	const diffs = [];
+	_diff(obj1, obj2, "", diffs);
+	return diffs;
+}
+function _diff(v1, v2, key, out) {
+	if (v1 === v2) return;
+	const leaf1 = v1 === null || typeof v1 !== "object";
+	const leaf2 = v2 === null || typeof v2 !== "object";
+	if (!leaf1 && !leaf2) {
+		const entries1 = _entries(v1);
+		const entries2 = _entries(v2);
+		for (const [k, child1] of entries1) {
+			const childKey = key ? `${key}.${k}` : k;
+			if (entries2.has(k)) _diff(child1, entries2.get(k), childKey, out);
+			else out.push(new DiffEntry(childKey, "removed", void 0, _toHashedObject(child1, childKey)));
+		}
+		for (const [k, child2] of entries2) {
+			if (entries1.has(k)) continue;
+			const childKey = key ? `${key}.${k}` : k;
+			out.push(new DiffEntry(childKey, "added", _toHashedObject(child2, childKey)));
+		}
+		return;
+	}
+	if (_hasKeys(v1, leaf1) || _hasKeys(v2, leaf2)) return;
+	const node1 = _emptyOrLeafNode(v1, key, leaf1);
+	const node2 = _emptyOrLeafNode(v2, key, leaf2);
+	if (node1.hash !== node2.hash) out.push(new DiffEntry(key, "changed", node2, node1));
+}
+function _entries(value) {
+	const entries = /* @__PURE__ */ new Map();
+	for (const key in value) if (key !== PROTO_KEY) entries.set(key, value[key]);
+	return entries;
+}
+function _hasKeys(value, isLeaf) {
+	if (isLeaf) return false;
+	for (const key in value) if (key !== PROTO_KEY) return true;
+	return false;
+}
+function _emptyOrLeafNode(value, key, isLeaf) {
+	return isLeaf ? new DiffHashedObject(key, value, _leafHash(value)) : new DiffHashedObject(key, value, "{}", Object.create(null));
+}
+function _toHashedObject(obj, key = "") {
+	if (obj === null || typeof obj !== "object") return new DiffHashedObject(key, obj, _leafHash(obj));
+	const props = Object.create(null);
+	const hashes = [];
+	for (const _key in obj) {
+		if (_key === PROTO_KEY) continue;
+		const child = _toHashedObject(obj[_key], key ? `${key}.${_key}` : _key);
+		props[_key] = child;
+		hashes.push(child.hash);
+	}
+	return new DiffHashedObject(key, obj, `{${hashes.join(":")}}`, props);
+}
+function _leafHash(value) {
+	switch (typeof value) {
+		case "string": return `'${value}'`;
+		case "number":
+		case "boolean": return "" + value;
+		case "bigint": return `${value}n`;
+		default: return serialize(value);
+	}
+}
+var DiffEntry = class {
+	key;
+	type;
+	newValue;
+	oldValue;
+	constructor(key, type, newValue, oldValue) {
+		this.key = key;
+		this.type = type;
+		this.newValue = newValue;
+		this.oldValue = oldValue;
+	}
+	toString() {
+		return this.toJSON();
+	}
+	toJSON() {
+		switch (this.type) {
+			case "added": return `Added   \`${this.key}\``;
+			case "removed": return `Removed \`${this.key}\``;
+			case "changed": return `Changed \`${this.key}\` from \`${this.oldValue?.toString() || "-"}\` to \`${this.newValue?.toString()}\``;
+		}
+	}
+};
+var DiffHashedObject = class {
+	key;
+	value;
+	hash;
+	props;
+	constructor(key, value, hash, props) {
+		this.key = key;
+		this.value = value;
+		this.hash = hash;
+		this.props = props;
+	}
+	toString() {
+		if (this.props) return `{${Object.keys(this.props).join(",")}}`;
+		else return JSON.stringify(this.value);
+	}
+	toJSON() {
+		const k = this.key || ".";
+		if (this.props) return `${k}({${Object.keys(this.props).join(",")}})`;
+		return `${k}(${this.value})`;
+	}
+};
+//#endregion
+export { dist_exports, utils_exports };

package/dist/cli/openapi-8WHjxiTJ.js

@@ -0,0 +1,66 @@
+import { r as defineCliCommand } from "./command-CK14fP91.js";
+import { r as writeIfChanged, t as display } from "./io-k41_z-jT.js";
+import { r as importExport } from "./config-D9R0o1LH.js";
+import { resolve } from "node:path";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+//#region src/cli/commands/openapi.ts
+const ARGS = {
+	action: {
+		type: "positional",
+		required: false,
+		description: "emit"
+	},
+	check: {
+		type: "boolean",
+		description: "Fail when the file differs from the document"
+	},
+	entry: {
+		type: "string",
+		description: "Defaults to openapi.entry. Exports `openapi` or default: a document or a function returning one",
+		valueHint: "file"
+	},
+	out: {
+		type: "string",
+		description: "Defaults to openapi.output",
+		valueHint: "file"
+	}
+};
+async function runOpenApi(config, args) {
+	const [action] = args._;
+	if (action !== "emit") return {
+		code: 2,
+		error: `${action ? `Unknown openapi action "${action}"` : "Name an action"}. Run \`better-supabase openapi emit\`.`
+	};
+	const entry = args.entry ?? config.openapi.entry;
+	const out = args.out ?? config.openapi.output;
+	const exported = await importExport(resolve(config.root, entry), "openapi");
+	const document = typeof exported === "function" ? await exported() : exported;
+	if (typeof document !== "object" || document === null || !("openapi" in document)) return {
+		code: 1,
+		error: `${display(config.root, entry)} must export an OpenAPI document (createOpenApi(...)) as \`openapi\` or default.`
+	};
+	const contents = `${JSON.stringify(document, null, 2)}\n`;
+	const path = resolve(config.root, out);
+	if (args.check === true) return (existsSync(path) ? await readFile(path, "utf8") : void 0) === contents ? {
+		code: 0,
+		output: `${display(config.root, out)} is up to date.`
+	} : {
+		code: 1,
+		error: `${display(config.root, out)} is out of date. Run \`better-supabase openapi emit\`.`
+	};
+	return {
+		code: 0,
+		output: `${await writeIfChanged(path, contents) ? "Wrote" : "Unchanged"} ${display(config.root, out)}`
+	};
+}
+const openapiCommand = defineCliCommand({
+	meta: {
+		name: "openapi",
+		description: "Writes the document your createOpenApi() module exports, so CI can check it for drift"
+	},
+	args: ARGS,
+	run: (args, { config }) => runOpenApi(config, args)
+});
+//#endregion
+export { openapiCommand };

package/dist/cli/project-B_GeXyHh.js

@@ -0,0 +1,70 @@
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+//#region src/cli/project.ts
+const FRAMEWORK_PACKAGES = [
+	["next", "next"],
+	["hono", "hono"],
+	["orpc", "@orpc/server"],
+	["vite", "vite"],
+	["expo", "expo"],
+	["tanstack-query", "@tanstack/react-query"]
+];
+async function readJson(path) {
+	if (!existsSync(path)) return void 0;
+	const text = await readFile(path, "utf8");
+	try {
+		return JSON.parse(text.replaceAll(/^\s*\/\/.*$/gm, "").replaceAll(/,(\s*[}\]])/g, "$1"));
+	} catch {
+		return;
+	}
+}
+function packageManager(root, declared) {
+	if (typeof declared === "string") {
+		const name = declared.split("@")[0];
+		if (name === "pnpm" || name === "npm" || name === "yarn" || name === "bun") return name;
+	}
+	if (existsSync(join(root, "pnpm-lock.yaml"))) return "pnpm";
+	if (existsSync(join(root, "bun.lock")) || existsSync(join(root, "bun.lockb"))) return "bun";
+	if (existsSync(join(root, "yarn.lock"))) return "yarn";
+	return existsSync(join(root, "package-lock.json")) ? "npm" : "pnpm";
+}
+async function detectProject(root) {
+	const pkg = await readJson(join(root, "package.json")) ?? {};
+	const dependencies = {};
+	for (const field of [
+		"peerDependencies",
+		"devDependencies",
+		"dependencies"
+	]) Object.assign(dependencies, pkg[field] ?? {});
+	const options = (await readJson(join(root, "tsconfig.json")))?.["compilerOptions"] ?? {};
+	return {
+		root,
+		name: typeof pkg["name"] === "string" ? pkg["name"] : void 0,
+		frameworks: FRAMEWORK_PACKAGES.filter(([, name]) => name in dependencies).map(([framework]) => framework),
+		packageManager: packageManager(root, pkg["packageManager"]),
+		dependencies,
+		srcDir: existsSync(join(root, "src")) ? "src" : ".",
+		tsExtensions: options["allowImportingTsExtensions"] === true || options["rewriteRelativeImportExtensions"] === true,
+		hasSupabase: existsSync(join(root, "supabase", "config.toml"))
+	};
+}
+function installCommand(manager, packages, dev = false) {
+	const list = packages.join(" ");
+	switch (manager) {
+		case "pnpm": return `pnpm add ${dev ? "-D " : ""}${list}`;
+		case "bun": return `bun add ${dev ? "-d " : ""}${list}`;
+		case "yarn": return `yarn add ${dev ? "-D " : ""}${list}`;
+		case "npm": return `npm install ${dev ? "-D " : ""}${list}`;
+		default: return manager;
+	}
+}
+/** Env variable prefix the framework exposes to the browser. */
+function publicPrefix(project) {
+	if (project.frameworks.includes("next")) return "NEXT_PUBLIC_";
+	if (project.frameworks.includes("expo")) return "EXPO_PUBLIC_";
+	if (project.frameworks.includes("vite")) return "VITE_";
+	return "";
+}
+//#endregion
+export { installCommand as n, publicPrefix as r, detectProject as t };