better-supabase 0.7.1 → 0.9.0

package/dist/cli/init-BHuEQrQK.js

@@ -1,765 +0,0 @@
-import { a as list, r as defineCliCommand } from "./command-CK14fP91.js";
-import { i as writeIfChanged, t as display } from "./io-DI1mTdSA.js";
-import { t as VERSION } from "./version-59gcepIG.js";
-import { a as loadConfig, r as findConfig } from "./config-NiPxAmUF.js";
-import { a as findSupabaseRoot, p as tomlGet, r as diffEngine, t as PGDELTA_TABLE, u as readSupabaseToml } from "./supabase-toml-B-bIukQF.js";
-import { t as TYPEGEN_VERSION } from "./typegen-version-DeFbtzYI.js";
-import { n as installCommand, t as detectProject } from "./project-DZRaBaY7.js";
-import { join, posix, resolve } from "node:path";
-import { existsSync } from "node:fs";
-import { glob, readFile } from "node:fs/promises";
-//#region src/cli/templates.ts
-const INTEGRATIONS = [
-	"next",
-	"hono",
-	"orpc",
-	"edge",
-	"expo",
-	"mcp",
-	"client",
-	"react"
-];
-const join$1 = (...parts) => posix.normalize(posix.join(...parts));
-const libDir = (context) => join$1(context.srcDir, "lib");
-/** `lib/supabase/`: the shared definition, `server.ts` and `client.ts`. */
-const supabaseDir = (context) => join$1(libDir(context), "supabase");
-/** `lib/supabase/index.ts`, imported as `lib/supabase` on both sides. */
-const libEntry = (context) => join$1(supabaseDir(context), "index.ts");
-/** Import path of `lib/supabase/index.ts`: the folder, unless the project keeps `.ts` extensions. */
-function importLib(context, from) {
-	const path = importFrom(context, from, libEntry(context));
-	return context.tsExtensions ? path : path.replace(/^(\.\.?\/.+)\/index$/, "$1");
-}
-/** Relative import from one project file to another, following the project's extension style. */
-function importFrom(context, from, to, keepTs = context.tsExtensions) {
-	let path = posix.relative(posix.dirname(from), to);
-	if (!path.startsWith(".")) path = `./${path}`;
-	return keepTs ? path : path.replace(/\.tsx?$/, "");
-}
-function publicEnv(context) {
-	const read = (prefix, access) => access === "vite" ? {
-		url: `import.meta.env.${prefix}SUPABASE_URL`,
-		key: `import.meta.env.${prefix}SUPABASE_PUBLISHABLE_KEY`
-	} : {
-		url: `process.env.${prefix}SUPABASE_URL!`,
-		key: `process.env.${prefix}SUPABASE_PUBLISHABLE_KEY!`
-	};
-	if (context.frameworks.includes("next")) return read("NEXT_PUBLIC_", "process");
-	if (context.frameworks.includes("expo")) return read("EXPO_PUBLIC_", "process");
-	if (context.frameworks.includes("vite")) return read("VITE_", "vite");
-	return read("", "process");
-}
-const denoJson = (context) => `${JSON.stringify({ imports: {
-	"better-supabase": `npm:better-supabase@^${context.version}`,
-	"better-supabase/": `npm:/better-supabase@^${context.version}/`,
-	"@supabase/supabase-js": "npm:@supabase/supabase-js@^2",
-	zod: "npm:zod@^4"
-} }, null, 2)}\n`;
-const SHARED = "supabase/functions/_shared/supabase.ts";
-function shared(context) {
-	return {
-		path: SHARED,
-		contents: `import { defineSupabase } from 'better-supabase';
-
-import { schema } from '${importFrom(context, SHARED, context.generated, true)}';
-
-export const betterSupabase = defineSupabase(schema);
-`
-	};
-}
-/** `supabase/functions/<name>/server.ts`: the function's `bs`. */
-function functionServer(name, contents) {
-	return {
-		path: `supabase/functions/${name}/server.ts`,
-		contents: contents("../_shared/supabase.ts")
-	};
-}
-/** Edge Functions import `_shared/supabase.ts`, so they don't need the app definition. */
-const needsLib = (names) => names.length === 0 || names.some((name) => name !== "edge" && name !== "mcp");
-/** The files `init` writes: the config and, unless `lib` is false, the isomorphic definition. */
-function baseFiles(context, casing, lib = true) {
-	const config = {
-		path: "better-supabase.config.ts",
-		contents: `import { defineConfig } from 'better-supabase/config';
-
-export default defineConfig({
-  casing: '${casing}',
-  output: '${context.generated}',
-});
-`
-	};
-	if (!lib) return [config];
-	const path = libEntry(context);
-	const generated = importFrom(context, path, context.generated);
-	const expo = context.frameworks.includes("expo");
-	return [config, {
-		path,
-		contents: `import { defineSupabase } from 'better-supabase';
-${expo ? "import { Temporal } from 'temporal-polyfill';\n" : ""}
-import { schema } from '${generated}';
-
-export type { Functions, Models } from '${generated}';
-
-export const betterSupabase = defineSupabase(schema${expo ? ", { temporal: Temporal }" : ""});
-`
-	}];
-}
-const TEMPLATES = {
-	client: {
-		description: "Browser client with cookie sessions shared with the server",
-		requires: [],
-		packages: ["@supabase/ssr"],
-		files: (context) => {
-			const path = join$1(supabaseDir(context), "client.ts");
-			const env = publicEnv(context);
-			return [{
-				path,
-				contents: `import { createClient } from 'better-supabase/client';
-
-import { betterSupabase } from '${importLib(context, path)}';
-
-export const bs = createClient(betterSupabase, {
-  env: {
-    url: ${env.url},
-    publishableKey: ${env.key},
-  },
-});
-`
-			}];
-		}
-	},
-	next: {
-		description: "Next.js proxy, Server Components, route handlers and actions",
-		requires: ["client"],
-		packages: [
-			"@supabase/ssr",
-			"@supabase/server",
-			"server-only"
-		],
-		files: (context) => {
-			const server = join$1(supabaseDir(context), "server.ts");
-			const proxy = join$1(context.srcDir, "proxy.ts");
-			return [{
-				path: server,
-				contents: `import 'server-only';
-
-import { createNext } from 'better-supabase/next';
-
-import { betterSupabase } from '${importLib(context, server)}';
-
-export const bs = createNext(betterSupabase);
-`
-			}, {
-				path: proxy,
-				contents: `import type { NextRequest } from 'next/server';
-
-import { bs } from '${importFrom(context, proxy, server)}';
-
-export const proxy = (request: NextRequest) => bs.proxy(request);
-
-export const config = {
-  matcher: ['/((?!_next/static|_next/image|favicon.ico|.*\\\\.(?:svg|png|jpg|webp)$).*)'],
-};
-`
-			}];
-		},
-		next: ["Read the session in Server Components with `const { db } = await bs.context()`."]
-	},
-	react: {
-		description: "React provider and typed hooks with TanStack Query",
-		requires: ["client"],
-		packages: ["@tanstack/react-query"],
-		files: (context) => {
-			const client = join$1(supabaseDir(context), "client.ts");
-			const providers = context.frameworks.includes("next") ? join$1(context.srcDir, "app", "providers.tsx") : join$1(context.srcDir, "providers.tsx");
-			const hooks = join$1(libDir(context), "hooks.ts");
-			return [{
-				path: providers,
-				contents: `${context.frameworks.includes("next") ? "'use client';\n\n" : ""}import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
-import { BetterSupabaseProvider } from 'better-supabase/react';
-import { type ReactNode, useState } from 'react';
-
-import { bs } from '${importFrom(context, providers, client)}';
-
-export function Providers({ children }: { children: ReactNode }) {
-  const [queryClient] = useState(() => new QueryClient());
-  return (
-    <QueryClientProvider client={queryClient}>
-      <BetterSupabaseProvider client={bs} queryClient={queryClient}>
-        {children}
-      </BetterSupabaseProvider>
-    </QueryClientProvider>
-  );
-}
-`
-			}, {
-				path: hooks,
-				contents: `import { createHooks } from 'better-supabase/react';
-
-import type { bs } from '${importFrom(context, hooks, client)}';
-
-export const { useDb, useQueries, useAuth, useSupabase } = createHooks<typeof bs>();
-`
-			}];
-		},
-		next: ["Wrap your app in <Providers>."]
-	},
-	hono: {
-		description: "Hono middleware, handlers and REST resources",
-		requires: [],
-		packages: ["hono", "@supabase/server"],
-		files: (context) => {
-			const path = join$1(context.srcDir, "server.ts");
-			return [{
-				path,
-				contents: `import { Hono } from 'hono';
-import { type HonoEnv, createHono } from 'better-supabase/hono';
-
-import { betterSupabase, type Functions, type Models } from '${importLib(context, path)}';
-
-export const bs = createHono(betterSupabase);
-
-const app = new Hono<HonoEnv<Models, Functions, unknown>>()
-  .onError(bs.onError)
-  .use('/api/*', bs.middleware())
-  .get('/api/me', (c) => c.json({ kind: c.var.auth.kind }));
-
-export default app;
-`
-			}];
-		}
-	},
-	orpc: {
-		description: "oRPC middleware with typed context and ORPCError mapping",
-		requires: [],
-		packages: ["@orpc/server", "@supabase/server"],
-		files: (context) => {
-			const path = join$1(context.srcDir, "router.ts");
-			return [{
-				path,
-				contents: `import { os } from '@orpc/server';
-import { createOrpc, type OrpcRequestContext } from 'better-supabase/orpc';
-
-import { betterSupabase } from '${importLib(context, path)}';
-
-export const bs = createOrpc(betterSupabase);
-
-const base = os.$context<OrpcRequestContext>();
-const authed = base.use(bs.middleware());
-
-export const router = {
-  me: authed.handler(({ context }) => ({ kind: context.auth.kind })),
-};
-`
-			}];
-		}
-	},
-	edge: {
-		description: "A Supabase Edge Function with CORS and Problem Details",
-		requires: [],
-		packages: [],
-		files: (context) => [
-			shared(context),
-			functionServer("api", (shared) => `import { createEdge } from 'better-supabase/edge';
-
-import { betterSupabase } from '${shared}';
-
-export const bs = createEdge(betterSupabase, { cors: true });
-`),
-			{
-				path: "supabase/functions/api/index.ts",
-				contents: `import { bs } from './server.ts';
-
-Deno.serve(bs.handler((_request, { auth }) => ({ kind: auth.kind })));
-`
-			},
-			{
-				path: "supabase/functions/api/deno.json",
-				contents: denoJson(context)
-			}
-		],
-		next: ["Serve it locally with `supabase functions serve api`."]
-	},
-	expo: {
-		description: "Expo Router server loaders, API routes and middleware, and a native client",
-		requires: ["client"],
-		packages: [
-			"expo-server",
-			"expo-secure-store",
-			"@supabase/supabase-js",
-			"temporal-polyfill"
-		],
-		files: (context) => {
-			const server = join$1(supabaseDir(context), "expo.ts");
-			const native = join$1(supabaseDir(context), "client.native.ts");
-			const middleware = join$1(context.srcDir, "app", "+middleware.ts");
-			const env = publicEnv(context);
-			return [
-				{
-					path: server,
-					contents: `import { createExpo } from 'better-supabase/expo';
-
-import { betterSupabase } from '${importLib(context, server)}';
-
-export const bs = createExpo(betterSupabase);
-`
-				},
-				{
-					path: native,
-					contents: `import { createClient as createSupabaseClient } from '@supabase/supabase-js';
-import { autoRefreshOnForeground, createNativeClient, secureStorage } from 'better-supabase/client/native';
-import * as SecureStore from 'expo-secure-store';
-import { AppState } from 'react-native';
-
-import { betterSupabase } from '${importLib(context, native)}';
-
-const supabase = createSupabaseClient(${env.url}, ${env.key}, {
-  auth: {
-    storage: secureStorage(SecureStore),
-    autoRefreshToken: true,
-    persistSession: true,
-    detectSessionInUrl: false,
-  },
-});
-
-autoRefreshOnForeground(supabase, AppState);
-
-export const bs = createNativeClient(betterSupabase, supabase);
-`
-				},
-				{
-					path: middleware,
-					contents: `import { bs } from '${importFrom(context, middleware, server)}';
-
-export default bs.middleware();
-`
-				}
-			];
-		},
-		next: ["Load data as the caller with `export const loader = bs.loader((ctx) => ctx.db.customers.findMany())`.", "Metro picks `client.native.ts` on iOS and Android and `client.ts` (cookie sessions) on the web."]
-	},
-	mcp: {
-		description: "An MCP server (Streamable HTTP) as an Edge Function",
-		requires: [],
-		packages: [],
-		files: (context) => [
-			shared(context),
-			functionServer("mcp", (shared) => `import { createMcp } from 'better-supabase/mcp';
-
-import { betterSupabase } from '${shared}';
-
-export const bs = createMcp(betterSupabase, {
-  name: 'app',
-  version: '0.1.0',
-  resources: {},
-});
-`),
-			{
-				path: "supabase/functions/mcp/index.ts",
-				contents: `import { bs } from './server.ts';
-
-Deno.serve(bs.fetch);
-`
-			},
-			{
-				path: "supabase/functions/mcp/deno.json",
-				contents: denoJson(context)
-			}
-		],
-		next: ["List tables under `resources` to expose them as tools, e.g. `customers: true`.", "Add `[functions.mcp] verify_jwt = false` and `[auth.oauth_server] enabled = true` to `supabase/config.toml`, so MCP clients get the sign-in challenge."]
-	}
-};
-/** The integration and what it requires, dependencies first, without duplicates. */
-function resolveIntegrations(names) {
-	const ordered = [];
-	const visit = (name) => {
-		if (ordered.includes(name)) return;
-		for (const dependency of TEMPLATES[name].requires) visit(dependency);
-		ordered.push(name);
-	};
-	for (const name of names) visit(name);
-	return ordered;
-}
-function isIntegration(name) {
-	return INTEGRATIONS.includes(name);
-}
-/** Integrations `init` adds for the frameworks it finds. */
-function suggestedIntegrations(frameworks) {
-	const names = [];
-	for (const framework of frameworks) switch (framework) {
-		case "next":
-			names.push("next");
-			break;
-		case "hono":
-			names.push("hono");
-			break;
-		case "orpc":
-			names.push("orpc");
-			break;
-		case "vite":
-			names.push("client");
-			break;
-		case "expo":
-			names.push("expo");
-			break;
-		case "tanstack-query":
-			names.push("react");
-			break;
-		default: throw new TypeError(`Unknown framework ${String(framework)}`);
-	}
-	return resolveIntegrations(names);
-}
-//#endregion
-//#region src/cli/workspace.ts
-const unquote = (value) => value.replace(/\s+#.*$/, "").trim().replace(/^(["'])(.*)\1$/, "$2");
-/** The `packages` globs of `pnpm-workspace.yaml`, in block or flow style. */
-function pnpmWorkspacePatterns(text) {
-	const lines = text.split(/\r?\n/);
-	const start = lines.findIndex((line) => /^packages\s*:/.test(line));
-	if (start === -1) return [];
-	const inline = /^packages\s*:\s*\[(.*)\]\s*(?:#.*)?$/.exec(lines[start]);
-	if (inline) return inline[1].split(",").map(unquote).filter((entry) => entry !== "");
-	const patterns = [];
-	for (const line of lines.slice(start + 1)) {
-		if (/^\s*(?:#.*)?$/.test(line)) continue;
-		const item = /^\s+-\s*(.+)$/.exec(line);
-		if (!item) break;
-		patterns.push(unquote(item[1]));
-	}
-	return patterns.filter((entry) => entry !== "");
-}
-function packageJsonPatterns(workspaces) {
-	let list = workspaces;
-	if (typeof workspaces === "object" && workspaces !== null && "packages" in workspaces) list = workspaces.packages;
-	return Array.isArray(list) ? list.filter((entry) => typeof entry === "string") : [];
-}
-async function matches(root, pattern) {
-	const dirs = [];
-	const base = pattern.replace(/^\.\//, "").replace(/\/$/, "");
-	for await (const path of glob(`${base}/package.json`, {
-		cwd: root,
-		exclude: (name) => name === "node_modules"
-	})) dirs.push(posix.dirname(path.replaceAll("\\", "/")));
-	return dirs;
-}
-/**
-* The workspace declared at `root` by `pnpm-workspace.yaml` or the
-* `workspaces` field of `package.json`, with its packages in path order.
-* `undefined` when `root` declares none.
-*/
-async function detectWorkspace(root) {
-	let file;
-	let patterns;
-	const yaml = join(root, "pnpm-workspace.yaml");
-	if (existsSync(yaml)) {
-		file = "pnpm-workspace.yaml";
-		patterns = pnpmWorkspacePatterns(await readFile(yaml, "utf8"));
-	} else {
-		const path = join(root, "package.json");
-		if (!existsSync(path)) return void 0;
-		let pkg;
-		try {
-			pkg = JSON.parse(await readFile(path, "utf8"));
-		} catch {
-			return;
-		}
-		if (typeof pkg !== "object" || pkg === null || !("workspaces" in pkg)) return void 0;
-		file = "package.json";
-		patterns = packageJsonPatterns(pkg.workspaces);
-		if (patterns.length === 0) return void 0;
-	}
-	const included = /* @__PURE__ */ new Set();
-	const excluded = /* @__PURE__ */ new Set();
-	for (const pattern of patterns) {
-		const negated = pattern.startsWith("!");
-		for (const dir of await matches(root, negated ? pattern.slice(1) : pattern)) (negated ? excluded : included).add(dir);
-	}
-	const dirs = [...included].filter((dir) => dir !== "." && !excluded.has(dir)).sort();
-	const packages = await Promise.all(dirs.map(async (dir) => ({
-		dir,
-		project: await detectProject(join(root, dir))
-	})));
-	return {
-		file,
-		packages
-	};
-}
-/** The package `init` suggests: one that uses better-supabase, then one with a framework. */
-function suggestedPackage(workspace) {
-	const packages = workspace.packages;
-	return (packages.find((entry) => "better-supabase" in entry.project.dependencies) ?? packages.find((entry) => entry.project.frameworks.length > 0) ?? packages[0])?.dir;
-}
-//#endregion
-//#region src/cli/commands/init.ts
-const INIT_ARGS = {
-	casing: {
-		type: "string",
-		description: "Row keys in camelCase (camel, the default) or the database's snake_case (snake)",
-		valueHint: "camel|snake"
-	},
-	with: {
-		type: "string",
-		description: "Integrations to add next to the detected ones: next, hono, orpc, edge, expo, mcp, client, react",
-		valueHint: "integration,..."
-	},
-	package: {
-		type: "string",
-		description: "Workspace package to write to, relative to --cwd",
-		valueHint: "dir"
-	},
-	force: {
-		type: "boolean",
-		description: "Overwrite files that exist"
-	},
-	"dry-run": {
-		type: "boolean",
-		description: "Show what would be written"
-	}
-};
-const ADD_ARGS = {
-	integration: {
-		type: "positional",
-		required: false,
-		description: "next, hono, orpc, edge, expo, mcp, client or react"
-	},
-	force: {
-		type: "boolean",
-		description: "Overwrite files that exist"
-	},
-	"dry-run": {
-		type: "boolean",
-		description: "Show what would be written"
-	}
-};
-const CANCELLED = {
-	code: 1,
-	error: "Cancelled."
-};
-/** `--force`, or the person's answer when files exist; `undefined` when they cancel. */
-async function overwrite(root, files, args, prompts, base = root) {
-	if (args.force === true) return true;
-	const existing = [...new Set(files.map((file) => file.path).filter((path) => existsSync(resolve(root, path))))];
-	if (!prompts || existing.length === 0) return false;
-	return prompts.confirm(`${existing.map((path) => display(base, resolve(root, path))).join(", ")} ${existing.length === 1 ? "exists" : "exist"}. Overwrite?`);
-}
-async function writeFiles(root, files, args, force, base = root) {
-	const dryRun = args["dry-run"] === true;
-	const lines = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const file of files) {
-		if (seen.has(file.path)) continue;
-		seen.add(file.path);
-		const path = resolve(root, file.path);
-		const shown = display(base, path);
-		if (existsSync(path) && !force) {
-			lines.push(`Kept    ${shown} (exists)`);
-			continue;
-		}
-		if (dryRun) {
-			lines.push(`Would write ${shown}`);
-			continue;
-		}
-		lines.push(`${await writeIfChanged(path, file.contents) ? "Wrote  " : "Same   "} ${shown}`);
-	}
-	return lines;
-}
-/**
-* Adds `[experimental.pgdelta] enabled = true` to `supabase/config.toml`
-* when it has no such table, so `supabase db schema declarative sync`
-* runs on pg-delta. A table set to `enabled = false` is left alone.
-*/
-async function enablePgDelta(root, args, base) {
-	const supabaseRoot = findSupabaseRoot(root);
-	const toml = await readSupabaseToml(root);
-	if (supabaseRoot === void 0 || toml === void 0) return [];
-	const path = join(supabaseRoot, "supabase/config.toml");
-	const shown = display(base, path);
-	if (diffEngine(toml) === "pg-delta") return [];
-	if (tomlGet(toml.document, ["experimental", "pgdelta"]) !== void 0 || toml.text.includes("pgdelta")) return [`Kept    ${shown} (pg-delta is off; set [experimental.pgdelta] enabled = true, remove [db.migrations] schema_paths and use \`supabase db schema declarative sync\` instead of \`supabase db diff\`)`];
-	if (args["dry-run"] === true) return [`Would enable pg-delta in ${shown}`];
-	const separator = toml.text === "" || toml.text.endsWith("\n\n") ? "" : toml.text.endsWith("\n") ? "\n" : "\n\n";
-	await writeIfChanged(path, `${toml.text}${separator}${PGDELTA_TABLE}`);
-	return [`Enabled pg-delta in ${shown}`];
-}
-function context(project, generated) {
-	return {
-		srcDir: project.srcDir,
-		generated,
-		tsExtensions: project.tsExtensions,
-		frameworks: project.frameworks,
-		version: VERSION
-	};
-}
-function integrationFiles(names, templateContext) {
-	return names.flatMap((name) => TEMPLATES[name].files(templateContext));
-}
-function packagesFor(project, names) {
-	const wanted = [
-		"better-supabase",
-		"@supabase/supabase-js",
-		...names.flatMap((name) => TEMPLATES[name].packages)
-	];
-	return [...new Set(wanted)].filter((name) => !(name in project.dependencies));
-}
-/** pg and the pinned postgrest-typegen as dev dependencies, the ones the project lacks. */
-function devPackages(project) {
-	const missing = [..."pg" in project.dependencies ? [] : ["pg"], ..."@supabase/postgrest-typegen" in project.dependencies ? [] : [`@supabase/postgrest-typegen@${TYPEGEN_VERSION}`]];
-	return missing.length === 0 ? [] : [missing];
-}
-function chooseIntegrations(prompts, initial) {
-	return prompts.multiselect("Integrations", INTEGRATIONS.map((name) => ({
-		value: name,
-		label: name,
-		hint: TEMPLATES[name].description
-	})), initial);
-}
-function parseIntegrations(values) {
-	const unknown = values.filter((value) => !isIntegration(value));
-	if (unknown.length > 0) return `Unknown integration ${unknown.join(", ")}. Available: ${INTEGRATIONS.join(", ")}`;
-	return values.filter(isIntegration);
-}
-/** Where `init` writes: `--cwd`, `--package`, or the workspace package the person picks. */
-async function initTarget(cwd, args, prompts) {
-	if (args.package !== void 0) {
-		const dir = posix.normalize(args.package.replaceAll("\\", "/"));
-		if (!existsSync(join(cwd, dir, "package.json"))) return {
-			code: 2,
-			error: `--package ${args.package} has no package.json. Pass the directory of a workspace package, relative to --cwd.`
-		};
-		return { dir: dir.replace(/\/$/, "") || "." };
-	}
-	const workspace = await detectWorkspace(cwd);
-	if (!workspace || workspace.packages.length === 0) return { dir: "." };
-	const suggested = suggestedPackage(workspace) ?? ".";
-	if (!prompts) return {
-		code: 2,
-		error: `${workspace.file} makes this a workspace root. Pass --package with the package that owns the runtime (${workspace.packages.map((entry) => entry.dir).join(", ")}), or --package . to write here.`
-	};
-	const dir = await prompts.select("Package that owns the runtime", [...workspace.packages.map((entry) => ({
-		value: entry.dir,
-		label: entry.dir,
-		...entry.project.name ? { hint: entry.project.name } : {}
-	})), {
-		value: ".",
-		label: ".",
-		hint: "the workspace root"
-	}], suggested);
-	return dir === void 0 ? CANCELLED : { dir };
-}
-async function runInit(config, args, prompts) {
-	const casing = args.casing ?? (prompts ? await prompts.select("Row keys", [{
-		value: "camel",
-		label: "camelCase",
-		hint: "customerId"
-	}, {
-		value: "snake",
-		label: "snake_case",
-		hint: "customer_id, as in the database"
-	}], "camel") : "camel");
-	if (casing === void 0) return CANCELLED;
-	if (casing !== "camel" && casing !== "snake") return {
-		code: 2,
-		error: "--casing must be \"camel\" or \"snake\""
-	};
-	const target = await initTarget(config.root, args, prompts);
-	if ("code" in target) return target;
-	const root = resolve(config.root, target.dir);
-	const inPackage = target.dir !== ".";
-	const workspaceProject = await detectProject(config.root);
-	const project = inPackage ? {
-		...await detectProject(root),
-		packageManager: workspaceProject.packageManager
-	} : workspaceProject;
-	const installTarget = inPackage ? {
-		dir: target.dir,
-		name: project.name
-	} : void 0;
-	const requested = parseIntegrations(list(args.with));
-	if (typeof requested === "string") return {
-		code: 2,
-		error: requested
-	};
-	const detected = resolveIntegrations([...suggestedIntegrations(project.frameworks), ...requested]);
-	const chosen = args.with === void 0 && prompts ? await chooseIntegrations(prompts, detected) : detected;
-	if (chosen === void 0) return CANCELLED;
-	const integrations = resolveIntegrations(chosen);
-	const hasConfig = findConfig(root) !== void 0;
-	let generated = posix.normalize(posix.join(project.srcDir, "lib/supabase/generated.ts"));
-	if (hasConfig) generated = inPackage ? (await loadConfig(root)).output : config.output;
-	const templateContext = context(project, generated);
-	const files = [...baseFiles(templateContext, casing, needsLib(integrations)), ...integrationFiles(integrations, templateContext)];
-	const force = await overwrite(root, files, args, prompts, config.root);
-	if (force === void 0) return CANCELLED;
-	const where = inPackage ? ` in ${target.dir}` : "";
-	const lines = [
-		project.frameworks.length > 0 ? `Found ${project.frameworks.join(", ")}${where}.` : `No framework found${where}.`,
-		"",
-		...await writeFiles(root, files, args, force, config.root),
-		...await enablePgDelta(root, args, config.root)
-	];
-	const packages = packagesFor(project, integrations);
-	const cwdFlag = inPackage ? ` --cwd ${target.dir}` : "";
-	const steps = [
-		...packages.length > 0 ? [installCommand(project.packageManager, packages, false, installTarget)] : [],
-		...devPackages(project).map((names) => installCommand(project.packageManager, names, true, installTarget)),
-		...project.hasSupabase || workspaceProject.hasSupabase ? [] : ["supabase init"],
-		"supabase start",
-		`better-supabase env${cwdFlag}`,
-		`better-supabase gen${cwdFlag}`
-	];
-	lines.push("", "Next:", ...steps.map((step, index) => `  ${index + 1}. ${step}`));
-	for (const name of integrations) for (const hint of TEMPLATES[name].next ?? []) lines.push(`  - ${hint}`);
-	lines.push("", "Agent skills: better-supabase skills install");
-	return {
-		code: 0,
-		output: lines.join("\n")
-	};
-}
-async function runAdd(config, args, prompts) {
-	const named = args._.length === 0 && prompts ? await chooseIntegrations(prompts, []) : args._;
-	if (named === void 0) return CANCELLED;
-	if (named.length === 0) return {
-		code: 2,
-		error: `Name at least one integration: ${INTEGRATIONS.join(", ")}`
-	};
-	const requested = parseIntegrations(named);
-	if (typeof requested === "string") return {
-		code: 2,
-		error: requested
-	};
-	const project = await detectProject(config.root);
-	const integrations = resolveIntegrations(requested);
-	const templateContext = context(project, config.output);
-	const files = integrationFiles(integrations, templateContext);
-	const force = await overwrite(config.root, files, args, prompts);
-	if (force === void 0) return CANCELLED;
-	const lines = await writeFiles(config.root, files, args, force);
-	const lib = libEntry(templateContext);
-	if (!existsSync(resolve(config.root, lib)) && integrations.some((name) => needsLib([name]))) lines.push("", `Warning: ${lib} is missing. Run \`better-supabase init\` first.`);
-	const packages = packagesFor(project, integrations).filter((name) => name !== "better-supabase" && name !== "@supabase/supabase-js");
-	if (packages.length > 0) lines.push("", `Install: ${installCommand(project.packageManager, packages)}`);
-	for (const name of integrations) for (const hint of TEMPLATES[name].next ?? []) lines.push(`- ${hint}`);
-	return {
-		code: 0,
-		output: lines.join("\n")
-	};
-}
-const initCommand = defineCliCommand({
-	meta: {
-		name: "init",
-		description: "Writes better-supabase.config.ts, src/lib/supabase/index.ts and glue for the frameworks in package.json"
-	},
-	args: INIT_ARGS,
-	lists: ["with"],
-	run: (args, { config, io }) => runInit(config, args, io.prompts)
-});
-const addCommand = defineCliCommand({
-	meta: {
-		name: "add",
-		description: "Adds glue for an integration to an existing project"
-	},
-	args: ADD_ARGS,
-	run: (args, { config, io }) => runAdd(config, args, io.prompts)
-});
-//#endregion
-export { addCommand, initCommand };