better-supabase 0.14.0 → 0.15.1

package/dist/cli/config-group-C8tjut39.js

@@ -0,0 +1,391 @@
+import { a as configObject, c as mask, g as skipSpace, i as closingIndex, l as properties, o as indentAt } from "./config-edit-CrWfk8s3.js";
+import { CONFIG_GROUPS, RENAMED_BLOCK_KEYS, RENAMED_CONFIG_KEYS, groupEntries, hasFlatTables } from "better-supabase/config";
+//#region src/cli/codemod-record-bindings.ts
+/** Blocks whose record section export became `<block>Binding` in 0.15. */
+const BLOCK_BINDINGS = [
+	"comments",
+	"attachments",
+	"tags",
+	"shareLinks",
+	"ledger",
+	"assets",
+	"scores",
+	"moderation",
+	"enrollments",
+	"relations",
+	"versions",
+	"workItemChecklist",
+	"sla",
+	"guests",
+	"passes",
+	"billableTime",
+	"courseLearners",
+	"contracts",
+	"dispatch",
+	"shipments",
+	"leases",
+	"giving"
+];
+/** Section types that became record binding types in 0.15. */
+const BINDING_TYPES = [
+	"Data",
+	"Definition",
+	"Options",
+	"Permissions",
+	"Result",
+	"Write",
+	"WriteInput",
+	"WriteName",
+	"WriteOutput",
+	"Writes"
+];
+/** The 0.14 record section and feature exports, with their 0.15 names. */
+const RECORD_BINDING_RENAMES = {
+	...Object.fromEntries(BLOCK_BINDINGS.map((block) => [`${block}Section`, `${block}Binding`])),
+	...Object.fromEntries(BINDING_TYPES.map((suffix) => [`Section${suffix}`, `RecordBinding${suffix}`])),
+	Section: "RecordBinding",
+	AnySection: "AnyRecordBinding",
+	AnySectionWrite: "AnyRecordBindingWrite",
+	SectionBlocks: "BindingBlocks",
+	SectionCheck: "BindingCheck",
+	SectionName: "BindingName",
+	SectionSource: "BindingSource",
+	SectionWritesOf: "BindingWritesOf",
+	SectionRowInput: "RecordRowInput",
+	LoadedSections: "LoadedBindings",
+	LoadSectionsOptions: "LoadBindingsOptions",
+	PlainSection: "PlainBinding",
+	PlainSections: "PlainBindings",
+	RecordFeature: "RecordType",
+	RecordFeatureSpec: "RecordTypeSpec",
+	FeatureBlocks: "RecordTypeBlocks",
+	FeaturePermissions: "RecordTypePermissions",
+	FeatureWriteInput: "RecordTypeWriteInput",
+	FeatureWriteOutput: "RecordTypeWriteOutput",
+	RecordSectionQueries: "RecordBindingQueries",
+	TestSectionOptions: "TestRecordBindingOptions",
+	countSection: "countBinding",
+	defineRecordFeature: "defineRecordType",
+	defineSection: "defineRecordBinding",
+	findSectionWrite: "findBindingWrite",
+	loadSections: "loadBindings",
+	sectionCan: "bindingCan",
+	sectionEventMatches: "recordEventMatches",
+	sectionRowInput: "recordRowInput",
+	sectionWrite: "recordBindingWrite",
+	timelineSections: "timelineBindings",
+	sectionTag: "bindingTag",
+	invalidateSection: "invalidateBinding",
+	testSection: "testRecordBinding"
+};
+/** `generateFeatures`, flat or under `gen`, renamed to `recordTypes`. */
+function withRecordTypes(source) {
+	return source.replaceAll(/(["']?)\bgenerateFeatures\1(\s*:)/g, "$1recordTypes$1$2");
+}
+//#endregion
+//#region src/cli/sql/config-group.ts
+const GROUP_ORDER = [
+	"database",
+	"auth",
+	"gen",
+	"api",
+	"tooling"
+];
+const GROUP_KEYS = new Set(GROUP_ORDER);
+const GROUP_OF = new Map(Object.entries(CONFIG_GROUPS).flatMap(([group, keys]) => keys.map((key) => [key, group])));
+const ENVIRONMENT_KEY = /^\$(?:development|production|test|ci)$/;
+function applyEdits(source, edits) {
+	let text = source;
+	for (const edit of edits.toSorted((a, b) => b.start - a.start)) text = text.slice(0, edit.start) + edit.text + text.slice(edit.end);
+	return text;
+}
+const isObjectAt = (code, index) => code[index] === "{";
+/** The key token of `prop` renamed, keeping its quotes. */
+function renameAt(source, prop, to) {
+	const quote = source[prop.start];
+	const quoted = quote === "\"" || quote === "'";
+	const length = (prop.key?.length ?? 0) + (quoted ? 2 : 0);
+	if (prop.valueStart === prop.start) return {
+		start: prop.start,
+		end: prop.start + length,
+		text: `${to}: ${prop.key ?? ""}`
+	};
+	return {
+		start: prop.start,
+		end: prop.start + length,
+		text: quoted ? `${quote}${to}${quote}` : to
+	};
+}
+/** Renames the keys of the object at `open` by `pairs` (flat to grouped). */
+function renameIn(source, code, open, pairs) {
+	return (properties(source, code, open) ?? []).flatMap((prop) => {
+		const pair = pairs.find(([, flat]) => flat === prop.key);
+		return pair === void 0 ? [] : [renameAt(source, prop, pair[0])];
+	});
+}
+/** The same renames in every object value of the object at `open`. */
+function renameEach(source, code, open, pairs) {
+	return (properties(source, code, open) ?? []).flatMap((prop) => isObjectAt(code, prop.valueStart) ? renameIn(source, code, prop.valueStart, pairs) : []);
+}
+/** The range to cut for `props[index]`, with its comma and line. */
+function cutRange(source, code, open, props, index, multiline) {
+	const prop = props[index];
+	const previous = props[index - 1];
+	const after = skipSpace(code, prop.valueEnd);
+	const tailFrom = code[after] === "," ? after + 1 : prop.valueEnd;
+	if (!multiline) return {
+		start: prop.start,
+		end: code[after] === "," ? skipSpace(code, tailFrom) : prop.valueEnd,
+		text: source.slice(prop.start, prop.valueEnd)
+	};
+	let before = open + 1;
+	if (previous) before = skipSpace(code, previous.valueEnd) + 1;
+	const newline = source.slice(before, prop.start).indexOf("\n");
+	const start = newline === -1 ? before : before + newline + 1;
+	const lineEnd = source.indexOf("\n", tailFrom);
+	const restIsBlank = lineEnd !== -1 && code.slice(tailFrom, lineEnd).trim() === "";
+	const trailing = restIsBlank ? source.slice(tailFrom, lineEnd).trimEnd() : "";
+	return {
+		start,
+		end: restIsBlank ? lineEnd + 1 : tailFrom,
+		text: `${source.slice(start, prop.valueEnd)},${trailing}`
+	};
+}
+/**
+* Pulls `claims.tenant` and `plugins.tenant.column` out of the root object at
+* `open`: the edits that remove them and the values for `auth.organization`.
+*/
+function organizationEdits(source, code, open, props) {
+	const edits = [];
+	const organization = {};
+	const claims = props.find((prop) => prop.key === "claims");
+	if (claims !== void 0 && isObjectAt(code, claims.valueStart)) {
+		const inner = properties(source, code, claims.valueStart) ?? [];
+		const index = inner.findIndex((prop) => prop.key === "tenant");
+		const tenant = inner[index];
+		if (tenant !== void 0) {
+			organization.claim = source.slice(tenant.valueStart, tenant.valueEnd);
+			const [from, list, at] = inner.length === 1 ? [
+				open,
+				props,
+				props.indexOf(claims)
+			] : [
+				claims.valueStart,
+				inner,
+				index
+			];
+			const cut = cutRange(source, code, from, list, at, code.slice(from, closingIndex(code, from)).includes("\n"));
+			edits.push({
+				start: cut.start,
+				end: cut.end,
+				text: ""
+			});
+		}
+	}
+	const plugins = props.find((prop) => prop.key === "plugins");
+	if (plugins !== void 0 && isObjectAt(code, plugins.valueStart)) {
+		const tenant = (properties(source, code, plugins.valueStart) ?? []).find((prop) => prop.key === "tenant");
+		if (tenant !== void 0 && isObjectAt(code, tenant.valueStart)) {
+			const column = (properties(source, code, tenant.valueStart) ?? []).find((prop) => prop.key === "column");
+			if (column !== void 0) organization.column = source.slice(column.valueStart, column.valueEnd);
+			edits.push({
+				start: tenant.valueStart,
+				end: tenant.valueEnd,
+				text: "true"
+			});
+		}
+	}
+	return {
+		edits,
+		organization
+	};
+}
+/**
+* `text` with its first line at `first` and each later line indented by `by`,
+* except lines inside a string literal, whose text is part of the value.
+*/
+function reindent(text, first, by) {
+	const code = mask(text);
+	const lines = text.split("\n");
+	let offset = 0;
+	let open = false;
+	return lines.map((line, index) => {
+		const inString = open;
+		for (const char of code.slice(offset, offset + line.length)) if (char === "\"" || char === "'" || char === "`") open = !open;
+		offset += line.length + 1;
+		if (index === 0) return first + line.trimStart();
+		return inString || line.trim() === "" ? line : by + line;
+	}).join("\n");
+}
+/**
+* The object literal at `open` with the 0.15 grouping applied, or a reason it
+* can't be: a spread or computed key at the top level.
+*/
+function groupObjectAt(source, open) {
+	const code = mask(source);
+	const props = properties(source, code, open);
+	if (props === void 0) return {
+		ok: false,
+		reason: "the config object could not be read"
+	};
+	const edits = [];
+	for (const prop of props) {
+		const objectValue = isObjectAt(code, prop.valueStart);
+		if (prop.key === "sql" && objectValue) edits.push(...renameIn(source, code, prop.valueStart, [["owner", "scope"]]));
+		else if (prop.key === "blocks" && objectValue) edits.push(...renameEach(source, code, prop.valueStart, RENAMED_BLOCK_KEYS));
+		else if (prop.key === "appTables" && objectValue) edits.push(...renameEach(source, code, prop.valueStart, [["owner", "scope"]]));
+		else if (prop.key === "$env" && objectValue) {
+			for (const env of properties(source, code, prop.valueStart) ?? []) if (isObjectAt(code, env.valueStart)) edits.push(...nestedEdit(source, env));
+		} else if (prop.key !== void 0 && ENVIRONMENT_KEY.test(prop.key) && objectValue) edits.push(...nestedEdit(source, prop));
+	}
+	const { edits: orgEdits, organization } = organizationEdits(source, code, open, props);
+	return regroup(applyEdits(source, [...edits, ...orgEdits]), open, organization);
+}
+/** An environment block's object, grouped, as one edit. */
+function nestedEdit(source, prop) {
+	const code = mask(source);
+	const close = closingIndex(code, prop.valueStart);
+	const inner = source.slice(prop.valueStart, close + 1);
+	const grouped = groupObjectAt(inner, 0);
+	return grouped.ok && grouped.text !== inner ? [{
+		start: prop.valueStart,
+		end: close + 1,
+		text: grouped.text
+	}] : [];
+}
+function regroup(source, open, organization) {
+	const code = mask(source);
+	const props = properties(source, code, open);
+	if (props === void 0) return {
+		ok: false,
+		reason: "the config object could not be read"
+	};
+	if (props.some((prop) => prop.key === void 0)) return {
+		ok: false,
+		reason: "the config object has a spread or a computed key; move its keys into the groups by hand"
+	};
+	const close = closingIndex(code, open);
+	const multiline = code.slice(open, close).includes("\n");
+	const indent = multiline ? indentAt(source, props[0]?.start ?? open) : "";
+	const unit = multiline ? "  " : "";
+	const members = /* @__PURE__ */ new Map();
+	const firstAt = /* @__PURE__ */ new Map();
+	const edits = [];
+	let moved = organization.claim !== void 0 || organization.column !== void 0;
+	const addMember = (group, text, at) => {
+		members.set(group, [...members.get(group) ?? [], text]);
+		if (!firstAt.has(group)) firstAt.set(group, at);
+	};
+	const flatTables = hasFlatTables(props.flatMap((prop) => prop.key ?? []));
+	for (const [index, prop] of props.entries()) {
+		const key = prop.key;
+		const group = key === "tables" && !flatTables ? void 0 : GROUP_OF.get(key);
+		const rename = RENAMED_CONFIG_KEYS.find(([, flat]) => flat === key);
+		const isGroup = GROUP_KEYS.has(key);
+		if (group === void 0 && !isGroup) {
+			if (rename !== void 0) {
+				edits.push(renameAt(source, prop, rename[0]));
+				moved = true;
+			}
+			continue;
+		}
+		const cut = cutRange(source, code, open, props, index, multiline);
+		if (isGroup) {
+			if (!isObjectAt(code, prop.valueStart)) continue;
+			const trimmed = source.slice(prop.valueStart + 1, closingIndex(code, prop.valueStart)).trim().replace(/,$/, "");
+			const first = (properties(source, code, prop.valueStart) ?? [])[0];
+			const own = first === void 0 ? "" : indentAt(source, first.start);
+			if (trimmed !== "") addMember(key, multiline ? `${own}${trimmed},`.split("\n").map((line) => line.startsWith(own) ? indent + unit + line.slice(own.length) : line).join("\n") : `${trimmed},`, cut.start);
+			else if (!firstAt.has(key)) firstAt.set(key, cut.start);
+			edits.push({
+				start: cut.start,
+				end: cut.end,
+				text: ""
+			});
+			continue;
+		}
+		moved = true;
+		addMember(group, multiline ? reindent(cut.text.replace(/\n$/, ""), indent + unit, unit) : cut.text, cut.start);
+		edits.push({
+			start: cut.start,
+			end: cut.end,
+			text: ""
+		});
+	}
+	const org = [organization.claim === void 0 ? "" : `claim: ${organization.claim}`, organization.column === void 0 ? "" : `column: ${organization.column}`].filter((part) => part !== "");
+	if (org.length > 0) {
+		const text = `organization: { ${org.join(", ")} },`;
+		members.set("auth", [multiline ? `${indent}${unit}${text}` : text, ...members.get("auth") ?? []]);
+		if (!firstAt.has("auth")) {
+			const last = props.at(-1);
+			const comma = last && code[skipSpace(code, last.valueEnd)] === ",";
+			if (last !== void 0 && !comma) edits.push({
+				start: last.valueEnd,
+				end: last.valueEnd,
+				text: ","
+			});
+			firstAt.set("auth", multiline ? source.lastIndexOf("\n", close - 1) + 1 : close);
+			if (!multiline && last !== void 0) members.set("auth", [` ${members.get("auth")[0]}`]);
+		}
+	}
+	for (const group of GROUP_ORDER) {
+		const list = members.get(group);
+		const at = firstAt.get(group);
+		if (list === void 0 || at === void 0) continue;
+		const body = multiline ? list.map((text) => text.replace(/,+(\s*(?:\/\/[^\n]*)?)$/, ",$1")).join("\n") : list.map((text) => text.trim().replace(/,$/, "")).join(", ");
+		edits.push({
+			start: at,
+			end: at,
+			text: multiline ? `${indent}${group}: {\n${body}\n${indent}},\n` : `${group}: { ${body} }, `
+		});
+	}
+	if (!moved) return {
+		ok: true,
+		text: source
+	};
+	const text = applyEdits(source, edits);
+	return {
+		ok: true,
+		text: multiline ? text : tidyInline(text, open)
+	};
+}
+/** Removes the `, }` an inline regroup leaves before the object's brace. */
+function tidyInline(text, open) {
+	const close = closingIndex(mask(text), open);
+	if (text.slice(open + 1, close).trim() === "") return `${text.slice(0, open + 1)}${text.slice(close)}`;
+	return text.slice(0, close).replace(/,\s*$/, " ") + text.slice(close);
+}
+/** `better-supabase.config.ts` with the 0.15 grouping applied. */
+function groupConfigSource(original) {
+	const source = withRecordTypes(original);
+	const open = configObject(mask(source));
+	if (open === void 0) return {
+		ok: false,
+		reason: "no defineConfig({...}) or default export object found"
+	};
+	return groupObjectAt(source, open);
+}
+/** {@link groupConfigSource} for a `better-supabase.config.json`. */
+function groupConfigJson(original) {
+	const source = withRecordTypes(original);
+	let config;
+	try {
+		config = JSON.parse(source);
+	} catch {
+		return {
+			ok: false,
+			reason: "it isn't valid JSON"
+		};
+	}
+	if (typeof config !== "object" || config === null || Array.isArray(config)) return {
+		ok: false,
+		reason: "it isn't a JSON object"
+	};
+	const text = `${JSON.stringify(groupEntries(config), null, 2)}\n`;
+	return {
+		ok: true,
+		text: JSON.stringify(JSON.parse(text)) === JSON.stringify(config) ? source : text
+	};
+}
+//#endregion
+export { RECORD_BINDING_RENAMES as a, tidyInline as i, groupConfigJson as n, groupConfigSource as r, cutRange as t };

package/dist/cli/content-mapper-Cdx6arxu.js

@@ -0,0 +1,182 @@
+import { r as readIfExists } from "./io-DH1kcmmP.js";
+import { t as CACHE_DIR } from "./cache-DkplpIGe.js";
+import { x as installedVersion } from "./snapshot-Bzcigm7T.js";
+import { t as i } from "./jsonc-D5Fu67jw.js";
+import { resolve } from "node:path";
+import { createHash } from "node:crypto";
+//#region src/cli/content-mapper.ts
+/** The file extension the content mapper handles. */
+const MAPPER_EXTENSION = ".bsb";
+/** The `contentMappers` entry `init --content-mapper` adds to `tsconfig.json`. */
+const CONTENT_MAPPER_ENTRY = {
+	package: "better-supabase",
+	extensions: [MAPPER_EXTENSION]
+};
+/** The flag `tsc` needs before it runs a content mapper. */
+const RUN_EXTERNAL_CODE = "--runExternalCode";
+/**
+* The file `gen` rewrites when the schema types change in mapper mode. The
+* mapper lists it in `watchedFiles`, so an editor reloads `schema.bsb` after
+* `gen` or `gen --watch` reads a new schema.
+*/
+function schemaStampPath(root, output) {
+	const id = createHash("sha256").update(output).digest("hex").slice(0, 16);
+	return resolve(root, CACHE_DIR, `schema-${id}.stamp`);
+}
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** Whether a parsed tsconfig lists the better-supabase content mapper. */
+function hasContentMapper(tsconfig) {
+	if (!isObject(tsconfig) || !Array.isArray(tsconfig["contentMappers"])) return false;
+	return tsconfig["contentMappers"].some((entry) => isObject(entry) && entry["package"] === CONTENT_MAPPER_ENTRY.package && Array.isArray(entry["extensions"]) && entry["extensions"].includes(MAPPER_EXTENSION));
+}
+/** The indent of the first indented line, or two spaces. */
+function indentOf(text) {
+	return /^([ \t]+)\S/m.exec(text)?.[1] ?? "  ";
+}
+function parseJson(text) {
+	try {
+		return JSON.parse(text);
+	} catch {
+		return;
+	}
+}
+/**
+* Whether a TypeScript version reads `contentMappers`: 7.1 and later, betas
+* included.
+*/
+function supportsContentMappers(version) {
+	const match = /^(\d+)\.(\d+)/.exec(version);
+	if (!match) return false;
+	const major = Number(match[1]);
+	return major > 7 || major === 7 && Number(match[2]) >= 1;
+}
+const TSC = /\btsc\b/;
+/** Whether a script runs `tsc` without the flag a content mapper needs. */
+function needsRunExternalCode(script) {
+	return TSC.test(script) && !script.includes("--runExternalCode");
+}
+async function contentMapperSetup(root) {
+	const [tsconfig, manifest, typescript] = await Promise.all([
+		readIfExists(resolve(root, "tsconfig.json")),
+		readIfExists(resolve(root, "package.json")),
+		installedVersion("typescript", root)
+	]);
+	let parsed;
+	try {
+		parsed = tsconfig === void 0 ? void 0 : i(tsconfig, { allowTrailingComma: true });
+	} catch {
+		parsed = void 0;
+	}
+	const json = manifest === void 0 ? void 0 : parseJson(manifest);
+	const typecheck = (isObject(json) && isObject(json["scripts"]) ? json["scripts"] : {})["typecheck"];
+	return {
+		tsconfig: parsed,
+		typescript,
+		typecheck: typeof typecheck === "string" ? typecheck : void 0
+	};
+}
+/**
+* Adds the content mapper entry to a `tsconfig.json`. A file with comments or
+* trailing commas is left alone (rewriting it would drop them), so the caller
+* prints the entry instead.
+*/
+function addContentMapper(text) {
+	let parsed;
+	try {
+		parsed = i(text, { allowTrailingComma: true });
+	} catch {
+		return {
+			kind: "manual",
+			reason: "it does not parse"
+		};
+	}
+	if (hasContentMapper(parsed)) return { kind: "unchanged" };
+	const json = parseJson(text);
+	if (!isObject(json)) return {
+		kind: "manual",
+		reason: "it holds comments"
+	};
+	const mappers = Array.isArray(json["contentMappers"]) ? json["contentMappers"] : [];
+	return {
+		kind: "edited",
+		contents: `${JSON.stringify({
+			...json,
+			contentMappers: [...mappers, CONTENT_MAPPER_ENTRY]
+		}, null, indentOf(text))}\n`
+	};
+}
+/**
+* Adds `--runExternalCode` to the `typecheck` script of a `package.json` when
+* that script runs `tsc` without it.
+*/
+function addRunExternalCode(text) {
+	const json = parseJson(text);
+	if (!isObject(json)) return {
+		kind: "manual",
+		reason: "it does not parse"
+	};
+	const scripts = isObject(json["scripts"]) ? json["scripts"] : {};
+	const script = scripts["typecheck"];
+	if (typeof script !== "string" || !TSC.test(script)) return {
+		kind: "manual",
+		reason: "it has no typecheck script that runs tsc"
+	};
+	if (script.includes("--runExternalCode")) return { kind: "unchanged" };
+	return {
+		kind: "edited",
+		contents: `${JSON.stringify({
+			...json,
+			scripts: {
+				...scripts,
+				typecheck: script.replace(TSC, `tsc ${RUN_EXTERNAL_CODE}`)
+			}
+		}, null, indentOf(text))}\n`
+	};
+}
+const MISSING = {
+	kind: "manual",
+	reason: "it does not exist"
+};
+/** The snippet a note prints when `init` can't edit `tsconfig.json` itself. */
+const TSCONFIG_SNIPPET = `"contentMappers": [${JSON.stringify(CONTENT_MAPPER_ENTRY)}]`;
+const EDITS = [{
+	path: "tsconfig.json",
+	edit: addContentMapper,
+	note: (reason) => `Add ${TSCONFIG_SNIPPET} to tsconfig.json, next to compilerOptions (init left the file alone: ${reason})`
+}, {
+	path: "package.json",
+	edit: addRunExternalCode,
+	note: (reason) => `Run tsc with ${RUN_EXTERNAL_CODE} (TypeScript 7.1 or later), or it can't load the content mapper (init left package.json alone: ${reason})`
+}];
+/**
+* The `tsconfig.json` and `package.json` edits that turn the content mapper on,
+* and a note for each file it can't edit.
+*/
+async function contentMapperFiles(root) {
+	const files = [];
+	const notes = [];
+	for (const { path, edit, note } of EDITS) {
+		const text = await readIfExists(resolve(root, path));
+		const result = text === void 0 ? MISSING : edit(text);
+		switch (result.kind) {
+			case "unchanged": break;
+			case "edited":
+				files.push({
+					path,
+					contents: result.contents,
+					policy: "edit"
+				});
+				break;
+			case "manual":
+				notes.push(note(result.reason));
+				break;
+			default: throw new Error(`Unhandled edit: ${JSON.stringify(result)}`);
+		}
+	}
+	return {
+		files,
+		notes
+	};
+}
+//#endregion
+export { hasContentMapper as a, supportsContentMappers as c, contentMapperSetup as i, TSCONFIG_SNIPPET as n, needsRunExternalCode as o, contentMapperFiles as r, schemaStampPath as s, RUN_EXTERNAL_CODE as t };