appflare 0.0.28 → 0.1.0

package/cli/utils/schema-discovery.ts

@@ -0,0 +1,390 @@
+import { readdir } from "node:fs/promises";
+import { resolve } from "node:path";
+import type { LoadedAppflareConfig } from "../types";
+
+export type DiscoveredColumn = {
+	name: string;
+	expression: string;
+	type: "string" | "number" | "boolean" | "unknown";
+	optional: boolean;
+	primaryKey: boolean;
+	autoIncrement: boolean;
+};
+
+export type DiscoveredTable = {
+	exportName: string;
+	tableName: string;
+	columns: DiscoveredColumn[];
+};
+
+export type DiscoveredSchema = {
+	schemaPath: string;
+	tables: DiscoveredTable[];
+};
+
+function splitTopLevel(value: string): string[] {
+	const result: string[] = [];
+	let current = "";
+	let depthParen = 0;
+	let depthBrace = 0;
+	let depthBracket = 0;
+	let inSingleQuote = false;
+	let inDoubleQuote = false;
+	let inTemplateString = false;
+	let escaped = false;
+
+	for (let i = 0; i < value.length; i += 1) {
+		const char = value[i];
+
+		if (escaped) {
+			current += char;
+			escaped = false;
+			continue;
+		}
+
+		if (char === "\\") {
+			current += char;
+			escaped = true;
+			continue;
+		}
+
+		if (!inDoubleQuote && !inTemplateString && char === "'") {
+			inSingleQuote = !inSingleQuote;
+			current += char;
+			continue;
+		}
+
+		if (!inSingleQuote && !inTemplateString && char === '"') {
+			inDoubleQuote = !inDoubleQuote;
+			current += char;
+			continue;
+		}
+
+		if (!inSingleQuote && !inDoubleQuote && char === "`") {
+			inTemplateString = !inTemplateString;
+			current += char;
+			continue;
+		}
+
+		if (inSingleQuote || inDoubleQuote || inTemplateString) {
+			current += char;
+			continue;
+		}
+
+		if (char === "(") {
+			depthParen += 1;
+		} else if (char === ")") {
+			depthParen -= 1;
+		} else if (char === "{") {
+			depthBrace += 1;
+		} else if (char === "}") {
+			depthBrace -= 1;
+		} else if (char === "[") {
+			depthBracket += 1;
+		} else if (char === "]") {
+			depthBracket -= 1;
+		}
+
+		if (
+			char === "," &&
+			depthParen === 0 &&
+			depthBrace === 0 &&
+			depthBracket === 0
+		) {
+			const segment = current.trim();
+			if (segment.length > 0) {
+				result.push(segment);
+			}
+			current = "";
+			continue;
+		}
+
+		current += char;
+	}
+
+	const trailing = current.trim();
+	if (trailing.length > 0) {
+		result.push(trailing);
+	}
+
+	return result;
+}
+
+function getTopLevelColonIndex(entry: string): number {
+	let depthParen = 0;
+	let depthBrace = 0;
+	let depthBracket = 0;
+	let inSingleQuote = false;
+	let inDoubleQuote = false;
+	let inTemplateString = false;
+	let escaped = false;
+
+	for (let i = 0; i < entry.length; i += 1) {
+		const char = entry[i];
+
+		if (escaped) {
+			escaped = false;
+			continue;
+		}
+
+		if (char === "\\") {
+			escaped = true;
+			continue;
+		}
+
+		if (!inDoubleQuote && !inTemplateString && char === "'") {
+			inSingleQuote = !inSingleQuote;
+			continue;
+		}
+
+		if (!inSingleQuote && !inTemplateString && char === '"') {
+			inDoubleQuote = !inDoubleQuote;
+			continue;
+		}
+
+		if (!inSingleQuote && !inDoubleQuote && char === "`") {
+			inTemplateString = !inTemplateString;
+			continue;
+		}
+
+		if (inSingleQuote || inDoubleQuote || inTemplateString) {
+			continue;
+		}
+
+		if (char === "(") {
+			depthParen += 1;
+			continue;
+		}
+		if (char === ")") {
+			depthParen -= 1;
+			continue;
+		}
+		if (char === "{") {
+			depthBrace += 1;
+			continue;
+		}
+		if (char === "}") {
+			depthBrace -= 1;
+			continue;
+		}
+		if (char === "[") {
+			depthBracket += 1;
+			continue;
+		}
+		if (char === "]") {
+			depthBracket -= 1;
+			continue;
+		}
+
+		if (
+			char === ":" &&
+			depthParen === 0 &&
+			depthBrace === 0 &&
+			depthBracket === 0
+		) {
+			return i;
+		}
+	}
+
+	return -1;
+}
+
+function inferColumnType(expression: string): DiscoveredColumn["type"] {
+	const lowered = expression.toLowerCase();
+	if (/\.(int|integer|real|numeric|decimal|float|double)\s*\(/.test(lowered)) {
+		return "number";
+	}
+	if (/\.(text|varchar|char)\s*\(/.test(lowered)) {
+		return "string";
+	}
+	if (/\.(boolean|bool)\s*\(/.test(lowered)) {
+		return "boolean";
+	}
+	return "unknown";
+}
+
+function discoverColumns(rawColumns: string): DiscoveredColumn[] {
+	const entries = splitTopLevel(rawColumns);
+	const columns: DiscoveredColumn[] = [];
+
+	for (const entry of entries) {
+		const colonIndex = getTopLevelColonIndex(entry);
+		if (colonIndex === -1) {
+			continue;
+		}
+
+		const key = entry
+			.slice(0, colonIndex)
+			.trim()
+			.replace(/^['"]|['"]$/g, "");
+		if (!key) {
+			continue;
+		}
+
+		const expression = entry.slice(colonIndex + 1).trim();
+		const primaryKey = /\.primarykey\s*\(/i.test(expression);
+		const autoIncrement = /autoincrement\s*:\s*true/i.test(expression);
+		const hasDefault = /\.default\s*\(/i.test(expression);
+		const notNull = /\.notnull\s*\(/i.test(expression);
+		const optional = !notNull || hasDefault || autoIncrement;
+
+		columns.push({
+			name: key,
+			expression,
+			type: inferColumnType(expression),
+			optional,
+			primaryKey,
+			autoIncrement,
+		});
+	}
+
+	return columns;
+}
+
+function discoverTables(schemaSource: string): DiscoveredTable[] {
+	const tablePattern =
+		/export\s+const\s+(\w+)\s*=\s*table\s*\(\s*["'`]([^"'`]+)["'`]/g;
+	const tables: DiscoveredTable[] = [];
+
+	const findMatchingBrace = (source: string, startIndex: number): number => {
+		let depth = 0;
+		let inSingleQuote = false;
+		let inDoubleQuote = false;
+		let inTemplateString = false;
+		let escaped = false;
+
+		for (let i = startIndex; i < source.length; i += 1) {
+			const char = source[i];
+
+			if (escaped) {
+				escaped = false;
+				continue;
+			}
+
+			if (char === "\\") {
+				escaped = true;
+				continue;
+			}
+
+			if (!inDoubleQuote && !inTemplateString && char === "'") {
+				inSingleQuote = !inSingleQuote;
+				continue;
+			}
+
+			if (!inSingleQuote && !inTemplateString && char === '"') {
+				inDoubleQuote = !inDoubleQuote;
+				continue;
+			}
+
+			if (!inSingleQuote && !inDoubleQuote && char === "`") {
+				inTemplateString = !inTemplateString;
+				continue;
+			}
+
+			if (inSingleQuote || inDoubleQuote || inTemplateString) {
+				continue;
+			}
+
+			if (char === "{") {
+				depth += 1;
+				continue;
+			}
+
+			if (char === "}") {
+				depth -= 1;
+				if (depth === 0) {
+					return i;
+				}
+			}
+		}
+
+		return -1;
+	};
+
+	let match = tablePattern.exec(schemaSource);
+	while (match) {
+		const exportName = match[1];
+		const tableName = match[2];
+		const objectStart = schemaSource.indexOf("{", tablePattern.lastIndex);
+		if (objectStart === -1) {
+			match = tablePattern.exec(schemaSource);
+			continue;
+		}
+
+		const objectEnd = findMatchingBrace(schemaSource, objectStart);
+		if (objectEnd === -1) {
+			match = tablePattern.exec(schemaSource);
+			continue;
+		}
+
+		const rawColumns = schemaSource.slice(objectStart + 1, objectEnd);
+		tables.push({
+			exportName,
+			tableName,
+			columns: discoverColumns(rawColumns),
+		});
+		match = tablePattern.exec(schemaSource);
+	}
+
+	return tables;
+}
+
+async function findSchemaCandidates(dirPath: string): Promise<string[]> {
+	const entries = await readdir(dirPath, { withFileTypes: true });
+	const discovered: string[] = [];
+
+	for (const entry of entries) {
+		if (entry.name.startsWith(".")) {
+			continue;
+		}
+		if (entry.name === "node_modules" || entry.name === "_generated") {
+			continue;
+		}
+
+		const entryPath = resolve(dirPath, entry.name);
+		if (entry.isDirectory()) {
+			discovered.push(...(await findSchemaCandidates(entryPath)));
+			continue;
+		}
+
+		if (entry.isFile() && entry.name === "schema.ts") {
+			discovered.push(entryPath);
+		}
+	}
+
+	return discovered;
+}
+
+export async function discoverSchema(
+	loadedConfig: LoadedAppflareConfig,
+	prioritySchemaPaths: string[] = [],
+): Promise<DiscoveredSchema> {
+	const scanCandidates = await findSchemaCandidates(
+		loadedConfig.scanDirAbs,
+	).catch(() => []);
+
+	const fallbackCandidate = resolve(loadedConfig.configDir, "schema.ts");
+	const candidates = [
+		...prioritySchemaPaths,
+		...(scanCandidates.length ? scanCandidates : [fallbackCandidate]),
+	];
+
+	for (const schemaPath of candidates) {
+		const file = Bun.file(schemaPath);
+		if (!(await file.exists())) {
+			continue;
+		}
+		const source = await file.text();
+		const tables = discoverTables(source);
+		if (tables.length > 0) {
+			return {
+				schemaPath,
+				tables,
+			};
+		}
+	}
+
+	throw new Error(
+		`Unable to discover schema.ts under scanDir (${loadedConfig.scanDirAbs}) or fallback (${fallbackCandidate}).`,
+	);
+}

package/index.ts

@@ -1,4 +1,27 @@
-export * from "./lib/db";
-export * from "./lib/values";
-export * from "./lib/location";
-export { AppflareConfig } from "./cli/utils/utils";
+export type {
+	AppflareConfig,
+	AppflareDatabaseBinding,
+	AppflareKVNamespace,
+	AppflareR2Bucket,
+	LoadedAppflareConfig,
+	NormalizedAppflareConfig,
+} from "./cli/types";
+export { loadConfig } from "./cli/load-config";
+export { generateArtifacts } from "./cli/generate";
+export {
+	schema,
+	table,
+	v,
+	isSchemaDefinition,
+	type ColumnDefinition,
+	type RelationDefinition,
+	type SchemaDefinition,
+	type TableDefinition,
+} from "./schema";
+export { useQuery } from "./react";
+export { useInfiniteQuery } from "./react";
+export { useMutation } from "./react";
+export type {
+	UseAppflareQueryOptions,
+	UseAppflareInfiniteQueryOptions,
+} from "./react";

package/package.json

@@ -1,38 +1,41 @@
 {
 	"name": "appflare",
-	"version": "0.0.28",
+	"version": "0.1.0",
 	"bin": {
 		"appflare": "./cli/index.ts"
 	},
 	"exports": {
 		".": "./index.ts",
-		"./db": "./lib/db.ts",
-		"./values": "./lib/values.ts",
-		"./location": "./lib/location.ts",
-		"./*": "./*.ts",
-		"./react/*": "./react/*.ts",
 		"./react": "./react/index.ts",
-		"./server/db": "./server/db.ts",
-		"./server/storage": "./server/storage.ts",
-		"./server/auth": "./server/auth.ts"
+		"./*": "./*.ts"
 	},
 	"scripts": {},
+	"peerDependencies": {
+		"@tanstack/react-query": "^5.90.21",
+		"react": ">=18"
+	},
 	"devDependencies": {
-		"@cloudflare/workers-types": "^4.20241112.0",
-		"@types/react": "^18.3.12",
-		"typescript": "^5.9.3",
-		"@tanstack/react-query": "^5.90.12",
-		"react": "^18.3.1"
+		"@cloudflare/workers-types": "^4.20260219.0",
+		"@types/react": "^19.2.0",
+		"@tanstack/react-query": "^5.90.21",
+		"@types/bun": "^1.3.9",
+		"@types/node": "^25.3.0",
+		"npm-check-updates": "^19.4.0",
+		"typescript": "^5.9.3"
 	},
 	"dependencies": {
-		"@hono/standard-validator": "^0.2.1",
+		"@better-auth/cli": "^1.4.18",
+		"@hono/standard-validator": "^0.2.2",
 		"better-auth": "^1.4.18",
+		"better-auth-cloudflare": "^0.2.9",
 		"better-fetch": "^1.1.2",
+		"bun": "^1.3.9",
 		"chokidar": "^5.0.0",
-		"cloudflare-do-mongo": "^0.1.2",
-		"commander": "^14.0.1",
-		"hono": "^4.6.8",
-		"mongodb": "^7.0.0",
-		"zod": "^4.1.13"
+		"commander": "^14.0.3",
+		"drizzle-kit": "^0.31.9",
+		"drizzle-orm": "^0.45.1",
+		"hono": "^4.12.0",
+		"wrangler": "^4.67.0",
+		"zod": "^4.3.6"
 	}
 }

package/react/index.ts

@@ -1,3 +1,5 @@
-export * from "./hooks/useMutation";
-export * from "./hooks/usePaginatedQuery";
-export * from "./hooks/useQuery";
+export { useQuery } from "./use-query";
+export type { UseAppflareQueryOptions } from "./use-query";
+export { useInfiniteQuery } from "./use-infinite-query";
+export type { UseAppflareInfiniteQueryOptions } from "./use-infinite-query";
+export { useMutation } from "./use-mutation";

package/react/use-infinite-query.ts

@@ -0,0 +1,190 @@
+import {
+	type InfiniteData,
+	type QueryKey,
+	type UseInfiniteQueryOptions,
+	type UseInfiniteQueryResult,
+	useInfiniteQuery as useTanstackInfiniteQuery,
+	useQueryClient,
+} from "@tanstack/react-query";
+import { useEffect, useMemo } from "react";
+
+type AppflareRequestErrorLike = {
+	message: string;
+	status?: number;
+};
+
+type AppflareRequestResultLike<TData> = {
+	data: TData | null;
+	error: AppflareRequestErrorLike | null;
+};
+
+type AppflareRealtimeSubscriptionLike = {
+	remove: () => void;
+};
+
+type AppflareRealtimeQueryUpdateLike<TData> = {
+	event: "query:update";
+	payload: {
+		queryName: string;
+		signature: string;
+		data: TData;
+	};
+};
+
+type AppflareQueryLike<TArgs, TData> = {
+	run: (
+		args: TArgs,
+		options?: any,
+	) => Promise<AppflareRequestResultLike<TData>>;
+	subscribe?: (options: {
+		args?: TArgs;
+		authToken?: string;
+		requestOptions?: any;
+		signal?: AbortSignal;
+		onChange: (
+			data: TData,
+			update: AppflareRealtimeQueryUpdateLike<TData>,
+		) => void;
+		onError?: (error: unknown) => void;
+	}) => AppflareRealtimeSubscriptionLike;
+};
+
+export type UseAppflareInfiniteQueryOptions<
+	TArgs,
+	TData,
+	TPageParam,
+	TSelected = InfiniteData<TData, TPageParam>,
+	TKey extends QueryKey = QueryKey,
+> = {
+	realtime?: {
+		enabled?: boolean;
+		authToken?: string;
+		requestOptions?: any;
+		onChange?: (
+			data: TData,
+			update: AppflareRealtimeQueryUpdateLike<TData>,
+		) => void;
+		onError?: (error: unknown) => void;
+	};
+	requestOptions?: any;
+	pageParamToArgs?: (baseArgs: TArgs, pageParam: TPageParam) => TArgs;
+	queryOptions?: Omit<
+		UseInfiniteQueryOptions<TData, Error, TSelected, TKey, TPageParam>,
+		"queryFn" | "queryKey"
+	> & {
+		queryKey?: TKey;
+	};
+};
+
+function toError(error: AppflareRequestErrorLike): Error {
+	const next = new Error(error.message);
+	if (error.status !== undefined) {
+		(next as Error & { status?: number }).status = error.status;
+	}
+	return next;
+}
+
+export function useInfiniteQuery<
+	TArgs,
+	TData,
+	TPageParam = unknown,
+	TSelected = InfiniteData<TData, TPageParam>,
+	TKey extends QueryKey = QueryKey,
+>(
+	query: AppflareQueryLike<TArgs, TData>,
+	args: TArgs,
+	options?: UseAppflareInfiniteQueryOptions<
+		TArgs,
+		TData,
+		TPageParam,
+		TSelected,
+		TKey
+	>,
+): UseInfiniteQueryResult<TSelected, Error> {
+	const queryClient = useQueryClient();
+	const resolvedQueryKey = useMemo(() => {
+		return (
+			options?.queryOptions?.queryKey ??
+			(["appflare", "infinite-query", query, args] as unknown as TKey)
+		);
+	}, [args, options?.queryOptions?.queryKey, query]);
+
+	const result = useTanstackInfiniteQuery<
+		TData,
+		Error,
+		TSelected,
+		TKey,
+		TPageParam
+	>({
+		...(options?.queryOptions as Omit<
+			UseInfiniteQueryOptions<TData, Error, TSelected, TKey, TPageParam>,
+			"queryFn" | "queryKey"
+		>),
+		queryKey: resolvedQueryKey,
+		queryFn: async ({ pageParam }) => {
+			const nextArgs =
+				pageParam === undefined || !options?.pageParamToArgs
+					? args
+					: options.pageParamToArgs(args, pageParam as TPageParam);
+			const response = await query.run(nextArgs, options?.requestOptions);
+			if (response.error) {
+				throw toError(response.error);
+			}
+			return response.data as TData;
+		},
+	});
+
+	useEffect(() => {
+		if (options?.realtime?.enabled === false || !query.subscribe) {
+			return;
+		}
+
+		const controller = new AbortController();
+		const subscription = query.subscribe({
+			args,
+			authToken: options.realtime?.authToken,
+			requestOptions: options.realtime?.requestOptions,
+			signal: controller.signal,
+			onChange: (data, update) => {
+				queryClient.setQueryData<InfiniteData<TData, TPageParam>>(
+					resolvedQueryKey,
+					(previous) => {
+						if (!previous || previous.pages.length === 0) {
+							return previous;
+						}
+
+						return {
+							...previous,
+							pages: [data as TData, ...previous.pages.slice(1)],
+						};
+					},
+				);
+				options.realtime?.onChange?.(
+					data as TData,
+					update as AppflareRealtimeQueryUpdateLike<TData>,
+				);
+			},
+			onError: (error) => {
+				options.realtime?.onError?.(error);
+			},
+		});
+
+		return () => {
+			controller.abort();
+			subscription.remove();
+		};
+	}, [
+		args,
+		options?.realtime?.authToken,
+		options?.realtime?.enabled,
+		options?.realtime?.onChange,
+		options?.realtime?.onError,
+		options?.realtime?.requestOptions,
+		query,
+		query.subscribe,
+		queryClient,
+		resolvedQueryKey,
+	]);
+
+	return result;
+}