appflare 0.0.28 → 0.1.0

package/cli/commands/index.ts

@@ -0,0 +1,140 @@
+import chokidar from "chokidar";
+import { resolve } from "node:path";
+import { generateArtifacts } from "../generate";
+import { loadConfig } from "../load-config";
+
+type MigrateOptions = {
+	local?: boolean;
+	remote?: boolean;
+	preview?: boolean;
+};
+
+export async function runBuild(configPath?: string): Promise<void> {
+	const loadedConfig = await loadConfig(configPath);
+	await generateArtifacts(loadedConfig);
+	if (loadedConfig.wranglerOutDirAbs === loadedConfig.outDirAbs) {
+		process.stdout.write(
+			`✅ Generated artifacts in ${loadedConfig.outDirAbs}\n`,
+		);
+		return;
+	}
+
+	process.stdout.write(
+		`✅ Generated server/client in ${loadedConfig.outDirAbs} and wrangler.json in ${loadedConfig.wranglerOutDirAbs}\n`,
+	);
+}
+
+export async function runDev(
+	configPath?: string,
+	watch = false,
+): Promise<void> {
+	await runBuild(configPath);
+
+	if (!watch) {
+		return;
+	}
+
+	const loadedConfig = await loadConfig(configPath);
+	let isRunning = false;
+	let shouldRerun = false;
+
+	const rebuild = async (): Promise<void> => {
+		if (isRunning) {
+			shouldRerun = true;
+			return;
+		}
+
+		isRunning = true;
+		try {
+			await runBuild(configPath);
+		} catch (error) {
+			process.stderr.write(`❌ Build failed: ${(error as Error).message}\n`);
+		} finally {
+			isRunning = false;
+			if (shouldRerun) {
+				shouldRerun = false;
+				await rebuild();
+			}
+		}
+	};
+
+	const watcher = chokidar.watch(loadedConfig.scanDirAbs, {
+		ignoreInitial: true,
+	});
+
+	watcher.on("all", async (_eventName, changedPath) => {
+		process.stdout.write(`🔄 Change detected: ${changedPath}\n`);
+		await rebuild();
+	});
+
+	process.stdout.write(`👀 Watching ${loadedConfig.scanDirAbs}\n`);
+}
+
+export async function runMigrate(
+	configPath?: string,
+	options: MigrateOptions = {},
+): Promise<void> {
+	const loadedConfig = await loadConfig(configPath);
+	const selectedTargetCount = [
+		Boolean(options.local),
+		Boolean(options.remote),
+		Boolean(options.preview),
+	].filter(Boolean).length;
+
+	if (selectedTargetCount > 1) {
+		throw new Error("Only one of --local, --remote, or --preview can be set.");
+	}
+
+	const drizzleConfigPath = resolve(
+		loadedConfig.outDirAbs,
+		"drizzle.config.ts",
+	);
+	const drizzleGenerate = Bun.spawn(
+		["npx", "drizzle-kit", "generate", "--config", drizzleConfigPath],
+		{
+			cwd: loadedConfig.configDir,
+			stdin: "inherit",
+			stdout: "inherit",
+			stderr: "inherit",
+		},
+	);
+
+	const drizzleExitCode = await drizzleGenerate.exited;
+	if (drizzleExitCode !== 0) {
+		throw new Error(
+			`drizzle-kit generate failed with exit code ${drizzleExitCode}`,
+		);
+	}
+
+	const databaseName = loadedConfig.config.database[0].databaseName;
+	const wranglerArgs = [
+		"npx",
+		"wrangler",
+		"d1",
+		"migrations",
+		"apply",
+		databaseName,
+	];
+
+	if (options.local) {
+		wranglerArgs.push("--local");
+	} else if (options.remote) {
+		wranglerArgs.push("--remote");
+	} else if (options.preview) {
+		wranglerArgs.push("--preview");
+	}
+
+	const wranglerApply = Bun.spawn(wranglerArgs, {
+		cwd: loadedConfig.configDir,
+		stdin: "inherit",
+		stdout: "inherit",
+		stderr: "inherit",
+	});
+
+	const wranglerExitCode = await wranglerApply.exited;
+	if (wranglerExitCode !== 0) {
+		throw new Error(
+			`wrangler d1 migrations apply failed with exit code ${wranglerExitCode}`,
+		);
+	}
+}

package/cli/generate.ts

@@ -0,0 +1,149 @@
+import { mkdir } from "node:fs/promises";
+import { relative, resolve } from "node:path";
+import { generateAuthConfigSource } from "./templates/auth/config";
+import { generateClientArtifacts } from "./templates/core/client";
+import { generateDrizzleConfigSource } from "./templates/core/drizzle";
+import { generateHandlersArtifacts } from "./templates/core/handlers";
+import { generateServerSource } from "./templates/core/server";
+import { generateWranglerJson } from "./templates/core/wrangler";
+import { compileSchemaDsl } from "./schema-compiler";
+import type { LoadedAppflareConfig } from "./types";
+import { discoverHandlerOperations } from "./utils/handler-discovery";
+import { discoverSchema } from "./utils/schema-discovery";
+import { ensureRelativeImportPath } from "./utils/path-utils";
+
+function toConfigRelativePath(configDir: string, absolutePath: string): string {
+	const relativePath = relative(configDir, absolutePath).replace(/\\/g, "/");
+	return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+}
+
+export async function generateArtifacts(
+	loadedConfig: LoadedAppflareConfig,
+): Promise<void> {
+	const { outDirAbs, wranglerOutDirAbs, config, configPath, configDir } =
+		loadedConfig;
+	const configImport = ensureRelativeImportPath(outDirAbs, configPath);
+	const clientOutDirAbs = resolve(outDirAbs, "client");
+	const clientConfigImport = ensureRelativeImportPath(
+		clientOutDirAbs,
+		configPath,
+	);
+
+	await Promise.all([
+		mkdir(outDirAbs, { recursive: true }),
+		mkdir(clientOutDirAbs, { recursive: true }),
+		mkdir(wranglerOutDirAbs, { recursive: true }),
+	]);
+
+	const serverPath = resolve(outDirAbs, "server.ts");
+	const clientPath = resolve(outDirAbs, "client.ts");
+	const authConfigPath = resolve(outDirAbs, "auth.config.ts");
+	const authSchemaPath = resolve(outDirAbs, "auth.schema.ts");
+	const drizzleConfigPath = resolve(outDirAbs, "drizzle.config.ts");
+	const wranglerPath = resolve(wranglerOutDirAbs, "wrangler.json");
+	const compiledSchema = await compileSchemaDsl(loadedConfig);
+
+	const discoveredSchema = await discoverSchema(
+		loadedConfig,
+		compiledSchema ? [compiledSchema.schemaPath] : [],
+	);
+	const schemaImport = ensureRelativeImportPath(
+		outDirAbs,
+		discoveredSchema.schemaPath,
+	);
+	const discoveredHandlers = await discoverHandlerOperations(loadedConfig);
+
+	const serverSource = generateServerSource(
+		config.auth.basePath,
+		config.database[0].binding,
+		config.kv[0]?.binding,
+		config.scheduler.binding,
+		config.r2[0]?.binding,
+		config.realtime.binding,
+		config.realtime.objectName,
+		config.realtime.subscribePath,
+		config.realtime.websocketPath,
+		config.realtime.protocol,
+	);
+	const clientArtifacts = generateClientArtifacts(
+		clientConfigImport,
+		discoveredHandlers,
+	);
+	const handlerArtifacts = generateHandlersArtifacts(
+		schemaImport,
+		discoveredHandlers,
+		config.r2[0]?.binding,
+	);
+	const authConfigSource = generateAuthConfigSource(configImport);
+	const drizzleSchemaPaths = compiledSchema
+		? [
+				toConfigRelativePath(configDir, compiledSchema.schemaPath),
+				...config.schema.filter((schemaPath) => {
+					return !/(^|\/)schema\.ts$/.test(schemaPath);
+				}),
+			]
+		: config.schema;
+	const drizzleConfigSource = generateDrizzleConfigSource(drizzleSchemaPaths);
+	const wranglerJson = generateWranglerJson(loadedConfig, discoveredHandlers);
+	const handlerWriteOperations = handlerArtifacts.map((artifact) => {
+		return Bun.write(
+			resolve(outDirAbs, artifact.relativePath),
+			artifact.source,
+		);
+	});
+	const clientWriteOperations = clientArtifacts.map((artifact) => {
+		return Bun.write(
+			resolve(outDirAbs, artifact.relativePath),
+			artifact.source,
+		);
+	});
+
+	await Promise.all([
+		Bun.write(serverPath, serverSource),
+		Bun.write(clientPath, 'export * from "./client/index";\n'),
+		...clientWriteOperations,
+		...handlerWriteOperations,
+		Bun.write(authConfigPath, authConfigSource),
+		Bun.write(authSchemaPath, ""),
+		Bun.write(drizzleConfigPath, drizzleConfigSource),
+		Bun.write(wranglerPath, `${JSON.stringify(wranglerJson, null, 2)}\n`),
+	]);
+
+	const authConfigPathFromConfigDir = relative(
+		configDir,
+		authConfigPath,
+	).replace(/\\/g, "/");
+	const authConfigCliPath = authConfigPathFromConfigDir.startsWith(".")
+		? authConfigPathFromConfigDir
+		: `./${authConfigPathFromConfigDir}`;
+	const authSchemaPathFromConfigDir = relative(
+		configDir,
+		authSchemaPath,
+	).replace(/\\/g, "/");
+	const authSchemaCliPath = authSchemaPathFromConfigDir.startsWith(".")
+		? authSchemaPathFromConfigDir
+		: `./${authSchemaPathFromConfigDir}`;
+
+	const betterAuthGenerate = Bun.spawn(
+		[
+			"npx",
+			"@better-auth/cli",
+			"generate",
+			"--config",
+			authConfigCliPath,
+			"--output",
+			authSchemaCliPath,
+			"--yes",
+		],
+		{
+			cwd: configDir,
+			stdout: "inherit",
+			stderr: "inherit",
+		},
+	);
+
+	const exitCode = await betterAuthGenerate.exited;
+	if (exitCode !== 0) {
+		throw new Error(`better-auth generation failed with exit code ${exitCode}`);
+	}
+}