appflare 0.1.13 → 0.2.1

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

@@ -1,112 +1 @@
-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);
-}
-`;
-}
+export { generateClientAppflareSource } from "../client/appflare";

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

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

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

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

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

@@ -1,180 +1 @@
-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;
-		},
-	};
-}
-`;
-}
+export { generateClientStorageSource } from "../client/storage";

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

@@ -1,145 +1 @@
-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";
-		};
-	};
-};
-`;
-}
+export { generateClientTypesSource } from "../client/types";

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

@@ -0,0 +1,39 @@
+import { generateClientAppflareSource } from "./client/appflare";
+import { generateClientHandlersSource } from "./client/handlers";
+import { generateClientIndexSource } from "./client/index";
+import { generateClientStorageSource } from "./client/storage";
+import { generateClientTypesSource } from "./client/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/client.ts

@@ -1,39 +1,4 @@
-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(),
-		},
-	];
-}
+export {
+	generateClientArtifacts,
+	type GeneratedClientArtifact,
+} from "./client.artifacts";

package/cli/templates/core/server.ts

@@ -1,7 +1,7 @@
 import { generateAuthRoute } from "../auth/route";
 import { generateAppCreation } from "./app-creation";
 import { generateExport } from "./export";
-import { generateHandlersRoute } from "./handlers-route";
+import { generateHandlersRoute } from "./handlers.route";
 import { generateImports } from "./imports";
 import { generateTypes } from "./types";
 

package/cli/templates/handlers/generators/types/query-definitions.ts

@@ -17,21 +17,83 @@ type TableFindManyArgs<TName extends TableName> = TableQuery<TName> extends {
 }
 	? TArgs
 	: never;
-type TableFindManyResult<TName extends TableName> = TableQuery<TName> extends {
-	findMany: (args?: unknown) => infer TResult;
+type TableFindManyMethod<TName extends TableName> = TableQuery<TName> extends {
+	findMany: infer TMethod;
 }
+	? TMethod
+	: never;
+type NativeFindManyWith<TName extends TableName> =
+	NonNullable<TableFindManyArgs<TName>> extends { with?: infer TWith }
+		? TWith
+		: never;
+type ResolveNativeFindManyWith<
+	TName extends TableName,
+	TArgs extends QueryFindManyArgs<TName> | undefined,
+> = TArgs extends { with?: infer TWith }
+	? Extract<TWith, NativeFindManyWith<TName>>
+	: never;
+type ResolveTableFindManyArgs<
+	TName extends TableName,
+	TArgs extends QueryFindManyArgs<TName> | undefined,
+> = TArgs extends undefined
+	? undefined
+	: Omit<NonNullable<TableFindManyArgs<TName>>, "where" | "with"> &
+			(ResolveNativeFindManyWith<TName, TArgs> extends never
+				? {}
+				: { with?: ResolveNativeFindManyWith<TName, TArgs> });
+type TableFindManyResult<
+	TName extends TableName,
+	TArgs extends QueryFindManyArgs<TName> | undefined =
+		| QueryFindManyArgs<TName>
+		| undefined,
+> = TableFindManyMethod<TName> extends (
+	args?: ResolveTableFindManyArgs<TName, TArgs>,
+) => infer TResult
 	? TResult
-	: Promise<Array<TableModel<TName>>>;
+	: TableFindManyMethod<TName> extends (args?: unknown) => infer TResult
+		? TResult
+		: Promise<Array<TableModel<TName>>>;
 type TableFindFirstArgs<TName extends TableName> = TableQuery<TName> extends {
 	findFirst: (args?: infer TArgs) => Promise<unknown>;
 }
 	? TArgs
 	: never;
-type TableFindFirstResult<TName extends TableName> = TableQuery<TName> extends {
-	findFirst: (args?: unknown) => infer TResult;
+type TableFindFirstMethod<TName extends TableName> = TableQuery<TName> extends {
+	findFirst: infer TMethod;
 }
+	? TMethod
+	: never;
+type NativeFindFirstWith<TName extends TableName> =
+	NonNullable<TableFindFirstArgs<TName>> extends { with?: infer TWith }
+		? TWith
+		: never;
+type ResolveNativeFindFirstWith<
+	TName extends TableName,
+	TArgs extends QueryFindFirstArgs<TName> | undefined,
+> = TArgs extends { with?: infer TWith }
+	? Extract<TWith, NativeFindFirstWith<TName>>
+	: never;
+type ResolveTableFindFirstArgs<
+	TName extends TableName,
+	TArgs extends QueryFindFirstArgs<TName> | undefined,
+> = TArgs extends undefined
+	? undefined
+	: Omit<NonNullable<TableFindFirstArgs<TName>>, "where" | "with"> &
+			(ResolveNativeFindFirstWith<TName, TArgs> extends never
+				? {}
+				: { with?: ResolveNativeFindFirstWith<TName, TArgs> });
+type TableFindFirstResult<
+	TName extends TableName,
+	TArgs extends QueryFindFirstArgs<TName> | undefined =
+		| QueryFindFirstArgs<TName>
+		| undefined,
+> = TableFindFirstMethod<TName> extends (
+	args?: ResolveTableFindFirstArgs<TName, TArgs>,
+) => infer TResult
 	? TResult
-	: Promise<TableModel<TName> | null>;
+	: TableFindFirstMethod<TName> extends (args?: unknown) => infer TResult
+		? TResult
+		: Promise<TableModel<TName> | null>;
 type TableModel<TName extends TableName> = InferSelectModel<
 	(typeof mergedSchema)[TName]
 >;
@@ -176,22 +238,16 @@ type QueryWithInput<TWith> = TWith extends Record<string, unknown>
 
 export type QueryFindManyArgs<TName extends TableName> = Omit<
 	NonNullable<TableFindManyArgs<TName>>,
-	"where" | "with"
+	"where"
 > & {
 	where?: WhereInput<TableModel<TName>>;
-	with?: TableFindManyArgs<TName> extends { with?: infer TWith }
-		? QueryWithInput<TWith>
-		: never;
 };
 
 export type QueryFindFirstArgs<TName extends TableName> = Omit<
 	NonNullable<TableFindFirstArgs<TName>>,
-	"where" | "with"
+	"where"
 > & {
 	where?: WhereInput<TableModel<TName>>;
-	with?: TableFindFirstArgs<TName> extends { with?: infer TWith }
-		? QueryWithInput<TWith>
-		: never;
 };
 
 export type QueryInsertArgs<TName extends TableName> = {
@@ -303,20 +359,20 @@ export type QueryUpsertArgs<TName extends TableName> = {
 };
 
 export type QueryTableApi<TName extends TableName> = {
-	findMany: <
+	findMany: TableFindManyMethod<TName> & (<
 		TArgs extends QueryFindManyArgs<TName> | undefined =
 			| QueryFindManyArgs<TName>
 			| undefined,
 	>(
 		args?: TArgs,
-	) => ApplyFindManyWithAggregateResult<TableFindManyResult<TName>, TArgs>;
-	findFirst: <
+	) => ApplyFindManyWithAggregateResult<TableFindManyResult<TName, TArgs>, TArgs>);
+	findFirst: TableFindFirstMethod<TName> & (<
 		TArgs extends QueryFindFirstArgs<TName> | undefined =
 			| QueryFindFirstArgs<TName>
 			| undefined,
 	>(
 		args?: TArgs,
-	) => ApplyFindFirstWithAggregateResult<TableFindFirstResult<TName>, TArgs>;
+	) => ApplyFindFirstWithAggregateResult<TableFindFirstResult<TName, TArgs>, TArgs>);
 	insert: (args: QueryInsertArgs<TName>) => Promise<Array<TableModel<TName>>>;
 	update: (args: QueryUpdateArgs<TName>) => Promise<Array<TableModel<TName>>>;
 	upsert: (args: QueryUpsertArgs<TName>) => Promise<Array<TableModel<TName>>>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "appflare",
-	"version": "0.1.13",
+	"version": "0.2.1",
 	"bin": {
 		"appflare": "./cli/index.ts"
 	},