@shivaedev/create-app 0.11.24 → 0.13.0

package/src/packTemplate.ts

@@ -1,7 +1,7 @@
 import { Buffer } from "node:buffer";
 import { basename, join } from "node:path";
 import { Effect, FileSystem, type PlatformError, Schema } from "effect";
-import { MIGRATION_FILE_PATTERN, MIGRATIONS_DIRECTORY } from "@shivaedev/effect-sql/migrationConvention.ts";
+import { MIGRATION_FILE_PATTERN } from "@shivaedev/effect-sql/migrationConvention.ts";
 import { CreateAppError } from "#CreateAppError.ts";
 import { prepareFile, type Template, Versions } from "#template.ts";
 
@@ -11,7 +11,7 @@ const appPaths = new Map([
 	["pnpm-workspace.copy.yaml", "pnpm-workspace.yaml"],
 ]);
 const excluded = new Set(["node_modules", "dist", "coverage", "pnpm-lock.yaml", ".git"]);
-const rootExcluded = new Set(["published-versions.json", "AGENTS.md", "CLAUDE.md", "README.md"]);
+const rootExcluded = new Set(["published-versions.json", "AGENTS.md", "CLAUDE.md", "README.md", "quality.config.ts"]);
 function included(path: string) {
 	return !(rootExcluded.has(path) || excluded.has(basename(path))) && (!basename(path).startsWith(".env") || basename(path) === ".env.example");
 }
@@ -31,7 +31,7 @@ export const packTemplate = Effect.fn("CreateApp.packTemplate")(function* (start
 			if ((yield* fs.stat(join(starter, path))).type === "Directory") {
 				yield* visit(path);
 			} else {
-				if (directory === join(MIGRATIONS_DIRECTORY) && !MIGRATION_FILE_PATTERN.test(name)) {
+				if (basename(directory) === "migrations" && !MIGRATION_FILE_PATTERN.test(name)) {
 					return yield* new CreateAppError({ message: `Invalid migration filename: ${path}` });
 				}
 				const target = appPaths.get(path) ?? path;

package/src/runProcess.ts

@@ -0,0 +1,25 @@
+import { Effect, Stream } from "effect";
+import { ChildProcess, ChildProcessSpawner } from "effect/process";
+import { CreateAppError } from "./CreateAppError.ts";
+
+export const runProcess = Effect.fn("CreateApp.runProcess")(function* (cwd: string, command: string, args: readonly string[]) {
+	return yield* Effect.scoped(
+		Effect.gen(function* () {
+			const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+			const child = yield* spawner.spawn(ChildProcess.make(command, args, { cwd, stdin: "ignore" }));
+			const [stdout, stderr, code] = yield* Effect.all(
+				[Stream.mkString(Stream.decodeText(child.stdout)), Stream.mkString(Stream.decodeText(child.stderr)), child.exitCode],
+				{ concurrency: "unbounded" },
+			);
+			return { code: Number(code), stderr, stdout };
+		}),
+	);
+});
+
+export const checkedProcess = Effect.fn("CreateApp.checkedProcess")(function* (cwd: string, command: string, args: readonly string[]) {
+	const result = yield* runProcess(cwd, command, args);
+	if (result.code !== 0) {
+		return yield* new CreateAppError({ message: `${command} ${args[0]} failed: ${result.stderr.trim()}` });
+	}
+	return result.stdout;
+});

package/src/starterPatch.ts

@@ -0,0 +1,43 @@
+import { join } from "node:path";
+import { Effect, FileSystem } from "effect";
+import { renderTemplate } from "./generation.ts";
+import { checkedProcess } from "./runProcess.ts";
+import type { Template } from "./template.ts";
+
+export const starterPatch = Effect.fn("CreateApp.starterPatch")(function* (
+	target: string,
+	directory: string,
+	name: string,
+	before: Template,
+	after: Template,
+) {
+	const fs = yield* FileSystem.FileSystem;
+	const deleted = new Set<string>();
+	for (const entry of before) {
+		if (!(yield* fs.exists(join(target, entry.path)))) {
+			deleted.add(entry.path);
+		}
+	}
+	const base = before.filter((entry) => !deleted.has(entry.path));
+	const incoming = after.filter((entry) => !deleted.has(entry.path));
+	const repository = join(directory, "merge");
+	yield* fs.makeDirectory(repository);
+	yield* checkedProcess(repository, "git", ["init", "--quiet"]);
+	yield* renderTemplate(repository, base, name);
+	yield* checkedProcess(repository, "git", ["add", "--all"]);
+	const tree = (yield* checkedProcess(repository, "git", ["write-tree"])).trim();
+	for (const entry of base) {
+		yield* checkedProcess(target, "git", ["hash-object", "-w", "--", join(repository, entry.path)]);
+	}
+	for (const path of yield* fs.readDirectory(repository)) {
+		if (path !== ".git") {
+			yield* fs.remove(join(repository, path), { recursive: true });
+		}
+	}
+	yield* renderTemplate(repository, incoming, name);
+	yield* checkedProcess(repository, "git", ["add", "--all"]);
+	const patch = yield* checkedProcess(repository, "git", ["diff", "--cached", "--binary", "--full-index", "--no-renames", tree]);
+	const path = join(directory, "starter.patch");
+	yield* fs.writeFileString(path, patch);
+	return { empty: patch.length === 0, path };
+});

package/src/template.ts

@@ -61,13 +61,13 @@ export function prepareManifest(source: string, versions: Readonly<Record<string
 }
 
 export function prepareFile(path: string, content: Buffer, versions: Readonly<Record<string, string>>) {
-	if (["src/server/dev.ts", "src/test-support/adminCommand.ts", "src/test-support/deployChild.ts"].includes(path)) {
+	if (["src/test-support/adminCommand.ts", "src/test-support/deployChild.ts"].includes(path)) {
 		return Buffer.from(content.toString().replaceAll('"--conditions=source", ', ""));
 	}
 	if (path === "package.json") {
 		return Buffer.from(prepareManifest(content.toString(), versions));
 	}
-	if (["tsconfig.json", "vite.config.ts", "vitest.config.ts"].includes(path)) {
+	if (["tsconfig.json", "vite.config.ts", "vitest.config.ts", "src/server/dev.ts"].includes(path)) {
 		return Buffer.from(content.toString().replaceAll('"source", ', "").replaceAll('["source"]', "[]"));
 	}
 	return content;

package/src/updateApp.ts

@@ -0,0 +1,40 @@
+import { join, resolve } from "node:path";
+import { Console, Effect, FileSystem, Schema } from "effect";
+import { CreateAppError } from "./CreateAppError.ts";
+import { GENERATION_FILE, Generation, readTemplate, writeGeneration } from "./generation.ts";
+import { historicalTemplate } from "./historicalTemplate.ts";
+import { checkedProcess, runProcess } from "./runProcess.ts";
+import { starterPatch } from "./starterPatch.ts";
+
+export const updateApp = Effect.fn("CreateApp.updateApp")(function* (folder: string, templatePath: string, version: string) {
+	return yield* Effect.scoped(
+		Effect.gen(function* () {
+			const fs = yield* FileSystem.FileSystem;
+			const target = resolve(folder);
+			yield* checkedProcess(target, "git", ["rev-parse", "--show-toplevel"]);
+			if ((yield* checkedProcess(target, "git", ["status", "--porcelain"])).trim() !== "") {
+				return yield* new CreateAppError({ message: "Refusing to update a dirty working tree. Commit or stash your changes first." });
+			}
+			const generation = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Generation))(
+				yield* fs.readFileString(join(target, GENERATION_FILE)),
+			);
+			const directory = yield* fs.makeTempDirectoryScoped({ prefix: "create-app-update-" });
+			const current = yield* readTemplate(templatePath);
+			const previous = generation.version === version ? current : yield* historicalTemplate(directory, generation.version);
+			const patch = yield* starterPatch(target, directory, generation.name, previous, current);
+			if (!patch.empty) {
+				const result = yield* runProcess(target, "git", ["apply", "--3way", patch.path]);
+				if (result.code !== 0) {
+					const conflicts = (yield* checkedProcess(target, "git", ["diff", "--name-only", "--diff-filter=U"])).trim();
+					return yield* new CreateAppError({
+						message: conflicts
+							? `Resolve these conflicts, then commit your changes:\n${conflicts}\nThe recorded version remains ${generation.version}.`
+							: result.stderr.trim(),
+					});
+				}
+			}
+			yield* writeGeneration(target, { ...generation, version });
+			yield* Console.log(`Applied create-app ${version}. Review the changes, run pnpm install and commit when ready.`);
+		}),
+	);
+});