appflare 0.0.28 → 0.1.1

package/cli/templates/core/client-modules/handlers.ts

@@ -0,0 +1 @@
+export { generateClientHandlersSource } from "./handlers/index";

package/cli/templates/core/client-modules/index.ts

@@ -0,0 +1,7 @@
+export function generateClientIndexSource(): string {
+	return `export * from "./types";
+export * from "./appflare";
+export * from "./storage";
+export * from "./handlers";
+`;
+}

package/cli/templates/core/client-modules/storage.ts

@@ -0,0 +1,180 @@
+export function generateClientStorageSource(): string {
+	return `import type { StorageClient, StorageSignedUrlResponse, StorageListResponse } from "./types";
+
+type AuthTokenResolver = (() => string | Promise<string>) | undefined;
+
+function toHeaderRecord(headers: HeadersInit | undefined): Record<string, string> {
+	const result: Record<string, string> = {};
+	if (!headers) {
+		return result;
+	}
+
+	if (Array.isArray(headers)) {
+		for (const entry of headers) {
+			if (!Array.isArray(entry) || entry.length < 2) {
+				continue;
+			}
+			result[String(entry[0])] = String(entry[1]);
+		}
+		return result;
+	}
+
+	if (typeof (headers as { forEach?: unknown }).forEach === "function") {
+		(headers as Headers).forEach((value, key) => {
+			result[key] = String(value);
+		});
+		return result;
+	}
+
+	for (const [key, value] of Object.entries(headers as Record<string, unknown>)) {
+		result[key] = String(value ?? "");
+	}
+
+	return result;
+}
+
+function hasAuthorizationHeader(headers: Record<string, string>): boolean {
+	for (const key of Object.keys(headers)) {
+		if (key.toLowerCase() === "authorization") {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+async function createAuthorizedHeaders(
+	headers: HeadersInit | undefined,
+	onGetAuthToken: AuthTokenResolver,
+): Promise<HeadersInit | undefined> {
+	const resolvedHeaders = toHeaderRecord(headers);
+	if (onGetAuthToken) {
+		const authToken = await onGetAuthToken();
+		if (typeof authToken === "string" && authToken.trim().length > 0) {
+			if (!hasAuthorizationHeader(resolvedHeaders)) {
+				resolvedHeaders.authorization = \`Bearer \${authToken.trim()}\`;
+			}
+		}
+	}
+
+	return resolvedHeaders;
+}
+
+export function createStorageClient(
+	endpoint: string,
+	request: typeof fetch = fetch,
+	onGetAuthToken?: () => string | Promise<string>,
+): StorageClient {
+	return {
+		upload: async (args) => {
+			const headers = await createAuthorizedHeaders(
+				{
+					"content-type": "application/json",
+				},
+				onGetAuthToken,
+			);
+
+			const response = await request(\`\${endpoint}/storage/upload\`, {
+				method: "POST",
+				headers,
+				body: JSON.stringify(args),
+			});
+			if (!response.ok) {
+				throw new Error(await response.text());
+			}
+
+			return (await response.json()) as StorageSignedUrlResponse;
+		},
+		download: async (args) => {
+			const query = new URLSearchParams({
+				path: args.path,
+				...(args.fileName ? { fileName: args.fileName } : {}),
+				...(typeof args.expiresIn === "number"
+					? { expiresIn: String(args.expiresIn) }
+					: {}),
+			});
+			const response = await request(
+				\`\${endpoint}/storage/download?\${query.toString()}\`,
+				{
+					headers: await createAuthorizedHeaders(undefined, onGetAuthToken),
+				},
+			);
+			if (!response.ok) {
+				throw new Error(await response.text());
+			}
+
+			return (await response.json()) as StorageSignedUrlResponse;
+		},
+		preview: async (args) => {
+			const query = new URLSearchParams({
+				path: args.path,
+				...(typeof args.expiresIn === "number"
+					? { expiresIn: String(args.expiresIn) }
+					: {}),
+			});
+			const response = await request(
+				\`\${endpoint}/storage/preview?\${query.toString()}\`,
+				{
+					headers: await createAuthorizedHeaders(undefined, onGetAuthToken),
+				},
+			);
+			if (!response.ok) {
+				throw new Error(await response.text());
+			}
+
+			return (await response.json()) as StorageSignedUrlResponse;
+		},
+		delete: async (args) => {
+			const query = new URLSearchParams({
+				path: args.path,
+			});
+			const response = await request(
+				\`\${endpoint}/storage/object?\${query.toString()}\`,
+				{
+					method: "DELETE",
+					headers: await createAuthorizedHeaders(undefined, onGetAuthToken),
+				},
+			);
+			if (!response.ok) {
+				throw new Error(await response.text());
+			}
+
+			return (await response.json()) as { ok: boolean; path: string };
+		},
+		list: async (args = {}) => {
+			const query = new URLSearchParams();
+			if (args.prefix) {
+				query.set("prefix", args.prefix);
+			}
+			if (args.cursor) {
+				query.set("cursor", args.cursor);
+			}
+			if (typeof args.limit === "number") {
+				query.set("limit", String(args.limit));
+			}
+			if (args.delimiter) {
+				query.set("delimiter", args.delimiter);
+			}
+			if (args.method) {
+				query.set("method", args.method);
+			}
+
+			const querySuffix = query.toString();
+			const response = await request(
+				querySuffix.length > 0
+					? \`\${endpoint}/storage/list?\${querySuffix}\`
+					: \`\${endpoint}/storage/list\`,
+				{
+					headers: await createAuthorizedHeaders(undefined, onGetAuthToken),
+				},
+			);
+			if (!response.ok) {
+				throw new Error(await response.text());
+			}
+
+			return (await response.json()) as StorageListResponse;
+		},
+	};
+}
+`;
+}

package/cli/templates/core/client-modules/types.ts

@@ -0,0 +1,145 @@
+export function generateClientTypesSource(configPathImport: string): string {
+	return `import { createAuthClient, type BetterAuthClientOptions } from "better-auth/client";
+import type appflareConfig from "${configPathImport}";
+
+export type AppflareConfig = typeof appflareConfig;
+export type InferredAuthOptions = AppflareConfig["auth"]["clientOptions"];
+
+export type AppflareAuth<Options extends BetterAuthClientOptions = InferredAuthOptions> = ReturnType<
+	typeof createAuthClient<Options>
+>;
+
+export type AppflareAuthTokenResolver = () => string | Promise<string>;
+
+export type AppflareOptions<Options extends BetterAuthClientOptions = InferredAuthOptions> = {
+	endpoint: string;
+	wsEndpoint?: string;
+	authPath?: string;
+	authOptions?: Options;
+	fetch?: typeof fetch;
+	requestOptions?: AppflareResultRouteCallOptions;
+	onSetAuthToken?: (token: string) => void | Promise<void>;
+	onGetAuthToken?: AppflareAuthTokenResolver;
+};
+
+export type AppflareErrorMode = "throw" | "return";
+
+export type AppflareRequestError = {
+	route: string;
+	method: "GET" | "POST";
+	status: number;
+	message: string;
+	body?: unknown;
+	responseText?: string;
+};
+
+export type AppflareRequestResult<TData> = {
+	data: TData | null;
+	error: AppflareRequestError | null;
+};
+
+export type AppflareRouteCallOptions<
+	Mode extends AppflareErrorMode = "throw",
+> = {
+	errorMode?: Mode;
+	headers?: HeadersInit;
+	signal?: AbortSignal;
+	onError?: (error: AppflareRequestError) => void;
+};
+
+export type AppflareResultRouteCallOptions = Omit<
+	AppflareRouteCallOptions<"return">,
+	"errorMode"
+>;
+
+export type AppflareRouteClient<
+	TSchema extends import("zod").ZodObject<import("zod").ZodRawShape>,
+	TOutput,
+> = {
+	schema: TSchema;
+	run(
+		args: import("zod").input<TSchema>,
+		options?: AppflareResultRouteCallOptions,
+	): Promise<AppflareRequestResult<TOutput>>;
+};
+
+export type AppflareRealtimeSubscription = {
+	remove: () => void;
+};
+
+export type AppflareRealtimeQueryUpdate<TOutput> = {
+	event: "query:update";
+	payload: {
+		queryName: string;
+		signature: string;
+		data: TOutput;
+	};
+};
+
+export type AppflareQuerySubscribeOptions<TInput, TOutput> = {
+	args?: TInput;
+	authToken?: string;
+	onChange: (data: TOutput, update: AppflareRealtimeQueryUpdate<TOutput>) => void;
+	onError?: (error: unknown) => void;
+	requestOptions?: AppflareRouteCallOptions;
+	signal?: AbortSignal;
+};
+
+export type AppflareQueryRouteClient<
+	TSchema extends import("zod").ZodObject<import("zod").ZodRawShape>,
+	TOutput,
+> = AppflareRouteClient<TSchema, TOutput> & {
+	subscribe: (
+		options: AppflareQuerySubscribeOptions<import("zod").input<TSchema>, TOutput>,
+	) => AppflareRealtimeSubscription;
+};
+
+export type StorageSignedUrlResponse = {
+	url: string;
+	method: "GET" | "PUT" | "DELETE";
+	path: string;
+	disposition?: "attachment" | "inline";
+	expiresIn?: number;
+};
+
+export type StorageListResponse = unknown;
+
+export type StorageClient = {
+	upload: (args: {
+		path: string;
+		contentType?: string;
+		expiresIn?: number;
+	}) => Promise<StorageSignedUrlResponse>;
+	download: (args: {
+		path: string;
+		expiresIn?: number;
+		fileName?: string;
+	}) => Promise<StorageSignedUrlResponse>;
+	preview: (args: {
+		path: string;
+		expiresIn?: number;
+	}) => Promise<StorageSignedUrlResponse>;
+	delete: (args: { path: string }) => Promise<{ ok: boolean; path: string }>;
+	list: (args?: {
+		prefix?: string;
+		cursor?: string;
+		limit?: number;
+		delimiter?: string;
+		method?: "download" | "get" | "delete" | "list" | "put" | "preview";
+	}) => Promise<StorageListResponse>;
+};
+
+export type RealtimeSubscriptionResponse = {
+	token: string;
+	signature: string;
+	websocket: {
+		url: string;
+		protocol: string;
+		params: {
+			tokenParam: "token";
+			authTokenParam: "authToken";
+		};
+	};
+};
+`;
+}

package/cli/templates/core/client.ts

@@ -0,0 +1,39 @@
+import { generateClientAppflareSource } from "./client-modules/appflare";
+import { generateClientHandlersSource } from "./client-modules/handlers";
+import { generateClientIndexSource } from "./client-modules/index";
+import { generateClientStorageSource } from "./client-modules/storage";
+import { generateClientTypesSource } from "./client-modules/types";
+import type { DiscoveredHandlerOperation } from "../../utils/handler-discovery";
+
+export type GeneratedClientArtifact = {
+	relativePath: string;
+	source: string;
+};
+
+export function generateClientArtifacts(
+	configPathImport: string,
+	operations: DiscoveredHandlerOperation[],
+): GeneratedClientArtifact[] {
+	return [
+		{
+			relativePath: "client/index.ts",
+			source: generateClientIndexSource(),
+		},
+		{
+			relativePath: "client/types.ts",
+			source: generateClientTypesSource(configPathImport),
+		},
+		{
+			relativePath: "client/storage.ts",
+			source: generateClientStorageSource(),
+		},
+		{
+			relativePath: "client/handlers.ts",
+			source: generateClientHandlersSource(operations),
+		},
+		{
+			relativePath: "client/appflare.ts",
+			source: generateClientAppflareSource(),
+		},
+	];
+}

package/cli/templates/core/drizzle.ts

@@ -0,0 +1,15 @@
+export function generateDrizzleConfigSource(schema: string[]): string {
+	return `import { defineConfig } from "drizzle-kit";
+
+export default defineConfig({
+	dialect: "sqlite",
+	schema: ${JSON.stringify(schema)},
+	driver: "d1-http",
+	dbCredentials: {
+		accountId: "accountId",
+		databaseId: "databaseId",
+		token: "token",
+	},
+});
+`;
+}

package/cli/templates/core/export.ts

@@ -0,0 +1,14 @@
+export function generateExport(): string {
+	return `export { AppflareRealtimeDurableObject };
+
+export default {
+\tfetch: app.fetch,
+	queue: async (batch, env) => {
+		await executeScheduledBatch(batch, env, generatedHandlerOptions);
+	},
+	scheduled: async (controller, env) => {
+		await executeCronTriggers(controller, env, generatedHandlerOptions);
+	},
+};
+`;
+}

package/cli/templates/core/handlers-route.ts

@@ -0,0 +1,23 @@
+export function generateHandlersRoute(
+	databaseBinding: string,
+	kvBinding?: string,
+	schedulerBinding = "APPFLARE_SCHEDULER_QUEUE",
+	r2Binding?: string,
+	realtimeBinding = "APPFLARE_REALTIME",
+	realtimeObjectName = "global",
+	realtimeSubscribePath = "/realtime/subscribe",
+	realtimeWebsocketPath = "/realtime/ws",
+	realtimeProtocol = "appflare.realtime.v1",
+): string {
+	const kvLine = kvBinding ? `\n\tkvBinding: "${kvBinding}",` : "";
+	const storageLine = r2Binding ? `\n\tr2Binding: "${r2Binding}",` : "";
+	const realtimeLines = `\n\trealtimeBinding: "${realtimeBinding}",\n\trealtimeObjectName: "${realtimeObjectName}",\n\trealtimeSubscribePath: "${realtimeSubscribePath}",\n\trealtimeWebsocketPath: "${realtimeWebsocketPath}",\n\trealtimeProtocol: "${realtimeProtocol}",`;
+
+	return `const generatedHandlerOptions = {
+	databaseBinding: "${databaseBinding}",${kvLine}
+	schedulerBinding: "${schedulerBinding}",${storageLine}${realtimeLines}
+};
+registerGeneratedHandlers(app, generatedHandlerOptions);
+registerGeneratedStorageRoutes(app, generatedHandlerOptions);
+`;
+}

package/cli/templates/core/handlers.ts

@@ -0,0 +1 @@
+export { generateHandlersArtifacts } from "../handlers/index";

package/cli/templates/core/imports.ts

@@ -0,0 +1,8 @@
+export function generateImports(): string {
+	return `import { createAuth } from "./auth.config";
+import { AppflareRealtimeDurableObject, executeCronTriggers, executeScheduledBatch, registerGeneratedHandlers, registerGeneratedStorageRoutes } from "./handlers.routes";
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import type { D1Database, IncomingRequestCfProperties, KVNamespace } from "@cloudflare/workers-types";
+`;
+}

package/cli/templates/core/server.ts

@@ -0,0 +1,38 @@
+import { generateAuthRoute } from "../auth/route";
+import { generateAppCreation } from "./app-creation";
+import { generateExport } from "./export";
+import { generateHandlersRoute } from "./handlers-route";
+import { generateImports } from "./imports";
+import { generateTypes } from "./types";
+
+export function generateServerSource(
+	authBasePath: string,
+	databaseBinding: string,
+	kvBinding?: string,
+	schedulerBinding?: string,
+	r2Binding?: string,
+	realtimeBinding?: string,
+	realtimeObjectName?: string,
+	realtimeSubscribePath?: string,
+	realtimeWebsocketPath?: string,
+	realtimeProtocol?: string,
+): string {
+	return (
+		generateImports() +
+		generateTypes() +
+		generateAppCreation() +
+		generateHandlersRoute(
+			databaseBinding,
+			kvBinding,
+			schedulerBinding,
+			r2Binding,
+			realtimeBinding,
+			realtimeObjectName,
+			realtimeSubscribePath,
+			realtimeWebsocketPath,
+			realtimeProtocol,
+		) +
+		generateAuthRoute(authBasePath, databaseBinding, kvBinding) +
+		generateExport()
+	);
+}

package/cli/templates/core/types.ts

@@ -0,0 +1,6 @@
+export function generateTypes(): string {
+	return `type WorkerEnv = {
+\tBindings: Record<string, unknown>;
+};
+`;
+}

package/cli/templates/core/wrangler.ts

@@ -0,0 +1,109 @@
+import type { JsonObject, LoadedAppflareConfig } from "../../types";
+import type { DiscoveredHandlerOperation } from "../../utils/handler-discovery";
+import { deepMergeJson } from "../../utils/json-utils";
+
+function unique(values: string[]): string[] {
+	return Array.from(new Set(values.filter((value) => value.length > 0)));
+}
+
+export function generateWranglerJson(
+	config: LoadedAppflareConfig,
+	operations: DiscoveredHandlerOperation[],
+): JsonObject {
+	const schedulerOperations = operations.filter(
+		(operation) => operation.kind === "scheduler" || operation.kind === "cron",
+	);
+	const cronTriggers = unique(
+		operations
+			.filter((operation) => operation.kind === "cron")
+			.flatMap((operation) => operation.cronTriggers ?? []),
+	);
+	const schedulerEnabled =
+		config.config.scheduler.enabled && schedulerOperations.length > 0;
+	const realtimeEnabled = config.config.realtime.enabled;
+	const workerNameOverride =
+		typeof config.config.wranglerOverrides?.name === "string"
+			? config.config.wranglerOverrides.name
+			: undefined;
+	const workerName = workerNameOverride ?? "appflare-worker";
+	const schedulerQueueName =
+		config.config.scheduler.queue ?? `${workerName}-scheduler`;
+
+	const wranglerBase: JsonObject = {
+		name: workerName,
+		main: "./src/index.ts",
+		d1_databases: config.config.database.map((database) => ({
+			binding: database.binding,
+			database_name: database.databaseName,
+			database_id: database.databaseId,
+			preview_database_id: database.previewDatabaseId ?? database.databaseId,
+			...(database.migrationsDir
+				? { migrations_dir: database.migrationsDir }
+				: {}),
+		})),
+		kv_namespaces: config.config.kv.map((namespace) => ({
+			binding: namespace.binding,
+			id: namespace.id,
+			...(namespace.previewId ? { preview_id: namespace.previewId } : {}),
+		})),
+		r2_buckets: config.config.r2.map((bucket) => ({
+			binding: bucket.binding,
+			bucket_name: bucket.bucketName,
+			...(bucket.previewBucketName
+				? { preview_bucket_name: bucket.previewBucketName }
+				: {}),
+			...(bucket.jurisdiction ? { jurisdiction: bucket.jurisdiction } : {}),
+		})),
+		...(schedulerEnabled
+			? {
+					queues: {
+						producers: [
+							{
+								binding: config.config.scheduler.binding,
+								queue: schedulerQueueName,
+							},
+						],
+						consumers: [
+							{
+								queue: schedulerQueueName,
+							},
+						],
+					},
+				}
+			: {}),
+		...(cronTriggers.length > 0
+			? {
+					triggers: {
+						crons: cronTriggers,
+					},
+				}
+			: {}),
+		...(realtimeEnabled
+			? {
+					durable_objects: {
+						bindings: [
+							{
+								name: config.config.realtime.binding,
+								class_name: config.config.realtime.className,
+							},
+						],
+					},
+					migrations: [
+						{
+							tag: "appflare-realtime-v1",
+							new_classes: [config.config.realtime.className],
+						},
+					],
+				}
+			: {}),
+	};
+
+	if (!config.config.wranglerOverrides) {
+		return wranglerBase;
+	}
+
+	const { scheduler: _ignoredSchedulerOverride, ...wranglerOverrides } =
+		config.config.wranglerOverrides;
+
+	return deepMergeJson(wranglerBase, wranglerOverrides);
+}