better-supabase 0.8.0 → 0.9.0

package/dist/cli/glue-C1UE8gQN.js

@@ -1,468 +0,0 @@
-import { a as parseNames } from "./errors-CqTLXe2M.js";
-import { a as writeIfChanged, t as display } from "./io-CFzJVJ68.js";
-import { t as VERSION } from "./version-B4k0aUxS.js";
-import { n as INTEGRATIONS } from "./names-D6LrQnOv.js";
-import { posix, resolve } from "node:path";
-import { existsSync } from "node:fs";
-//#region src/cli/templates.ts
-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, integrations = []) {
-	const config = {
-		path: "better-supabase.config.ts",
-		contents: `import { defineConfig } from 'better-supabase/config';
-
-export default defineConfig({
-  casing: '${casing}',
-  output: '${context.generated}',${integrations.length > 0 ? `\n  integrations: [${integrations.map((name) => `'${name}'`).join(", ")}],` : ""}
-  // \`better-supabase gen\` runs every task this file sets up: types, then
-  // sql, spec, seed and scaffold when they are configured. Pin the list with:
-  // gen: { tasks: ['types', 'sql', 'spec'] },
-  // env: { output: '.env.local' },
-  // doctor: { format: 'sarif', output: 'doctor.sarif' },
-});
-`
-	};
-	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/glue.ts
-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;
-}
-function templateContextFor(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));
-}
-function chooseIntegrations(prompts, initial) {
-	return prompts.multiselect("Integrations", INTEGRATIONS.map((name) => ({
-		value: name,
-		label: name,
-		hint: TEMPLATES[name].description
-	})), initial);
-}
-function parseIntegrations(values) {
-	return parseNames(values, isIntegration, "integration", INTEGRATIONS);
-}
-//#endregion
-export { packagesFor as a, writeFiles as c, libEntry as d, needsLib as f, overwrite as i, TEMPLATES as l, suggestedIntegrations as m, chooseIntegrations as n, parseIntegrations as o, resolveIntegrations as p, integrationFiles as r, templateContextFor as s, CANCELLED as t, baseFiles as u };