appflare 0.0.28 → 0.1.1

package/cli/templates/handlers/utils.ts

@@ -0,0 +1,48 @@
+import type { DiscoveredColumn } from "../../utils/schema-discovery";
+
+export function toPascalCase(value: string): string {
+	return value
+		.replace(/[_-]+/g, " ")
+		.replace(/\s+(.)/g, (_match, char: string) => char.toUpperCase())
+		.replace(/\s/g, "")
+		.replace(/^(.)/, (_match, char: string) => char.toUpperCase());
+}
+
+export function singularize(value: string): string {
+	if (value.endsWith("ies")) {
+		return `${value.slice(0, -3)}y`;
+	}
+	if (value.endsWith("ses")) {
+		return value.slice(0, -2);
+	}
+	if (value.endsWith("s") && value.length > 1) {
+		return value.slice(0, -1);
+	}
+	return value;
+}
+
+export function zodForColumn(column: DiscoveredColumn): string {
+	if (column.type === "number") {
+		return `z.number()${column.optional ? ".optional()" : ""}`;
+	}
+	if (column.type === "boolean") {
+		return `z.boolean()${column.optional ? ".optional()" : ""}`;
+	}
+	if (column.type === "string") {
+		return `z.string()${column.optional ? ".optional()" : ""}`;
+	}
+	return `z.unknown()${column.optional ? ".optional()" : ""}`;
+}
+
+export function zodForQueryColumn(column: DiscoveredColumn): string {
+	if (column.type === "number") {
+		return "z.coerce.number().optional()";
+	}
+	if (column.type === "boolean") {
+		return "z.coerce.boolean().optional()";
+	}
+	if (column.type === "string") {
+		return "z.string().optional()";
+	}
+	return "z.unknown().optional()";
+}

package/cli/types.ts

@@ -0,0 +1,108 @@
+import type { BetterAuthOptions } from "better-auth";
+import type { BetterAuthClientOptions } from "better-auth/client";
+
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonObject | JsonValue[];
+export type JsonObject = {
+	[key: string]: JsonValue;
+};
+
+export type AppflareDatabaseBinding = {
+	binding: string;
+	databaseName: string;
+	databaseId: string;
+	previewDatabaseId?: string;
+	migrationsDir?: string;
+};
+
+export type AppflareKVNamespace = {
+	binding: string;
+	id: string;
+	previewId?: string;
+};
+
+export type AppflareR2Bucket = {
+	binding: string;
+	bucketName: string;
+	previewBucketName?: string;
+	jurisdiction?: string;
+};
+
+export type AppflareSchemaDslConfig = {
+	entry: string;
+	exportName?: string;
+	outFile?: string;
+	typesOutFile?: string;
+	zodOutFile?: string;
+	namingStrategy?: "camelToSnake";
+};
+
+export type AppflareSchedulerConfig = {
+	enabled?: boolean;
+	binding?: string;
+	queue?: string;
+};
+
+export type AppflareRealtimeConfig = {
+	enabled?: boolean;
+	binding?: string;
+	className?: string;
+	objectName?: string;
+	subscribePath?: string;
+	websocketPath?: string;
+	protocol?: string;
+};
+
+export type AppflareConfig = {
+	scanDir: string;
+	outDir: string;
+	wranglerOutDir?: string;
+	wranglerOutPath?: string;
+	schema: string[];
+	schemaDsl?: AppflareSchemaDslConfig;
+	database: AppflareDatabaseBinding | AppflareDatabaseBinding[];
+	kv?: AppflareKVNamespace | AppflareKVNamespace[];
+	r2?: AppflareR2Bucket | AppflareR2Bucket[];
+	auth: {
+		enabled: boolean;
+		basePath: string;
+		options: Partial<BetterAuthOptions>;
+		clientOptions: BetterAuthClientOptions;
+	};
+	scheduler?: AppflareSchedulerConfig;
+	realtime?: AppflareRealtimeConfig;
+	wranglerOverrides?: JsonObject;
+};
+
+export type NormalizedAppflareConfig = Omit<
+	AppflareConfig,
+	"database" | "kv" | "r2" | "wranglerOutPath"
+> & {
+	database: AppflareDatabaseBinding[];
+	kv: AppflareKVNamespace[];
+	r2: AppflareR2Bucket[];
+	wranglerOutDir: string;
+	scheduler: Required<Pick<AppflareSchedulerConfig, "enabled" | "binding">> &
+		Pick<AppflareSchedulerConfig, "queue">;
+	realtime: Required<
+		Pick<
+			AppflareRealtimeConfig,
+			| "enabled"
+			| "binding"
+			| "className"
+			| "objectName"
+			| "subscribePath"
+			| "websocketPath"
+			| "protocol"
+		>
+	>;
+};
+
+export type LoadedAppflareConfig = {
+	configPath: string;
+	configDir: string;
+	scanDirAbs: string;
+	outDirAbs: string;
+	wranglerOutDirAbs: string;
+	config: NormalizedAppflareConfig;
+};

package/cli/utils/handler-discovery.ts

@@ -0,0 +1,366 @@
+import { readdir } from "node:fs/promises";
+import { extname, relative, resolve } from "node:path";
+import * as ts from "typescript";
+import type { LoadedAppflareConfig } from "../types";
+import { ensureRelativeImportPath } from "./path-utils";
+
+export type HandlerKind =
+	| "query"
+	| "mutation"
+	| "scheduler"
+	| "cron"
+	| "storage";
+
+export type DiscoveredHandlerOperation = {
+	kind: HandlerKind;
+	exportName: string;
+	filePath: string;
+	importPath: string;
+	clientImportPath: string;
+	routePath: string;
+	handlerName?: string;
+	clientSegments?: string[];
+	taskName?: string;
+	cronTriggers?: string[];
+};
+
+const supportedExtensions = new Set([".ts", ".tsx", ".mts", ".cts"]);
+
+async function discoverFiles(dirPath: string): Promise<string[]> {
+	const entries = await readdir(dirPath, { withFileTypes: true });
+	const files: string[] = [];
+
+	for (const entry of entries) {
+		if (entry.name.startsWith(".")) {
+			continue;
+		}
+		if (entry.name === "node_modules" || entry.name === "_generated") {
+			continue;
+		}
+
+		const entryPath = resolve(dirPath, entry.name);
+		if (entry.isDirectory()) {
+			files.push(...(await discoverFiles(entryPath)));
+			continue;
+		}
+
+		if (entry.isFile() && supportedExtensions.has(extname(entry.name))) {
+			files.push(entryPath);
+		}
+	}
+
+	return files;
+}
+
+function withoutExtension(filePath: string): string {
+	return filePath.replace(/\.[cm]?tsx?$/, "");
+}
+
+type DiscoveredExport = {
+	exportName: string;
+	kind: HandlerKind;
+	cronTriggers: string[];
+};
+
+function isExportedConst(
+	statement: ts.Statement,
+): statement is ts.VariableStatement {
+	if (!ts.isVariableStatement(statement)) {
+		return false;
+	}
+
+	return (
+		statement.modifiers?.some(
+			(modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword,
+		) ?? false
+	);
+}
+
+function readIdentifierText(expression: ts.Expression): string | null {
+	if (ts.isIdentifier(expression)) {
+		return expression.text;
+	}
+
+	if (ts.isParenthesizedExpression(expression)) {
+		return readIdentifierText(expression.expression);
+	}
+
+	return null;
+}
+
+function readCronTriggers(argument: ts.Expression | undefined): string[] {
+	if (!argument || !ts.isObjectLiteralExpression(argument)) {
+		return [];
+	}
+
+	const cronProperty = argument.properties.find((property) => {
+		if (!ts.isPropertyAssignment(property)) {
+			return false;
+		}
+
+		if (!ts.isIdentifier(property.name)) {
+			return false;
+		}
+
+		return property.name.text === "cronTrigger";
+	});
+
+	if (!cronProperty || !ts.isPropertyAssignment(cronProperty)) {
+		return [];
+	}
+
+	const initializer = cronProperty.initializer;
+	if (
+		ts.isStringLiteral(initializer) ||
+		ts.isNoSubstitutionTemplateLiteral(initializer)
+	) {
+		return [initializer.text.trim()].filter((value) => value.length > 0);
+	}
+
+	if (ts.isArrayLiteralExpression(initializer)) {
+		return initializer.elements
+			.map((element) => {
+				if (
+					ts.isStringLiteral(element) ||
+					ts.isNoSubstitutionTemplateLiteral(element)
+				) {
+					return element.text.trim();
+				}
+				return "";
+			})
+			.filter((value) => value.length > 0);
+	}
+
+	return [];
+}
+
+function discoverExports(source: string, filePath: string): DiscoveredExport[] {
+	const sourceFile = ts.createSourceFile(
+		filePath,
+		source,
+		ts.ScriptTarget.Latest,
+		true,
+		ts.ScriptKind.TS,
+	);
+	const exports: DiscoveredExport[] = [];
+
+	for (const statement of sourceFile.statements) {
+		if (!isExportedConst(statement)) {
+			continue;
+		}
+
+		for (const declaration of statement.declarationList.declarations) {
+			if (!ts.isIdentifier(declaration.name) || !declaration.initializer) {
+				continue;
+			}
+
+			if (!ts.isCallExpression(declaration.initializer)) {
+				continue;
+			}
+
+			const callee = readIdentifierText(declaration.initializer.expression);
+			if (
+				callee !== "query" &&
+				callee !== "mutation" &&
+				callee !== "scheduler" &&
+				callee !== "cron" &&
+				callee !== "storageManager"
+			) {
+				continue;
+			}
+
+			exports.push({
+				exportName: declaration.name.text,
+				kind: callee === "storageManager" ? "storage" : callee,
+				cronTriggers:
+					callee === "cron"
+						? readCronTriggers(declaration.initializer.arguments[0])
+						: [],
+			});
+		}
+	}
+
+	return exports;
+}
+
+function buildRoutePath(
+	kindDirectory: "queries" | "mutations",
+	relativeFilePath: string,
+	exportName: string,
+): string {
+	const normalizedRelativePath = relativeFilePath.replace(/\\/g, "/");
+	const relativeWithoutExtension = withoutExtension(normalizedRelativePath);
+	const segments = relativeWithoutExtension.split("/").filter(Boolean);
+	const routeSegments = [kindDirectory, ...segments, exportName]
+		.filter(Boolean)
+		.map((segment) => segment.trim())
+		.filter((segment) => segment.length > 0);
+
+	return `/${routeSegments.join("/")}`;
+}
+
+function relativePathForKind(
+	relativeToScanDir: string,
+	kindDirectory: "queries" | "mutations" | "schedulers" | "crons",
+): string {
+	const normalized = relativeToScanDir.replace(/\\/g, "/");
+	const marker = `${kindDirectory}/`;
+	const markerIndex = normalized.indexOf(marker);
+
+	if (markerIndex >= 0) {
+		return normalized.slice(markerIndex + marker.length);
+	}
+
+	if (normalized === kindDirectory) {
+		return "index.ts";
+	}
+
+	return normalized;
+}
+
+function buildTaskName(relativeFilePath: string, exportName: string): string {
+	const normalizedRelativePath = relativeFilePath.replace(/\\/g, "/");
+	const relativeWithoutExtension = withoutExtension(normalizedRelativePath);
+	const segments = relativeWithoutExtension.split("/").filter(Boolean);
+	const fileName = segments[segments.length - 1] ?? "index";
+	const dirName = segments.length > 1 ? segments[segments.length - 2] : "root";
+
+	return [dirName, fileName, exportName]
+		.map((segment) => segment.trim())
+		.filter((segment) => segment.length > 0)
+		.join("/");
+}
+
+export async function discoverHandlerOperations(
+	loadedConfig: LoadedAppflareConfig,
+): Promise<DiscoveredHandlerOperation[]> {
+	const operations: DiscoveredHandlerOperation[] = [];
+
+	const files = await discoverFiles(loadedConfig.scanDirAbs).catch(() => []);
+	for (const filePath of files) {
+		const sourceFile = Bun.file(filePath);
+		if (!(await sourceFile.exists())) {
+			continue;
+		}
+
+		const source = await sourceFile.text();
+		const relativeToScanDir = relative(loadedConfig.scanDirAbs, filePath);
+		const discoveredExports = discoverExports(source, filePath);
+
+		const discoveredKinds: Array<{
+			kind: HandlerKind;
+			kindDirectory: "queries" | "mutations" | "schedulers" | "crons";
+			exports: DiscoveredExport[];
+		}> = [
+			{
+				kind: "query",
+				kindDirectory: "queries",
+				exports: discoveredExports.filter((entry) => entry.kind === "query"),
+			},
+			{
+				kind: "mutation",
+				kindDirectory: "mutations",
+				exports: discoveredExports.filter((entry) => entry.kind === "mutation"),
+			},
+			{
+				kind: "scheduler",
+				kindDirectory: "schedulers",
+				exports: discoveredExports.filter(
+					(entry) => entry.kind === "scheduler",
+				),
+			},
+			{
+				kind: "cron",
+				kindDirectory: "crons",
+				exports: discoveredExports.filter((entry) => entry.kind === "cron"),
+			},
+			{
+				kind: "storage",
+				kindDirectory: "queries",
+				exports: discoveredExports.filter((entry) => entry.kind === "storage"),
+			},
+		];
+
+		for (const discovered of discoveredKinds) {
+			if (discovered.exports.length === 0) {
+				continue;
+			}
+
+			const relativeForKind = relativePathForKind(
+				relativeToScanDir,
+				discovered.kindDirectory,
+			);
+
+			for (const discoveredExport of discovered.exports) {
+				const handlerName =
+					discovered.kind === "query" || discovered.kind === "mutation"
+						? buildTaskName(relativeForKind, discoveredExport.exportName)
+						: undefined;
+				const taskName =
+					discovered.kind === "scheduler" || discovered.kind === "cron"
+						? buildTaskName(relativeForKind, discoveredExport.exportName)
+						: undefined;
+				const clientSegments =
+					discovered.kind === "query" || discovered.kind === "mutation"
+						? [
+								...withoutExtension(relativeForKind).split("/").filter(Boolean),
+								discoveredExport.exportName,
+							]
+						: undefined;
+				const routePath =
+					discovered.kind === "query"
+						? buildRoutePath(
+								"queries",
+								relativeForKind,
+								discoveredExport.exportName,
+							)
+						: discovered.kind === "mutation"
+							? buildRoutePath(
+									"mutations",
+									relativeForKind,
+									discoveredExport.exportName,
+								)
+							: discovered.kind === "storage"
+								? `/storage/managers/${discoveredExport.exportName}`
+								: `/${discovered.kindDirectory}/${taskName}`;
+
+				operations.push({
+					kind: discovered.kind,
+					exportName: discoveredExport.exportName,
+					filePath,
+					importPath: ensureRelativeImportPath(
+						loadedConfig.outDirAbs,
+						filePath,
+					),
+					clientImportPath: ensureRelativeImportPath(
+						resolve(loadedConfig.outDirAbs, "client"),
+						filePath,
+					),
+					routePath,
+					handlerName,
+					clientSegments,
+					taskName,
+					cronTriggers: discoveredExport.cronTriggers,
+				});
+			}
+		}
+	}
+
+	operations.sort((a, b) => a.routePath.localeCompare(b.routePath));
+
+	const seen = new Map<string, string>();
+	for (const operation of operations) {
+		const uniqueKey = operation.taskName
+			? `task:${operation.taskName}`
+			: `route:${operation.routePath}`;
+		const previous = seen.get(uniqueKey);
+		if (previous) {
+			throw new Error(
+				`Duplicate handler operation discovered: ${operation.taskName ?? operation.routePath} (${previous} and ${operation.filePath}#${operation.exportName}).`,
+			);
+		}
+		seen.set(uniqueKey, `${operation.filePath}#${operation.exportName}`);
+	}
+
+	return operations;
+}

package/cli/utils/json-utils.ts

@@ -0,0 +1,24 @@
+import type { JsonObject, JsonValue } from "../types";
+
+function isObject(value: JsonValue | undefined): value is JsonObject {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+export function deepMergeJson(
+	base: JsonObject,
+	override: JsonObject,
+): JsonObject {
+	const merged: JsonObject = { ...base };
+
+	for (const [key, overrideValue] of Object.entries(override)) {
+		const currentValue = merged[key];
+		if (isObject(currentValue) && isObject(overrideValue)) {
+			merged[key] = deepMergeJson(currentValue, overrideValue);
+			continue;
+		}
+
+		merged[key] = overrideValue;
+	}
+
+	return merged;
+}

package/cli/utils/path-utils.ts

@@ -0,0 +1,19 @@
+import { relative } from "node:path";
+
+function toPosixPath(value: string): string {
+	return value.replaceAll("\\", "/");
+}
+
+export function ensureRelativeImportPath(
+	fromDir: string,
+	toFile: string,
+): string {
+	const relativePath = toPosixPath(relative(fromDir, toFile)).replace(
+		/\.tsx?$/,
+		"",
+	);
+	if (relativePath.startsWith(".")) {
+		return relativePath;
+	}
+	return `./${relativePath}`;
+}