typion 0.0.0-stage → 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,827 @@
+import { n as ConfigError } from "../errors-D-CKO-px.js";
+import { PgTable, getTableConfig } from "drizzle-orm/pg-core";
+import { is, sql } from "drizzle-orm";
+import { parseArgs } from "node:util";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { spawnSync } from "node:child_process";
+import { createInterface } from "node:readline/promises";
+//#region src/cli/output.ts
+var CliError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "CliError";
+	}
+};
+const consoleIo = {
+	out: (line) => console.log(line),
+	err: (line) => console.error(line)
+};
+//#endregion
+//#region src/cli/config.ts
+const NAMES = [
+	"typion.config.ts",
+	"typion.config.js",
+	"typion.config.mts",
+	"typion.config.mjs"
+];
+const DIRS = [
+	"",
+	"src",
+	"app",
+	"config"
+];
+function findConfig(cwd, given) {
+	if (given !== void 0) {
+		const path = isAbsolute(given) ? given : resolve(cwd, given);
+		if (!existsSync(path)) throw new CliError(`No config at ${path}`);
+		return path;
+	}
+	let dir = resolve(cwd);
+	for (;;) {
+		for (const sub of DIRS) for (const name of NAMES) {
+			const candidate = join(dir, sub, name);
+			if (existsSync(candidate)) return candidate;
+		}
+		const parent = dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	throw new CliError(`No typion.config.ts found from ${cwd}. Pass --config <path>, or run \`typion init\`.`);
+}
+async function importConfig(path) {
+	try {
+		return await withoutTypelessWarning(async () => await import(pathToFileURL(path).href));
+	} catch (error) {
+		const jiti = await loadJiti(path);
+		if (jiti === null) throw error;
+		return await jiti.import(path, {});
+	}
+}
+async function withoutTypelessWarning(load) {
+	const emit = process.emitWarning;
+	process.emitWarning = ((warning, ...rest) => {
+		if ((rest[0]?.code ?? rest[1]) === "MODULE_TYPELESS_PACKAGE_JSON") return;
+		emit.call(process, warning, ...rest);
+	});
+	try {
+		return await load();
+	} finally {
+		process.emitWarning = emit;
+	}
+}
+async function loadJiti(path) {
+	try {
+		return (await import("jiti")).createJiti(pathToFileURL(path).href, { interopDefault: true });
+	} catch {
+		return null;
+	}
+}
+function pickConfig(exports, path) {
+	const candidates = [
+		exports.config,
+		exports.default,
+		...Object.values(exports)
+	];
+	for (const value of candidates) if (typeof value === "object" && value !== null && "definition" in value && "schema" in value && typeof value.definition === "object") return value;
+	throw new CliError(`${path} exports no Typion config (expected \`export const config = defineConfig(…)\`)`);
+}
+function loadEnv(dir) {
+	for (const name of [".env.local", ".env"]) {
+		const path = join(dir, name);
+		if (existsSync(path)) process.loadEnvFile(path);
+	}
+}
+async function loadConfig(cwd, given) {
+	loadEnv(cwd);
+	const path = findConfig(cwd, given);
+	return {
+		config: pickConfig(await importConfig(path), path),
+		path,
+		dir: dirname(path)
+	};
+}
+//#endregion
+//#region src/cli/db.ts
+const BREAKPOINT = "--> statement-breakpoint";
+const DEFAULT_DIR = "typion/migrations";
+const DEFAULT_TABLE = "typion_migrations";
+async function api() {
+	try {
+		return await import("drizzle-kit/api-postgres");
+	} catch {
+		throw new CliError("The database commands need drizzle-kit installed (`pnpm add -D drizzle-kit`)");
+	}
+}
+function schemaOf(loaded) {
+	return loaded.config.schema;
+}
+function projectRoot(loaded) {
+	let dir = loaded.dir;
+	for (;;) {
+		if (existsSync(join(dir, "package.json"))) return dir;
+		const parent = dirname(dir);
+		if (parent === dir) return loaded.dir;
+		dir = parent;
+	}
+}
+function migrationsDir(loaded) {
+	const dir = loaded.config.migrations?.dir ?? DEFAULT_DIR;
+	return isAbsolute(dir) ? dir : resolve(projectRoot(loaded), dir);
+}
+function migrationsTable(loaded) {
+	return {
+		schema: loaded.config.migrations?.schema ?? "public",
+		table: loaded.config.migrations?.table ?? DEFAULT_TABLE
+	};
+}
+function readJournal(dir) {
+	try {
+		return JSON.parse(readFileSync(join(dir, "meta", "journal.json"), "utf8"));
+	} catch {
+		return {
+			version: 1,
+			entries: []
+		};
+	}
+}
+function writeJournal(dir, journal) {
+	mkdirSync(join(dir, "meta"), { recursive: true });
+	writeFileSync(join(dir, "meta", "journal.json"), `${JSON.stringify(journal, null, 2)}\n`);
+}
+function connect(loaded) {
+	const adapter = loaded.config.db;
+	if (adapter === void 0) throw new CliError("The config has no database adapter (`db` in defineConfig)");
+	adapter.check?.();
+	return adapter.connect(loaded.config.definition.relations);
+}
+async function push(loaded, io, options) {
+	const { pushSchema } = await api();
+	const db = connect(loaded);
+	const { sqlStatements, hints, apply } = await pushSchema(schemaOf(loaded), db);
+	if (sqlStatements.length === 0) {
+		io.out("The database already matches the config.");
+		return;
+	}
+	for (const statement of sqlStatements) io.out(statement);
+	if (hints.length > 0) {
+		for (const hint of hints) io.err(`! ${hint.hint}`);
+		if (options.force !== true) throw new CliError("These changes can lose data: run again with --force to apply them.");
+	}
+	await apply();
+	io.out(`Applied ${sqlStatements.length} statement(s).`);
+	await loaded.config.db?.close?.();
+}
+async function generate(loaded, io, options) {
+	const { generateDrizzleJson, generateMigration } = await api();
+	const dir = migrationsDir(loaded);
+	const journal = readJournal(dir);
+	const last = journal.entries.at(-1);
+	const previous = last === void 0 ? await generateDrizzleJson({}) : JSON.parse(readFileSync(join(dir, "meta", `${String(last.idx).padStart(4, "0")}_snapshot.json`), "utf8"));
+	const current = await generateDrizzleJson(schemaOf(loaded), previous.id);
+	const statements = await generateMigration(previous, current);
+	if (statements.length === 0) {
+		io.out("No changes: the migrations already describe the config.");
+		return;
+	}
+	const idx = (last?.idx ?? -1) + 1;
+	const tag = `${String(idx).padStart(4, "0")}_${(options.name ?? "change").replace(/[^a-z0-9_-]+/gi, "_")}`;
+	mkdirSync(join(dir, "meta"), { recursive: true });
+	writeFileSync(join(dir, `${tag}.sql`), `${statements.join(`\n${BREAKPOINT}\n`)}\n`);
+	writeFileSync(join(dir, "meta", `${String(idx).padStart(4, "0")}_snapshot.json`), `${JSON.stringify(current, null, 2)}\n`);
+	journal.entries.push({
+		idx,
+		tag,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString()
+	});
+	writeJournal(dir, journal);
+	io.out(`Wrote ${tag}.sql with ${statements.length} statement(s).`);
+}
+async function applied(db, where) {
+	if (where.schema !== "public") await db.execute(sql.raw(`create schema if not exists "${where.schema}"`));
+	await db.execute(sql.raw(`create table if not exists "${where.schema}"."${where.table}" (tag text primary key, applied_at timestamptz not null default now())`));
+	const rows = await db.execute(sql.raw(`select tag from "${where.schema}"."${where.table}"`));
+	const list = rows.rows ?? rows;
+	return new Set(list.map((row) => row.tag));
+}
+async function migrate(loaded, io) {
+	const dir = migrationsDir(loaded);
+	const journal = readJournal(dir);
+	if (journal.entries.length === 0) {
+		io.out("No migrations to apply: run `typion db generate` first.");
+		return;
+	}
+	const db = connect(loaded);
+	const where = migrationsTable(loaded);
+	const done = await applied(db, where);
+	const pending = journal.entries.filter((entry) => !done.has(entry.tag));
+	if (pending.length === 0) {
+		io.out("The database is up to date.");
+		await loaded.config.db?.close?.();
+		return;
+	}
+	for (const entry of pending) {
+		const statements = readFileSync(join(dir, `${entry.tag}.sql`), "utf8").split(BREAKPOINT).map((statement) => statement.trim()).filter((statement) => statement !== "");
+		await db.transaction(async (tx) => {
+			for (const statement of statements) await tx.execute(sql.raw(statement));
+			await tx.execute(sql.raw(`insert into "${where.schema}"."${where.table}" (tag) values ('${entry.tag}')`));
+		});
+		io.out(`Applied ${entry.tag} (${statements.length} statement(s)).`);
+	}
+	await loaded.config.db?.close?.();
+}
+const SEED_FILES = [
+	"typion/seed.ts",
+	"typion/seed.js",
+	"seed.ts",
+	"seed.js"
+];
+function findSeedFile(loaded, given) {
+	if (given !== void 0) {
+		const path = isAbsolute(given) ? given : resolve(process.cwd(), given);
+		if (!existsSync(path)) throw new CliError(`No seed file at ${path}`);
+		return path;
+	}
+	for (const dir of [projectRoot(loaded), loaded.dir]) for (const name of SEED_FILES) {
+		const candidate = join(dir, name);
+		if (existsSync(candidate)) return candidate;
+	}
+	return null;
+}
+async function anyRows(loaded) {
+	const db = connect(loaded);
+	for (const entity of Object.values(loaded.config.definition.entities)) {
+		if (entity.owner !== "user") continue;
+		const where = `"${entity.pgSchema ?? "public"}"."${entity.tableName}"`;
+		const rows = await db.execute(sql.raw(`select 1 from ${where} limit 1`));
+		if ((rows.rows ?? rows).length > 0) return true;
+	}
+	return false;
+}
+async function seed(loaded, io, options) {
+	if (options.ifEmpty === true && await anyRows(loaded)) {
+		io.out("The collections already hold rows: nothing seeded.");
+		await loaded.config.db?.close?.();
+		return;
+	}
+	const { resetTables, seedCollections } = await import("../seed/index.js");
+	if (options.reset === true) {
+		await resetTables(loaded.config);
+		io.out("Emptied every table of the config.");
+	}
+	if (options.random === true) {
+		await seedCollections(loaded.config, {
+			count: options.count,
+			seed: options.seed
+		});
+		io.out(`Seeded every collection with ${options.count ?? 10} rows.`);
+		await loaded.config.db?.close?.();
+		return;
+	}
+	const file = findSeedFile(loaded, options.file);
+	if (file === null) throw new CliError("No seed file found (typion/seed.ts). Write one, point at it with --file, or use --random.");
+	const { getTypion } = await import("../typion-TJWDkHGh.js").then((n) => n.i);
+	const typion = await getTypion(loaded.config);
+	const seedModule = await import(pathToFileURL(file).href);
+	const run = seedModule.seed ?? seedModule.default;
+	if (typeof run !== "function") throw new CliError(`${file} exports no seed function (\`export async function seed({ typion })\`)`);
+	await run({
+		typion,
+		config: loaded.config
+	});
+	io.out(`Ran ${file}.`);
+	await loaded.config.db?.close?.();
+}
+async function status(loaded, io) {
+	const journal = readJournal(migrationsDir(loaded));
+	const done = await applied(connect(loaded), migrationsTable(loaded));
+	if (journal.entries.length === 0) io.out("No migrations yet.");
+	for (const entry of journal.entries) io.out(`${done.has(entry.tag) ? "applied" : "pending"}  ${entry.tag}`);
+	const tables = Object.values(schemaOf(loaded)).filter((value) => is(value, PgTable));
+	io.out(`${tables.length} table(s) in the config: ${tables.map((t) => getTableConfig(t).name).join(", ")}`);
+	await loaded.config.db?.close?.();
+}
+async function studio(loaded, io, options) {
+	const { startStudioServer } = await api();
+	const credentials = loaded.config.db?.credentials?.();
+	if (credentials === void 0) throw new CliError("This database adapter cannot open Studio: pass `url` to dbAdapter(), or use typion/db/pglite.");
+	io.out(`Studio on https://local.drizzle.studio (port ${options.port ?? 4983})`);
+	await startStudioServer(schemaOf(loaded), credentials, { port: options.port });
+}
+//#endregion
+//#region src/cli/agents.ts
+const START_MARKER = "<!-- BEGIN:typion-agent-rules -->";
+const END_MARKER = "<!-- END:typion-agent-rules -->";
+const AGENT_RULES = `${START_MARKER}
+
+# Typion
+
+This application's data layer is Typion, which is newer than your training data. Before you add or change a
+collection, an access rule, a hook, a query or an API route, read \`node_modules/typion/docs/README.md\` (resolved
+from this file's directory) and the page it points to for the task.
+
+- Read and write the application's data through Typion, bound to the caller: \`getApp(config)\` on Next.js,
+  \`c.var.typion\` on Hono, \`typion.$fromRequest(request)\` elsewhere, \`typion.$as(ctx)\`. Never through
+  \`typion.$db\`, Drizzle or SQL: they skip the access rules, tenants, soft delete, drafts, hooks and the history.
+- \`typion.$system({ reason })\` skips the access rules: for seeds, jobs and webhooks, never to answer a user's
+  request.
+- Authorization lives in each collection's \`access\` rules, deny by default, not in pages, routes or server
+  actions.
+- Every schema change ships a migration: \`typion db generate --name <change>\`.
+
+This block is written by \`typion init\`; run it again after upgrading Typion.
+
+${END_MARKER}`;
+const SKILL_MARKER = "<!-- Written by `typion init`, which rewrites it: keep project notes in AGENTS.md. -->";
+const SKILL = `---
+name: typion
+description: Use for any change to this application's data layer with Typion — collections, access rules, hooks, queries and descriptors, API routes, seeds, migrations, or tests that touch typion.config.ts or the typion/ folder next to it.
+---
+
+${SKILL_MARKER}
+
+Typion is newer than your training data. Its guide ships with the installed version, in \`node_modules/typion/docs/\`.
+
+1. Read \`node_modules/typion/docs/README.md\`: the model, the rules, where things go.
+2. Read the page for the task:
+   - \`collections.md\`: a collection, its columns and relations, a many-to-many
+   - \`access.md\`: who reads and writes what, hidden columns, what a caller sees
+   - \`auth.md\`: signing in, who the caller is
+   - \`hooks.md\`: reacting to writes
+   - \`queries.md\`: reads, writes, descriptors, transactions, errors
+   - \`http.md\`: Next.js pages and server actions, Hono, the routes, the browser client, business operations
+   - \`database.md\`: drivers, migrations, seed
+   - \`testing.md\`: tests
+   - \`features/\`: localization, multi-tenancy, soft delete, versions and drafts
+3. Before you call the change done: \`tsc\` passes, every new collection has its rules, a test covers a caller the
+   rules allow and one they refuse, and a schema change has its migration.
+`;
+function upsert(existing) {
+	const eol = existing.includes("\r\n") ? "\r\n" : "\n";
+	const block = AGENT_RULES.replace(/\n/g, eol);
+	const start = existing.indexOf(START_MARKER);
+	const end = existing.indexOf(END_MARKER, start);
+	if (start !== -1 && end !== -1) return existing.slice(0, start) + block + existing.slice(end + 31);
+	if (existing.length === 0) return `${block}${eol}`;
+	return `${existing.endsWith(eol) ? existing : `${existing}${eol}`}${eol}${block}${eol}`;
+}
+function writeFile(path, next, previous) {
+	if (previous === next) return "unchanged";
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, next);
+	return previous === null ? "created" : "updated";
+}
+function read(path) {
+	return existsSync(path) ? readFileSync(path, "utf8") : null;
+}
+function writeAgentNotes(root, io) {
+	const agentsPath = join(root, "AGENTS.md");
+	const claudePath = join(root, "CLAUDE.md");
+	const agents = read(agentsPath);
+	const claude = read(claudePath);
+	const report = (path, outcome) => {
+		const verb = {
+			created: "Created",
+			updated: "Updated",
+			kept: "Kept",
+			unchanged: null
+		}[outcome];
+		if (verb !== null) io.out(`${verb} ${relative(process.cwd(), path)}.`);
+	};
+	const claudeHostsBlock = claude?.includes("<!-- BEGIN:typion-agent-rules -->") ?? false;
+	if (agents !== null && (agents.includes("<!-- BEGIN:typion-agent-rules -->") || !claudeHostsBlock)) report(agentsPath, writeFile(agentsPath, upsert(agents), agents));
+	else if (claude !== null) report(claudePath, writeFile(claudePath, upsert(claude), claude));
+	else {
+		report(agentsPath, writeFile(agentsPath, upsert(""), null));
+		report(claudePath, writeFile(claudePath, "@AGENTS.md\n", null));
+	}
+	const skillPath = join(root, ".claude", "skills", "typion", "SKILL.md");
+	const skill = read(skillPath);
+	if (skill !== null && !skill.includes(SKILL_MARKER)) io.out(`Kept ${relative(process.cwd(), skillPath)} (it is not Typion's any more).`);
+	else report(skillPath, writeFile(skillPath, SKILL, skill));
+}
+//#endregion
+//#region src/cli/init.ts
+const DRIZZLE = "1.0.0-rc.4";
+function packageManager(root) {
+	if (existsSync(join(root, "pnpm-lock.yaml"))) return "pnpm";
+	if (existsSync(join(root, "yarn.lock"))) return "yarn";
+	if (existsSync(join(root, "bun.lock")) || existsSync(join(root, "bun.lockb"))) return "bun";
+	if (existsSync(join(root, "package-lock.json"))) return "npm";
+	const agent = process.env.npm_config_user_agent ?? "";
+	if (agent.startsWith("yarn")) return "yarn";
+	if (agent.startsWith("bun")) return "bun";
+	if (agent.startsWith("pnpm")) return "pnpm";
+	return "npm";
+}
+function installCommand(manager, packages, dev) {
+	const flag = dev ? manager === "npm" ? "--save-dev" : "-D" : "";
+	return {
+		command: manager,
+		args: [
+			manager === "npm" ? "install" : "add",
+			...flag === "" ? [] : [flag],
+			...packages
+		]
+	};
+}
+async function confirm(question, io) {
+	if (!process.stdin.isTTY) {
+		io.out(`${question} — not a terminal, so nothing was installed. Re-run with --yes.`);
+		return false;
+	}
+	const rl = createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	try {
+		const answer = (await rl.question(`${question} [Y/n] `)).trim().toLowerCase();
+		return answer === "" || answer === "y" || answer === "yes";
+	} finally {
+		rl.close();
+	}
+}
+function run$1(command, args, cwd, io) {
+	io.out(`> ${command} ${args.join(" ")}`);
+	const result = spawnSync(command, [...args], {
+		cwd,
+		stdio: "inherit"
+	});
+	if (result.error !== void 0 || result.status !== null && result.status !== 0) throw new CliError(`\`${command} ${args.join(" ")}\` failed; install them yourself and re-run.`);
+}
+function readJson(path) {
+	try {
+		return JSON.parse(readFileSync(path, "utf8"));
+	} catch {
+		return null;
+	}
+}
+function inspect(cwd) {
+	const pkg = readJson(join(cwd, "package.json"));
+	if (pkg === null) throw new CliError(`No package.json in ${cwd}: run this inside your project.`);
+	const deps = {
+		...pkg.dependencies,
+		...pkg.devDependencies
+	};
+	const src = existsSync(join(cwd, "src")) ? join(cwd, "src") : cwd;
+	const appDir = [join(src, "app"), join(cwd, "app")].find((dir) => existsSync(dir)) ?? null;
+	return {
+		root: cwd,
+		src,
+		framework: deps.next !== void 0 ? "next" : deps.hono !== void 0 ? "hono" : "none",
+		dependencies: new Set(Object.keys(deps)),
+		appDir
+	};
+}
+function write(path, contents, io) {
+	if (existsSync(path)) {
+		io.out(`Kept ${relative(process.cwd(), path)} (it exists already).`);
+		return false;
+	}
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, contents);
+	io.out(`Created ${relative(process.cwd(), path)}.`);
+	return true;
+}
+const COLLECTION = `import { text } from 'drizzle-orm/pg-core'
+import { collection } from 'typion'
+
+export const pages = collection('pages', {
+  columns: {
+    title: text().notNull(),
+    slug: text().notNull().unique(),
+  },
+  public: true,
+})
+`;
+function configFile(driver) {
+	return `${driver === "pglite" ? `import { defineConfig, defineSetup } from 'typion'\nimport { pglite } from 'typion/db/pglite'` : `import { drizzle } from 'drizzle-orm/node-postgres'\nimport { dbAdapter, defineConfig, defineSetup } from 'typion'`}
+import { pages } from './typion/collections/pages.ts'
+
+// What the application knows about a caller: rules, hooks and field rules read it. Registered below as well, since
+// field rules are typed before this config exists.
+export type AppContext = {
+  actorId: string | null
+}
+
+// A constant of its own: the collections read it to type their options and their columns, which happens before
+// this config exists. It takes the features (\`localization\`, \`multiTenant\`) and the plugins (\`plugins: […]\`).
+export const setup = defineSetup({})
+
+export const config = defineConfig({
+  setup,
+  collections: [pages],
+${driver === "pglite" ? `  db: pglite({ dataDir: '.pglite' }),` : `  db: dbAdapter((relations) => drizzle(process.env.DATABASE_URL!, { relations }), {\n    url: process.env.DATABASE_URL,\n  }),`}
+  // Who is calling. Return your own shape; declare the return type, the body may query \`system\`.
+  context: async ({ headers }): Promise<AppContext> => {
+    void headers
+    return { actorId: null }
+  },
+})
+
+declare module 'typion' {
+  interface Register {
+    setup: typeof setup
+    config: typeof config
+    context: AppContext
+  }
+}
+`;
+}
+function allowTsImports(root, io) {
+	const path = join(root, "tsconfig.json");
+	if (!existsSync(path)) return;
+	const json = readJson(path);
+	const options = json?.compilerOptions ?? {};
+	if (options.allowImportingTsExtensions === true || options.rewriteRelativeImportExtensions === true) return;
+	const flag = options.noEmit === true ? "allowImportingTsExtensions" : "rewriteRelativeImportExtensions";
+	if (json === null) {
+		io.out(`Add "${flag}": true to the compilerOptions of tsconfig.json: Typion's imports end in .ts.`);
+		return;
+	}
+	json.compilerOptions = {
+		...options,
+		[flag]: true
+	};
+	writeFileSync(path, `${JSON.stringify(json, null, 2)}\n`);
+	io.out(`Set ${flag} in tsconfig.json: Typion's imports end in .ts.`);
+}
+const ROUTE = `import { rest } from '@typion/rest'
+import { rpc } from '@typion/rpc'
+import { routeHandlers } from 'typion/next'
+import { config } from '@/typion.config.ts'
+
+// What the app serves over HTTP: a resource per collection, and the endpoint the browser client posts to. Leave
+// out what you do not use.
+export const { GET, POST, PATCH, PUT, DELETE, OPTIONS } = await routeHandlers(config, {
+  transports: [rest(), rpc()],
+})
+`;
+async function init(cwd, io, options) {
+	const project = inspect(cwd);
+	const driver = options.driver === "postgres" ? "postgres" : "pglite";
+	if (write(join(project.src, "typion.config.ts"), configFile(driver), io)) write(join(project.src, "typion", "collections", "pages.ts"), COLLECTION, io);
+	allowTsImports(project.root, io);
+	if (project.framework === "next" && project.appDir !== null) write(join(project.appDir, "api", "[...path]", "route.ts"), ROUTE, io);
+	writeAgentNotes(project.root, io);
+	await installDependencies(project, driver, io, options);
+	io.out("");
+	io.out("Next:");
+	io.out("  1. turn on what you need: `softDelete` or `versions` on a collection, `localization`, `multiTenant` or `plugins` in `defineSetup`");
+	io.out(existsSync(join(project.root, "typion", "migrations")) ? "  2. `typion db migrate` to apply the migrations, then `typion db seed`" : "  2. `typion db push` to create the tables, then `typion db seed`");
+	if (project.framework === "next") io.out("  3. read from a server component with `const app = await getApp(config)` (typion/next)");
+	if (project.framework === "hono") {
+		io.out("  3. mount the transports in your Hono app: `.all('/api/*', typionRoutes(config, { transports: [rest(), rpc()] }))` (typion/hono)");
+		io.out("  4. bind the caller in your own routes with `typionMiddleware(config)`: `c.var.typion`");
+	}
+}
+async function installDependencies(project, driver, io, options) {
+	const deps = [
+		"typion",
+		"drizzle-orm",
+		driver === "pglite" ? "@electric-sql/pglite" : "pg",
+		...project.framework === "none" ? [] : ["@typion/rest", "@typion/rpc"]
+	];
+	const dev = ["drizzle-kit"];
+	const spec = (name) => name.startsWith("drizzle-") ? `${name}@${DRIZZLE}` : name;
+	const missing = deps.filter((name) => !project.dependencies.has(name)).map(spec);
+	const missingDev = dev.filter((name) => !project.dependencies.has(name)).map(spec);
+	if (missing.length === 0 && missingDev.length === 0) return;
+	const manager = packageManager(project.root);
+	const lines = [...missing.length === 0 ? [] : [installCommand(manager, missing, false)], ...missingDev.length === 0 ? [] : [installCommand(manager, missingDev, true)]];
+	io.out("");
+	io.out("Missing packages:");
+	for (const line of lines) io.out(`  ${line.command} ${line.args.join(" ")}`);
+	if (options.skipInstall === true) return;
+	if (!(options.yes === true || await confirm(`Install them with ${manager}?`, io))) return;
+	for (const line of lines) run$1(line.command, line.args, project.root, io);
+}
+//#endregion
+//#region src/cli/make.ts
+function pascal(name) {
+	return name.replace(/(^|[-_ ])(\w)/g, (_, __, char) => char.toUpperCase());
+}
+function camel(name) {
+	const upper = pascal(name);
+	return upper.charAt(0).toLowerCase() + upper.slice(1);
+}
+function collectionsDir(loaded, given) {
+	if (given !== void 0) return isAbsolute(given) ? given : resolve(process.cwd(), given);
+	const candidates = [join(loaded.dir, "typion", "collections"), join(loaded.dir, "collections")];
+	return candidates.find((dir) => existsSync(dir)) ?? candidates[0];
+}
+function template(name, tenant) {
+	return `import { text } from 'drizzle-orm/pg-core'
+import { collection } from 'typion'
+
+export const ${camel(name)} = collection('${camel(name)}', {
+  columns: {
+    // Plain Drizzle columns; the features and plugins add their own options next to \`columns\`.
+    title: text().notNull(),
+  },${tenant ? "\n  tenant: true," : ""}
+}).define({
+  // Deny by default: an operation without a rule is refused. Give each one the rule it needs, for example
+  // \`read: ({ ctx }) => ctx.actorId !== null\`.
+  access: {},
+})
+`;
+}
+function importPath(from, to) {
+	const path = relative(from, to).replaceAll("\\", "/");
+	return path.startsWith(".") ? path : `./${path}`;
+}
+function register(loaded, name, file, io) {
+	const source = readFileSync(loaded.path, "utf8");
+	const specifier = importPath(loaded.dir, file).replace(/\.ts$/, ".ts");
+	const line = `import { ${camel(name)} } from '${specifier}'`;
+	const list = /collections:\s*\[([^\]]*)\]/.exec(source);
+	if (source.includes(line) || list === null) {
+		io.out("Add it to the config:");
+		io.out(`  ${line}`);
+		io.out(`  collections: [ …, ${camel(name)} ]`);
+		return;
+	}
+	const entries = list[1].trim();
+	const updated = source.replace(/(^import .*\n)(?![\s\S]*^import )/m, `$1${line}\n`).replace(/collections:\s*\[([^\]]*)\]/, `collections: [${entries === "" ? "" : `${entries.replace(/,\s*$/, "")}, `}${camel(name)}]`);
+	writeFileSync(loaded.path, updated);
+	io.out(`Registered it in ${relative(process.cwd(), loaded.path)}.`);
+}
+function pluginTemplate(name) {
+	const id = camel(name);
+	const Kinds = `${pascal(name)}Kinds`;
+	const Options = `${pascal(name)}Options`;
+	return `import { definePlugin } from 'typion'
+import type { CollectionKinds } from 'typion'
+
+// What this plugin adds to every collection. A collection that does not set the option gets nothing.
+export type ${Options} = { ${id}?: boolean }
+
+// How the option turns into columns and into engine options, read from \`this['options']\`.
+interface ${Kinds} extends CollectionKinds {
+  readonly columns: this['options'] extends { ${id}: true } ? {} : {}
+  readonly entity: this['options'] extends { ${id}: true } ? {} : {}
+}
+
+export function ${id}() {
+  return definePlugin({
+    id: '${id}',
+    collection: {
+      $options: {} as ${Options},
+      $kinds: {} as ${Kinds},
+      // Option keys this plugin reads, so they never reach the engine as entity options.
+      consumes: ['${id}'],
+      columns: (options) => (options.${id} === true ? {} : {}),
+      entity: (options) => (options.${id} === true ? {} : {}),
+    },
+    // Tables, relations, entities, hooks, api, routes, errors and context go here too; see @typion/audit.
+  })
+}
+`;
+}
+function makePlugin(loaded, io, name, options) {
+	if (!/^[a-z][a-z0-9_-]*$/i.test(name)) throw new CliError(`'${name}' is not a plugin name (letters, digits, dash, underscore)`);
+	const dir = options.dir === void 0 ? join(loaded.dir, "typion", "plugins") : isAbsolute(options.dir) ? options.dir : resolve(process.cwd(), options.dir);
+	const file = join(dir, `${camel(name)}.ts`);
+	if (existsSync(file)) throw new CliError(`${relative(process.cwd(), file)} already exists`);
+	mkdirSync(dir, { recursive: true });
+	writeFileSync(file, pluginTemplate(name));
+	io.out(`Created ${relative(process.cwd(), file)}.`);
+	io.out("Install it in the config:");
+	io.out(`  import { ${camel(name)} } from './${relative(loaded.dir, file).replaceAll("\\", "/")}'`);
+	io.out(`  export const setup = defineSetup({ plugins: [ …, ${camel(name)}() ] })`);
+}
+function makeCollection(loaded, io, name, options) {
+	if (!/^[a-z][a-z0-9_-]*$/i.test(name)) throw new CliError(`'${name}' is not a collection name (letters, digits, dash, underscore)`);
+	const dir = collectionsDir(loaded, options.dir);
+	const file = join(dir, `${camel(name)}.ts`);
+	if (existsSync(file)) throw new CliError(`${relative(process.cwd(), file)} already exists`);
+	mkdirSync(dirname(file), { recursive: true });
+	const tenant = loaded.config.definition.plugins.some((plugin) => plugin.id === "multiTenant");
+	writeFileSync(file, template(name, tenant));
+	io.out(`Created ${relative(process.cwd(), file)}.`);
+	register(loaded, name, file, io);
+	io.out("Then `typion db push` (or `typion db generate` + `typion db migrate`).");
+}
+//#endregion
+//#region src/cli/index.ts
+const HELP = `typion — the CLI of a Typion project
+
+Usage
+  typion <group> <command> [options]
+
+Database (everything that touches the schema, through drizzle-kit)
+  typion db push [--force]        make the database match the config (development)
+  typion db generate [--name x]   write the SQL of what changed, with its snapshot
+  typion db migrate               apply the migrations the database has not applied
+  typion db seed [--file path]    run the project's seed through the engine
+                 [--random]       ask drizzle-seed for rows instead (--count, --seed)
+                 [--reset]        empty every table of the config first
+                 [--if-empty]     do nothing when a collection already holds rows
+  typion db status                what is applied, what is pending
+  typion db studio [--port n]     open Drizzle Studio on this config
+
+Project
+  typion make collection <name> [--dir path]   a new collection, registered in the config
+  typion make plugin <name> [--dir path]       a plugin skeleton for this project
+  typion init [--driver pglite|postgres] [--yes] [--skip-install]
+                                               set Typion up in a project that exists, with the
+                                               notes its agents read (run it again after upgrading)
+
+Options
+  --config <path>   the config to read; by default the nearest typion.config.ts
+  --help            this text (also: typion db --help)
+`;
+const DB_HELP = `typion db — the database of a Typion config
+
+  push [--force]        make the database match the config (development)
+  generate [--name x]   write the SQL of what changed, with its snapshot
+  migrate               apply the migrations the database has not applied
+  seed [--file|--random] fill the database: the project's seed, or drizzle-seed rows
+  status                what is applied, what is pending
+  studio [--port n]     open Drizzle Studio on this config
+`;
+const OPTIONS = {
+	config: { type: "string" },
+	name: { type: "string" },
+	dir: { type: "string" },
+	driver: { type: "string" },
+	port: { type: "string" },
+	file: { type: "string" },
+	count: { type: "string" },
+	seed: { type: "string" },
+	force: { type: "boolean" },
+	random: { type: "boolean" },
+	reset: { type: "boolean" },
+	"if-empty": { type: "boolean" },
+	"skip-install": { type: "boolean" },
+	yes: { type: "boolean" },
+	help: { type: "boolean" }
+};
+function port(raw) {
+	if (raw === void 0) return void 0;
+	if (!/^\d+$/.test(raw)) throw new CliError("--port must be a number");
+	return Number(raw);
+}
+async function run(argv, io = consoleIo, cwd = process.cwd()) {
+	const { values, positionals } = parseArgs({
+		args: [...argv],
+		options: OPTIONS,
+		allowPositionals: true,
+		strict: true
+	});
+	const [group, command, argument] = positionals;
+	if (group === void 0 || values.help === true) {
+		io.out(group === "db" ? DB_HELP : HELP);
+		return;
+	}
+	const config = async () => loadConfig(cwd, values.config);
+	switch (`${group} ${command ?? ""}`.trim()) {
+		case "db push": return push(await config(), io, { force: values.force });
+		case "db generate": return generate(await config(), io, { name: values.name });
+		case "db migrate": return migrate(await config(), io);
+		case "db seed": return seed(await config(), io, {
+			file: values.file,
+			random: values.random,
+			count: values.count === void 0 ? void 0 : Number(values.count),
+			seed: values.seed === void 0 ? void 0 : Number(values.seed),
+			reset: values.reset,
+			ifEmpty: values["if-empty"]
+		});
+		case "db status": return status(await config(), io);
+		case "db studio": return studio(await config(), io, { port: port(values.port) });
+		case "db":
+			io.out(DB_HELP);
+			return;
+		case "make collection":
+			if (argument === void 0) throw new CliError("Usage: typion make collection <name>");
+			return makeCollection(await config(), io, argument, { dir: values.dir });
+		case "make plugin":
+			if (argument === void 0) throw new CliError("Usage: typion make plugin <name>");
+			return makePlugin(await config(), io, argument, { dir: values.dir });
+		case "make": throw new CliError("Usage: typion make collection|plugin <name>");
+		case "init": return init(cwd, io, {
+			driver: values.driver,
+			yes: values.yes,
+			skipInstall: values["skip-install"]
+		});
+		default: throw new CliError(`Unknown command '${[group, command].filter(Boolean).join(" ")}'. Try \`typion --help\`.`);
+	}
+}
+async function main(argv) {
+	try {
+		await run(argv);
+		return 0;
+	} catch (error) {
+		if (error instanceof CliError || error instanceof ConfigError) {
+			console.error(error.message);
+			return 1;
+		}
+		console.error(error);
+		return 1;
+	}
+}
+//#endregion
+export { CliError, main, run };
+
+//# sourceMappingURL=index.js.map