better-supabase 0.16.0 → 0.18.0

package/dist/cli/{module-migration-O_IxewFs.js → migrations-BoIyGczt.js}

@@ -2,7 +2,7 @@ import { n as CliError } from "./errors-BTe6A15O.js";
 import { d as readSupabaseToml, p as sqlWorkflow } from "./supabase-toml-CncmQbO0.js";
 import { t as importFresh } from "./fresh-import-DzgsGHkX.js";
 import { i as changeLines, r as applyPlan } from "./files-CX71yBm8.js";
-import { a as sqlPlan, i as schemasDirOf, n as migrationsDir, r as moduleLayoutFor } from "./sql-layout-lUWenjJw.js";
+import { a as sqlPlan, i as schemasDirOf, n as migrationsDir, r as moduleLayoutFor } from "./sql-layout-D8QrNvt4.js";
 import { resolve } from "node:path";
 import { readFile, readdir } from "node:fs/promises";
 import { MODULE_ID_TYPES, compileReadSets, moduleIdType, moduleLayout, modulePermissionKeys, moduleSchemaExtensions, renderBlocks, resolveBlocks, scopeProblems, templateFunctions } from "better-supabase/sql";
@@ -374,7 +374,7 @@ async function dataMigration(config, args, now) {
 		error: [`No migration before the data migration creates ${missing.map((extension) => extension.name).join(", ")}, and the schema migration needs ${missing.length === 1 ? "it" : "them"} while it applies.`, "Run `better-supabase upgrade` to write the extensions migration, then create the schema migration again after it."].join("\n")
 	};
 	const files = rendered.filter((file) => file.kind === "data");
-	const contents = `-- better-supabase add --adopt: the rows and settings of ${files.map((file) => file.module).join(", ")}, which a schema diff skips.\n\n${files.map((file) => file.contents.trim()).join("\n\n")}\n`;
+	const contents = `-- better-supabase add --adopt: the rows and settings of ${files.map((file) => file.module).join(", ")}, which a schema diff skips.\n\nset lock_timeout = '5s';\n\n${files.map((file) => file.contents.trim()).join("\n\n")}\n`;
 	const dir = migrationsDir(config);
 	const existing = await readdir(resolve(config.root, dir)).catch(() => []);
 	const latest = existing.toSorted().findLast((name) => name.endsWith(DATA_SUFFIX));
@@ -410,114 +410,4 @@ async function dataMigration(config, args, now) {
 	};
 }
 //#endregion
-//#region src/cli/sql/module-migration.ts
-/** The migration the migrations workflow writes the SQL modules into. */
-const MODULES_SUFFIX = "_better_supabase_modules.sql";
-/**
-* The migration `gen` writes the read-sets module into under the migrations
-* workflow.
-*/
-const READ_SETS_SUFFIX = "_better_supabase_read_sets.sql";
-const UPGRADE_START = "-- @bsb-upgrade-start";
-const UPGRADE_END = "-- @bsb-upgrade-end";
-/**
-* Whether the project runs the migrations workflow, with no declarative
-* schemas.
-*/
-async function writesMigrations(config) {
-	return sqlWorkflow(config, await readSupabaseToml(config.root)) === "migrations";
-}
-/**
-* One migration that holds, in order, the extensions, the upgrade steps, each
-* module's schema body with its `@bsb-block` header, the realtime topic
-* policies and the data statements. Every statement is re-runnable, so a later
-* migration carries all of them, not only the changes.
-*/
-function renderModuleMigration(parts) {
-	const schema = parts.files.filter((file) => file.kind === "schema");
-	const data = parts.files.filter((file) => file.kind === "data");
-	const modules = [...new Set(schema.map((file) => file.instance ?? file.module))];
-	const extensions = moduleSchemaExtensions(parts.files);
-	const upgrade = parts.upgrade ?? [];
-	return `${[
-		[
-			`-- better-supabase sql: ${modules.length > 0 ? `the SQL modules ${modules.join(", ")}` : "the realtime topic policies"}, in one migration (database.sql.workflow: 'migrations').`,
-			"-- Managed by `better-supabase add` and `better-supabase upgrade`, which write a new migration when they change.",
-			"-- Change them through `blocks` in better-supabase.config.ts and the module's SQL hooks."
-		].join("\n"),
-		...extensions.length > 0 ? [extensions.map((extension) => extension.statement).join("\n")] : [],
-		...upgrade.length > 0 ? [[
-			UPGRADE_START,
-			...upgrade,
-			UPGRADE_END
-		].join("\n\n")] : [],
-		...schema.map((file) => file.contents.trim()),
-		...parts.topics === void 0 ? [] : [parts.topics.trim()],
-		...data.map((file) => file.contents.trim())
-	].join("\n\n")}\n`;
-}
-/**
-* The migration without its upgrade steps and package versions, which a later
-* one doesn't repeat.
-*/
-function comparable(text) {
-	return text.replaceAll("\r\n", "\n").replace(/\n\n-- @bsb?-upgrade-start\n[\s\S]*?\n-- @bsb?-upgrade-end/, "").replaceAll(/^(-- better-supabase module: [^\n(]*?)(?: \([^)]*\))?$/gm, "$1");
-}
-/** Whether two module migrations hold the same modules. */
-const sameModuleMigration = (current, expected) => current !== void 0 && comparable(current) === comparable(expected);
-/** Whether a module migration holds `contents` (one module's file) unchanged. */
-const migrationHolds = (text, contents) => comparable(text).includes(comparable(contents.trim()));
-/** The newest migration that ends in `suffix`, with its text. */
-async function latestMigration(config, suffix) {
-	const dir = migrationsDir(config);
-	const latest = (await readdir(resolve(config.root, dir)).catch(() => [])).toSorted().findLast((name) => name.endsWith(suffix));
-	if (latest === void 0) return;
-	return {
-		path: `${dir}/${latest}`,
-		text: await readFile(resolve(config.root, dir, latest), "utf-8")
-	};
-}
-const MODULE_MARKERS = /^-- @(?:bsb-block|bs-module) ([a-zA-Z0-9-]+)@(\d+)(?: [a-z]+(?: ([a-z0-9-]+))?)?$/gm;
-/**
-* The modules and versions a module migration installs, from its `@bsb-block`
-* lines.
-*/
-function migrationModules(text) {
-	return new Map([...text.matchAll(MODULE_MARKERS)].map((match) => [match[1], Number(match[2])]));
-}
-/**
-* The instances a module migration installs under another name than their
-* block, each to its block.
-*/
-function migrationInstances(text) {
-	return new Map([...text.matchAll(MODULE_MARKERS)].flatMap((match) => match[3] === void 0 ? [] : [[match[1], match[3]]]));
-}
-/**
-* Writes `contents` as a new migration ending in `suffix`, unless the newest
-* one already holds the same statements. `force` writes it anyway, for upgrade
-* steps that have to run once.
-*/
-async function writeLatestMigration(config, suffix, contents, options) {
-	const latest = await latestMigration(config, suffix);
-	if (options.force !== true && latest !== void 0 && sameModuleMigration(latest.text, contents)) return {
-		path: latest.path,
-		wrote: false,
-		line: `Unchanged ${latest.path} (it has these statements)`
-	};
-	const dir = migrationsDir(config);
-	const path = `${dir}/${stampAfter(await readdir(resolve(config.root, dir)).catch(() => []), options.now)}${suffix}`;
-	const applied = await applyPlan(sqlPlan(config, {
-		regenerate: "better-supabase upgrade",
-		files: [{
-			path,
-			contents
-		}]
-	}), { "dry-run": options.dryRun });
-	return {
-		path,
-		wrote: applied.mode === "write",
-		line: changeLines(applied).join("\n")
-	};
-}
-//#endregion
-export { entitlementsMode as C, unsafeKey as E, entitlementRequirements as S, providerLabel as T, layoutFor as _, migrationInstances as a, accessProviderMode as b, sameModuleMigration as c, DATA_NEXT as d, dataMigration as f, layout as g, MEMBERSHIP_CLAIM_MODULES as h, migrationHolds as i, writeLatestMigration as l, writeExtensionsMigration as m, READ_SETS_SUFFIX as n, migrationModules as o, migrationStamp as p, latestMigration as r, renderModuleMigration as s, MODULES_SUFFIX as t, writesMigrations as u, providerOwnsMemberships as v, moduleKeyProblems as w, accessRequirements as x, compiledReadSets as y };
+export { unsafeKey as _, writeExtensionsMigration as a, layoutFor as c, accessProviderMode as d, accessRequirements as f, providerLabel as g, moduleKeyProblems as h, stampAfter as i, providerOwnsMemberships as l, entitlementsMode as m, dataMigration as n, MEMBERSHIP_CLAIM_MODULES as o, entitlementRequirements as p, migrationStamp as r, layout as s, DATA_NEXT as t, compiledReadSets as u };

package/dist/cli/module-migration-DXvo0EqU.js

@@ -0,0 +1,119 @@
+import { i as stampAfter } from "./migrations-BoIyGczt.js";
+import { d as readSupabaseToml, p as sqlWorkflow } from "./supabase-toml-CncmQbO0.js";
+import { i as changeLines, r as applyPlan } from "./files-CX71yBm8.js";
+import { a as sqlPlan, n as migrationsDir } from "./sql-layout-D8QrNvt4.js";
+import { resolve } from "node:path";
+import { readFile, readdir } from "node:fs/promises";
+import { moduleSchemaExtensions } from "better-supabase/sql";
+//#region src/cli/sql/module-migration.ts
+/** The migration the migrations workflow writes the SQL modules into. */
+const MODULES_SUFFIX = "_better_supabase_modules.sql";
+/**
+* The migration `gen` writes the read-sets module into under the migrations
+* workflow.
+*/
+const READ_SETS_SUFFIX = "_better_supabase_read_sets.sql";
+const UPGRADE_START = "-- @bsb-upgrade-start";
+const UPGRADE_END = "-- @bsb-upgrade-end";
+/**
+* Whether the project runs the migrations workflow, with no declarative
+* schemas.
+*/
+async function writesMigrations(config) {
+	return sqlWorkflow(config, await readSupabaseToml(config.root)) === "migrations";
+}
+/**
+* One migration that holds, in order, the extensions, the upgrade steps, each
+* module's schema body with its `@bsb-block` header, the realtime topic
+* policies and the data statements. Every statement is re-runnable, so a later
+* migration carries all of them, not only the changes.
+*/
+function renderModuleMigration(parts) {
+	const schema = parts.files.filter((file) => file.kind === "schema");
+	const data = parts.files.filter((file) => file.kind === "data");
+	const modules = [...new Set(schema.map((file) => file.instance ?? file.module))];
+	const extensions = moduleSchemaExtensions(parts.files);
+	const upgrade = parts.upgrade ?? [];
+	return `${[
+		[
+			`-- better-supabase sql: ${modules.length > 0 ? `the SQL modules ${modules.join(", ")}` : "the realtime topic policies"}, in one migration (database.sql.workflow: 'migrations').`,
+			"-- Managed by `better-supabase add` and `better-supabase upgrade`, which write a new migration when they change.",
+			"-- Change them through `blocks` in better-supabase.config.ts and the module's SQL hooks."
+		].join("\n"),
+		...extensions.length > 0 ? [extensions.map((extension) => extension.statement).join("\n")] : [],
+		...upgrade.length > 0 ? [[
+			UPGRADE_START,
+			...upgrade,
+			UPGRADE_END
+		].join("\n\n")] : [],
+		...schema.map((file) => file.contents.trim()),
+		...parts.topics === void 0 ? [] : [parts.topics.trim()],
+		...data.map((file) => file.contents.trim())
+	].join("\n\n")}\n`;
+}
+/**
+* The migration without its upgrade steps and package versions, which a later
+* one doesn't repeat.
+*/
+function comparable(text) {
+	return text.replaceAll("\r\n", "\n").replace(/\n\n-- @bsb?-upgrade-start\n[\s\S]*?\n-- @bsb?-upgrade-end/, "").replaceAll(/^(-- better-supabase module: [^\n(]*?)(?: \([^)]*\))?$/gm, "$1");
+}
+/** Whether two module migrations hold the same modules. */
+const sameModuleMigration = (current, expected) => current !== void 0 && comparable(current) === comparable(expected);
+/** Whether a module migration holds `contents` (one module's file) unchanged. */
+const migrationHolds = (text, contents) => comparable(text).includes(comparable(contents.trim()));
+/** The newest migration that ends in `suffix`, with its text. */
+async function latestMigration(config, suffix) {
+	const dir = migrationsDir(config);
+	const latest = (await readdir(resolve(config.root, dir)).catch(() => [])).toSorted().findLast((name) => name.endsWith(suffix));
+	if (latest === void 0) return;
+	return {
+		path: `${dir}/${latest}`,
+		text: await readFile(resolve(config.root, dir, latest), "utf-8")
+	};
+}
+const MODULE_MARKERS = /^-- @(?:bsb-block|bs-module) ([a-zA-Z0-9-]+)@(\d+)(?: [a-z]+(?: ([a-z0-9-]+))?)?$/gm;
+/**
+* The modules and versions a module migration installs, from its `@bsb-block`
+* lines.
+*/
+function migrationModules(text) {
+	return new Map([...text.matchAll(MODULE_MARKERS)].map((match) => [match[1], Number(match[2])]));
+}
+/**
+* The instances a module migration installs under another name than their
+* block, each to its block.
+*/
+function migrationInstances(text) {
+	return new Map([...text.matchAll(MODULE_MARKERS)].flatMap((match) => match[3] === void 0 ? [] : [[match[1], match[3]]]));
+}
+/**
+* Writes `contents` as a new migration ending in `suffix`, unless the newest
+* one already holds the same statements. `force` writes it anyway, for upgrade
+* steps that have to run once.
+*/
+async function writeLatestMigration(config, suffix, contents, options) {
+	const latest = await latestMigration(config, suffix);
+	if (options.force !== true && latest !== void 0 && sameModuleMigration(latest.text, contents)) return {
+		path: latest.path,
+		wrote: false,
+		line: `Unchanged ${latest.path} (it has these statements)`
+	};
+	const dir = migrationsDir(config);
+	const names = await readdir(resolve(config.root, dir)).catch(() => []);
+	const path = `${dir}/${stampAfter(names, options.now)}${suffix}`;
+	const applied = await applyPlan(sqlPlan(config, {
+		regenerate: "better-supabase upgrade",
+		files: [{
+			path,
+			contents
+		}]
+	}), { "dry-run": options.dryRun });
+	return {
+		path,
+		wrote: applied.mode === "write",
+		line: changeLines(applied).join("\n")
+	};
+}
+//#endregion
+export { migrationInstances as a, sameModuleMigration as c, migrationHolds as i, writeLatestMigration as l, READ_SETS_SUFFIX as n, migrationModules as o, latestMigration as r, renderModuleMigration as s, MODULES_SUFFIX as t, writesMigrations as u };

package/dist/cli/{moved-CsfDQcyk.js → moved-DVwgE8lV.js}

@@ -1,5 +1,5 @@
 import { n as CliError } from "./errors-BTe6A15O.js";
-import { s as positionalIndex } from "./parse-B9Iv_-Pf.js";
+import { s as positionalIndex } from "./parse-B079x40m.js";
 //#region src/cli/core/moved.ts
 const API_REPLACEMENT = "defineApi includes every table and block instance, and createOrpc(betterSupabase).router(api) serves it: https://bettersupabase.com/docs/frameworks/orpc#serve-the-api";
 /** Commands removed in 0.15, with what replaces them, longest path first. */

package/dist/cli/{parse-B9Iv_-Pf.js → parse-B079x40m.js}

@@ -1,5 +1,5 @@
 import { r as __toESM } from "./rolldown-runtime-kJ_i4yPo.js";
-import { t as GLOBAL_ARGS } from "./command-CQ61x6gN.js";
+import { t as GLOBAL_ARGS } from "./command-BWEEXmtz.js";
 import { n as CliError } from "./errors-BTe6A15O.js";
 //#region src/cli/core/parse.ts
 /**

package/dist/cli/powersync-D-0yV_L_.js

@@ -0,0 +1,283 @@
+import { p as commandMeta, r as defineCliCommand } from "./command-BWEEXmtz.js";
+import { c as layoutFor, i as stampAfter } from "./migrations-BoIyGczt.js";
+import { n as PLAN_ARGS, r as applyPlan, u as planResult } from "./files-CX71yBm8.js";
+import { n as migrationsDir } from "./sql-layout-D8QrNvt4.js";
+import { existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { readFile, readdir } from "node:fs/promises";
+import { declaredColumnTypes, renderBlocks } from "better-supabase/sql";
+import { SPEC_PINS } from "better-supabase";
+//#region src/cli/powersync/streams.ts
+/** The blocks `gen.powersync` can sync. */
+const POWERSYNC_BLOCKS = ["notifications", "attachments"];
+const isPowerSyncBlock = (value) => POWERSYNC_BLOCKS.some((block) => block === value);
+const GENERATED = "@generated by better-supabase gen";
+const SAFE_IDENT = /^[a-z_][a-z0-9_]*$/;
+const ident = (name) => SAFE_IDENT.test(name) ? name : `"${name.replaceAll("\"", "\"\"")}"`;
+const qualifiedIdent = (qualified) => {
+	const dot = qualified.indexOf(".");
+	return `${ident(qualified.slice(0, dot))}.${ident(qualified.slice(dot + 1))}`;
+};
+const baseName = (qualified) => qualified.slice(qualified.indexOf(".") + 1);
+/** The PowerSync column type a Postgres type syncs as. */
+function powersyncColumnType(type) {
+	const base = type.replace(/\[\]$/, "").replace(/\(.*\)$/, "");
+	if (/^(?:smallint|integer|int|int2|int4|int8|bigint|boolean|bool|smallserial|serial|bigserial)$/.test(base) && !type.endsWith("[]")) return "integer";
+	if (/^(?:real|double precision|float4|float8|numeric|decimal)$/.test(base) && !type.endsWith("[]")) return "real";
+	return "text";
+}
+const CREATE_TABLE = /create table (?:if not exists )?("(?:[^"]|"")+"|[a-z_][a-z0-9_$]*)\./gi;
+const unquote = (name) => name.startsWith("\"") ? name.slice(1, -1).replaceAll("\"\"", "\"") : name;
+function tablesOf(input, key) {
+	const files = input.files.flatMap((file) => file.kind === "schema" && (file.instance ?? file.module) === key ? [{ text: file.contents }] : []);
+	const schemas = new Set(files.flatMap(({ text }) => [...text.matchAll(CREATE_TABLE)].map((match) => unquote(match[1]))));
+	return declaredColumnTypes(files, [...schemas]);
+}
+/** The table of `tables` that has every one of `columns`. */
+function tableWith(tables, columns, what) {
+	const found = [...tables].find(([, declared]) => columns.every((column) => declared.has(column)));
+	if (found === void 0) throw new Error(`gen.powersync: found no ${what} table`);
+	return found;
+}
+function notificationTables(input, instance) {
+	const tables = tablesOf(input, instance.key);
+	const [recipients, recipientColumns] = tableWith(tables, [
+		"event_id",
+		"user_id",
+		"read_at",
+		"dismissed_at"
+	], `${instance.key} recipients`);
+	const [events, eventColumns] = tableWith(tables, [
+		"type",
+		"idempotency_key",
+		"summary"
+	], `${instance.key} events`);
+	const mine = `${qualifiedIdent(recipients)} WHERE user_id = auth.user_id()`;
+	return [{
+		qualified: recipients,
+		name: baseName(recipients),
+		stream: `${instance.key}_recipients`,
+		query: `SELECT * FROM ${mine}`,
+		columns: recipientColumns
+	}, {
+		qualified: events,
+		name: baseName(events),
+		stream: `${instance.key}_events`,
+		query: `SELECT * FROM ${qualifiedIdent(events)} WHERE id IN (SELECT event_id FROM ${mine})`,
+		columns: eventColumns
+	}];
+}
+function attachmentTables(input, instance) {
+	const [attachments, columns] = tableWith(tablesOf(input, instance.key), [
+		"bucket",
+		"object_path",
+		"uploaded_by"
+	], `${instance.key} attachments`);
+	const memberships = [...tablesOf(input, "memberships")].find(([, declared]) => declared.has("user_id") && declared.has("role"));
+	if (memberships === void 0) throw new Error(`gen.powersync: ${instance.key} syncs the files of the user's organizations, which needs the memberships block`);
+	const [membershipTable, membershipColumns] = memberships;
+	const tenant = [...columns.keys()].find((column) => column.endsWith("_id") && column !== "user_id" && membershipColumns.has(column));
+	if (tenant === void 0) throw new Error(`gen.powersync: ${instance.key} and memberships share no organization column`);
+	return [{
+		qualified: attachments,
+		name: baseName(attachments),
+		stream: instance.key,
+		query: `SELECT * FROM ${qualifiedIdent(attachments)} WHERE ${ident(tenant)} IN (SELECT ${ident(tenant)} FROM ${qualifiedIdent(membershipTable)} WHERE user_id = auth.user_id())`,
+		columns
+	}];
+}
+function syncedTables(input, instance) {
+	switch (instance.block) {
+		case "notifications": return notificationTables(input, instance);
+		case "attachments": return attachmentTables(input, instance);
+		default: {
+			const unknown = instance.block;
+			throw new Error(`gen.powersync: ${String(unknown)} can't sync`);
+		}
+	}
+}
+const yamlString = (text) => JSON.stringify(text);
+function streamsYaml(tables) {
+	const streams = tables.flatMap((table) => [
+		`  ${table.stream}:`,
+		"    auto_subscribe: true",
+		`    query: ${yamlString(table.query)}`
+	]);
+	return [
+		`# ${GENERATED}. Do not edit; run \`better-supabase gen\` instead.`,
+		"config:",
+		`  edition: ${SPEC_PINS.powersyncSyncStreams}`,
+		"",
+		"streams:",
+		...streams,
+		""
+	].join("\n");
+}
+function publicationSql(tables) {
+	const names = tables.map((table) => `('${table.qualified.replaceAll("'", "''")}')`).join(", ");
+	return `-- ${GENERATED}: the block tables PowerSync replicates.
+do $$
+declare
+  t record;
+begin
+  if not exists (select 1 from pg_publication where pubname = 'powersync') then
+    create publication powersync;
+  end if;
+
+  for t in
+    select n.nspname as schema_name, c.relname as table_name
+    from (values ${names}) as wanted (name)
+    join pg_class c on c.oid = wanted.name::regclass
+    join pg_namespace n on n.oid = c.relnamespace
+    where not exists (
+      select 1 from pg_publication_tables p
+      where p.pubname = 'powersync' and p.schemaname = n.nspname and p.tablename = c.relname
+    )
+  loop
+    execute format('alter publication powersync add table %I.%I', t.schema_name, t.table_name);
+  end loop;
+end;
+$$;
+`;
+}
+const propertyName = (name) => /^[A-Za-z_$][\w$]*$/.test(name) ? name : JSON.stringify(name);
+function schemaModule(tables, importFrom) {
+	const definitions = tables.map((table) => {
+		const columns = [...table.columns].filter(([column]) => column !== "id").map(([column, type]) => `  ${propertyName(column)}: column.${powersyncColumnType(type)},`);
+		return [
+			`export const ${table.name} = new Table({`,
+			...columns,
+			"});"
+		].join("\n");
+	});
+	return [
+		`// ${GENERATED}. Do not edit; run \`better-supabase gen\` instead.`,
+		"",
+		`import { column, Table } from ${JSON.stringify(importFrom)};`,
+		"",
+		...definitions.flatMap((definition) => [definition, ""]),
+		"/** The block tables, to spread into the app's `new Schema({ ... })`. */",
+		`export const blockTables = { ${tables.map((table) => table.name).join(", ")} };`,
+		""
+	].join("\n");
+}
+/** The sync streams, publication and PowerSync schema for `input.instances`. */
+function powersyncOutput(input) {
+	const byInstance = input.instances.map((instance) => [instance.key, syncedTables(input, instance)]);
+	const tables = byInstance.flatMap(([, synced]) => synced);
+	return {
+		streams: streamsYaml(tables),
+		publication: publicationSql(tables),
+		schema: schemaModule(tables, input.importFrom),
+		tables: Object.fromEntries(byInstance.map(([key, synced]) => [key, synced.map(({ name }) => name)]))
+	};
+}
+//#endregion
+//#region src/cli/commands/powersync.ts
+const ARGS = {
+	instance: {
+		type: "string",
+		description: "Block instances to sync, comma separated. Defaults to gen.powersync.instances",
+		valueHint: "keys"
+	},
+	out: {
+		type: "string",
+		description: "Folder for sync-streams.yaml and schema.ts. Defaults to gen.powersync.out, then powersync",
+		valueHint: "dir"
+	},
+	...PLAN_ARGS
+};
+const PUBLICATION_SUFFIX = "_powersync_publication.sql";
+const REGENERATE = "better-supabase powersync streams";
+function instancesOf(config, keys) {
+	const instances = [];
+	for (const key of keys) {
+		const block = config.instances[key]?.block;
+		if (block === void 0) return `${key} is not a block in the config.`;
+		if (!isPowerSyncBlock(block)) return `${key} installs ${block}, which can't sync yet. PowerSync syncs ${POWERSYNC_BLOCKS.join(" and ")}.`;
+		instances.push({
+			key,
+			block
+		});
+	}
+	return instances;
+}
+/**
+* The publication migration, unless the newest one already adds these tables: a
+* pushed migration is never rewritten, so a change gets a new one.
+*/
+async function publicationMigration(config, sql, now) {
+	const dir = resolve(config.root, migrationsDir(config));
+	const names = existsSync(dir) ? (await readdir(dir)).toSorted() : [];
+	const latest = names.findLast((name) => name.endsWith(PUBLICATION_SUFFIX));
+	if (latest !== void 0 && await readFile(join(dir, latest), "utf-8") === sql) return;
+	return {
+		path: join(dir, `${stampAfter(names, now())}${PUBLICATION_SUFFIX}`),
+		contents: sql,
+		policy: "create",
+		note: "adds the tables to the powersync publication"
+	};
+}
+/**
+* Writes `sync-streams.yaml` and `schema.ts` for the synced block instances,
+* and a migration that adds their tables to the `powersync` publication.
+*/
+async function runPowerSync(config, args, now = () => /* @__PURE__ */ new Date()) {
+	const settings = config.gen.powersync;
+	const keys = args.instance === void 0 ? settings?.instances ?? [] : args.instance.split(",").map((key) => key.trim()).filter(Boolean);
+	if (keys.length === 0) return {
+		code: 1,
+		errorCode: "config_invalid",
+		error: "Name the block instances to sync: set gen.powersync.instances, or pass --instance notifications."
+	};
+	const instances = instancesOf(config, keys);
+	if (typeof instances === "string") return {
+		code: 1,
+		errorCode: "config_invalid",
+		error: instances
+	};
+	const layout = await layoutFor(config, {}, config.blockNames);
+	let output;
+	try {
+		output = powersyncOutput({
+			files: renderBlocks(config.blockNames, layout),
+			instances,
+			importFrom: settings?.import ?? "@powersync/common"
+		});
+	} catch (cause) {
+		return {
+			code: 1,
+			errorCode: "config_invalid",
+			error: cause instanceof Error ? cause.message : String(cause)
+		};
+	}
+	const out = resolve(config.root, args.out ?? settings?.out ?? "powersync");
+	const migration = await publicationMigration(config, output.publication, now);
+	const plan = {
+		root: config.root,
+		regenerate: REGENERATE,
+		files: [
+			{
+				path: join(out, "sync-streams.yaml"),
+				contents: output.streams
+			},
+			{
+				path: join(out, "schema.ts"),
+				contents: output.schema
+			},
+			...migration === void 0 ? [] : [migration]
+		]
+	};
+	const applied = await applyPlan(plan, args);
+	return planResult(plan, applied, { data: {
+		instances: keys,
+		tables: output.tables
+	} });
+}
+const powersyncStreamsCommand = defineCliCommand({
+	meta: commandMeta("powersync streams"),
+	args: ARGS,
+	run: (args, { config }) => runPowerSync(config, args)
+});
+//#endregion
+export { runPowerSync as n, powersyncStreamsCommand as t };

package/dist/cli/powersync-DXVsKkAu.js

@@ -0,0 +1 @@
+export { t as powersyncStreamsCommand } from "./powersync-D-0yV_L_.js";

package/dist/cli/{print-DosQIFSy.js → print-CRon4lXf.js}

@@ -1,5 +1,6 @@
 import { n as CliError } from "./errors-BTe6A15O.js";
-import { g as layout, o as migrationModules, r as latestMigration, u as writesMigrations } from "./module-migration-O_IxewFs.js";
+import { s as layout } from "./migrations-BoIyGczt.js";
+import { o as migrationModules, r as latestMigration, u as writesMigrations } from "./module-migration-DXvo0EqU.js";
 import { existsSync } from "node:fs";
 import { resolve } from "node:path";
 import { SQL_MODULES, contractSignature, customContracts, moduleBody, moduleFilePaths } from "better-supabase/sql";

package/dist/cli/{remove-DK2G_KHm.js → remove-D89s99ha.js}

@@ -1,16 +1,16 @@
-import { p as commandMeta, r as defineCliCommand } from "./command-CQ61x6gN.js";
+import { p as commandMeta, r as defineCliCommand } from "./command-BWEEXmtz.js";
 import { i as plain } from "./style-Bm2X5JrN.js";
 import { n as CliError } from "./errors-BTe6A15O.js";
 import { r as readIfExists, t as display } from "./io-DH1kcmmP.js";
-import { _ as layoutFor } from "./module-migration-O_IxewFs.js";
+import { c as layoutFor } from "./migrations-BoIyGczt.js";
 import { i as changeLines, n as PLAN_ARGS, r as applyPlan, t as HAND_EDITED, u as planResult } from "./files-CX71yBm8.js";
-import { a as sqlPlan } from "./sql-layout-lUWenjJw.js";
-import { g as templateContextFor, i as blocksWiringPath, n as blockClients } from "./add-D7TkPdco.js";
+import { a as sqlPlan } from "./sql-layout-D8QrNvt4.js";
+import { g as templateContextFor, i as blocksWiringPath, n as blockClients } from "./add-B1S3yK4L.js";
 import { t as detectProject } from "./detect-D9JaAX20.js";
 import { _ as wiringBlocks, a as configObject, c as mask, i as closingIndex, l as properties } from "./config-edit-CrWfk8s3.js";
-import { n as guardedRemoval } from "./sync-CZMRB3aU.js";
+import { n as guardedRemoval } from "./sync-s1iKFIos.js";
 import { t as SQL_ARGS } from "./args-UEwg0l-N.js";
-import { t as blockNames } from "./blocks-xk-SE8gS.js";
+import { t as blockNames } from "./blocks-DDm1Zc2S.js";
 import { i as tidyInline, t as cutRange } from "./config-group-C8tjut39.js";
 import { existsSync } from "node:fs";
 import { resolve } from "node:path";

package/dist/cli/{render-5y5a1QZr.js → render-BJF9ytUi.js}

@@ -1,10 +1,10 @@
 import { n as CliError, r as errorText } from "./errors-BTe6A15O.js";
 import { n as importPath } from "./io-DH1kcmmP.js";
-import { i as cachedTypesModule, n as cachedDatabaseTypes, s as typesModuleKey } from "./cache-AznIssjI.js";
+import { i as cachedTypesModule, n as cachedDatabaseTypes, s as typesModuleKey } from "./cache-DE2IH1-C.js";
 import { t as byCodePoint } from "./compare-BmIWVEui.js";
-import { f as generateDatabaseTypes, h as restrictSchemas, p as oxfmtInstalled, v as tsTypeOf } from "./snapshot-uTUlEzY2.js";
+import { f as generateDatabaseTypes, h as restrictSchemas, p as oxfmtInstalled, v as tsTypeOf } from "./snapshot-BXmU3IXN.js";
 import { t as isRecord$1 } from "./guards-CUlDNYZs.js";
-import { a as toCatalog } from "./source-D2gJHKwC.js";
+import { a as toCatalog } from "./source-irttnsEb.js";
 import { basename, dirname, isAbsolute, join, posix, relative, resolve } from "node:path";
 import { entityNames } from "better-supabase/blocks";
 import { DEFAULT_CLAIMS, blockEntities, blockEntityRenames, blockSubjectTypes, tenantClaimPaths, tenantNameOf } from "better-supabase/config";
@@ -1627,7 +1627,7 @@ function schemaExtensions(config) {
 		return [{
 			export: manifest.extension,
 			subpath: `blocks/${manifest.name}`,
-			args: manifest.name === "memberships" ? tenantArgs : ""
+			args: manifest.name === "memberships" ? tenantArgs : STAMPED.has(manifest.name) ? stampArgs(name, config.blocks?.[name]?.options?.["stamp"]) : ""
 		}];
 	});
 	if (tenant !== void 0 && !extensions.some((entry) => entry.subpath === "blocks/memberships")) extensions.push({
@@ -1637,6 +1637,12 @@ function schemaExtensions(config) {
 	});
 	return extensions;
 }
+const STAMPED = /* @__PURE__ */ new Set(["created-by", "updated-at"]);
+function stampArgs(name, stamp) {
+	if (stamp === void 0 || stamp === "client") return "";
+	if (stamp === "trigger") return "{ stamp: \"trigger\" }";
+	throw new TypeError(`blocks.${name}.options.stamp must be "client" or "trigger", got ${JSON.stringify(stamp)}`);
+}
 /** The installed blocks with their final names, for `GeneratorModel.blocks`. */
 function generatorBlocks(config) {
 	return Object.entries(blockConfigEntries(config)).filter(([, entry]) => entry.block === void 0).map(([name, entry]) => {
@@ -1721,13 +1727,14 @@ function renamedBlockLines(entries) {
 * `defineBlocks(blockConfig, blocks)`. A renamed instance uses its renamed
 * constant; the others import their block.
 */
-function instanceMapLines(entries, renamed) {
+function instanceMapLines(entries, renamed, synced) {
 	const imported = /* @__PURE__ */ new Map();
 	const members = [];
 	for (const [instance, entry] of Object.entries(entries)) {
 		const manifest = MANIFESTS.get(entry.block ?? instance);
 		const client = manifest?.client;
 		if (manifest === void 0 || client === void 0 || client === null) continue;
+		if (synced !== void 0 && !synced.has(instance)) members.push("  /** Needs the network on native. */");
 		const constant = renamed.get(instance);
 		if (constant !== void 0) {
 			members.push(`  ${prop(instance)}: ${constant},`);
@@ -1754,6 +1761,7 @@ function instanceMapLines(entries, renamed) {
 			" * Every installed block instance with a client, under its key, for",
 			" * `defineBlocks(blockConfig, { ...blocks, ... })`. Override an entry to give",
 			" * a block its ports (`notifications: notificationsBlock.using(...)`).",
+			...synced === void 0 ? [] : [" * Instances outside `gen.powersync.instances` call the Data API, so", " * their hooks need the network on native."],
 			" * @public",
 			" */",
 			"export const blocks = {",
@@ -1807,7 +1815,8 @@ function emitBlockConfig(config, options = {}) {
 	const runtime = options.runtimeImport ?? "better-supabase";
 	const renamed = renamedBlockLines(entries);
 	const constants = nameConstantLines(config, entries);
-	const instances = instanceMapLines(entries, renamed.constants);
+	const synced = config.gen.powersync?.instances;
+	const instances = instanceMapLines(entries, renamed.constants, synced === void 0 ? void 0 : new Set(synced));
 	const specifiers = [
 		...events.length === 0 ? [] : [
 			"type AppTableEventData",