appflare 0.0.28 → 0.1.0

package/cli/templates/handlers/types.ts

@@ -0,0 +1,960 @@
+export function generateTypes(): string {
+	return `
+import { betterAuth } from "better-auth";
+import { auth } from "./auth.config";
+import {
+	and,
+	eq,
+	ne,
+	inArray,
+	notInArray,
+	gt,
+	gte,
+	lt,
+	lte,
+	isNull,
+	isNotNull,
+	getTableColumns,
+	sql,
+	type InferInsertModel,
+	type InferSelectModel,
+	type SQL,
+} from "drizzle-orm";
+
+export type WorkerEnv = {
+	Bindings: Record<string, unknown>;
+};
+
+export type RegisterHandlersOptions = {
+	databaseBinding: string;
+	kvBinding?: string;
+	schedulerBinding?: string;
+	r2Binding?: string;
+	realtimeBinding?: string;
+	realtimeObjectName?: string;
+	realtimeSubscribePath?: string;
+	realtimeWebsocketPath?: string;
+	realtimeProtocol?: string;
+};
+
+export type StorageMethod =
+	| "download"
+	| "get"
+	| "delete"
+	| "list"
+	| "put"
+	| "preview";
+
+export type StorageAuthorizationArgs = {
+	path: string;
+	method: StorageMethod;
+	headers?: Headers;
+	query?: Record<string, string>;
+	contentType?: string;
+};
+
+export type StorageHandler = (
+	ctx: AppflareContext,
+	args: StorageAuthorizationArgs,
+) => boolean | Promise<boolean>;
+
+export type RegisteredStorageHandler = {
+	kind: "storage-manager";
+	definition: {
+		handler: StorageHandler;
+	};
+};
+
+export function storageManager(definition: {
+	handler: StorageHandler;
+}): RegisteredStorageHandler {
+	return {
+		kind: "storage-manager",
+		definition,
+	};
+}
+
+const storageHandlers: StorageHandler[] = [];
+
+export function setStorageHandlers(handlers: StorageHandler[]): void {
+	storageHandlers.length = 0;
+	storageHandlers.push(...handlers);
+}
+
+export async function isStorageAllowed(
+	ctx: AppflareContext,
+	args: StorageAuthorizationArgs,
+): Promise<boolean> {
+	if (storageHandlers.length === 0) {
+		return false;
+	}
+
+	for (const handler of storageHandlers) {
+		const allowed = await handler(ctx, args);
+		if (allowed) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+const mergedSchema = {
+	...authSchema,
+	...schema,
+};
+
+export const createDb = (database: D1Database) =>
+	drizzle(database, { schema: mergedSchema });
+
+export type AppflareDb = ReturnType<typeof createDb>;
+
+type QueryTables = AppflareDb["query"];
+type TableName = Extract<keyof QueryTables, string>;
+type TableQuery<TName extends TableName> = QueryTables[TName];
+type TableFindManyArgs<TName extends TableName> = TableQuery<TName> extends {
+	findMany: (args?: infer TArgs) => Promise<unknown>;
+}
+	? TArgs
+	: never;
+type TableFindManyResult<TName extends TableName> = TableQuery<TName> extends {
+	findMany: (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;
+}
+	? TResult
+	: Promise<TableModel<TName> | null>;
+type TableModel<TName extends TableName> = InferSelectModel<
+	(typeof mergedSchema)[TName]
+>;
+type TableInsertModel<TName extends TableName> = InferInsertModel<
+	(typeof mergedSchema)[TName]
+>;
+
+type Primitive = string | number | boolean | Date;
+type NonNil<T> = Exclude<T, null | undefined>;
+type Friendly<T> = T extends Date ? Date | number : T;
+type Comparable<T> = Friendly<Extract<NonNil<T>, Primitive>>;
+type RegexOperand<T> = T extends string ? string : never;
+
+type GeoPoint = {
+	latitude: number;
+	longitude: number;
+};
+
+type GeoCoordinates = {
+	type?: "Point";
+	coordinates: [number, number] | readonly [number, number];
+};
+
+type GeoWithinOperand = {
+	$geometry: GeoPoint | GeoCoordinates;
+	latitudeField?: string;
+	longitudeField?: string;
+	$minDistance?: number;
+	$maxDistance?: number;
+	gt?: number;
+	gte?: number;
+	lt?: number;
+	lte?: number;
+	$gt?: number;
+	$gte?: number;
+	$lt?: number;
+	$lte?: number;
+};
+
+type FieldOperators<T> = {
+	eq?: Friendly<NonNil<T>>;
+	$eq?: Friendly<NonNil<T>>;
+	ne?: Friendly<NonNil<T>>;
+	$ne?: Friendly<NonNil<T>>;
+	in?: ReadonlyArray<Friendly<NonNil<T>>>;
+	$in?: ReadonlyArray<Friendly<NonNil<T>>>;
+	nin?: ReadonlyArray<Friendly<NonNil<T>>>;
+	$nin?: ReadonlyArray<Friendly<NonNil<T>>>;
+	gt?: Comparable<T>;
+	$gt?: Comparable<T>;
+	gte?: Comparable<T>;
+	$gte?: Comparable<T>;
+	lt?: Comparable<T>;
+	$lt?: Comparable<T>;
+	lte?: Comparable<T>;
+	$lte?: Comparable<T>;
+	exists?: boolean;
+	regex?: RegexOperand<T>;
+	$options?: string;
+	geoWithin?: GeoWithinOperand;
+};
+
+type WhereFieldValue<T> = Friendly<NonNil<T>> | FieldOperators<T>;
+
+export type WhereInput<TModel extends Record<string, unknown>> = {
+	[K in keyof TModel]?: WhereFieldValue<TModel[K]>;
+} & {
+	geoWithin?: GeoWithinOperand;
+	$geoWithin?: GeoWithinOperand;
+};
+
+export type QueryFindManyArgs<TName extends TableName> = Omit<
+	NonNullable<TableFindManyArgs<TName>>,
+	"where"
+> & {
+	where?: WhereInput<TableModel<TName>>;
+};
+
+export type QueryFindFirstArgs<TName extends TableName> = Omit<
+	NonNullable<TableFindFirstArgs<TName>>,
+	"where"
+> & {
+	where?: WhereInput<TableModel<TName>>;
+};
+
+export type QueryInsertArgs<TName extends TableName> = {
+	values: TableInsertModel<TName> | Array<TableInsertModel<TName>>;
+};
+
+export type QueryUpdateArgs<TName extends TableName> = {
+	set: Partial<TableInsertModel<TName>>;
+	where?: WhereInput<TableModel<TName>>;
+	limit?: number;
+};
+
+export type QueryDeleteArgs<TName extends TableName> = {
+	where?: WhereInput<TableModel<TName>>;
+	limit?: number;
+};
+
+export type QueryUpsertArgs<TName extends TableName> = {
+	values: TableInsertModel<TName> | Array<TableInsertModel<TName>>;
+	target?:
+		| Extract<keyof TableInsertModel<TName>, string>
+		| Array<Extract<keyof TableInsertModel<TName>, string>>;
+	set?: Partial<TableInsertModel<TName>>;
+};
+
+export type QueryTableApi<TName extends TableName> = {
+	findMany: (
+		args?: QueryFindManyArgs<TName>,
+	) => TableFindManyResult<TName>;
+	findFirst: (
+		args?: QueryFindFirstArgs<TName>,
+	) => TableFindFirstResult<TName>;
+	insert: (args: QueryInsertArgs<TName>) => Promise<Array<TableModel<TName>>>;
+	update: (args: QueryUpdateArgs<TName>) => Promise<Array<TableModel<TName>>>;
+	upsert: (args: QueryUpsertArgs<TName>) => Promise<Array<TableModel<TName>>>;
+	delete: (args?: QueryDeleteArgs<TName>) => Promise<Array<TableModel<TName>>>;
+};
+
+export type AppflareQueryDb = {
+	[TName in TableName]: QueryTableApi<TName>;
+};
+
+export type DbMutationKind = "insert" | "update" | "upsert" | "delete";
+
+export type DbMutationEvent = {
+	kind: DbMutationKind;
+	table: string;
+	args: Record<string, unknown>;
+	rows: unknown[];
+};
+
+export type QueryDbOptions = {
+	onMutation?: (event: DbMutationEvent) => void;
+};
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null;
+}
+
+function readOperatorValue(record: Record<string, unknown>, key: string): unknown {
+	if (record[key] !== undefined) {
+		return record[key];
+	}
+	const prefixed = "$" + key;
+	return record[prefixed];
+}
+
+function normalizeGeoPoint(
+	value: GeoPoint | GeoCoordinates,
+): { latitude: number; longitude: number } | null {
+	if ((value as GeoPoint).latitude !== undefined) {
+		const point = value as GeoPoint;
+		if (
+			typeof point.latitude === "number" &&
+			typeof point.longitude === "number"
+		) {
+			return {
+				latitude: point.latitude,
+				longitude: point.longitude,
+			};
+		}
+		return null;
+	}
+
+	const coordinates = (value as GeoCoordinates).coordinates;
+	if (!Array.isArray(coordinates) || coordinates.length < 2) {
+		return null;
+	}
+
+	const [longitude, latitude] = coordinates;
+	if (typeof latitude !== "number" || typeof longitude !== "number") {
+		return null;
+	}
+
+	return {
+		latitude,
+		longitude,
+	};
+}
+
+function createGeoDistanceFilter(
+	operand: GeoWithinOperand,
+	fields: Record<string, unknown>,
+	fallbackLatitudeField?: string,
+): SQL | undefined {
+	const geometry = normalizeGeoPoint(operand.$geometry);
+	if (!geometry) {
+		return undefined;
+	}
+
+	const latitudeField = operand.latitudeField ?? fallbackLatitudeField;
+	const longitudeField = operand.longitudeField;
+	if (!latitudeField || !longitudeField) {
+		return undefined;
+	}
+
+	const latitudeColumn = fields[latitudeField];
+	if (!latitudeColumn) {
+		return undefined;
+	}
+
+	const longitudeColumn = fields[longitudeField];
+	if (!longitudeColumn) {
+		return undefined;
+	}
+
+	const distanceExpression = sql<number>\`(
+		6371000 * acos(
+			cos(radians(\${geometry.latitude})) * cos(radians(\${latitudeColumn}))
+			* cos(radians(\${longitudeColumn}) - radians(\${geometry.longitude}))
+			+ sin(radians(\${geometry.latitude})) * sin(radians(\${latitudeColumn}))
+		)
+	)\`;
+
+	const minDistance =
+		operand.$minDistance ??
+		operand.gte ??
+		operand.$gte ??
+		operand.gt ??
+		operand.$gt;
+	const maxDistance =
+		operand.$maxDistance ??
+		operand.lte ??
+		operand.$lte ??
+		operand.lt ??
+		operand.$lt;
+
+	const filters: SQL[] = [];
+	if (typeof minDistance === "number") {
+		filters.push(sql\`\${distanceExpression} >= \${minDistance}\`);
+	}
+	if (typeof maxDistance === "number") {
+		filters.push(sql\`\${distanceExpression} <= \${maxDistance}\`);
+	}
+
+	if (filters.length === 0) {
+		return undefined;
+	}
+
+	if (filters.length === 1) {
+		return filters[0];
+	}
+
+	return and(...filters);
+}
+
+function buildFieldFilter(
+	fieldName: string,
+	field: unknown,
+	value: unknown,
+	fields: Record<string, unknown>,
+): SQL | undefined {
+	if (!isRecord(value) || value instanceof Date || Array.isArray(value)) {
+		return eq(field as never, value as never);
+	}
+
+	const filters: SQL[] = [];
+	const eqValue = readOperatorValue(value, "eq");
+	if (eqValue !== undefined) {
+		filters.push(eq(field as never, eqValue as never));
+	}
+
+	const neValue = readOperatorValue(value, "ne");
+	if (neValue !== undefined) {
+		filters.push(ne(field as never, neValue as never));
+	}
+
+	const inValue = readOperatorValue(value, "in");
+	if (Array.isArray(inValue) && inValue.length > 0) {
+		filters.push(inArray(field as never, inValue as never));
+	}
+
+	const ninValue = readOperatorValue(value, "nin");
+	if (Array.isArray(ninValue) && ninValue.length > 0) {
+		filters.push(notInArray(field as never, ninValue as never));
+	}
+
+	const gtValue = readOperatorValue(value, "gt");
+	if (gtValue !== undefined) {
+		filters.push(gt(field as never, gtValue as never));
+	}
+
+	const gteValue = readOperatorValue(value, "gte");
+	if (gteValue !== undefined) {
+		filters.push(gte(field as never, gteValue as never));
+	}
+
+	const ltValue = readOperatorValue(value, "lt");
+	if (ltValue !== undefined) {
+		filters.push(lt(field as never, ltValue as never));
+	}
+
+	const lteValue = readOperatorValue(value, "lte");
+	if (lteValue !== undefined) {
+		filters.push(lte(field as never, lteValue as never));
+	}
+
+	if (typeof value.exists === "boolean") {
+		filters.push(value.exists ? isNotNull(field as never) : isNull(field as never));
+	}
+
+	if (typeof value.regex === "string") {
+		const caseInsensitive = typeof value.$options === "string" && value.$options.includes("i");
+		const pattern = "%" + value.regex + "%";
+		if (caseInsensitive) {
+			filters.push(
+				sql\`lower(\${field as never}) like lower(\${pattern})\`,
+			);
+		} else {
+			filters.push(sql\`\${field as never} like \${pattern}\`);
+		}
+	}
+
+	if (isRecord(value.geoWithin)) {
+		const geoFilter = createGeoDistanceFilter(
+			value.geoWithin as GeoWithinOperand,
+			fields,
+			fieldName,
+		);
+		if (geoFilter) {
+			filters.push(geoFilter);
+		}
+	}
+
+	if (filters.length === 0) {
+		return eq(field as never, value as never);
+	}
+
+	if (filters.length === 1) {
+		return filters[0];
+	}
+
+	return and(...filters);
+}
+
+function buildWhereFilter(
+	table: unknown,
+	where?: Record<string, unknown>,
+): SQL | undefined {
+	if (!table || !where || Object.keys(where).length === 0) {
+		return undefined;
+	}
+
+	const fields = getTableColumns(table as never) as Record<string, unknown>;
+	const filters: SQL[] = [];
+
+	const topLevelGeoWithin = isRecord(where.geoWithin)
+		? (where.geoWithin as GeoWithinOperand)
+		: isRecord(where.$geoWithin)
+			? (where.$geoWithin as GeoWithinOperand)
+			: undefined;
+
+	if (topLevelGeoWithin) {
+		const geoFilter = createGeoDistanceFilter(topLevelGeoWithin, fields);
+		if (geoFilter) {
+			filters.push(geoFilter);
+		}
+	}
+
+	for (const [fieldName, fieldValue] of Object.entries(where)) {
+		if (fieldName === "geoWithin" || fieldName === "$geoWithin") {
+			continue;
+		}
+
+		if (fieldValue === undefined) {
+			continue;
+		}
+
+		const field = fields[fieldName];
+		if (!field) {
+			continue;
+		}
+
+		const filter = buildFieldFilter(fieldName, field, fieldValue, fields);
+		if (filter) {
+			filters.push(filter);
+		}
+	}
+
+	if (filters.length === 0) {
+		return undefined;
+	}
+
+	if (filters.length === 1) {
+		return filters[0];
+	}
+
+	return and(...filters);
+}
+
+function inferConflictTarget(table: unknown): string[] {
+	if (!table) {
+		return [];
+	}
+
+	const columns = getTableColumns(table as never) as Record<string, unknown>;
+	if (columns.id) {
+		return ["id"];
+	}
+
+	return [];
+}
+
+export function createQueryDb(
+	$db: AppflareDb,
+	options?: QueryDbOptions,
+): AppflareQueryDb {
+	const cache = new Map<string, unknown>();
+	const onMutation = options?.onMutation;
+	const queryDb = $db.query as Record<
+		string,
+		{
+			findMany: (args?: unknown) => Promise<unknown>;
+			findFirst: (args?: unknown) => Promise<unknown>;
+		}
+	>;
+
+	return new Proxy({} as AppflareQueryDb, {
+		get: (_target, property) => {
+			const tableName = String(property);
+			if (cache.has(tableName)) {
+				return cache.get(tableName);
+			}
+
+			const queryTable = queryDb[tableName];
+			if (!queryTable) {
+				return undefined;
+			}
+
+			const table = (mergedSchema as Record<string, unknown>)[tableName];
+
+			const emitMutation = (
+				kind: DbMutationKind,
+				args: Record<string, unknown>,
+				rows: unknown[],
+			): void => {
+				onMutation?.({
+					kind,
+					table: tableName,
+					args,
+					rows,
+				});
+			};
+
+			const tableApi = {
+				findMany: (args?: Record<string, unknown>) => {
+					const where = isRecord(args?.where)
+						? (args?.where as Record<string, unknown>)
+						: undefined;
+					const whereFilter = buildWhereFilter(table, where);
+					if (!whereFilter) {
+						return queryTable.findMany(args);
+					}
+
+					return queryTable.findMany({
+						...(args ?? {}),
+						where: () => whereFilter,
+					});
+				},
+				findFirst: (args?: Record<string, unknown>) => {
+					const where = isRecord(args?.where)
+						? (args?.where as Record<string, unknown>)
+						: undefined;
+					const whereFilter = buildWhereFilter(table, where);
+					if (!whereFilter) {
+						return queryTable.findFirst(args);
+					}
+
+					return queryTable.findFirst({
+						...(args ?? {}),
+						where: () => whereFilter,
+					});
+				},
+				insert: async (args: QueryInsertArgs<TableName>) => {
+					let insertQuery: any = ($db as any)
+						.insert(table as any)
+						.values(args.values as any);
+
+					if (typeof insertQuery.returning === "function") {
+						insertQuery = insertQuery.returning();
+					}
+
+					const rows = (await insertQuery) as Array<TableModel<TableName>>;
+					emitMutation(
+						"insert",
+						{ values: args.values as unknown as Record<string, unknown> },
+						rows,
+					);
+					return rows;
+				},
+				update: async (args: QueryUpdateArgs<TableName>) => {
+					const whereFilter = buildWhereFilter(
+						table,
+						args.where as Record<string, unknown> | undefined,
+					);
+					let updateQuery: any = ($db as any)
+						.update(table as any)
+						.set(args.set as any);
+
+					if (whereFilter) {
+						updateQuery = updateQuery.where(whereFilter);
+					}
+					if (typeof args.limit === "number" && typeof updateQuery.limit === "function") {
+						updateQuery = updateQuery.limit(args.limit);
+					}
+					if (typeof updateQuery.returning === "function") {
+						updateQuery = updateQuery.returning();
+					}
+
+					const rows = (await updateQuery) as Array<TableModel<TableName>>;
+					emitMutation(
+						"update",
+						{
+							set: args.set as unknown as Record<string, unknown>,
+							where: (args.where ?? undefined) as unknown as Record<string, unknown>,
+							limit: args.limit,
+						},
+						rows,
+					);
+					return rows;
+				},
+				upsert: async (args: QueryUpsertArgs<TableName>) => {
+					const valuesArray = Array.isArray(args.values)
+						? args.values
+						: [args.values];
+					const values = Array.isArray(args.values)
+						? args.values
+						: args.values;
+
+					const targets = args.target
+						? Array.isArray(args.target)
+							? args.target
+							: [args.target]
+						: inferConflictTarget(table);
+
+					if (targets.length === 0) {
+						throw new Error(
+							"Unable to infer conflict target for table " + tableName + ". Provide target explicitly.",
+						);
+					}
+
+					const tableColumns = getTableColumns(table as never) as Record<string, unknown>;
+					const targetColumns = targets
+						.map((target) => tableColumns[target])
+						.filter(Boolean);
+
+					if (targetColumns.length === 0) {
+						throw new Error(
+							"Invalid conflict target for table " + tableName + ".",
+						);
+					}
+
+					const setPayload = args.set ?? valuesArray[0] ?? {};
+					let upsertQuery: any = ($db as any)
+						.insert(table as any)
+						.values(values as any)
+						.onConflictDoUpdate({
+							target: targetColumns as any,
+							set: setPayload as any,
+						});
+
+					if (typeof upsertQuery.returning === "function") {
+						upsertQuery = upsertQuery.returning();
+					}
+
+					const rows = (await upsertQuery) as Array<TableModel<TableName>>;
+					emitMutation(
+						"upsert",
+						{
+							values: args.values as unknown as Record<string, unknown>,
+							target: targets as unknown as Record<string, unknown>,
+							set: (args.set ?? undefined) as unknown as Record<string, unknown>,
+						},
+						rows,
+					);
+					return rows;
+				},
+				delete: async (args?: QueryDeleteArgs<TableName>) => {
+					const whereFilter = buildWhereFilter(
+						table,
+						args?.where as Record<string, unknown> | undefined,
+					);
+					let deleteQuery: any = ($db as any).delete(table as any);
+
+					if (whereFilter) {
+						deleteQuery = deleteQuery.where(whereFilter);
+					}
+					if (typeof args?.limit === "number" && typeof deleteQuery.limit === "function") {
+						deleteQuery = deleteQuery.limit(args.limit);
+					}
+					if (typeof deleteQuery.returning === "function") {
+						deleteQuery = deleteQuery.returning();
+					}
+
+					const rows = (await deleteQuery) as Array<TableModel<TableName>>;
+					emitMutation(
+						"delete",
+						{
+							where: (args?.where ?? undefined) as unknown as Record<string, unknown>,
+							limit: args?.limit,
+						},
+						rows,
+					);
+					return rows;
+				},
+			};
+
+			cache.set(tableName, tableApi);
+			return tableApi;
+		},
+	}) as AppflareQueryDb;
+}
+
+export class AppflareHandledError extends Error {
+	public readonly status: number;
+	public readonly payload: unknown;
+
+	public constructor(status: number, payload: unknown) {
+		super(typeof payload === "object" ? "Handled error" : String(payload));
+		this.status = status;
+		this.payload = payload;
+	}
+}
+
+
+
+type AuthSession = typeof auth.$Infer.Session;
+type User = AuthSession['user']
+type Session = AuthSession['session']
+
+export type StoragePutArgs = {
+	path: string;
+	body: ReadableStream | ArrayBuffer | ArrayBufferView | string | Blob;
+	contentType?: string;
+	httpMetadata?: Record<string, unknown>;
+	customMetadata?: Record<string, string>;
+};
+
+export type StorageGetArgs = {
+	path: string;
+	method?: StorageMethod;
+	onlyIf?: unknown;
+	range?: unknown;
+	includeBody?: boolean;
+};
+
+export type StorageDeleteArgs = {
+	path: string;
+};
+
+export type StorageListArgs = {
+	prefix?: string;
+	cursor?: string;
+	limit?: number;
+	delimiter?: string;
+	include?: Array<"httpMetadata" | "customMetadata">;
+	method?: StorageMethod;
+};
+
+export type StorageSignedUrlArgs = {
+	path: string;
+	method?: "GET" | "PUT" | "DELETE";
+	expiresIn?: number;
+	contentType?: string;
+	downloadAsAttachment?: boolean;
+	fileName?: string;
+};
+
+export type AppflareStorage = {
+	put: (args: StoragePutArgs) => Promise<unknown>;
+	get: (args: StorageGetArgs) => Promise<unknown | null>;
+	delete: (args: StorageDeleteArgs) => Promise<void>;
+	list: (args?: StorageListArgs) => Promise<unknown>;
+	signedUrl: (args: StorageSignedUrlArgs) => Promise<string>;
+};
+
+export type AppflareContext = {
+	$db: AppflareDb;
+	db: AppflareQueryDb;
+	mutationEvents: DbMutationEvent[];
+	user: User;
+	session: Session;
+	context: Context<WorkerEnv>;
+	scheduler: Scheduler;
+	storage: AppflareStorage;
+	error: (status: number, message: string, details?: unknown) => never;
+};
+
+type InferOperationArgs<TShape extends ZodRawShape> = z.output<z.ZodObject<TShape>>;
+
+export type SchedulerEnqueueOptions = {
+	delaySeconds?: number;
+};
+
+declare global {
+	interface AppflareSchedulerHandlerMap {}
+}
+
+export type SchedulerTaskName = keyof AppflareSchedulerHandlerMap extends never
+	? string
+	: Extract<keyof AppflareSchedulerHandlerMap, string>;
+
+export type SchedulerTaskPayload<TTask extends SchedulerTaskName> =
+	TTask extends keyof AppflareSchedulerHandlerMap
+		? AppflareSchedulerHandlerMap[TTask]
+		: unknown;
+
+export type SchedulerEnqueue = {
+	<TTask extends SchedulerTaskName>(
+		task: TTask,
+		...args: undefined extends SchedulerTaskPayload<TTask>
+			? [
+					payload?: SchedulerTaskPayload<TTask>,
+					options?: SchedulerEnqueueOptions,
+			  ]
+			: [
+					payload: SchedulerTaskPayload<TTask>,
+					options?: SchedulerEnqueueOptions,
+			  ]
+	): Promise<void>;
+};
+
+export type Scheduler = {
+	enqueue: SchedulerEnqueue;
+};
+
+type OperationDefinition<
+	TShape extends ZodRawShape,
+	TResult,
+> = {
+	args: TShape;
+	authRequired: boolean;
+	middleware?: (
+		ctx: AppflareContext,
+		index: InferOperationArgs<TShape>,
+		request: Request,
+	) => void | Promise<void>;
+	handler: (
+		ctx: AppflareContext,
+		args: InferOperationArgs<TShape>,
+	) => TResult | Promise<TResult>;
+};
+
+type OperationDefinitionInput<
+	TShape extends ZodRawShape,
+	TResult,
+> = Omit<OperationDefinition<TShape, TResult>, "authRequired"> & {
+	authRequired?: boolean;
+};
+
+export type RegisteredOperation<
+	TShape extends ZodRawShape,
+	TResult,
+> = {
+	kind: "query" | "mutation";
+	definition: OperationDefinition<TShape, TResult>;
+};
+
+type SchedulerDefinition<TShape extends ZodRawShape | undefined> = {
+	args?: TShape;
+	handler: (
+		ctx: AppflareContext,
+		args: TShape extends ZodRawShape ? InferOperationArgs<TShape> : undefined,
+	) => void | Promise<void>;
+};
+
+export type RegisteredScheduler<TShape extends ZodRawShape | undefined> = {
+	kind: "scheduler";
+	definition: SchedulerDefinition<TShape>;
+};
+
+type CronDefinition = {
+	cronTrigger: string | string[];
+	handler: (ctx: AppflareContext) => void | Promise<void>;
+};
+
+export type RegisteredCron = {
+	kind: "cron";
+	definition: CronDefinition;
+};
+
+export function query<TShape extends ZodRawShape, TResult>(
+	definition: OperationDefinitionInput<TShape, TResult>,
+): RegisteredOperation<TShape, TResult> {
+	return {
+		kind: "query",
+		definition: {
+			authRequired: false,
+			...definition,
+		},
+	};
+}
+
+export function mutation<TShape extends ZodRawShape, TResult>(
+	definition: OperationDefinitionInput<TShape, TResult>,
+): RegisteredOperation<TShape, TResult> {
+	return {
+		kind: "mutation",
+		definition: {
+			authRequired: false,
+			...definition,
+		},
+	};
+}
+
+export function scheduler<TShape extends ZodRawShape | undefined = undefined>(
+	definition: SchedulerDefinition<TShape>,
+): RegisteredScheduler<TShape> {
+	return {
+		kind: "scheduler",
+		definition,
+	};
+}
+
+export function cron(definition: CronDefinition): RegisteredCron {
+	return {
+		kind: "cron",
+		definition,
+	};
+}
+
+`;
+}