appflare 0.1.12 → 0.2.0

package/cli/generate.ts

@@ -1,7 +1,7 @@
 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 { generateClientArtifacts } from "./templates/core/client.artifacts";
 import { generateDrizzleConfigSource } from "./templates/core/drizzle";
 import { generateHandlersArtifacts } from "./templates/core/handlers";
 import { generateServerSource } from "./templates/core/server";

package/cli/templates/auth/README.md

@@ -53,7 +53,7 @@ Behavior details:
 
 ---
 
-## `route-config.ts`
+## `route.config.ts`
 
 ### `generateKvField(kvBinding?: string): string`
 
@@ -73,7 +73,7 @@ This keeps route generation dynamic for projects that may or may not enable KV.
 
 ---
 
-## `route-handler.ts`
+## `route.handler.ts`
 
 ### `generateAuthHandler(authBasePath: string, databaseBinding: string, kvBinding?: string): string`
 
@@ -89,7 +89,7 @@ This is the bridge between framework routing and Better Auth request handling.
 
 ---
 
-## `route-request-utils.ts`
+## `route.request-utils.ts`
 
 Contains generated helper functions to sanitize incoming request headers.
 

package/cli/templates/auth/route-config.ts

@@ -1,18 +1 @@
-function generateKvField(kvBinding?: string): string {
-	if (!kvBinding) {
-		return "";
-	}
-
-	return `,\n\t\t\tKV: c.env["${kvBinding}"] as KVNamespace`;
-}
-
-function generateAuthConfig(
-	databaseBinding: string,
-	kvBinding?: string,
-): string {
-	return `{
-			DATABASE: c.env["${databaseBinding}"] as D1Database${generateKvField(kvBinding)}
-		}`;
-}
-
-export { generateKvField, generateAuthConfig };
+export { generateAuthConfig, generateKvField } from "./route.config";

package/cli/templates/auth/route-handler.ts

@@ -1,18 +1 @@
-import { generateAuthConfig } from "./route-config";
-
-function generateAuthHandler(
-	authBasePath: string,
-	databaseBinding: string,
-	kvBinding?: string,
-): string {
-	return `app.on(["GET", "POST"], "${authBasePath}/*", async (c) => {
-	const auth = createAuth(
-		${generateAuthConfig(databaseBinding, kvBinding)},
-		c.req.raw.cf as IncomingRequestCfProperties | undefined,
-	);
-	return auth.handler(getSanitizedRequest(c.req.raw));
-});
-`;
-}
-
-export { generateAuthHandler };
+export { generateAuthHandler } from "./route.handler";

package/cli/templates/auth/route-request-utils.ts

@@ -1,55 +1,5 @@
-function generateGetHeadersFunction(): string {
-	return `export const getHeaders = (headers: Headers) => {
-	const newHeaders = Object.fromEntries(headers as any);
-	const headerObject: Record<string, any> = {};
-	let hasCookie = false;
-
-	for (const key in newHeaders) {
-		if (key.toLowerCase() === "cookie") {
-			hasCookie = true;
-			break;
-		}
-	}
-
-	for (const key in newHeaders) {
-		const isAuthorization =
-			key.toLowerCase() === "authorization" &&
-			newHeaders[key]?.includes("Bearer");
-
-		if (hasCookie && key.toLowerCase() === "authorization") {
-			continue;
-		}
-
-		if (key.toLowerCase() === "authorization" && !isAuthorization) {
-			continue;
-		}
-
-		headerObject[key] = newHeaders[key];
-	}
-
-	return headerObject as any as Headers;
-};
-`;
-}
-
-function generateSanitizedRequestFunction(): string {
-	return `export const getSanitizedRequest = (req: Request) => {
-	const newRequest = new Request(req, {
-		headers: getHeaders(req.headers),
-	});
-	return newRequest;
-};
-`;
-}
-
-function generateRequestUtilities(): string {
-	return (
-		generateGetHeadersFunction() + "\n" + generateSanitizedRequestFunction()
-	);
-}
-
 export {
 	generateGetHeadersFunction,
-	generateSanitizedRequestFunction,
 	generateRequestUtilities,
-};
+	generateSanitizedRequestFunction,
+} from "./route.request-utils";

package/cli/templates/auth/route.config.ts

@@ -0,0 +1,18 @@
+function generateKvField(kvBinding?: string): string {
+	if (!kvBinding) {
+		return "";
+	}
+
+	return `,\n\t\t\tKV: c.env["${kvBinding}"] as KVNamespace`;
+}
+
+function generateAuthConfig(
+	databaseBinding: string,
+	kvBinding?: string,
+): string {
+	return `{
+			DATABASE: c.env["${databaseBinding}"] as D1Database${generateKvField(kvBinding)}
+		}`;
+}
+
+export { generateKvField, generateAuthConfig };

package/cli/templates/auth/route.handler.ts

@@ -0,0 +1,18 @@
+import { generateAuthConfig } from "./route.config";
+
+function generateAuthHandler(
+	authBasePath: string,
+	databaseBinding: string,
+	kvBinding?: string,
+): string {
+	return `app.on(["GET", "POST"], "${authBasePath}/*", async (c) => {
+	const auth = createAuth(
+		${generateAuthConfig(databaseBinding, kvBinding)},
+		c.req.raw.cf as IncomingRequestCfProperties | undefined,
+	);
+	return auth.handler(getSanitizedRequest(c.req.raw));
+});
+`;
+}
+
+export { generateAuthHandler };

package/cli/templates/auth/route.request-utils.ts

@@ -0,0 +1,55 @@
+function generateGetHeadersFunction(): string {
+	return `export const getHeaders = (headers: Headers) => {
+	const newHeaders = Object.fromEntries(headers as any);
+	const headerObject: Record<string, any> = {};
+	let hasCookie = false;
+
+	for (const key in newHeaders) {
+		if (key.toLowerCase() === "cookie") {
+			hasCookie = true;
+			break;
+		}
+	}
+
+	for (const key in newHeaders) {
+		const isAuthorization =
+			key.toLowerCase() === "authorization" &&
+			newHeaders[key]?.includes("Bearer");
+
+		if (hasCookie && key.toLowerCase() === "authorization") {
+			continue;
+		}
+
+		if (key.toLowerCase() === "authorization" && !isAuthorization) {
+			continue;
+		}
+
+		headerObject[key] = newHeaders[key];
+	}
+
+	return headerObject as any as Headers;
+};
+`;
+}
+
+function generateSanitizedRequestFunction(): string {
+	return `export const getSanitizedRequest = (req: Request) => {
+	const newRequest = new Request(req, {
+		headers: getHeaders(req.headers),
+	});
+	return newRequest;
+};
+`;
+}
+
+function generateRequestUtilities(): string {
+	return (
+		generateGetHeadersFunction() + "\n" + generateSanitizedRequestFunction()
+	);
+}
+
+export {
+	generateGetHeadersFunction,
+	generateSanitizedRequestFunction,
+	generateRequestUtilities,
+};

package/cli/templates/auth/route.ts

@@ -1,5 +1,5 @@
-import { generateAuthHandler } from "./route-handler";
-import { generateRequestUtilities } from "./route-request-utils";
+import { generateAuthHandler } from "./route.handler";
+import { generateRequestUtilities } from "./route.request-utils";
 
 export function generateAuthRoute(
 	authBasePath: string,

package/cli/templates/core/README.md

@@ -66,7 +66,7 @@ CORS behavior details:
 
 ---
 
-### `client.ts`
+### `client.artifacts.ts`
 
 Provides `generateClientArtifacts(configPathImport)`.
 
@@ -120,7 +120,7 @@ This is the standard Cloudflare Worker module format.
 
 ---
 
-### `handlers-route.ts`
+### `handlers.route.ts`
 
 Provides `generateHandlersRoute(databaseBinding, kvBinding?)`.
 

package/cli/templates/core/client/appflare.ts

@@ -2,29 +2,104 @@ export function generateClientAppflareSource(): string {
 	return `import { createAuthClient, type BetterAuthClientOptions } from "better-auth/client";
 import type {
 	AppflareAuth,
+	AppflareAuthTokenResolver,
 	AppflareOptions,
 	InferredAuthOptions,
 	StorageClient,
 } from "./types";
+import type { MutationsClient, QueriesClient } from "./handlers";
 import { createStorageClient } from "./storage";
+import { createMutationsClient, createQueriesClient } from "./handlers";
 
 export class Appflare<Options extends BetterAuthClientOptions = InferredAuthOptions> {
 	public readonly endpoint: string;
+	public readonly wsEndpoint: string;
 	public readonly auth: AppflareAuth<Options>;
 	public readonly storage: StorageClient;
+	public readonly queries: QueriesClient;
+	public readonly mutations: MutationsClient;
 
 	public constructor(options: AppflareOptions<Options>) {
-		this.endpoint = options.endpoint.replace(/\/$/, "");
+		this.endpoint = options.endpoint.replace(/\\/$/, "");
+		this.wsEndpoint = (options.wsEndpoint ?? this.endpoint).replace(/\\/$/, "");
 		const authOptions = (options.authOptions ?? {}) as Options;
 		const request = options.fetch ?? fetch;
+		const onSetAuthToken = options.onSetAuthToken;
+		const onGetAuthToken: AppflareAuthTokenResolver =
+			options.onGetAuthToken ?? (() => "");
+
+		const authFetchOptions =
+			(authOptions as { fetchOptions?: Record<string, unknown> }).fetchOptions ??
+			{};
+		const mergedAuthOptions = {
+			...(authOptions as Record<string, unknown>),
+			fetchOptions: {
+				...authFetchOptions,
+				onSuccess: async (ctx: {
+					response: { headers: { get: (name: string) => string | null } };
+				}) => {
+					if (
+						typeof (authFetchOptions as { onSuccess?: unknown }).onSuccess ===
+						"function"
+					) {
+						await (
+							(authFetchOptions as { onSuccess: (ctx: unknown) => unknown }).onSuccess
+						)(ctx);
+					}
+
+					const authToken = ctx.response.headers.get("set-auth-token");
+					if (authToken && onSetAuthToken) {
+						await onSetAuthToken(authToken);
+					}
+				},
+				onRequest: async (ctx: {
+					headers: Headers;
+				}) => {
+					let nextCtx = ctx;
+					if (
+						typeof (authFetchOptions as { onRequest?: unknown }).onRequest ===
+						"function"
+					) {
+						const maybeCtx = await (
+							(authFetchOptions as { onRequest: (ctx: unknown) => unknown }).onRequest
+						)(ctx);
+						if (
+							typeof maybeCtx === "object" &&
+							maybeCtx !== null &&
+							"headers" in maybeCtx
+						) {
+							nextCtx = maybeCtx as typeof ctx;
+						}
+					}
+
+					const authToken = await onGetAuthToken();
+					if (typeof authToken === "string" && authToken.trim().length > 0) {
+						nextCtx.headers.set("Authorization", \`Bearer \${authToken.trim()}\`);
+					}
+
+					return nextCtx;
+				},
+			},
+		};
 
 		this.auth = createAuthClient<Options>({
-			...authOptions,
+			...(mergedAuthOptions as Options),
 			baseURL: \`\${this.endpoint}\${options.authPath ?? "/api/auth"}\`,
 			fetch: request,
 		});
 
-		this.storage = createStorageClient(this.endpoint, request);
+		this.storage = createStorageClient(this.endpoint, request, onGetAuthToken);
+		this.queries = createQueriesClient(
+			this.endpoint,
+			options.requestOptions,
+			this.wsEndpoint,
+			onGetAuthToken,
+		);
+		this.mutations = createMutationsClient(
+			this.endpoint,
+			options.requestOptions,
+			onGetAuthToken,
+		);
 	}
 }
 

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

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

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

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

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

@@ -1,14 +1,82 @@
 export function generateClientStorageSource(): string {
 	return `import type { StorageClient, StorageSignedUrlResponse, StorageListResponse } from "./types";
 
-export function createStorageClient(endpoint: string, request: typeof fetch = fetch): StorageClient {
+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 response = await request(\`\${endpoint}/storage/upload\`, {
-				method: "POST",
-				headers: {
+			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) {
@@ -27,6 +95,9 @@ export function createStorageClient(endpoint: string, request: typeof fetch = fe
 			});
 			const response = await request(
 				\`\${endpoint}/storage/download?\${query.toString()}\`,
+				{
+					headers: await createAuthorizedHeaders(undefined, onGetAuthToken),
+				},
 			);
 			if (!response.ok) {
 				throw new Error(await response.text());
@@ -43,6 +114,9 @@ export function createStorageClient(endpoint: string, request: typeof fetch = fe
 			});
 			const response = await request(
 				\`\${endpoint}/storage/preview?\${query.toString()}\`,
+				{
+					headers: await createAuthorizedHeaders(undefined, onGetAuthToken),
+				},
 			);
 			if (!response.ok) {
 				throw new Error(await response.text());
@@ -56,7 +130,10 @@ export function createStorageClient(endpoint: string, request: typeof fetch = fe
 			});
 			const response = await request(
 				\`\${endpoint}/storage/object?\${query.toString()}\`,
-				{ method: "DELETE" },
+				{
+					method: "DELETE",
+					headers: await createAuthorizedHeaders(undefined, onGetAuthToken),
+				},
 			);
 			if (!response.ok) {
 				throw new Error(await response.text());
@@ -87,6 +164,9 @@ export function createStorageClient(endpoint: string, request: typeof fetch = fe
 				querySuffix.length > 0
 					? \`\${endpoint}/storage/list?\${querySuffix}\`
 					: \`\${endpoint}/storage/list\`,
+				{
+					headers: await createAuthorizedHeaders(undefined, onGetAuthToken),
+				},
 			);
 			if (!response.ok) {
 				throw new Error(await response.text());

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

@@ -9,11 +9,89 @@ export type AppflareAuth<Options extends BetterAuthClientOptions = InferredAuthO
 	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 = {
@@ -50,5 +128,18 @@ export type StorageClient = {
 		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";
+		};
+	};
+};
 `;
 }