appflare 0.2.24 → 0.2.26

package/cli/templates/handlers/generators/registration/modules/realtime/utils.ts

@@ -1,516 +1,516 @@
-export const realtimeUtilsModule = `
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === "object" && value !== null;
-}
-
-function stableStringify(value: unknown): string {
-	if (Array.isArray(value)) {
-		return "[" + value.map((entry) => stableStringify(entry)).join(",") + "]";
-	}
-
-	if (value instanceof Date) {
-		return JSON.stringify(value.toISOString());
-	}
-
-	if (isRecord(value)) {
-		const keys = Object.keys(value).sort((a, b) => a.localeCompare(b));
-		return (
-			"{" +
-			keys
-				.map((key) => JSON.stringify(key) + ":" + stableStringify(value[key]))
-				.join(",") +
-			"}"
-		);
-	}
-
-	return JSON.stringify(value ?? null);
-}
-
-function normalizeComparableValue(value: unknown): unknown {
-	if (Array.isArray(value)) {
-		return value.map((entry) => normalizeComparableValue(entry));
-	}
-
-	if (value instanceof Date) {
-		return value.toISOString();
-	}
-
-	if (isRecord(value)) {
-		return Object.entries(value)
-			.sort(([a], [b]) => a.localeCompare(b))
-			.reduce<Record<string, unknown>>((accumulator, [key, entry]) => {
-				accumulator[key] = normalizeComparableValue(entry);
-				return accumulator;
-			}, {});
-	}
-
-	return value;
-}
-
-function createSubscriptionSignature(
-	queryName: string,
-	args: Record<string, unknown>,
-): string {
-	const normalizedArgs = normalizeComparableValue(args);
-	return queryName + "::" + stableStringify(normalizedArgs);
-}
-
-type RealtimeQueryMethod = "findMany" | "findFirst" | "count" | "avg";
-
-type RealtimeQueryMatchDescriptor = {
-	table: string;
-	method: RealtimeQueryMethod;
-	where: Record<string, unknown> | null;
-};
-
-type RealtimeQueryMatchPlan = {
-	descriptors: RealtimeQueryMatchDescriptor[];
-	unsupported: boolean;
-};
-
-type RealtimePlanContextSeed = {
-	user: unknown;
-	session: unknown;
-};
-
-function normalizeQueryWhereArg(args: unknown): Record<string, unknown> | null {
-	if (!isRecord(args)) {
-		return null;
-	}
-
-	const where = args.where;
-	if (isRecord(where)) {
-		return where;
-	}
-
-	return null;
-}
-
-function normalizeQueryWithArg(args: unknown): Record<string, unknown> | null {
-	if (!isRecord(args)) {
-		return null;
-	}
-
-	const withArg = args.with;
-	if (isRecord(withArg)) {
-		return withArg;
-	}
-
-	return null;
-}
-
-function appendWithWhereDescriptors(
-	descriptors: RealtimeQueryMatchDescriptor[],
-	withInput: unknown,
-	method: RealtimeQueryMethod,
-): void {
-	if (!isRecord(withInput)) {
-		return;
-	}
-
-	for (const [relationName, relationValue] of Object.entries(withInput)) {
-		if (!isRecord(relationValue)) {
-			continue;
-		}
-
-		const relationWhere = relationValue.where;
-		if (isRecord(relationWhere)) {
-			descriptors.push({
-				table: relationName,
-				method,
-				where: relationWhere,
-			});
-		}
-
-		appendWithWhereDescriptors(descriptors, relationValue.with, method);
-	}
-}
-
-function readOperatorValue(record: Record<string, unknown>, key: string): unknown {
-	if (record[key] !== undefined) {
-		return record[key];
-	}
-	const prefixed = "$" + key;
-	return record[prefixed];
-}
-
-function toDateTimestamp(value: unknown): number | null {
-	if (value instanceof Date) {
-		return value.getTime();
-	}
-
-	if (typeof value === "string" || typeof value === "number") {
-		const date = new Date(value);
-		const timestamp = date.getTime();
-		if (!Number.isNaN(timestamp)) {
-			return timestamp;
-		}
-	}
-
-	return null;
-}
-
-function compareScalarValues(left: unknown, right: unknown): boolean {
-	if (left === right) {
-		return true;
-	}
-
-	const leftDate = toDateTimestamp(left);
-	const rightDate = toDateTimestamp(right);
-	if (leftDate !== null && rightDate !== null) {
-		return leftDate === rightDate;
-	}
-
-	return false;
-}
-
-function compareOrderValues(
-	left: unknown,
-	right: unknown,
-): { left: number | string; right: number | string } | null {
-	if (typeof left === "number" && typeof right === "number") {
-		return { left, right };
-	}
-
-	const leftDate = toDateTimestamp(left);
-	const rightDate = toDateTimestamp(right);
-	if (leftDate !== null && rightDate !== null) {
-		return { left: leftDate, right: rightDate };
-	}
-
-	if (typeof left === "string" && typeof right === "string") {
-		return { left, right };
-	}
-
-	return null;
-}
-
-function hasKnownOperator(condition: Record<string, unknown>): boolean {
-	return [
-		"eq",
-		"$eq",
-		"ne",
-		"$ne",
-		"in",
-		"$in",
-		"nin",
-		"$nin",
-		"gt",
-		"$gt",
-		"gte",
-		"$gte",
-		"lt",
-		"$lt",
-		"lte",
-		"$lte",
-		"exists",
-		"regex",
-		"$options",
-		"geoWithin",
-		"$geoWithin",
-	].some((key) => key in condition);
-}
-
-function hasPartialOverlap(left: unknown, right: unknown): boolean {
-	if (left === null || left === undefined || right === null || right === undefined) {
-		return false;
-	}
-
-	if (Array.isArray(left) && Array.isArray(right)) {
-		return left.some((leftValue) => {
-			return right.some((rightValue) => hasPartialOverlap(leftValue, rightValue));
-		});
-	}
-
-	if (Array.isArray(left)) {
-		return left.some((leftValue) => hasPartialOverlap(leftValue, right));
-	}
-
-	if (Array.isArray(right)) {
-		return right.some((rightValue) => hasPartialOverlap(left, rightValue));
-	}
-
-	if (isRecord(left) && isRecord(right)) {
-		const keys = Object.keys(left);
-		for (const key of keys) {
-			if (!(key in right)) {
-				continue;
-			}
-
-			if (hasPartialOverlap(left[key], right[key])) {
-				return true;
-			}
-		}
-
-		return false;
-	}
-
-	return left === right;
-}
-
-function matchesWhereFieldCondition(
-	condition: unknown,
-	fieldValue: unknown,
-): boolean {
-	if (!isRecord(condition) || condition instanceof Date || Array.isArray(condition)) {
-		return compareScalarValues(fieldValue, condition);
-	}
-
-	if (!hasKnownOperator(condition)) {
-		return hasPartialOverlap(condition, fieldValue);
-	}
-
-	const eqValue = readOperatorValue(condition, "eq");
-	if (eqValue !== undefined && !compareScalarValues(fieldValue, eqValue)) {
-		return false;
-	}
-
-	const neValue = readOperatorValue(condition, "ne");
-	if (neValue !== undefined && compareScalarValues(fieldValue, neValue)) {
-		return false;
-	}
-
-	const inValue = readOperatorValue(condition, "in");
-	if (Array.isArray(inValue) && inValue.length > 0) {
-		if (!inValue.some((entry) => compareScalarValues(fieldValue, entry))) {
-			return false;
-		}
-	}
-
-	const ninValue = readOperatorValue(condition, "nin");
-	if (Array.isArray(ninValue) && ninValue.length > 0) {
-		if (ninValue.some((entry) => compareScalarValues(fieldValue, entry))) {
-			return false;
-		}
-	}
-
-	const gtValue = readOperatorValue(condition, "gt");
-	if (gtValue !== undefined) {
-		const comparable = compareOrderValues(fieldValue, gtValue);
-		if (!comparable || !(comparable.left > comparable.right)) {
-			return false;
-		}
-	}
-
-	const gteValue = readOperatorValue(condition, "gte");
-	if (gteValue !== undefined) {
-		const comparable = compareOrderValues(fieldValue, gteValue);
-		if (!comparable || !(comparable.left >= comparable.right)) {
-			return false;
-		}
-	}
-
-	const ltValue = readOperatorValue(condition, "lt");
-	if (ltValue !== undefined) {
-		const comparable = compareOrderValues(fieldValue, ltValue);
-		if (!comparable || !(comparable.left < comparable.right)) {
-			return false;
-		}
-	}
-
-	const lteValue = readOperatorValue(condition, "lte");
-	if (lteValue !== undefined) {
-		const comparable = compareOrderValues(fieldValue, lteValue);
-		if (!comparable || !(comparable.left <= comparable.right)) {
-			return false;
-		}
-	}
-
-	if (typeof condition.exists === "boolean") {
-		const exists = fieldValue !== null && fieldValue !== undefined;
-		if (exists !== condition.exists) {
-			return false;
-		}
-	}
-
-	if (typeof condition.regex === "string") {
-		if (typeof fieldValue !== "string") {
-			return false;
-		}
-
-		const caseInsensitive =
-			typeof condition.$options === "string" && condition.$options.includes("i");
-		const source = caseInsensitive ? fieldValue.toLowerCase() : fieldValue;
-		const pattern = caseInsensitive
-			? condition.regex.toLowerCase()
-			: condition.regex;
-		if (!source.includes(pattern)) {
-			return false;
-		}
-	}
-
-	return true;
-}
-
-function doesWhereMatchCandidate(
-	where: Record<string, unknown>,
-	candidate: unknown,
-): boolean {
-	if (!isRecord(candidate)) {
-		return false;
-	}
-
-	for (const [fieldName, condition] of Object.entries(where)) {
-		if (fieldName === "geoWithin" || fieldName === "$geoWithin") {
-			continue;
-		}
-
-		if (!matchesWhereFieldCondition(condition, candidate[fieldName])) {
-			return false;
-		}
-	}
-
-	return true;
-}
-
-function collectMutationCandidates(event: DbMutationEvent): unknown[] {
-	const candidates: unknown[] = [...event.rows];
-	const values = event.args.values;
-	if (Array.isArray(values)) {
-		candidates.push(...values);
-	} else if (values !== undefined) {
-		candidates.push(values);
-	}
-
-	if (event.args.set !== undefined) {
-		candidates.push(event.args.set);
-	}
-
-	if (event.args.where !== undefined) {
-		candidates.push(event.args.where);
-	}
-
-	return candidates;
-}
-
-async function buildRealtimeQueryMatchPlan(
-	handler: (ctx: AppflareContext, args: unknown) => Promise<unknown> | unknown,
-	args: unknown,
-	ctxSeed: RealtimePlanContextSeed,
-): Promise<RealtimeQueryMatchPlan> {
-	const descriptors: RealtimeQueryMatchDescriptor[] = [];
-	let unsupported = false;
-
-	const unsupportedError = (message: string): Error =>
-		new Error("Realtime matcher unsupported: " + message);
-
-	const dbProxy = new Proxy({} as Record<string, unknown>, {
-		get(_target, tableProperty) {
-			if (typeof tableProperty !== "string") {
-				unsupported = true;
-				throw unsupportedError("invalid table access");
-			}
-
-			const tableName = tableProperty;
-			return new Proxy({} as Record<string, unknown>, {
-				get(_tableTarget, methodProperty) {
-					if (typeof methodProperty !== "string") {
-						unsupported = true;
-						throw unsupportedError("invalid method access");
-					}
-
-					if (
-						methodProperty === "findMany" ||
-						methodProperty === "findFirst" ||
-						methodProperty === "count" ||
-						methodProperty === "avg"
-					) {
-						return async (queryArgs?: unknown) => {
-							const methodName = methodProperty as RealtimeQueryMethod;
-							descriptors.push({
-								table: tableName,
-								method: methodName,
-								where: normalizeQueryWhereArg(queryArgs),
-							});
-							appendWithWhereDescriptors(
-								descriptors,
-								normalizeQueryWithArg(queryArgs),
-								methodName,
-							);
-
-							if (methodProperty === "findMany") {
-								return [];
-							}
-							if (methodProperty === "findFirst") {
-								return null;
-							}
-							if (methodProperty === "count") {
-								return 0;
-							}
-
-							return null;
-						};
-					}
-
-					unsupported = true;
-					throw unsupportedError("ctx.db." + tableName + "." + methodProperty);
-				},
-			});
-		},
-	});
-
-	const planCtx = new Proxy({} as Record<string, unknown>, {
-		get(_target, property) {
-			if (property === "db") {
-				return dbProxy;
-			}
-			if (property === "user") {
-				return ctxSeed.user;
-			}
-			if (property === "session") {
-				return ctxSeed.session;
-			}
-
-			unsupported = true;
-			throw unsupportedError("ctx." + String(property));
-		},
-	});
-
-	try {
-		await handler(planCtx as AppflareContext, args);
-	} catch (_error) {
-		unsupported = true;
-	}
-
-	if (descriptors.length === 0) {
-		unsupported = true;
-	}
-
-	return {
-		descriptors,
-		unsupported,
-	};
-}
-
-function doesSubscriptionMatchMutation(
-	plan: RealtimeQueryMatchPlan,
-	event: DbMutationEvent,
-): boolean {
-	if (plan.unsupported) {
-		return false;
-	}
-
-	const descriptors = plan.descriptors.filter(
-		(descriptor) => descriptor.table === event.table,
-	);
-	if (descriptors.length === 0) {
-		return false;
-	}
-
-	const candidates = collectMutationCandidates(event);
-	for (const descriptor of descriptors) {
-		if (!descriptor.where) {
-			if (candidates.length > 0) {
-				return true;
-			}
-			continue;
-		}
-
-		if (candidates.some((candidate) => doesWhereMatchCandidate(descriptor.where as Record<string, unknown>, candidate))) {
-			return true;
-		}
-	}
-
-	return false;
-}
-`;
+export const realtimeUtilsModule = `
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null;
+}
+
+function stableStringify(value: unknown): string {
+	if (Array.isArray(value)) {
+		return "[" + value.map((entry) => stableStringify(entry)).join(",") + "]";
+	}
+
+	if (value instanceof Date) {
+		return JSON.stringify(value.toISOString());
+	}
+
+	if (isRecord(value)) {
+		const keys = Object.keys(value).sort((a, b) => a.localeCompare(b));
+		return (
+			"{" +
+			keys
+				.map((key) => JSON.stringify(key) + ":" + stableStringify(value[key]))
+				.join(",") +
+			"}"
+		);
+	}
+
+	return JSON.stringify(value ?? null);
+}
+
+function normalizeComparableValue(value: unknown): unknown {
+	if (Array.isArray(value)) {
+		return value.map((entry) => normalizeComparableValue(entry));
+	}
+
+	if (value instanceof Date) {
+		return value.toISOString();
+	}
+
+	if (isRecord(value)) {
+		return Object.entries(value)
+			.sort(([a], [b]) => a.localeCompare(b))
+			.reduce<Record<string, unknown>>((accumulator, [key, entry]) => {
+				accumulator[key] = normalizeComparableValue(entry);
+				return accumulator;
+			}, {});
+	}
+
+	return value;
+}
+
+function createSubscriptionSignature(
+	queryName: string,
+	args: Record<string, unknown>,
+): string {
+	const normalizedArgs = normalizeComparableValue(args);
+	return queryName + "::" + stableStringify(normalizedArgs);
+}
+
+type RealtimeQueryMethod = "findMany" | "findFirst" | "count" | "avg";
+
+type RealtimeQueryMatchDescriptor = {
+	table: string;
+	method: RealtimeQueryMethod;
+	where: Record<string, unknown> | null;
+};
+
+type RealtimeQueryMatchPlan = {
+	descriptors: RealtimeQueryMatchDescriptor[];
+	unsupported: boolean;
+};
+
+type RealtimePlanContextSeed = {
+	user: unknown;
+	session: unknown;
+};
+
+function normalizeQueryWhereArg(args: unknown): Record<string, unknown> | null {
+	if (!isRecord(args)) {
+		return null;
+	}
+
+	const where = args.where;
+	if (isRecord(where)) {
+		return where;
+	}
+
+	return null;
+}
+
+function normalizeQueryWithArg(args: unknown): Record<string, unknown> | null {
+	if (!isRecord(args)) {
+		return null;
+	}
+
+	const withArg = args.with;
+	if (isRecord(withArg)) {
+		return withArg;
+	}
+
+	return null;
+}
+
+function appendWithWhereDescriptors(
+	descriptors: RealtimeQueryMatchDescriptor[],
+	withInput: unknown,
+	method: RealtimeQueryMethod,
+): void {
+	if (!isRecord(withInput)) {
+		return;
+	}
+
+	for (const [relationName, relationValue] of Object.entries(withInput)) {
+		if (!isRecord(relationValue)) {
+			continue;
+		}
+
+		const relationWhere = relationValue.where;
+		if (isRecord(relationWhere)) {
+			descriptors.push({
+				table: relationName,
+				method,
+				where: relationWhere,
+			});
+		}
+
+		appendWithWhereDescriptors(descriptors, relationValue.with, method);
+	}
+}
+
+function readOperatorValue(record: Record<string, unknown>, key: string): unknown {
+	if (record[key] !== undefined) {
+		return record[key];
+	}
+	const prefixed = "$" + key;
+	return record[prefixed];
+}
+
+function toDateTimestamp(value: unknown): number | null {
+	if (value instanceof Date) {
+		return value.getTime();
+	}
+
+	if (typeof value === "string" || typeof value === "number") {
+		const date = new Date(value);
+		const timestamp = date.getTime();
+		if (!Number.isNaN(timestamp)) {
+			return timestamp;
+		}
+	}
+
+	return null;
+}
+
+function compareScalarValues(left: unknown, right: unknown): boolean {
+	if (left === right) {
+		return true;
+	}
+
+	const leftDate = toDateTimestamp(left);
+	const rightDate = toDateTimestamp(right);
+	if (leftDate !== null && rightDate !== null) {
+		return leftDate === rightDate;
+	}
+
+	return false;
+}
+
+function compareOrderValues(
+	left: unknown,
+	right: unknown,
+): { left: number | string; right: number | string } | null {
+	if (typeof left === "number" && typeof right === "number") {
+		return { left, right };
+	}
+
+	const leftDate = toDateTimestamp(left);
+	const rightDate = toDateTimestamp(right);
+	if (leftDate !== null && rightDate !== null) {
+		return { left: leftDate, right: rightDate };
+	}
+
+	if (typeof left === "string" && typeof right === "string") {
+		return { left, right };
+	}
+
+	return null;
+}
+
+function hasKnownOperator(condition: Record<string, unknown>): boolean {
+	return [
+		"eq",
+		"$eq",
+		"ne",
+		"$ne",
+		"in",
+		"$in",
+		"nin",
+		"$nin",
+		"gt",
+		"$gt",
+		"gte",
+		"$gte",
+		"lt",
+		"$lt",
+		"lte",
+		"$lte",
+		"exists",
+		"regex",
+		"$options",
+		"geoWithin",
+		"$geoWithin",
+	].some((key) => key in condition);
+}
+
+function hasPartialOverlap(left: unknown, right: unknown): boolean {
+	if (left === null || left === undefined || right === null || right === undefined) {
+		return false;
+	}
+
+	if (Array.isArray(left) && Array.isArray(right)) {
+		return left.some((leftValue) => {
+			return right.some((rightValue) => hasPartialOverlap(leftValue, rightValue));
+		});
+	}
+
+	if (Array.isArray(left)) {
+		return left.some((leftValue) => hasPartialOverlap(leftValue, right));
+	}
+
+	if (Array.isArray(right)) {
+		return right.some((rightValue) => hasPartialOverlap(left, rightValue));
+	}
+
+	if (isRecord(left) && isRecord(right)) {
+		const keys = Object.keys(left);
+		for (const key of keys) {
+			if (!(key in right)) {
+				continue;
+			}
+
+			if (hasPartialOverlap(left[key], right[key])) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	return left === right;
+}
+
+function matchesWhereFieldCondition(
+	condition: unknown,
+	fieldValue: unknown,
+): boolean {
+	if (!isRecord(condition) || condition instanceof Date || Array.isArray(condition)) {
+		return compareScalarValues(fieldValue, condition);
+	}
+
+	if (!hasKnownOperator(condition)) {
+		return hasPartialOverlap(condition, fieldValue);
+	}
+
+	const eqValue = readOperatorValue(condition, "eq");
+	if (eqValue !== undefined && !compareScalarValues(fieldValue, eqValue)) {
+		return false;
+	}
+
+	const neValue = readOperatorValue(condition, "ne");
+	if (neValue !== undefined && compareScalarValues(fieldValue, neValue)) {
+		return false;
+	}
+
+	const inValue = readOperatorValue(condition, "in");
+	if (Array.isArray(inValue) && inValue.length > 0) {
+		if (!inValue.some((entry) => compareScalarValues(fieldValue, entry))) {
+			return false;
+		}
+	}
+
+	const ninValue = readOperatorValue(condition, "nin");
+	if (Array.isArray(ninValue) && ninValue.length > 0) {
+		if (ninValue.some((entry) => compareScalarValues(fieldValue, entry))) {
+			return false;
+		}
+	}
+
+	const gtValue = readOperatorValue(condition, "gt");
+	if (gtValue !== undefined) {
+		const comparable = compareOrderValues(fieldValue, gtValue);
+		if (!comparable || !(comparable.left > comparable.right)) {
+			return false;
+		}
+	}
+
+	const gteValue = readOperatorValue(condition, "gte");
+	if (gteValue !== undefined) {
+		const comparable = compareOrderValues(fieldValue, gteValue);
+		if (!comparable || !(comparable.left >= comparable.right)) {
+			return false;
+		}
+	}
+
+	const ltValue = readOperatorValue(condition, "lt");
+	if (ltValue !== undefined) {
+		const comparable = compareOrderValues(fieldValue, ltValue);
+		if (!comparable || !(comparable.left < comparable.right)) {
+			return false;
+		}
+	}
+
+	const lteValue = readOperatorValue(condition, "lte");
+	if (lteValue !== undefined) {
+		const comparable = compareOrderValues(fieldValue, lteValue);
+		if (!comparable || !(comparable.left <= comparable.right)) {
+			return false;
+		}
+	}
+
+	if (typeof condition.exists === "boolean") {
+		const exists = fieldValue !== null && fieldValue !== undefined;
+		if (exists !== condition.exists) {
+			return false;
+		}
+	}
+
+	if (typeof condition.regex === "string") {
+		if (typeof fieldValue !== "string") {
+			return false;
+		}
+
+		const caseInsensitive =
+			typeof condition.$options === "string" && condition.$options.includes("i");
+		const source = caseInsensitive ? fieldValue.toLowerCase() : fieldValue;
+		const pattern = caseInsensitive
+			? condition.regex.toLowerCase()
+			: condition.regex;
+		if (!source.includes(pattern)) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+function doesWhereMatchCandidate(
+	where: Record<string, unknown>,
+	candidate: unknown,
+): boolean {
+	if (!isRecord(candidate)) {
+		return false;
+	}
+
+	for (const [fieldName, condition] of Object.entries(where)) {
+		if (fieldName === "geoWithin" || fieldName === "$geoWithin") {
+			continue;
+		}
+
+		if (!matchesWhereFieldCondition(condition, candidate[fieldName])) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+function collectMutationCandidates(event: DbMutationEvent): unknown[] {
+	const candidates: unknown[] = [...event.rows];
+	const values = event.args.values;
+	if (Array.isArray(values)) {
+		candidates.push(...values);
+	} else if (values !== undefined) {
+		candidates.push(values);
+	}
+
+	if (event.args.set !== undefined) {
+		candidates.push(event.args.set);
+	}
+
+	if (event.args.where !== undefined) {
+		candidates.push(event.args.where);
+	}
+
+	return candidates;
+}
+
+async function buildRealtimeQueryMatchPlan(
+	handler: (ctx: AppflareContext, args: unknown) => Promise<unknown> | unknown,
+	args: unknown,
+	ctxSeed: RealtimePlanContextSeed,
+): Promise<RealtimeQueryMatchPlan> {
+	const descriptors: RealtimeQueryMatchDescriptor[] = [];
+	let unsupported = false;
+
+	const unsupportedError = (message: string): Error =>
+		new Error("Realtime matcher unsupported: " + message);
+
+	const dbProxy = new Proxy({} as Record<string, unknown>, {
+		get(_target, tableProperty) {
+			if (typeof tableProperty !== "string") {
+				unsupported = true;
+				throw unsupportedError("invalid table access");
+			}
+
+			const tableName = tableProperty;
+			return new Proxy({} as Record<string, unknown>, {
+				get(_tableTarget, methodProperty) {
+					if (typeof methodProperty !== "string") {
+						unsupported = true;
+						throw unsupportedError("invalid method access");
+					}
+
+					if (
+						methodProperty === "findMany" ||
+						methodProperty === "findFirst" ||
+						methodProperty === "count" ||
+						methodProperty === "avg"
+					) {
+						return async (queryArgs?: unknown) => {
+							const methodName = methodProperty as RealtimeQueryMethod;
+							descriptors.push({
+								table: tableName,
+								method: methodName,
+								where: normalizeQueryWhereArg(queryArgs),
+							});
+							appendWithWhereDescriptors(
+								descriptors,
+								normalizeQueryWithArg(queryArgs),
+								methodName,
+							);
+
+							if (methodProperty === "findMany") {
+								return [];
+							}
+							if (methodProperty === "findFirst") {
+								return null;
+							}
+							if (methodProperty === "count") {
+								return 0;
+							}
+
+							return null;
+						};
+					}
+
+					unsupported = true;
+					throw unsupportedError("ctx.db." + tableName + "." + methodProperty);
+				},
+			});
+		},
+	});
+
+	const planCtx = new Proxy({} as Record<string, unknown>, {
+		get(_target, property) {
+			if (property === "db") {
+				return dbProxy;
+			}
+			if (property === "user") {
+				return ctxSeed.user;
+			}
+			if (property === "session") {
+				return ctxSeed.session;
+			}
+
+			unsupported = true;
+			throw unsupportedError("ctx." + String(property));
+		},
+	});
+
+	try {
+		await handler(planCtx as AppflareContext, args);
+	} catch (_error) {
+		unsupported = true;
+	}
+
+	if (descriptors.length === 0) {
+		unsupported = true;
+	}
+
+	return {
+		descriptors,
+		unsupported,
+	};
+}
+
+function doesSubscriptionMatchMutation(
+	plan: RealtimeQueryMatchPlan,
+	event: DbMutationEvent,
+): boolean {
+	if (plan.unsupported) {
+		return false;
+	}
+
+	const descriptors = plan.descriptors.filter(
+		(descriptor) => descriptor.table === event.table,
+	);
+	if (descriptors.length === 0) {
+		return false;
+	}
+
+	const candidates = collectMutationCandidates(event);
+	for (const descriptor of descriptors) {
+		if (!descriptor.where) {
+			if (candidates.length > 0) {
+				return true;
+			}
+			continue;
+		}
+
+		if (candidates.some((candidate) => doesWhereMatchCandidate(descriptor.where as Record<string, unknown>, candidate))) {
+			return true;
+		}
+	}
+
+	return false;
+}
+`;