@tatara/cli 0.7.0 → 0.8.0

package/dist/bin.mjs

@@ -190,6 +190,18 @@ function ignored(v, text) {
 	return new RegExp(`tatara-check-ignore\\s+${v.rule}:\\s*\\S`).test(previous);
 }
 //#endregion
+//#region src/project/ejected.ts
+/** Packages the app ejected (`tatara eject`); their code lives in src/ejected/<name>. */
+function ejectedPackages(config) {
+	return Object.keys(config.ejected ?? {});
+}
+/** Points `@tatara/<name>` and `@tatara/<name>/<entry>` imports at the app's ejected copy. */
+function pointAtEjected(text, names) {
+	if (names.length === 0) return text;
+	const pattern = new RegExp(`(["'])@tatara/(${names.join("|")})(?:/([\\w-]+))?\\1`, "g");
+	return text.replace(pattern, (_match, quote, name, entry) => `${quote}#ejected/${name}/${entry ?? "index"}${quote}`);
+}
+//#endregion
 //#region src/commands/sync.ts
 var sync_exports = /* @__PURE__ */ __exportAll({
 	specifier: () => specifier,
@@ -235,19 +247,21 @@ async function writeIfChanged(path, content, written) {
 }
 async function sync(project = loadProject()) {
 	const { root } = project;
+	const ejected = ejectedPackages(project.config);
+	const write = (path, content, out) => writeIfChanged(path, pointAtEjected(content, ejected), out);
 	const out = join(root, "src/generated");
 	await mkdir(out, { recursive: true });
 	const written = [];
 	const dirs = ["src/core/*", "src/modules/*"];
 	const routes = await find(root, dirs.map((d) => `${d}/routes/*.routes.ts`));
-	await writeIfChanged(join(out, "routes.ts"), listModule(routes, {
+	await write(join(out, "routes.ts"), listModule(routes, {
 		prefix: "routes",
 		typeImport: "import type { RouteDefinition } from \"#core/http/routes\";",
 		typeName: "RouteDefinition",
 		exportName: "routes"
 	}), written);
 	const commands = await find(root, dirs.map((d) => `${d}/commands/*.ts`));
-	await writeIfChanged(join(out, "commands.ts"), listModule(commands, {
+	await write(join(out, "commands.ts"), listModule(commands, {
 		prefix: "command",
 		typeImport: "import type { CommandDefinition } from \"@tatara/core\";",
 		typeName: "CommandDefinition",
@@ -255,14 +269,14 @@ async function sync(project = loadProject()) {
 	}), written);
 	if (project.has("jobs")) {
 		const consumers = await find(root, dirs.map((d) => `${d}/consumers/*.ts`));
-		await writeIfChanged(join(out, "consumers.ts"), listModule(consumers, {
+		await write(join(out, "consumers.ts"), listModule(consumers, {
 			prefix: "consumer",
 			typeImport: "import type { ConsumerDefinition } from \"@tatara/jobs\";",
 			typeName: "ConsumerDefinition",
 			exportName: "consumers"
 		}), written);
 		const schedules = await find(root, dirs.map((d) => `${d}/schedules/*.ts`));
-		await writeIfChanged(join(out, "schedules.ts"), listModule(schedules, {
+		await write(join(out, "schedules.ts"), listModule(schedules, {
 			prefix: "schedule",
 			typeImport: "import type { ScheduleDefinition } from \"@tatara/jobs\";",
 			typeName: "ScheduleDefinition",
@@ -273,7 +287,7 @@ async function sync(project = loadProject()) {
 		const permissions = await find(root, ["src/modules/*/permissions/*.permissions.ts"]);
 		const imports = permissions.map((f) => `import ${identifier(f, "permissions")} from "${specifier(f)}";`);
 		const names = permissions.map((f) => identifier(f, "permissions"));
-		await writeIfChanged(join(out, "permissions.ts"), `${HEADER}import { authzPermissions, mergeCatalogs, type PermissionKeysOf } from "@tatara/authz";
+		await write(join(out, "permissions.ts"), `${HEADER}import { authzPermissions, mergeCatalogs, type PermissionKeysOf } from "@tatara/authz";
 ${imports.join("\n")}${imports.length ? "\n" : ""}
 export const catalog = mergeCatalogs(authzPermissions${names.map((n) => `, ${n}`).join("")});
 
@@ -283,7 +297,7 @@ export type PermissionKey =
 	}
 	if (project.config.database !== "none") {
 		const seeds = await find(root, dirs.map((d) => `${d}/db/seed.ts`));
-		await writeIfChanged(join(out, "seeds.ts"), listModule(seeds, {
+		await write(join(out, "seeds.ts"), listModule(seeds, {
 			prefix: "seed",
 			typeImport: "import type { SeedDefinition } from \"@tatara/db\";",
 			typeName: "SeedDefinition",
@@ -292,7 +306,7 @@ export type PermissionKey =
 	}
 	if (project.config.orm === "drizzle") {
 		const schemas = await find(root, dirs.map((d) => `${d}/db/*.schema.ts`));
-		await writeIfChanged(join(out, "schema.ts"), `${HEADER}${schemas.map((f) => `export * from "${specifier(f)}";`).join("\n")}\nexport {};\n`, written);
+		await write(join(out, "schema.ts"), `${HEADER}${schemas.map((f) => `export * from "${specifier(f)}";`).join("\n")}\nexport {};\n`, written);
 	}
 	if (project.config.orm === "prisma") {
 		const bin = join(root, "node_modules/.bin/prisma");
@@ -650,6 +664,121 @@ function printDoctor(checks) {
 	}
 }
 //#endregion
+//#region src/commands/eject.ts
+var EjectError = class extends Error {};
+const short = (name) => name.replace(/^@tatara\//, "");
+const full = (name) => `@tatara/${short(name)}`;
+const NOT_LIBRARIES = /* @__PURE__ */ new Set(["cli", "create-tatara"]);
+async function readJson(path) {
+	return JSON.parse(await readFile(path, "utf8"));
+}
+/**
+* Copies a package's source into src/ejected/<name>, points the app's imports at it and records
+* it in tatara.json. From then on the app owns that code and `tatara upgrade` leaves it alone.
+*/
+async function eject(project, name, opts = {}) {
+	const target = short(name);
+	if (NOT_LIBRARIES.has(target)) throw new EjectError(`${full(target)} is a tool, not a library`);
+	const appPkgPath = join(project.root, "package.json");
+	const appPkg = await readJson(appPkgPath);
+	const installed = Object.keys({
+		...appPkg.dependencies,
+		...appPkg.devDependencies
+	}).filter((dep) => dep.startsWith("@tatara/") && !NOT_LIBRARIES.has(short(dep))).map(short);
+	const already = ejectedPackages(project.config);
+	if (already.includes(target)) throw new EjectError(`${full(target)} is already ejected`);
+	if (!installed.includes(target)) throw new EjectError(`${full(target)} is not a dependency of this app`);
+	const manifests = /* @__PURE__ */ new Map();
+	for (const dep of installed) {
+		const path = join(project.root, "node_modules", full(dep), "package.json");
+		if (existsSync(path)) manifests.set(dep, await readJson(path));
+	}
+	const chain = [target];
+	for (let i = 0; i < chain.length; i++) for (const [dep, manifest] of manifests) {
+		if (chain.includes(dep)) continue;
+		if (full(chain[i]) in (manifest.peerDependencies ?? {})) chain.push(dep);
+	}
+	const dependents = chain.slice(1);
+	if (dependents.length > 0 && !opts.withDependents) throw new EjectError(`${dependents.map(full).join(", ")} depend on ${full(target)}. Eject them too with --with-dependents.`);
+	const report = {
+		ejected: chain,
+		copied: [],
+		rewritten: [],
+		added: []
+	};
+	const versions = {};
+	for (const dep of chain) {
+		const manifest = manifests.get(dep);
+		const source = join(project.root, "node_modules", full(dep), "src");
+		if (!manifest || !existsSync(source)) throw new EjectError(`${full(dep)} ships no source to eject; update it to a version that does, then run this again`);
+		versions[dep] = manifest.version;
+		const files = await glob(["**/*.ts"], {
+			cwd: source,
+			ignore: ["**/*.test.ts"]
+		});
+		for (const file of files) {
+			const to = `src/ejected/${dep}/${file}`;
+			await mkdir(dirname(join(project.root, to)), { recursive: true });
+			await cp(join(source, file), join(project.root, to));
+			report.copied.push(to);
+		}
+	}
+	const ejected = [...already, ...chain];
+	for (const file of await glob(["src/**/*.ts", "tests/**/*.ts"], { cwd: project.root })) {
+		const path = join(project.root, file);
+		const text = await readFile(path, "utf8");
+		const next = pointAtEjected(text, ejected);
+		if (next !== text) {
+			await writeFile(path, next);
+			if (!report.copied.includes(file)) report.rewritten.push(file);
+		}
+	}
+	const deps = { ...appPkg.dependencies };
+	const listed = new Set(Object.keys({
+		...appPkg.dependencies,
+		...appPkg.devDependencies
+	}));
+	for (const dep of chain) {
+		const manifest = manifests.get(dep);
+		for (const [peer, range] of Object.entries(manifest.peerDependencies ?? {})) {
+			if (listed.has(peer) || manifest.peerDependenciesMeta?.[peer]?.optional) continue;
+			if (peer.startsWith("@tatara/") && ejected.includes(short(peer))) continue;
+			deps[peer] = range;
+			listed.add(peer);
+			report.added.push(peer);
+		}
+	}
+	for (const dep of chain) delete deps[full(dep)];
+	const devDeps = { ...appPkg.devDependencies };
+	for (const dep of chain) delete devDeps[full(dep)];
+	const nextPkg = {
+		...appPkg,
+		imports: {
+			...appPkg.imports,
+			"#ejected/*": "./src/ejected/*.ts"
+		},
+		dependencies: Object.fromEntries(Object.entries(deps).sort(([a], [b]) => a.localeCompare(b))),
+		devDependencies: devDeps
+	};
+	await writeFile(appPkgPath, `${JSON.stringify(nextPkg, null, "	")}\n`);
+	const configPath = join(project.root, "tatara.json");
+	const config = await readJson(configPath);
+	await writeFile(configPath, `${JSON.stringify({
+		...config,
+		ejected: {
+			...config.ejected,
+			...versions
+		}
+	}, null, "	")}\n`);
+	if (opts.formatFile) for (const file of [
+		...report.copied,
+		...report.rewritten,
+		"package.json",
+		"tatara.json"
+	]) await opts.formatFile(file, project);
+	return report;
+}
+//#endregion
 //#region src/paths.ts
 /** Package root: one level above both src/ (dev) and dist/ (published, bundled). */
 const PACKAGE_ROOT = resolve(import.meta.dirname, "..");
@@ -2580,7 +2709,7 @@ async function generate(project, request) {
 	for (const [rel, text] of rendered) {
 		const full = join(project.root, rel);
 		await mkdir(dirname(full), { recursive: true });
-		await writeFile(full, text);
+		await writeFile(full, pointAtEjected(text, ejectedPackages(project.config)));
 	}
 	if (!request.skipPostProcess) await postProcess(project, files);
 	return {
@@ -3953,7 +4082,9 @@ function createContext(project, baseline, opts = {}) {
 	};
 	const abs = (path) => join(project.root, path);
 	let rendered;
-	const write = async (path, text) => {
+	const ejected = ejectedPackages(project.config);
+	const write = async (path, written) => {
+		const text = path.endsWith(".ts") ? pointAtEjected(written, ejected) : written;
 		if (!report.written.includes(path)) {
 			report.written.push(path);
 			const before = existsSync(abs(path)) ? await readFile(abs(path), "utf8") : void 0;
@@ -4014,6 +4145,11 @@ function createContext(project, baseline, opts = {}) {
 			return (await rendered).get(path);
 		},
 		async addDependency(name, range, { dev = false } = {}) {
+			if (ejected.includes(name.replace(/^@tatara\//, ""))) {
+				const note = `${name} is ejected; it was not added (its code is in src/ejected)`;
+				if (!report.notes.includes(note)) report.notes.push(note);
+				return;
+			}
 			const pkg = JSON.parse(await readFile(abs("package.json"), "utf8"));
 			const key = dev ? "devDependencies" : "dependencies";
 			pkg[key] = {
@@ -4182,6 +4318,17 @@ program.command("upgrade").description("Run this CLI version's codemods on the a
 	printUpgrade(await upgrade(project, { dryRun: flags.dryRun }), from, cliVersion());
 	if (!flags.dryRun && flags.verify !== false && !await verify(loadProject())) process.exitCode = 1;
 });
+program.command("eject <package>").description("Copy a @tatara/* package's source into src/ejected; the app owns it from then on").option("--with-dependents", "also eject installed @tatara/* packages that depend on it").action(async (name, flags) => {
+	const report = await eject(loadProject(), name, {
+		withDependents: flags.withDependents,
+		formatFile: biomeFormat
+	});
+	const names = report.ejected.map((n) => `@tatara/${n}`).join(", ");
+	console.log(pc.green(`ejected ${names} into src/ejected (${report.copied.length} files)`));
+	if (report.rewritten.length > 0) console.log(`  ${report.rewritten.length} files now import the ejected copy`);
+	if (report.added.length > 0) console.log(`  added dependencies: ${report.added.join(", ")}`);
+	console.log(`  run your package manager's install, then verify; tatara upgrade skips ${names} from now on`);
+});
 program.command("doctor").description("Check the toolchain, services, env and layout").option("--json", "machine-readable output").action(async (flags) => {
 	const checks = await doctor(loadProject());
 	if (flags.json) console.log(JSON.stringify(checks, null, 2));
@@ -4189,7 +4336,7 @@ program.command("doctor").description("Check the toolchain, services, env and la
 	if (checks.some((c) => !c.ok)) process.exitCode = 1;
 });
 program.parseAsync().catch((error) => {
-	if (error instanceof OptionsError || error instanceof NotATataraProject || error instanceof GeneratorError || error instanceof DbError) console.error(pc.red(error.message));
+	if (error instanceof OptionsError || error instanceof EjectError || error instanceof NotATataraProject || error instanceof GeneratorError || error instanceof DbError) console.error(pc.red(error.message));
 	else console.error(error);
 	process.exit(1);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tatara/cli",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Create and grow opinionated Hono backends",
   "type": "module",
   "license": "MIT",

package/templates/versions.json

@@ -31,12 +31,12 @@
   "@aws-sdk/s3-request-presigner": "3.1152.0",
   "nodemailer": "10.1.1",
   "@types/nodemailer": "8.0.2",
-  "@tatara/core": "0.1.0",
-  "@tatara/http": "0.1.0",
-  "@tatara/db": "0.1.0",
-  "@tatara/testing": "0.1.0",
-  "@tatara/auth": "0.1.0",
-  "@tatara/keycloak": "0.1.0",
+  "@tatara/core": "0.1.1",
+  "@tatara/http": "0.1.1",
+  "@tatara/db": "0.1.1",
+  "@tatara/testing": "0.1.1",
+  "@tatara/auth": "0.1.1",
+  "@tatara/keycloak": "0.1.1",
   "@tatara/authz": "0.1.0",
   "@tatara/storage": "0.1.0",
   "@tatara/email": "0.1.0",