appflare 0.0.28 → 0.1.0

package/cli/core/build.ts

@@ -1,187 +0,0 @@
-import { promises as fs } from "node:fs";
-import path from "node:path";
-import { spawn } from "node:child_process";
-import {
-	AppflareConfig,
-	assertDirExists,
-	assertFileExists,
-	toImportPathFromGeneratedSrc,
-} from "../utils/utils";
-import { getSchemaTableNames, generateSchemaTypes } from "../schema/schema";
-import {
-	generateDbHandlers,
-	discoverHandlers,
-	generateApiClient,
-	generateHonoServer,
-	generateWebsocketDurableObject,
-	generateSchedulerHandlers,
-	generateCronHandlers,
-} from "./handlers";
-
-export async function buildFromConfig(params: {
-	config: AppflareConfig;
-	configDirAbs: string;
-	configPathAbs: string;
-	emit: boolean;
-}): Promise<void> {
-	const { config, configDirAbs, emit, configPathAbs } = params;
-
-	const projectDirAbs = path.resolve(configDirAbs, config.dir);
-	const schemaPathAbs = path.resolve(configDirAbs, config.schema);
-	const outDirAbs = path.resolve(configDirAbs, config.outDir);
-
-	await assertDirExists(
-		projectDirAbs,
-		`Project dir not found: ${projectDirAbs}`,
-	);
-	await assertFileExists(schemaPathAbs, `Schema not found: ${schemaPathAbs}`);
-
-	await fs.mkdir(path.join(outDirAbs, "src"), { recursive: true });
-	await fs.mkdir(path.join(outDirAbs, "server"), { recursive: true });
-
-	// Re-export the user schema inside the generated output so downstream code can import it from the build directory.
-	const schemaImportPathForGeneratedSrc = toImportPathFromGeneratedSrc(
-		outDirAbs,
-		schemaPathAbs,
-	);
-	const schemaReexport = `import schema from ${JSON.stringify(schemaImportPathForGeneratedSrc)};
-export type AppflareGeneratedSchema = typeof schema;
-export default schema;
-`;
-	await fs.writeFile(path.join(outDirAbs, "src", "schema.ts"), schemaReexport);
-
-	const schemaTypesTs = await generateSchemaTypes({
-		schemaPathAbs,
-		configPathAbs,
-		outDirAbs,
-	});
-	await fs.writeFile(
-		path.join(outDirAbs, "src", "schema-types.ts"),
-		schemaTypesTs,
-	);
-
-	// (Re)generate built-in DB handlers based on the schema tables.
-	const schemaTableNames = await getSchemaTableNames(schemaPathAbs);
-	await generateDbHandlers({ outDirAbs, tableNames: schemaTableNames });
-
-	const handlers = await discoverHandlers({
-		projectDirAbs,
-		schemaPathAbs,
-		outDirAbs,
-		configPathAbs,
-	});
-
-	const apiTs = generateApiClient({
-		handlers,
-		outDirAbs,
-		authBasePath:
-			config.auth && config.auth.enabled === false
-				? undefined
-				: (config.auth?.basePath ?? "/auth"),
-		authEnabled: config.auth?.enabled !== false,
-		configPathAbs,
-	});
-	await fs.writeFile(path.join(outDirAbs, "src", "api.ts"), apiTs);
-
-	const serverTs = generateHonoServer({
-		handlers,
-		outDirAbs,
-		schemaPathAbs,
-		configPathAbs,
-		config,
-	});
-	await fs.writeFile(path.join(outDirAbs, "server", "server.ts"), serverTs);
-
-	const websocketDoTs = generateWebsocketDurableObject({
-		handlers,
-		outDirAbs,
-		schemaPathAbs,
-		configPathAbs,
-		config,
-	});
-	await fs.writeFile(
-		path.join(outDirAbs, "server", "websocket-hibernation-server.ts"),
-		websocketDoTs,
-	);
-
-	const schedulerTs = generateSchedulerHandlers({
-		handlers,
-		outDirAbs,
-		schemaPathAbs,
-		configPathAbs,
-	});
-	await fs.writeFile(
-		path.join(outDirAbs, "server", "scheduler.ts"),
-		schedulerTs,
-	);
-
-	const { code: cronTs } = generateCronHandlers({
-		handlers,
-		outDirAbs,
-		schemaPathAbs,
-		configPathAbs,
-	});
-	await fs.writeFile(path.join(outDirAbs, "server", "cron.ts"), cronTs);
-
-	if (emit) {
-		// Remove previous emit output to avoid stale files lingering.
-		await fs.rm(path.join(outDirAbs, "dist"), { recursive: true, force: true });
-
-		// Emit only the files that don't pull in user code outside rootDir.
-		// This avoids TS rootDir issues and dist overwrite issues caused by user modules.
-		const emitTsconfigAbs = await writeEmitTsconfig({
-			configDirAbs,
-			outDirAbs,
-		});
-		await runTscEmit(emitTsconfigAbs);
-	}
-}
-
-async function writeEmitTsconfig(params: {
-	configDirAbs: string;
-	outDirAbs: string;
-}): Promise<string> {
-	const outDirRel =
-		path.relative(params.configDirAbs, params.outDirAbs).replace(/\\/g, "/") ||
-		"./_generated";
-	const tsconfigPathAbs = path.join(
-		params.configDirAbs,
-		".appflare.tsconfig.emit.json",
-	);
-	const content = {
-		compilerOptions: {
-			noEmit: false,
-			declaration: true,
-			emitDeclarationOnly: false,
-			outDir: `./${outDirRel}/dist`,
-			rootDir: `.`,
-			sourceMap: false,
-			declarationMap: false,
-			skipLibCheck: true,
-			target: "ES2022",
-			module: "ES2022",
-			moduleResolution: "Bundler",
-			types: ["node"],
-		},
-		include: [
-			`./${outDirRel}/src/schema-types.ts`,
-			`./${outDirRel}/src/schema.ts`,
-			`./${outDirRel}/src/handlers/**/*`,
-		],
-	};
-	await fs.writeFile(tsconfigPathAbs, JSON.stringify(content, null, 2));
-	return tsconfigPathAbs;
-}
-
-async function runTscEmit(tsconfigPathAbs: string): Promise<void> {
-	await new Promise<void>((resolve, reject) => {
-		const child = spawn("bunx", ["tsc", "-p", tsconfigPathAbs], {
-			stdio: "inherit",
-		});
-		child.on("error", reject);
-		child.on("exit", (code) => {
-			if (code === 0) resolve();
-			reject(new Error(`tsc exited with code ${code}`));
-		});
-	});
-}

package/cli/core/config.ts

@@ -1,92 +0,0 @@
-import { promises as fs } from "node:fs";
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-import { AppflareConfig, assertFileExists } from "../utils/utils";
-
-export async function loadConfig(
-	configPathAbs: string,
-): Promise<{ config: AppflareConfig; configDirAbs: string }> {
-	await assertFileExists(configPathAbs, `Config not found: ${configPathAbs}`);
-	const configDirAbs = path.dirname(configPathAbs);
-
-	const mod = await import(pathToFileURL(configPathAbs).href);
-	const config = (mod?.default ?? mod) as Partial<AppflareConfig>;
-	if (!config || typeof config !== "object") {
-		throw new Error(
-			`Invalid config export in ${configPathAbs} (expected default export object)`,
-		);
-	}
-	if (typeof config.dir !== "string" || !config.dir) {
-		throw new Error(`Invalid config.dir in ${configPathAbs}`);
-	}
-	if (typeof config.schema !== "string" || !config.schema) {
-		throw new Error(`Invalid config.schema in ${configPathAbs}`);
-	}
-	if (typeof config.outDir !== "string" || !config.outDir) {
-		throw new Error(`Invalid config.outDir in ${configPathAbs}`);
-	}
-
-	const auth = (config as AppflareConfig).auth;
-	if (auth !== undefined) {
-		if (!auth || typeof auth !== "object") {
-			throw new Error(`Invalid config.auth in ${configPathAbs}`);
-		}
-		if (auth.basePath !== undefined && typeof auth.basePath !== "string") {
-			throw new Error(`Invalid config.auth.basePath in ${configPathAbs}`);
-		}
-		if (auth.enabled !== undefined && typeof auth.enabled !== "boolean") {
-			throw new Error(`Invalid config.auth.enabled in ${configPathAbs}`);
-		}
-		if (auth.options !== undefined && typeof auth.options !== "object") {
-			throw new Error(`Invalid config.auth.options in ${configPathAbs}`);
-		}
-		if (
-			auth.clientOptions !== undefined &&
-			typeof auth.clientOptions !== "object"
-		) {
-			throw new Error(`Invalid config.auth.clientOptions in ${configPathAbs}`);
-		}
-	}
-
-	const storage = (config as AppflareConfig).storage;
-	if (storage !== undefined) {
-		if (!storage || typeof storage !== "object") {
-			throw new Error(`Invalid config.storage in ${configPathAbs}`);
-		}
-		if (!Array.isArray(storage.rules)) {
-			throw new Error(`Invalid config.storage.rules in ${configPathAbs}`);
-		}
-		if (
-			storage.basePath !== undefined &&
-			typeof storage.basePath !== "string"
-		) {
-			throw new Error(`Invalid config.storage.basePath in ${configPathAbs}`);
-		}
-		if (
-			storage.bucketBinding !== undefined &&
-			typeof storage.bucketBinding !== "string"
-		) {
-			throw new Error(
-				`Invalid config.storage.bucketBinding in ${configPathAbs}`,
-			);
-		}
-		if (
-			storage.defaultCacheControl !== undefined &&
-			typeof storage.defaultCacheControl !== "string"
-		) {
-			throw new Error(
-				`Invalid config.storage.defaultCacheControl in ${configPathAbs}`,
-			);
-		}
-		if (
-			storage.kvBinding !== undefined &&
-			typeof storage.kvBinding !== "string"
-		) {
-			throw new Error(`Invalid config.storage.kvBinding in ${configPathAbs}`);
-		}
-		if (storage.kvId !== undefined && typeof storage.kvId !== "string") {
-			throw new Error(`Invalid config.storage.kvId in ${configPathAbs}`);
-		}
-	}
-	return { config: config as AppflareConfig, configDirAbs };
-}

package/cli/core/discover-handlers.ts

@@ -1,143 +0,0 @@
-import { promises as fs } from "node:fs";
-import path from "node:path";
-import * as ts from "typescript";
-import {
-	DiscoveredHandler,
-	HandlerKind,
-	walkTsFiles,
-	groupBy,
-} from "../utils/utils";
-
-export async function discoverHandlers(params: {
-	projectDirAbs: string;
-	schemaPathAbs: string;
-	outDirAbs: string;
-	configPathAbs: string;
-}): Promise<DiscoveredHandler[]> {
-	const ignoreDirs = new Set([
-		"node_modules",
-		".git",
-		"dist",
-		"build",
-		path.basename(params.outDirAbs),
-	]);
-
-	const files = await walkTsFiles(params.projectDirAbs, ignoreDirs);
-
-	const handlers: DiscoveredHandler[] = [];
-	for (const fileAbs of files) {
-		if (path.resolve(fileAbs) === path.resolve(params.schemaPathAbs)) continue;
-		if (path.resolve(fileAbs) === path.resolve(params.configPathAbs)) continue;
-
-		const relPathRaw = path.relative(params.projectDirAbs, fileAbs);
-		const relPath = relPathRaw.replace(/\\/g, "/");
-		const rawRoutePath = relPath.replace(/\.ts$/, "");
-		const routePath = rawRoutePath.endsWith("/index")
-			? rawRoutePath.slice(0, -"/index".length) || "index"
-			: rawRoutePath;
-
-		const content = await fs.readFile(fileAbs, "utf8");
-		const cronTriggersByHandler = extractCronTriggers(content);
-		const regex =
-			/export\s+const\s+([A-Za-z_$][\w$]*)\s*=\s*(query|mutation|internalQuery|internalMutation|scheduler|cron|http)\s*\(/g;
-		let match: RegExpExecArray | null;
-		while ((match = regex.exec(content)) !== null) {
-			const kind = match[2] as HandlerKind;
-			handlers.push({
-				fileName: path.basename(fileAbs, ".ts"),
-				routePath,
-				name: match[1],
-				kind,
-				sourceFileAbs: fileAbs,
-				cronTriggers:
-					kind === "cron" ? cronTriggersByHandler.get(match[1]) : undefined,
-			});
-		}
-	}
-
-	// De-dupe: keep first occurrence
-	const seen = new Set<string>();
-	const unique = handlers.filter((h) => {
-		const key = `${h.kind}:${h.routePath}:${h.name}`;
-		if (seen.has(key)) return false;
-		seen.add(key);
-		return true;
-	});
-
-	unique.sort((a, b) => {
-		if (a.kind !== b.kind) return a.kind.localeCompare(b.kind);
-		if (a.routePath !== b.routePath)
-			return a.routePath.localeCompare(b.routePath);
-		if (a.fileName !== b.fileName) return a.fileName.localeCompare(b.fileName);
-		return a.name.localeCompare(b.name);
-	});
-
-	return unique;
-}
-
-const cronPropertyNames = new Set(["cronTrigger", "cronTriggers"]);
-
-const isExported = (node: ts.Node): boolean => {
-	return Boolean(
-		ts.canHaveModifiers(node) &&
-		node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)
-	);
-};
-
-const extractCronTriggers = (sourceText: string): Map<string, string[]> => {
-	const sourceFile = ts.createSourceFile(
-		"cron-handlers.ts",
-		sourceText,
-		ts.ScriptTarget.Latest,
-		true
-	);
-	const triggersByHandler = new Map<string, string[]>();
-
-	const visit = (node: ts.Node): void => {
-		if (ts.isVariableStatement(node) && isExported(node)) {
-			for (const decl of node.declarationList.declarations) {
-				if (!ts.isIdentifier(decl.name)) continue;
-				const initializer = decl.initializer;
-				if (!initializer || !ts.isCallExpression(initializer)) continue;
-				const callee = initializer.expression;
-				if (!ts.isIdentifier(callee) || callee.text !== "cron") continue;
-				const cronTriggers = parseCronTriggerArg(initializer.arguments[0]);
-				if (cronTriggers && cronTriggers.length > 0) {
-					triggersByHandler.set(decl.name.text, cronTriggers);
-				}
-			}
-		}
-		ts.forEachChild(node, visit);
-	};
-
-	visit(sourceFile);
-	return triggersByHandler;
-};
-
-const parseCronTriggerArg = (arg?: ts.Expression): string[] | undefined => {
-	if (!arg || !ts.isObjectLiteralExpression(arg)) return undefined;
-	const cronProp = arg.properties.find((prop) => {
-		if (!ts.isPropertyAssignment(prop)) return false;
-		if (ts.isIdentifier(prop.name))
-			return cronPropertyNames.has(prop.name.text);
-		if (ts.isStringLiteralLike(prop.name))
-			return cronPropertyNames.has(prop.name.text);
-		return false;
-	});
-
-	if (!cronProp || !ts.isPropertyAssignment(cronProp)) return undefined;
-	const value = cronProp.initializer;
-	const triggers: string[] = [];
-	if (ts.isArrayLiteralExpression(value)) {
-		for (const element of value.elements) {
-			if (ts.isStringLiteralLike(element)) {
-				triggers.push(element.text.trim());
-			}
-		}
-	} else if (ts.isStringLiteralLike(value)) {
-		triggers.push(value.text.trim());
-	}
-
-	const unique = Array.from(new Set(triggers.filter(Boolean)));
-	return unique.length > 0 ? unique : undefined;
-};

package/cli/core/handlers.ts

@@ -1,7 +0,0 @@
-export { discoverHandlers } from "./discover-handlers";
-export { generateDbHandlers } from "../generators/generate-db-handlers";
-export { generateApiClient } from "../generators/generate-api-client";
-export { generateHonoServer } from "../generators/generate-hono-server";
-export { generateWebsocketDurableObject } from "../generators/generate-websocket-durable-object";
-export { generateSchedulerHandlers } from "../generators/generate-scheduler-handlers";
-export { generateCronHandlers } from "../generators/generate-cron-handlers";

package/cli/core/index.ts

@@ -1,205 +0,0 @@
-#!/usr/bin/env bun
-
-import { Command } from "commander";
-import { promises as fs } from "node:fs";
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-import {
-	discoverHandlers,
-	generateApiClient,
-	generateDbHandlers,
-	generateHonoServer,
-	generateWebsocketDurableObject,
-	generateSchedulerHandlers,
-} from "./handlers";
-import { generateSchemaTypes, getSchemaTableNames } from "../schema/schema";
-import { runTscEmit, writeEmitTsconfig } from "../utils/tsc";
-import {
-	assertDirExists,
-	assertFileExists,
-	toImportPathFromGeneratedSrc,
-} from "../utils/utils";
-
-type AppflareConfig = {
-	dir: string;
-	schema: string;
-	outDir: string;
-	auth?: {
-		enabled?: boolean;
-		basePath?: string;
-		clientOptions?: Record<string, unknown>;
-	};
-};
-
-const program = new Command();
-
-program.name("appflare").description("Appflare CLI").version("0.0.0");
-
-program
-	.command("build")
-	.description(
-		"Generate typed schema + query/mutation client/server into outDir",
-	)
-	.option(
-		"-c, --config <path>",
-		"Path to appflare.config.ts",
-		"appflare.config.ts",
-	)
-	.option("--emit", "Also run tsc to emit JS + .d.ts into outDir/dist")
-	.action(async (options: { config: string; emit?: boolean }) => {
-		try {
-			const configPath = path.resolve(process.cwd(), options.config);
-			const { config, configDirAbs } = await loadConfig(configPath);
-			await buildFromConfig({
-				config,
-				configDirAbs,
-				configPathAbs: configPath,
-				emit: Boolean(options.emit),
-			});
-		} catch (err) {
-			const message = err instanceof Error ? err.message : String(err);
-			console.error(message);
-			process.exitCode = 1;
-		}
-	});
-
-void main();
-
-async function main(): Promise<void> {
-	await program.parseAsync(process.argv);
-}
-
-async function loadConfig(
-	configPathAbs: string,
-): Promise<{ config: AppflareConfig; configDirAbs: string }> {
-	await assertFileExists(configPathAbs, `Config not found: ${configPathAbs}`);
-	const configDirAbs = path.dirname(configPathAbs);
-
-	const mod = await import(pathToFileURL(configPathAbs).href);
-	const config = (mod?.default ?? mod) as Partial<AppflareConfig>;
-	if (!config || typeof config !== "object") {
-		throw new Error(
-			`Invalid config export in ${configPathAbs} (expected default export object)`,
-		);
-	}
-	if (typeof config.dir !== "string" || !config.dir) {
-		throw new Error(`Invalid config.dir in ${configPathAbs}`);
-	}
-	if (typeof config.schema !== "string" || !config.schema) {
-		throw new Error(`Invalid config.schema in ${configPathAbs}`);
-	}
-	if (typeof config.outDir !== "string" || !config.outDir) {
-		throw new Error(`Invalid config.outDir in ${configPathAbs}`);
-	}
-	return { config: config as AppflareConfig, configDirAbs };
-}
-
-async function buildFromConfig(params: {
-	config: AppflareConfig;
-	configDirAbs: string;
-	configPathAbs: string;
-	emit: boolean;
-}): Promise<void> {
-	const { config, configDirAbs, emit, configPathAbs } = params;
-
-	const projectDirAbs = path.resolve(configDirAbs, config.dir);
-	const schemaPathAbs = path.resolve(configDirAbs, config.schema);
-	const outDirAbs = path.resolve(configDirAbs, config.outDir);
-
-	await assertDirExists(
-		projectDirAbs,
-		`Project dir not found: ${projectDirAbs}`,
-	);
-	await assertFileExists(schemaPathAbs, `Schema not found: ${schemaPathAbs}`);
-
-	await fs.mkdir(path.join(outDirAbs, "src"), { recursive: true });
-	await fs.mkdir(path.join(outDirAbs, "server"), { recursive: true });
-
-	const schemaImportPathForGeneratedSrc = toImportPathFromGeneratedSrc(
-		outDirAbs,
-		schemaPathAbs,
-	);
-	const schemaReexport = `import schema from ${JSON.stringify(schemaImportPathForGeneratedSrc)};
-export type AppflareGeneratedSchema = typeof schema;
-export default schema;
-`;
-	await fs.writeFile(path.join(outDirAbs, "src", "schema.ts"), schemaReexport);
-
-	const schemaTypesTs = await generateSchemaTypes({
-		schemaPathAbs,
-		configPathAbs,
-		outDirAbs,
-	});
-	await fs.writeFile(
-		path.join(outDirAbs, "src", "schema-types.ts"),
-		schemaTypesTs,
-	);
-
-	// (Re)generate built-in DB handlers based on the schema tables.
-	const schemaTableNames = await getSchemaTableNames(schemaPathAbs);
-	await generateDbHandlers({ outDirAbs, tableNames: schemaTableNames });
-
-	const handlers = await discoverHandlers({
-		projectDirAbs,
-		schemaPathAbs,
-		outDirAbs,
-		configPathAbs,
-	});
-
-	const apiTs = generateApiClient({
-		handlers,
-		outDirAbs,
-		authBasePath:
-			config.auth && config.auth.enabled === false
-				? undefined
-				: (config.auth?.basePath ?? "/auth"),
-		authEnabled: config.auth?.enabled !== false,
-		configPathAbs,
-	});
-	await fs.writeFile(path.join(outDirAbs, "src", "api.ts"), apiTs);
-
-	const serverTs = generateHonoServer({
-		handlers,
-		outDirAbs,
-		schemaPathAbs,
-		configPathAbs,
-		config,
-	});
-	await fs.writeFile(path.join(outDirAbs, "server", "server.ts"), serverTs);
-
-	const websocketDoTs = generateWebsocketDurableObject({
-		handlers,
-		outDirAbs,
-		schemaPathAbs,
-		configPathAbs,
-		config,
-	});
-	await fs.writeFile(
-		path.join(outDirAbs, "server", "websocket-hibernation-server.ts"),
-		websocketDoTs,
-	);
-
-	const schedulerTs = generateSchedulerHandlers({
-		handlers,
-		outDirAbs,
-		schemaPathAbs,
-		configPathAbs,
-	});
-	await fs.writeFile(
-		path.join(outDirAbs, "server", "scheduler.ts"),
-		schedulerTs,
-	);
-
-	if (emit) {
-		// Remove previous emit output to avoid stale files lingering.
-		await fs.rm(path.join(outDirAbs, "dist"), { recursive: true, force: true });
-
-		// Emit only the files that don't pull in user code outside rootDir.
-		// This avoids TS rootDir issues and dist overwrite issues caused by user modules.
-		const emitTsconfigAbs = await writeEmitTsconfig({
-			configDirAbs,
-			outDirAbs,
-		});
-		await runTscEmit(emitTsconfigAbs);
-	}
-}