appflare 0.0.28 → 0.1.1

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

@@ -0,0 +1,100 @@
+export function generateClientStorageSource(): string {
+	return `import type { StorageClient, StorageSignedUrlResponse, StorageListResponse } from "./types";
+
+export function createStorageClient(endpoint: string, request: typeof fetch = fetch): StorageClient {
+	return {
+		upload: async (args) => {
+			const response = await request(\`\${endpoint}/storage/upload\`, {
+				method: "POST",
+				headers: {
+					"content-type": "application/json",
+				},
+				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()}\`,
+			);
+			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()}\`,
+			);
+			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" },
+			);
+			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\`,
+			);
+			if (!response.ok) {
+				throw new Error(await response.text());
+			}
+
+			return (await response.json()) as StorageListResponse;
+		},
+	};
+}
+`;
+}

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

@@ -0,0 +1,54 @@
+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 AppflareOptions<Options extends BetterAuthClientOptions = InferredAuthOptions> = {
+	endpoint: string;
+	authPath?: string;
+	authOptions?: Options;
+	fetch?: typeof fetch;
+};
+
+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>;
+};
+`;
+}

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

@@ -0,0 +1,112 @@
+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.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>({
+			...(mergedAuthOptions as Options),
+			baseURL: \`\${this.endpoint}\${options.authPath ?? "/api/auth"}\`,
+			fetch: 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,
+		);
+	}
+}
+
+export function createAppflare<Options extends BetterAuthClientOptions = InferredAuthOptions>(
+	options: AppflareOptions<Options>,
+): Appflare<Options> {
+	return new Appflare(options);
+}
+`;
+}