appflare 0.0.28 → 0.1.1

package/cli/templates/handlers/generators/registration/modules/storage.ts

@@ -0,0 +1,194 @@
+export const storageModule = `
+function parseExpiresIn(value: string | undefined): number | undefined {
+	if (!value) {
+		return undefined;
+	}
+
+	const parsed = Number(value);
+	if (!Number.isFinite(parsed) || parsed <= 0) {
+		return undefined;
+	}
+
+	return Math.floor(parsed);
+}
+
+function toStoragePath(path: string): string {
+	const trimmed = path.trim();
+	if (!trimmed) {
+		throw new Error("Storage path is required");
+	}
+
+	return trimmed.startsWith("/") ? trimmed : "/" + trimmed;
+}
+
+function readStoragePath(c: { req: { query: (name: string) => string | undefined } }): string {
+	const path = c.req.query("path") ?? "";
+	return toStoragePath(path);
+}
+
+export function registerGeneratedStorageRoutes(
+	app: Hono<WorkerEnv>,
+	options: RegisterHandlersOptions,
+): void {
+	app.post("/storage/upload", async (c) => {
+		const ctx = await createExecutionContext(c, options);
+		try {
+			const body = await c.req.json().catch(() => ({} as Record<string, unknown>));
+			const path = toStoragePath(String(body.path ?? ""));
+			const contentType =
+				typeof body.contentType === "string" ? body.contentType : undefined;
+			const expiresIn =
+				typeof body.expiresIn === "number" && body.expiresIn > 0
+					? Math.floor(body.expiresIn)
+					: undefined;
+
+			const url = await ctx.storage.signedUrl({
+				path,
+				method: "PUT",
+				expiresIn,
+				contentType,
+			});
+
+			return c.json({
+				url,
+				method: "PUT",
+				path,
+				expiresIn: expiresIn ?? 300,
+			}, 200);
+		} catch (error) {
+			if (error instanceof AppflareHandledError) {
+				return c.json(error.payload, error.status);
+			}
+
+			return c.json(
+				{ message: (error as Error).message ?? "Unable to create upload URL" },
+				400,
+			);
+		}
+	});
+
+	app.get("/storage/download", async (c) => {
+		const ctx = await createExecutionContext(c, options);
+		try {
+			const path = readStoragePath(c);
+			const fileName = c.req.query("fileName") ?? undefined;
+			const expiresIn = parseExpiresIn(c.req.query("expiresIn"));
+			const url = await ctx.storage.signedUrl({
+				path,
+				method: "GET",
+				expiresIn,
+				downloadAsAttachment: true,
+				fileName,
+			});
+
+			return c.json({
+				url,
+				method: "GET",
+				path,
+				disposition: "attachment",
+			}, 200);
+		} catch (error) {
+			if (error instanceof AppflareHandledError) {
+				return c.json(error.payload, error.status);
+			}
+
+			return c.json(
+				{ message: (error as Error).message ?? "Unable to create download URL" },
+				400,
+			);
+		}
+	});
+
+	app.get("/storage/preview", async (c) => {
+		const ctx = await createExecutionContext(c, options);
+		try {
+			const path = readStoragePath(c);
+			const expiresIn = parseExpiresIn(c.req.query("expiresIn"));
+			const url = await ctx.storage.signedUrl({
+				path,
+				method: "GET",
+				expiresIn,
+				downloadAsAttachment: false,
+			});
+
+			return c.json({
+				url,
+				method: "GET",
+				path,
+				disposition: "inline",
+			}, 200);
+		} catch (error) {
+			if (error instanceof AppflareHandledError) {
+				return c.json(error.payload, error.status);
+			}
+
+			return c.json(
+				{ message: (error as Error).message ?? "Unable to create preview URL" },
+				400,
+			);
+		}
+	});
+
+	app.delete("/storage/object", async (c) => {
+		const ctx = await createExecutionContext(c, options);
+		try {
+			const path = readStoragePath(c);
+			await ctx.storage.delete({ path });
+			return c.json({ ok: true, path }, 200);
+		} catch (error) {
+			if (error instanceof AppflareHandledError) {
+				return c.json(error.payload, error.status);
+			}
+
+			return c.json(
+				{ message: (error as Error).message ?? "Unable to delete object" },
+				400,
+			);
+		}
+	});
+
+	app.get("/storage/list", async (c) => {
+		const ctx = await createExecutionContext(c, options);
+		try {
+			const prefix = c.req.query("prefix") ?? undefined;
+			const cursor = c.req.query("cursor") ?? undefined;
+			const delimiter = c.req.query("delimiter") ?? undefined;
+			const limitValue = c.req.query("limit");
+			const parsedLimit = limitValue ? Number(limitValue) : undefined;
+			const limit =
+				typeof parsedLimit === "number" && Number.isFinite(parsedLimit) && parsedLimit > 0
+					? Math.floor(parsedLimit)
+					: undefined;
+			const methodValue = c.req.query("method");
+			const method: StorageMethod | undefined =
+				methodValue === "download" ||
+				methodValue === "get" ||
+				methodValue === "delete" ||
+				methodValue === "list" ||
+				methodValue === "put" ||
+				methodValue === "preview"
+					? methodValue
+					: undefined;
+
+			const result = await ctx.storage.list({
+				prefix,
+				cursor,
+				delimiter,
+				limit,
+				method,
+			});
+
+			return c.json(result, 200);
+		} catch (error) {
+			if (error instanceof AppflareHandledError) {
+				return c.json(error.payload, error.status);
+			}
+
+			return c.json(
+				{ message: (error as Error).message ?? "Unable to list storage objects" },
+				400,
+			);
+		}
+	});
+}
+`;

package/cli/templates/handlers/generators/registration/sections.ts

@@ -0,0 +1,210 @@
+import type { DiscoveredHandlerOperation } from "../../../../utils/handler-discovery";
+
+type IndexedOperation = {
+	operation: DiscoveredHandlerOperation;
+	index: number;
+	alias: string;
+};
+
+export type RegistrationTemplateSections = {
+	imports: string;
+	operationSchemas: string;
+	schedulerSchemas: string;
+	queryRoutes: string;
+	mutationRoutes: string;
+	queryRegistryEntries: string;
+	schedulerEntries: string;
+	schedulerPayloadMapEntries: string;
+	cronEntries: string;
+	storageHandlersEntries: string;
+};
+
+function toSafeIdentifier(value: string): string {
+	const sanitized = value.replace(/[^A-Za-z0-9_]/g, "_");
+	if (/^[0-9]/.test(sanitized)) {
+		return `_${sanitized}`;
+	}
+	return sanitized;
+}
+
+function buildImportAlias(
+	operation: DiscoveredHandlerOperation,
+	index: number,
+): string {
+	const routeName = operation.routePath.replace(/^\//, "").replace(/\//g, "_");
+	return toSafeIdentifier(`op_${index}_${routeName}`);
+}
+
+function indexOperations(
+	operations: DiscoveredHandlerOperation[],
+): IndexedOperation[] {
+	return operations.map((operation, index) => ({
+		operation,
+		index,
+		alias: buildImportAlias(operation, index),
+	}));
+}
+
+function buildImports(operations: IndexedOperation[]): string {
+	return operations
+		.map(({ operation, alias }) => {
+			return `import { ${operation.exportName} as ${alias} } from "${operation.importPath}";`;
+		})
+		.join("\n");
+}
+
+function buildOperationSchemas(operations: IndexedOperation[]): string {
+	return operations
+		.filter(
+			({ operation }) =>
+				operation.kind === "query" || operation.kind === "mutation",
+		)
+		.map(({ alias }) => {
+			const schemaName = `${alias}Schema`;
+			return `const ${schemaName} = z.object(${alias}.definition.args);`;
+		})
+		.join("\n");
+}
+
+function buildSchedulerSchemas(operations: IndexedOperation[]): string {
+	return operations
+		.filter(({ operation }) => operation.kind === "scheduler")
+		.map(({ alias }) => {
+			const schemaName = `${alias}SchedulerSchema`;
+			return `const ${schemaName} = ${alias}.definition.args ? z.object(${alias}.definition.args) : z.undefined();`;
+		})
+		.join("\n");
+}
+
+function buildQueryRoutes(operations: IndexedOperation[]): string {
+	return operations
+		.filter(({ operation }) => operation.kind === "query")
+		.map(({ operation, alias }) => {
+			const schemaName = `${alias}Schema`;
+			return `
+	app.get(
+		"${operation.routePath}",
+		sValidator("query", ${schemaName}),
+		async (c) => {
+			const ctx = await createExecutionContext(c, options);
+			try {
+				return await executeOperation(c, ${alias}, c.req.valid("query"), ctx);
+			} catch (error) {
+				return handleOperationError(c, error, "Invalid query arguments");
+			}
+		},
+	);`;
+		})
+		.join("\n");
+}
+
+function buildMutationRoutes(operations: IndexedOperation[]): string {
+	return operations
+		.filter(({ operation }) => operation.kind === "mutation")
+		.map(({ operation, alias }) => {
+			const schemaName = `${alias}Schema`;
+			return `
+	app.post(
+		"${operation.routePath}",
+		sValidator("json", ${schemaName}),
+		async (c) => {
+			const ctx = await createExecutionContext(c, options);
+			try {
+				const response = await executeOperation(c, ${alias}, c.req.valid("json"), ctx);
+				await publishMutationEvents(c, options, ctx.mutationEvents);
+				return response;
+			} catch (error) {
+				return handleOperationError(c, error, "Invalid mutation arguments");
+			}
+		},
+	);`;
+		})
+		.join("\n");
+}
+
+function buildQueryRegistryEntries(operations: IndexedOperation[]): string {
+	return operations
+		.filter(({ operation }) => operation.kind === "query")
+		.map(({ operation, alias }) => {
+			const schemaName = `${alias}Schema`;
+			const queryName = operation.handlerName ?? operation.routePath;
+			return `
+	${JSON.stringify(queryName)}: {
+		definition: ${alias}.definition,
+		schema: ${schemaName},
+	},`;
+		})
+		.join("\n");
+}
+
+function buildSchedulerEntries(operations: IndexedOperation[]): string {
+	return operations
+		.filter(({ operation }) => operation.kind === "scheduler")
+		.map(({ operation, alias }) => {
+			const schemaName = `${alias}SchedulerSchema`;
+			const taskName = operation.taskName ?? `${operation.routePath}`;
+			return `
+	${JSON.stringify(taskName)}: {
+		definition: ${alias}.definition,
+		schema: ${schemaName},
+	},`;
+		})
+		.join("\n");
+}
+
+function buildSchedulerPayloadMapEntries(
+	operations: IndexedOperation[],
+): string {
+	return operations
+		.filter(({ operation }) => operation.kind === "scheduler")
+		.map(({ operation, alias }) => {
+			const taskName = operation.taskName ?? `${operation.routePath}`;
+			return `\t${JSON.stringify(taskName)}: Parameters<typeof ${alias}.definition.handler>[1];`;
+		})
+		.join("\n");
+}
+
+function buildCronEntries(operations: IndexedOperation[]): string {
+	return operations
+		.filter(({ operation }) => operation.kind === "cron")
+		.map(({ operation, alias }) => {
+			const taskName = operation.taskName ?? `${operation.routePath}`;
+			const cronTriggers = operation.cronTriggers ?? [];
+			return `
+	{
+		taskName: ${JSON.stringify(taskName)},
+		cronTriggers: ${JSON.stringify(cronTriggers)},
+		definition: ${alias}.definition,
+	},`;
+		})
+		.join("\n");
+}
+
+function buildStorageHandlersEntries(operations: IndexedOperation[]): string {
+	return operations
+		.filter(({ operation }) => operation.kind === "storage")
+		.map(({ alias }) => {
+			return `\n\t${alias}.definition.handler,`;
+		})
+		.join("\n");
+}
+
+export function buildRegistrationTemplateSections(
+	operations: DiscoveredHandlerOperation[],
+): RegistrationTemplateSections {
+	const indexedOperations = indexOperations(operations);
+
+	return {
+		imports: buildImports(indexedOperations),
+		operationSchemas: buildOperationSchemas(indexedOperations),
+		schedulerSchemas: buildSchedulerSchemas(indexedOperations),
+		queryRoutes: buildQueryRoutes(indexedOperations),
+		mutationRoutes: buildMutationRoutes(indexedOperations),
+		queryRegistryEntries: buildQueryRegistryEntries(indexedOperations),
+		schedulerEntries: buildSchedulerEntries(indexedOperations),
+		schedulerPayloadMapEntries:
+			buildSchedulerPayloadMapEntries(indexedOperations),
+		cronEntries: buildCronEntries(indexedOperations),
+		storageHandlersEntries: buildStorageHandlersEntries(indexedOperations),
+	};
+}

package/cli/templates/handlers/generators/types/context.ts

@@ -0,0 +1,64 @@
+export function generateTypesContextSection(): string {
+	return `type AuthSession = typeof auth.$Infer.Session;
+type User = AuthSession['user']
+type Session = AuthSession['session']
+
+export type StoragePutArgs = {
+	path: string;
+	body: ReadableStream | ArrayBuffer | ArrayBufferView | string | Blob;
+	contentType?: string;
+	httpMetadata?: Record<string, unknown>;
+	customMetadata?: Record<string, string>;
+};
+
+export type StorageGetArgs = {
+	path: string;
+	method?: StorageMethod;
+	onlyIf?: unknown;
+	range?: unknown;
+	includeBody?: boolean;
+};
+
+export type StorageDeleteArgs = {
+	path: string;
+};
+
+export type StorageListArgs = {
+	prefix?: string;
+	cursor?: string;
+	limit?: number;
+	delimiter?: string;
+	include?: Array<"httpMetadata" | "customMetadata">;
+	method?: StorageMethod;
+};
+
+export type StorageSignedUrlArgs = {
+	path: string;
+	method?: "GET" | "PUT" | "DELETE";
+	expiresIn?: number;
+	contentType?: string;
+	downloadAsAttachment?: boolean;
+	fileName?: string;
+};
+
+export type AppflareStorage = {
+	put: (args: StoragePutArgs) => Promise<unknown>;
+	get: (args: StorageGetArgs) => Promise<unknown | null>;
+	delete: (args: StorageDeleteArgs) => Promise<void>;
+	list: (args?: StorageListArgs) => Promise<unknown>;
+	signedUrl: (args: StorageSignedUrlArgs) => Promise<string>;
+};
+
+export type AppflareContext = {
+	$db: AppflareDb;
+	db: AppflareQueryDb;
+	mutationEvents: DbMutationEvent[];
+	user: User;
+	session: Session;
+	context: Context<WorkerEnv>;
+	scheduler: Scheduler;
+	storage: AppflareStorage;
+	error: (status: number, message: string, details?: unknown) => never;
+};
+`;
+}

package/cli/templates/handlers/generators/types/core.ts

@@ -0,0 +1,101 @@
+export function generateTypesCoreSection(): string {
+	return `import { betterAuth } from "better-auth";
+import { auth } from "./auth.config";
+import {
+	and,
+	eq,
+	ne,
+	inArray,
+	notInArray,
+	gt,
+	gte,
+	lt,
+	lte,
+	isNull,
+	isNotNull,
+	getTableColumns,
+	sql,
+	type InferInsertModel,
+	type InferSelectModel,
+	type SQL,
+} from "drizzle-orm";
+
+export type WorkerEnv = {
+	Bindings: Record<string, unknown>;
+};
+
+export type RegisterHandlersOptions = {
+	databaseBinding: string;
+	kvBinding?: string;
+	schedulerBinding?: string;
+	r2Binding?: string;
+	realtimeBinding?: string;
+	realtimeObjectName?: string;
+	realtimeSubscribePath?: string;
+	realtimeWebsocketPath?: string;
+	realtimeProtocol?: string;
+};
+
+export type StorageMethod =
+	| "download"
+	| "get"
+	| "delete"
+	| "list"
+	| "put"
+	| "preview";
+
+export type StorageAuthorizationArgs = {
+	path: string;
+	method: StorageMethod;
+	headers?: Headers;
+	query?: Record<string, string>;
+	contentType?: string;
+};
+
+export type StorageHandler = (
+	ctx: AppflareContext,
+	args: StorageAuthorizationArgs,
+) => boolean | Promise<boolean>;
+
+export type RegisteredStorageHandler = {
+	kind: "storage-manager";
+	definition: {
+		handler: StorageHandler;
+	};
+};
+
+export function storageManager(definition: {
+	handler: StorageHandler;
+}): RegisteredStorageHandler {
+	return {
+		kind: "storage-manager",
+		definition,
+	};
+}
+
+const storageHandlers: StorageHandler[] = [];
+
+export function setStorageHandlers(handlers: StorageHandler[]): void {
+	storageHandlers.length = 0;
+	storageHandlers.push(...handlers);
+}
+
+export async function isStorageAllowed(
+	ctx: AppflareContext,
+	args: StorageAuthorizationArgs,
+): Promise<boolean> {
+	if (storageHandlers.length === 0) {
+		return false;
+	}
+
+	for (const handler of storageHandlers) {
+		const allowed = await handler(ctx, args);
+		if (allowed) {
+			return true;
+		}
+	}
+
+	return false;
+}
+`;
+}

package/cli/templates/handlers/generators/types/operations.ts

@@ -0,0 +1,135 @@
+export function generateTypesOperationsSection(): string {
+	return `type InferOperationArgs<TShape extends ZodRawShape> = z.output<z.ZodObject<TShape>>;
+
+export type SchedulerEnqueueOptions = {
+	delaySeconds?: number;
+};
+
+declare global {
+	interface AppflareSchedulerHandlerMap {}
+}
+
+export type SchedulerTaskName = keyof AppflareSchedulerHandlerMap extends never
+	? string
+	: Extract<keyof AppflareSchedulerHandlerMap, string>;
+
+export type SchedulerTaskPayload<TTask extends SchedulerTaskName> =
+	TTask extends keyof AppflareSchedulerHandlerMap
+		? AppflareSchedulerHandlerMap[TTask]
+		: unknown;
+
+export type SchedulerEnqueue = {
+	<TTask extends SchedulerTaskName>(
+		task: TTask,
+		...args: undefined extends SchedulerTaskPayload<TTask>
+			? [
+					payload?: SchedulerTaskPayload<TTask>,
+					options?: SchedulerEnqueueOptions,
+			  ]
+			: [
+					payload: SchedulerTaskPayload<TTask>,
+					options?: SchedulerEnqueueOptions,
+			  ]
+	): Promise<void>;
+};
+
+export type Scheduler = {
+	enqueue: SchedulerEnqueue;
+};
+
+type OperationDefinition<
+	TShape extends ZodRawShape,
+	TResult,
+> = {
+	args: TShape;
+	authRequired: boolean;
+	middleware?: (
+		ctx: AppflareContext,
+		index: InferOperationArgs<TShape>,
+		request: Request,
+	) => void | Promise<void>;
+	handler: (
+		ctx: AppflareContext,
+		args: InferOperationArgs<TShape>,
+	) => TResult | Promise<TResult>;
+};
+
+type OperationDefinitionInput<
+	TShape extends ZodRawShape,
+	TResult,
+> = Omit<OperationDefinition<TShape, TResult>, "authRequired"> & {
+	authRequired?: boolean;
+};
+
+export type RegisteredOperation<
+	TShape extends ZodRawShape,
+	TResult,
+> = {
+	kind: "query" | "mutation";
+	definition: OperationDefinition<TShape, TResult>;
+};
+
+type SchedulerDefinition<TShape extends ZodRawShape | undefined> = {
+	args?: TShape;
+	handler: (
+		ctx: AppflareContext,
+		args: TShape extends ZodRawShape ? InferOperationArgs<TShape> : undefined,
+	) => void | Promise<void>;
+};
+
+export type RegisteredScheduler<TShape extends ZodRawShape | undefined> = {
+	kind: "scheduler";
+	definition: SchedulerDefinition<TShape>;
+};
+
+type CronDefinition = {
+	cronTrigger: string | string[];
+	handler: (ctx: AppflareContext) => void | Promise<void>;
+};
+
+export type RegisteredCron = {
+	kind: "cron";
+	definition: CronDefinition;
+};
+
+export function query<TShape extends ZodRawShape, TResult>(
+	definition: OperationDefinitionInput<TShape, TResult>,
+): RegisteredOperation<TShape, TResult> {
+	return {
+		kind: "query",
+		definition: {
+			authRequired: false,
+			...definition,
+		},
+	};
+}
+
+export function mutation<TShape extends ZodRawShape, TResult>(
+	definition: OperationDefinitionInput<TShape, TResult>,
+): RegisteredOperation<TShape, TResult> {
+	return {
+		kind: "mutation",
+		definition: {
+			authRequired: false,
+			...definition,
+		},
+	};
+}
+
+export function scheduler<TShape extends ZodRawShape | undefined = undefined>(
+	definition: SchedulerDefinition<TShape>,
+): RegisteredScheduler<TShape> {
+	return {
+		kind: "scheduler",
+		definition,
+	};
+}
+
+export function cron(definition: CronDefinition): RegisteredCron {
+	return {
+		kind: "cron",
+		definition,
+	};
+}
+`;
+}