better-supabase 0.5.0 → 0.6.0

package/dist/cli/gen-DAH8FM2W.js

@@ -0,0 +1,2 @@
+import { n as genCommand } from "./gen-BGLb_zou.js";
+export { genCommand };

package/dist/cli/index.d.ts

@@ -1,7 +1,6 @@
 import { styleText } from "node:util";
-import { Catalog, CatalogCheck, CatalogColumn, CatalogColumnGrant, CatalogEnum, CatalogForeignKey, CatalogFunction, CatalogFunctionArg, CatalogGrant, CatalogIndex, CatalogPolicy, CatalogTable, CatalogTrigger, CatalogUnique, ExtrasFunction, ExtrasHook, ExtrasHookFunction, ExtrasTable, ForeignKeyAction, GeneratedFile, GeneratorMetadata, ResolvedConfig, Snapshot, SnapshotBucket, SnapshotExtras } from "better-supabase/config";
+import { Catalog, CatalogCheck, CatalogColumn, CatalogColumnGrant, CatalogEnum, CatalogForeignKey, CatalogFunction, CatalogFunctionArg, CatalogGrant, CatalogIndex, CatalogPolicy, CatalogTable, CatalogTrigger, CatalogUnique, ExtrasFunction, ExtrasHook, ExtrasHookFunction, ExtrasTable, ForeignKeyAction, GeneratedFile, GeneratorMetadata, GeneratorMetadata as GeneratorMetadata$1, ResolvedConfig, Snapshot, SnapshotBucket, SnapshotExtras } from "better-supabase/config";
 import { Casing, Codec, FunctionMeta, RelationMeta, SchemaMeta, TableMeta } from "better-supabase";
-import { GeneratorMetadata as GeneratorMetadata$1, Queryable } from "@supabase/postgrest-typegen";
 //#region ../../node_modules/.pnpm/citty@0.2.2/node_modules/citty/dist/index.d.mts
 //#region src/types.d.ts
 type ArgType = "boolean" | "string" | "enum" | "positional" | undefined;
@@ -148,6 +147,10 @@ interface CommandResult {
 interface CliContext {
   readonly cwd: string;
   readonly config: ResolvedConfig;
+  /** The config file `config` came from, when there is one. */
+  readonly configFile?: string;
+  /** Loads the config file again, for commands that run until stopped. */
+  readonly reloadConfig?: () => Promise<ResolvedConfig>;
   /** `prompts` is unset in CI and under `--json` or `--yes`. */
   readonly io: CliIo;
   readonly env: CliEnv;
@@ -298,6 +301,14 @@ interface PgConnection {
 /** Opens a `pg` connection. `pg` is an optional peer, loaded on demand. */
 declare function connect(url: string, load?: () => Promise<unknown>, options?: ConnectOptions): Promise<PgConnection>;
 //#endregion
+//#region src/cli/introspect/typegen.d.ts
+/** A connection `introspect()` reads the catalog through, as postgrest-typegen types it. */
+interface Queryable {
+  query(sql: string): Promise<{
+    rows: any[];
+  }>;
+}
+//#endregion
 //#region src/cli/introspect/source.d.ts
 /** A connection introspection can query, plus how to release it. */
 interface IntrospectionSource {
@@ -358,13 +369,25 @@ interface GenOptions extends SnapshotSource {
   readonly paint?: Paint;
   /** Pre-loaded snapshot (tests, watch mode). */
   readonly snapshot?: Snapshot;
+  /**
+   * Writes only the generated files (`gen --metadata --out`): no read-set SQL
+   * module, and the manifest that removes files an earlier run wrote is
+   * neither read nor written.
+   */
+  readonly isolated?: boolean;
+}
+interface RenderOptions {
+  /** Where the generated module imports the runtime from. Defaults to `better-supabase`. */
+  readonly runtimeImport?: string;
+  /** Writes the metadata into the main module, so it stands alone on stdout. */
+  readonly inlineMeta?: boolean;
 }
 /**
  * Renders every generated file for a snapshot, without touching disk:
  * `database.types.ts` (what `supabase gen types` prints), the main module,
  * then each configured generator's files.
  */
-export declare function renderFiles(config: ResolvedConfig, snapshot: Snapshot): Promise<GeneratedFile[]>;
+export declare function renderFiles(config: ResolvedConfig, snapshot: Snapshot, options?: RenderOptions): Promise<GeneratedFile[]>;
 export declare function runGen(options: GenOptions): Promise<CommandResult>;
 //#endregion
 //#region src/cli/introspect/extras.d.ts
@@ -405,6 +428,8 @@ interface ColumnModel {
   readonly nullable: boolean;
   /** Optional on insert. */
   readonly optional: boolean;
+  /** An insert may leave it out: a default, `insertOptional`, or a CHECK-narrowed column a `before insert` trigger can fill. */
+  readonly filled: boolean;
   /** Not writable (generated always / identity always). */
   readonly readonly: boolean;
   readonly values: readonly string[] | undefined;
@@ -417,6 +442,11 @@ interface ColumnModel {
 }
 interface RelationModel {
   readonly name: string;
+  /** The name before casing, from database names. */
+  readonly base: string;
+  /** Database names of the foreign key's columns and the ones it references. */
+  readonly fkColumns: readonly string[];
+  readonly refColumns: readonly string[];
   readonly meta: RelationMeta;
 }
 interface TableModel {
@@ -430,8 +460,12 @@ interface TableModel {
 interface EnumModel {
   readonly schema: string;
   readonly name: string;
+  /** Key in `meta.enums`: the name, or `schema_name` when another schema has the same enum name. */
+  readonly key: string;
   /** Constant name for the value array, e.g. `noteKindValues`. */
   readonly constant: string;
+  /** Exported type name, e.g. `NoteKind`. */
+  readonly typeName: string;
   readonly values: readonly string[];
 }
 interface FunctionModel {
@@ -459,6 +493,8 @@ interface Model {
   readonly catalog: Catalog;
   /** Typegen metadata restricted to the configured schemas. */
   readonly introspection: GeneratorMetadata$1;
+  /** Config entries that matched nothing in the schema. */
+  readonly warnings: readonly string[];
 }
 /** Builds the codegen model from a snapshot and config. */
 export declare function buildModel(snapshot: Snapshot, config: ResolvedConfig): Model;
@@ -474,6 +510,8 @@ interface EmitOptions {
   readonly importPathFor: (from: string) => string;
   /** Import path from the generated module to the metadata module (`emitMeta`). */
   readonly metaImport?: string;
+  /** Writes the metadata into the module instead of importing it, so it is one file. */
+  readonly inlineMeta?: boolean;
 }
 /** Renders the generated module. */
 export declare function emitModule(model: Model, options: EmitOptions): string;
@@ -483,11 +521,12 @@ export declare function emitModule(model: Model, options: EmitOptions): string;
  * Loads `better-supabase.config.*` with c12 and checks it against the config
  * schema. c12 imports `.ts` natively (Node 24 strips the types), so no
  * loader is needed; rc files, `package.json`, env overrides and `extends`
- * are off so the one file is the whole config.
+ * are off so the one file is the whole config. A discovered file sets the
+ * project root to its own directory; `--config` keeps `cwd` as the root.
  */
 export declare function loadConfig(cwd: string, explicit?: string): Promise<ResolvedConfig>;
 //#endregion
 //#region src/cli/version.d.ts
-export declare const VERSION = "0.5.0";
+export declare const VERSION = "0.6.0";
 //#endregion
 export type { Catalog, CatalogCheck, CatalogColumn, CatalogColumnGrant, CatalogEnum, CatalogForeignKey, CatalogFunction, CatalogFunctionArg, CatalogGrant, CatalogIndex, CatalogPolicy, CatalogTable, CatalogTrigger, CatalogUnique, CliArgs, CliCommandDef, CliContext, CliEnv, CliErrorCode, CliErrorOptions, CliIo, CliProblem, CliProblemExtensions, Command, CommandContext, CommandResult, ExitCode, ExtrasFunction, ExtrasHook, ExtrasHookFunction, ExtrasTable, ForeignKeyAction, GeneratorMetadata, IntrospectionSource, ManagementSourceOptions, ParsedArgs, Queryable, RunOptions, RunResult, Snapshot, SnapshotBucket, SnapshotExtras };

package/dist/cli/index.js

@@ -1,9 +1,9 @@
 import { a as list, r as defineCliCommand } from "./command-CK14fP91.js";
 import { n as CliError, t as CLI_ERRORS_URL } from "./errors-4v4DTtda.js";
-import { i as run, n as help, r as registerCommand, t as commandNames } from "./run-BKR2W_79.js";
-import { t as VERSION } from "./version-BDJuO0UR.js";
-import { a as loadConfig } from "./config-CPVpXP5I.js";
-import { A as toCatalog, b as emitModule, f as introspect, g as buildModel, i as runGen, l as parseSnapshot, m as pgSource, o as loadSnapshot, p as managementSource, r as renderFiles, u as serializeSnapshot, y as GENERATED_HEADER } from "./gen-C2osRcr5.js";
+import { i as run, n as help, r as registerCommand, t as commandNames } from "./run-DNWxHynX.js";
+import { t as VERSION } from "./version-hr88OZG0.js";
+import { a as loadConfig } from "./config-NiPxAmUF.js";
+import { L as toCatalog, a as renderFiles, b as emitModule, c as loadSnapshot, d as parseSnapshot, f as serializeSnapshot, g as pgSource, h as managementSource, m as introspect, o as runGen, x as buildModel, y as GENERATED_HEADER } from "./gen-BGLb_zou.js";
 //#region src/cli/introspect/from-catalog.ts
 /**
 * Builds a snapshot from catalog records: the inverse of `toCatalog`. Tests
@@ -124,12 +124,12 @@ function fromCatalog(catalog) {
 		const args = [...fn.args.map((arg) => ({
 			mode: "in",
 			name: arg.name,
-			type_id: argType(fn.schema, arg.isArray ? `_${arg.udt}` : arg.udt),
+			type_id: argType(arg.typeSchema ?? fn.schema, arg.isArray ? `_${arg.udt}` : arg.udt),
 			has_default: arg.hasDefault
 		})), ...(fn.returnsTable ?? []).map((entry) => ({
 			mode: "table",
 			name: entry.name,
-			type_id: argType(fn.schema, entry.udt),
+			type_id: argType(entry.typeSchema ?? fn.schema, entry.udt),
 			has_default: false
 		}))];
 		meta.functions.push({
@@ -142,7 +142,7 @@ function fromCatalog(catalog) {
 			args,
 			argument_types: fn.signature,
 			identity_argument_types: fn.signature,
-			return_type_id: fn.returnsRelation ? typeId(fn.returnsRelation.split(".")[0], fn.returns) : argType(fn.schema, fn.returns),
+			return_type_id: fn.returnsRelation ? typeId(fn.returnsRelation.split(".")[0], fn.returns) : argType(fn.returnsSchema ?? fn.schema, fn.returns),
 			return_type: fn.returns,
 			return_type_relation_id: fn.returnsRelation ? relationIds.get(fn.returnsRelation) ?? null : null,
 			is_set_returning_function: fn.returnsSet,

package/dist/cli/{init-Saf5-R9T.js → init-BIIwclPg.js}

@@ -1,16 +1,20 @@
 import { a as list, r as defineCliCommand } from "./command-CK14fP91.js";
-import { r as writeIfChanged, t as display } from "./io-k41_z-jT.js";
-import { t as VERSION } from "./version-BDJuO0UR.js";
-import { n as findConfig } from "./config-CPVpXP5I.js";
-import { n as installCommand, t as detectProject } from "./project-B_GeXyHh.js";
-import { posix, resolve } from "node:path";
+import { i as writeIfChanged, t as display } from "./io-DI1mTdSA.js";
+import { t as VERSION } from "./version-hr88OZG0.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"
@@ -87,15 +91,16 @@ export default defineConfig({
 	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);
+export const betterSupabase = defineSupabase(schema${expo ? ", { temporal: Temporal }" : ""});
 `
 	}];
 }
@@ -275,6 +280,64 @@ Deno.serve(bs.handler((_request, { auth }) => ({ kind: auth.kind })));
 		],
 		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: [],
@@ -303,7 +366,7 @@ Deno.serve(bs.fetch);
 				contents: denoJson(context)
 			}
 		],
-		next: ["List tables under `resources` to expose them as tools, e.g. `customers: true`."]
+		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. */
@@ -334,9 +397,11 @@ function suggestedIntegrations(frameworks) {
 			names.push("orpc");
 			break;
 		case "vite":
-		case "expo":
 			names.push("client");
 			break;
+		case "expo":
+			names.push("expo");
+			break;
 		case "tanstack-query":
 			names.push("react");
 			break;
@@ -345,6 +410,86 @@ function suggestedIntegrations(frameworks) {
 	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: {
@@ -354,9 +499,14 @@ const INIT_ARGS = {
 	},
 	with: {
 		type: "string",
-		description: "Integrations to add next to the detected ones: next, hono, orpc, edge, mcp, client, react",
+		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"
@@ -370,7 +520,7 @@ const ADD_ARGS = {
 	integration: {
 		type: "positional",
 		required: false,
-		description: "next, hono, orpc, edge, mcp, client or react"
+		description: "next, hono, orpc, edge, expo, mcp, client or react"
 	},
 	force: {
 		type: "boolean",
@@ -386,13 +536,13 @@ const CANCELLED = {
 	error: "Cancelled."
 };
 /** `--force`, or the person's answer when files exist; `undefined` when they cancel. */
-async function overwrite(root, files, args, prompts) {
+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(root, path)).join(", ")} ${existing.length === 1 ? "exists" : "exist"}. Overwrite?`);
+	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) {
+async function writeFiles(root, files, args, force, base = root) {
 	const dryRun = args["dry-run"] === true;
 	const lines = [];
 	const seen = /* @__PURE__ */ new Set();
@@ -400,7 +550,7 @@ async function writeFiles(root, files, args, force) {
 		if (seen.has(file.path)) continue;
 		seen.add(file.path);
 		const path = resolve(root, file.path);
-		const shown = display(root, file.path);
+		const shown = display(base, path);
 		if (existsSync(path) && !force) {
 			lines.push(`Kept    ${shown} (exists)`);
 			continue;
@@ -413,6 +563,24 @@ async function writeFiles(root, files, args, force) {
 	}
 	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,
@@ -433,9 +601,10 @@ function packagesFor(project, names) {
 	];
 	return [...new Set(wanted)].filter((name) => !(name in project.dependencies));
 }
-/** pg as a dev dependency, when the project lacks it. */
+/** pg and the pinned postgrest-typegen as dev dependencies, the ones the project lacks. */
 function devPackages(project) {
-	return "pg" in project.dependencies ? [] : [["pg"]];
+	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) => ({
@@ -449,6 +618,34 @@ function parseIntegrations(values) {
 	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",
@@ -464,7 +661,19 @@ async function runInit(config, args, prompts) {
 		code: 2,
 		error: "--casing must be \"camel\" or \"snake\""
 	};
-	const project = await detectProject(config.root);
+	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,
@@ -474,23 +683,29 @@ async function runInit(config, args, prompts) {
 	const chosen = args.with === void 0 && prompts ? await chooseIntegrations(prompts, detected) : detected;
 	if (chosen === void 0) return CANCELLED;
 	const integrations = resolveIntegrations(chosen);
-	const templateContext = context(project, findConfig(config.root) !== void 0 ? config.output : posix.normalize(posix.join(project.srcDir, "lib/supabase/generated.ts")));
+	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(config.root, files, args, prompts);
+	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(", ")}.` : "No framework found.",
+		project.frameworks.length > 0 ? `Found ${project.frameworks.join(", ")}${where}.` : `No framework found${where}.`,
 		"",
-		...await writeFiles(config.root, files, args, force)
+		...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)] : [],
-		...devPackages(project).map((names) => installCommand(project.packageManager, names, true)),
-		...project.hasSupabase ? [] : ["supabase init"],
+		...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",
-		"better-supabase gen"
+		`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}`);

package/dist/cli/{introspect--H7oGmcd.js → introspect-DNUTuNvb.js}

@@ -1,8 +1,8 @@
 import { r as defineCliCommand } from "./command-CK14fP91.js";
-import { r as writeIfChanged, t as display } from "./io-k41_z-jT.js";
+import { i as writeIfChanged, r as sameText, t as display } from "./io-DI1mTdSA.js";
 import { r as painter } from "./style-C0NFdJRL.js";
 import { t as fileDiff } from "./diff-SjkO5rNr.js";
-import { _ as restrictSchemas, a as sourceArgs, o as loadSnapshot, t as SOURCE_ARGS, u as serializeSnapshot, v as serializeGenerator } from "./gen-C2osRcr5.js";
+import { T as serializeGenerator, c as loadSnapshot, f as serializeSnapshot, s as sourceArgs, t as SOURCE_ARGS, w as restrictSchemas } from "./gen-BGLb_zou.js";
 import { n as withSpinner } from "./prompts-BNcNfAve.js";
 import { resolve } from "node:path";
 import { readFile } from "node:fs/promises";
@@ -10,7 +10,7 @@ import { readFile } from "node:fs/promises";
 const ARGS = {
 	out: {
 		type: "string",
-		description: "Defaults to supabase/snapshot.json, or supabase/generator-metadata.json",
+		description: "Defaults to source.snapshot, supabase/snapshot.json, or supabase/generator-metadata.json",
 		valueHint: "file"
 	},
 	format: {
@@ -42,12 +42,12 @@ const introspectCommand = defineCliCommand({
 			live: true,
 			...signal ? { signal } : {}
 		}));
-		const out = args.out ?? (format === "snapshot" ? "supabase/snapshot.json" : "supabase/generator-metadata.json");
+		const out = args.out ?? (format === "snapshot" ? config.source.snapshot ?? "supabase/snapshot.json" : "supabase/generator-metadata.json");
 		const contents = format === "snapshot" ? serializeSnapshot(snapshot) : `${await serializeGenerator(restrictSchemas(snapshot.generator, config.schemas))}\n`;
 		if (args.check === true) {
 			const current = await readFile(resolve(config.root, out), "utf8").catch(() => void 0);
 			const file = display(config.root, out);
-			return current === contents ? {
+			return sameText(current, contents) ? {
 				code: 0,
 				output: `${file} is up to date.`,
 				data: {

package/dist/cli/{io-k41_z-jT.js → io-DI1mTdSA.js}

@@ -2,10 +2,19 @@ import { dirname, relative, resolve, sep } from "node:path";
 import { existsSync } from "node:fs";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 //#region src/cli/io.ts
-/** Writes a file when its contents changed. Returns whether it wrote. */
+/** `text` with `\r\n` line endings turned into `\n`. */
+const withLf = (text) => text.replaceAll("\r\n", "\n");
+/**
+* Whether a file on disk holds `expected`, ignoring line endings: a checkout
+* with `core.autocrlf` turns every `\n` into `\r\n`.
+*/
+function sameText(current, expected) {
+	return current !== void 0 && withLf(current) === withLf(expected);
+}
+/** Writes a file when its contents changed, ignoring line endings. Returns whether it wrote. */
 async function writeIfChanged(path, contents) {
 	if (existsSync(path)) {
-		if (await readFile(path, "utf8") === contents) return false;
+		if (sameText(await readFile(path, "utf8"), contents)) return false;
 	}
 	await mkdir(dirname(path), { recursive: true });
 	await writeFile(path, contents);
@@ -21,4 +30,4 @@ function display(root, path) {
 	return relative(root, resolve(root, path)).split(sep).join("/") || ".";
 }
 //#endregion
-export { importPath as n, writeIfChanged as r, display as t };
+export { writeIfChanged as i, importPath as n, sameText as r, display as t };