better-convex 0.7.2 → 0.8.0

package/dist/plugins/ratelimit/react/index.d.ts

@@ -0,0 +1,76 @@
+'use client';
+import { FunctionReference } from "convex/server";
+
+//#region src/plugins/ratelimit/types.d.ts
+type RateLimitSnapshot = {
+  value: number;
+  ts: number;
+  shard: number;
+  config: ResolvedAlgorithm;
+};
+type FixedWindowAlgorithm = {
+  kind: 'fixedWindow';
+  limit: number;
+  window: number;
+  capacity: number;
+  start?: number;
+  maxReserved?: number;
+  shards: number;
+};
+type SlidingWindowAlgorithm = {
+  kind: 'slidingWindow';
+  limit: number;
+  window: number;
+  maxReserved?: number;
+  shards: number;
+};
+type TokenBucketAlgorithm = {
+  kind: 'tokenBucket';
+  refillRate: number;
+  interval: number;
+  maxTokens: number;
+  maxReserved?: number;
+  shards: number;
+};
+type ResolvedAlgorithm = FixedWindowAlgorithm | SlidingWindowAlgorithm | TokenBucketAlgorithm;
+type HookCheckValue = {
+  value: number;
+  ts: number;
+  config: ResolvedAlgorithm;
+  shard: number;
+  ok: boolean;
+  retryAt?: number;
+};
+//#endregion
+//#region src/plugins/ratelimit/react/use-rate-limit.d.ts
+type GetRateLimitValueQueryRef = FunctionReference<'query', 'public', {
+  identifier?: string;
+  sampleShards?: number;
+}, RateLimitSnapshot>;
+type GetServerTimeMutationRef = FunctionReference<'mutation', 'public', Record<string, never>, number>;
+type GetRateLimitValueQuery = GetRateLimitValueQueryRef | string;
+type GetServerTimeMutation = GetServerTimeMutationRef | string;
+type UseRateLimitOptions = {
+  identifier?: string;
+  count?: number;
+  sampleShards?: number;
+  getServerTimeMutation?: GetServerTimeMutation;
+};
+declare function useRateLimit(getRateLimitValueQuery: GetRateLimitValueQuery, options?: UseRateLimitOptions): {
+  status: undefined;
+  check: (ts?: number, requestedCount?: number) => HookCheckValue | undefined;
+} | {
+  status: {
+    ok: false;
+    retryAt: number;
+  };
+  check: (ts?: number, requestedCount?: number) => HookCheckValue | undefined;
+} | {
+  status: {
+    ok: true;
+    retryAt: undefined;
+  };
+  check: (ts?: number, requestedCount?: number) => HookCheckValue | undefined;
+};
+//#endregion
+export { GetRateLimitValueQuery, GetRateLimitValueQueryRef, GetServerTimeMutation, GetServerTimeMutationRef, UseRateLimitOptions, useRateLimit };

package/dist/plugins/ratelimit/react/index.js

@@ -0,0 +1,294 @@
+'use client';
+import { c } from "react/compiler-runtime";
+import { useConvex, useQuery } from "convex/react";
+import { useEffect, useState } from "react";
+import { makeFunctionReference } from "convex/server";
+
+//#region src/plugins/ratelimit/core/calculate-rate-limit.ts
+function calculateRateLimit(state, algorithm, now, count) {
+	if (algorithm.kind === "fixedWindow") return calculateFixedWindow(state, algorithm, now, count);
+	if (algorithm.kind === "tokenBucket") return calculateTokenBucket(state, algorithm, now, count);
+	return calculateSlidingWindow(state, algorithm, now, count);
+}
+function calculateTokenBucket(state, config, now, count) {
+	const ratePerMs = config.refillRate / config.interval;
+	const initial = state ?? {
+		value: config.maxTokens,
+		ts: now
+	};
+	const elapsed = Math.max(0, now - initial.ts);
+	const nextValue = Math.min(initial.value + elapsed * ratePerMs, config.maxTokens) - count;
+	const retryAfter = nextValue < 0 ? Math.ceil(-nextValue / ratePerMs) : void 0;
+	return {
+		state: {
+			value: nextValue,
+			ts: now
+		},
+		retryAfter,
+		remaining: Math.max(0, Math.floor(nextValue)),
+		reset: retryAfter ? now + retryAfter : now,
+		limit: config.maxTokens
+	};
+}
+function calculateFixedWindow(state, config, now, count) {
+	const windowStart = alignWindowStart(now, config.window, config.start);
+	const initial = state ?? {
+		value: config.capacity,
+		ts: windowStart
+	};
+	const elapsedWindows = Math.max(0, Math.floor((now - initial.ts) / config.window));
+	const replenished = Math.min(initial.value + config.limit * elapsedWindows, config.capacity);
+	const ts = initial.ts + elapsedWindows * config.window;
+	const nextValue = replenished - count;
+	const retryAfter = nextValue < 0 ? ts + config.window * Math.ceil(-nextValue / config.limit) - now : void 0;
+	return {
+		state: {
+			value: nextValue,
+			ts
+		},
+		retryAfter,
+		remaining: Math.max(0, Math.floor(nextValue)),
+		reset: ts + config.window,
+		limit: config.limit
+	};
+}
+function calculateSlidingWindow(state, config, now, count) {
+	const windowStart = alignWindowStart(now, config.window);
+	const previousWindowStart = windowStart - config.window;
+	const elapsedInWindow = now - windowStart;
+	const previousWeight = Math.max(0, (config.window - elapsedInWindow) / config.window);
+	let currentCount = 0;
+	let previousCount = 0;
+	if (state) {
+		if (state.ts === windowStart) {
+			currentCount = Math.max(0, state.value);
+			if (state.auxTs === previousWindowStart) previousCount = Math.max(0, state.auxValue ?? 0);
+		} else if (state.ts === previousWindowStart) previousCount = Math.max(0, state.value);
+	}
+	const projectedCurrent = currentCount + count;
+	const projectedUsed = projectedCurrent + previousCount * previousWeight;
+	const remaining = config.limit - projectedUsed;
+	const retryAfter = remaining < 0 ? Math.max(1, config.window - elapsedInWindow) : void 0;
+	return {
+		state: {
+			value: projectedCurrent,
+			ts: windowStart,
+			auxValue: previousCount,
+			auxTs: previousWindowStart
+		},
+		retryAfter,
+		remaining: Math.max(0, Math.floor(remaining)),
+		reset: windowStart + config.window,
+		limit: config.limit
+	};
+}
+function alignWindowStart(now, window, start = 0) {
+	const offsetNow = now - start;
+	return start + Math.floor(offsetNow / window) * window;
+}
+
+//#endregion
+//#region src/plugins/ratelimit/react/use-rate-limit.ts
+function useRateLimit(getRateLimitValueQuery, options) {
+	const $ = c(38);
+	const [timeOffset, setTimeOffset] = useState(0);
+	const [now, setNow] = useState(_temp);
+	const convex = useConvex();
+	let t0;
+	if ($[0] !== getRateLimitValueQuery) {
+		t0 = resolveGetRateLimitValueQuery(getRateLimitValueQuery);
+		$[0] = getRateLimitValueQuery;
+		$[1] = t0;
+	} else t0 = $[1];
+	const getRateLimitValueQueryRef = t0;
+	let t1;
+	if ($[2] !== options) {
+		t1 = options ?? {};
+		$[2] = options;
+		$[3] = t1;
+	} else t1 = $[3];
+	const { getServerTimeMutation, count, identifier, sampleShards } = t1;
+	let t2;
+	if ($[4] !== getServerTimeMutation) {
+		t2 = getServerTimeMutation ? resolveGetServerTimeMutation(getServerTimeMutation) : void 0;
+		$[4] = getServerTimeMutation;
+		$[5] = t2;
+	} else t2 = $[5];
+	const getServerTimeMutationRef = t2;
+	let t3;
+	let t4;
+	if ($[6] !== convex || $[7] !== getServerTimeMutationRef) {
+		t3 = () => {
+			if (!getServerTimeMutationRef) return;
+			const clientTime = Date.now();
+			convex.mutation(getServerTimeMutationRef, {}).then((serverTime) => {
+				const latency = Date.now() - clientTime;
+				setTimeOffset(serverTime - clientTime - latency / 2);
+			});
+		};
+		t4 = [convex, getServerTimeMutationRef];
+		$[6] = convex;
+		$[7] = getServerTimeMutationRef;
+		$[8] = t3;
+		$[9] = t4;
+	} else {
+		t3 = $[8];
+		t4 = $[9];
+	}
+	useEffect(t3, t4);
+	let t5;
+	if ($[10] !== identifier || $[11] !== sampleShards) {
+		t5 = {
+			identifier,
+			sampleShards
+		};
+		$[10] = identifier;
+		$[11] = sampleShards;
+		$[12] = t5;
+	} else t5 = $[12];
+	const rateLimitData = useQuery(getRateLimitValueQueryRef, t5);
+	let t6;
+	if ($[13] !== count || $[14] !== rateLimitData || $[15] !== timeOffset) {
+		t6 = (ts, requestedCount) => {
+			if (!rateLimitData) return;
+			const serverTs = (ts ?? Date.now()) + timeOffset;
+			const evaluation = evaluateSnapshot(rateLimitData, serverTs, requestedCount ?? count ?? 1);
+			return {
+				value: evaluation.value,
+				ts: evaluation.ts - timeOffset,
+				config: rateLimitData.config,
+				shard: rateLimitData.shard,
+				ok: evaluation.value >= 0,
+				retryAt: evaluation.retryAfter ? serverTs + evaluation.retryAfter - timeOffset : void 0
+			};
+		};
+		$[13] = count;
+		$[14] = rateLimitData;
+		$[15] = timeOffset;
+		$[16] = t6;
+	} else t6 = $[16];
+	const check = t6;
+	const t7 = count ?? 1;
+	let t8;
+	if ($[17] !== check || $[18] !== now || $[19] !== t7) {
+		t8 = check(now, t7);
+		$[17] = check;
+		$[18] = now;
+		$[19] = t7;
+		$[20] = t8;
+	} else t8 = $[20];
+	const current = t8;
+	let t9;
+	bb0: {
+		if (!current) {
+			let t10;
+			if ($[21] !== check) {
+				t10 = {
+					status: void 0,
+					check
+				};
+				$[21] = check;
+				$[22] = t10;
+			} else t10 = $[22];
+			t9 = t10;
+			break bb0;
+		}
+		if (current.value < 0) {
+			let t10;
+			if ($[23] !== current.retryAt) {
+				t10 = {
+					ok: false,
+					retryAt: current.retryAt
+				};
+				$[23] = current.retryAt;
+				$[24] = t10;
+			} else t10 = $[24];
+			let t11;
+			if ($[25] !== check || $[26] !== t10) {
+				t11 = {
+					status: t10,
+					check
+				};
+				$[25] = check;
+				$[26] = t10;
+				$[27] = t11;
+			} else t11 = $[27];
+			t9 = t11;
+			break bb0;
+		}
+		let t10;
+		if ($[28] === Symbol.for("react.memo_cache_sentinel")) {
+			t10 = {
+				ok: true,
+				retryAt: void 0
+			};
+			$[28] = t10;
+		} else t10 = $[28];
+		let t11;
+		if ($[29] !== check) {
+			t11 = {
+				status: t10,
+				check
+			};
+			$[29] = check;
+			$[30] = t11;
+		} else t11 = $[30];
+		t9 = t11;
+	}
+	const response = t9;
+	let t10;
+	if ($[31] !== now || $[32] !== response.status) {
+		t10 = () => {
+			if (response.status?.ok !== false || !response.status.retryAt) return;
+			const timeout = setTimeout(() => setNow(Date.now()), Math.max(0, response.status.retryAt - now));
+			return () => clearTimeout(timeout);
+		};
+		$[31] = now;
+		$[32] = response.status;
+		$[33] = t10;
+	} else t10 = $[33];
+	const t11 = response.status?.ok;
+	const t12 = response.status?.retryAt;
+	let t13;
+	if ($[34] !== now || $[35] !== t11 || $[36] !== t12) {
+		t13 = [
+			now,
+			t11,
+			t12
+		];
+		$[34] = now;
+		$[35] = t11;
+		$[36] = t12;
+		$[37] = t13;
+	} else t13 = $[37];
+	useEffect(t10, t13);
+	return response;
+}
+function _temp() {
+	return Date.now();
+}
+function resolveGetRateLimitValueQuery(ref) {
+	if (typeof ref === "string") return makeFunctionReference(ref);
+	return ref;
+}
+function resolveGetServerTimeMutation(ref) {
+	if (typeof ref === "string") return makeFunctionReference(ref);
+	return ref;
+}
+function evaluateSnapshot(snapshot, now, count) {
+	const evaluated = calculateRateLimit(snapshot.config.kind === "slidingWindow" ? {
+		value: Math.max(0, snapshot.config.limit - snapshot.value),
+		ts: snapshot.ts
+	} : {
+		value: snapshot.value,
+		ts: snapshot.ts
+	}, snapshot.config, now, count);
+	return {
+		value: snapshot.config.kind === "slidingWindow" ? evaluated.retryAfter !== void 0 ? -1 : evaluated.remaining : evaluated.state.value,
+		ts: evaluated.state.ts,
+		retryAfter: evaluated.retryAfter
+	};
+}
+
+//#endregion
+export { useRateLimit };

package/dist/{procedure-caller-CcjtUFvL.d.ts → procedure-caller-DYjpq7rG.d.ts}

@@ -1,7 +1,8 @@
-import { C as HttpProcedure, D as ProcedureMeta, G as DataTransformerOptions, N as MiddlewareBuilder, O as AnyMiddleware, P as MiddlewareFunction, Q as getTransformer, R as Overwrite$1, S as HttpMethod, V as UnsetMarker, c as InferHttpInput, d as CRPCHttpRouter, j as IntersectIfDefined, l as InferHttpOutput, p as HttpRouterRecord, w as HttpProcedureBuilderDef, x as HttpHandlerOpts } from "./http-types-BCf2wCgp.js";
-import { ConvexError, GenericId, GenericValidator, Infer, ObjectType, OptionalProperty, PropertyValidators, VAny, VArray, VBoolean, VBytes, VFloat64, VId, VInt64, VLiteral, VNull, VObject, VOptional, VRecord, VString, VUnion, Validator, v } from "convex/values";
+import { t as VRequired } from "./validators-BcQFm1oY.js";
+import { C as HttpProcedure, D as ProcedureMeta, G as DataTransformerOptions, N as MiddlewareBuilder, O as AnyMiddleware, P as MiddlewareFunction, Q as getTransformer, R as Overwrite$1, S as HttpMethod, V as UnsetMarker, c as InferHttpInput, d as CRPCHttpRouter, j as IntersectIfDefined, l as InferHttpOutput, p as HttpRouterRecord, w as HttpProcedureBuilderDef, x as HttpHandlerOpts } from "./http-types-BK7FuIcR.js";
+import { ConvexError, GenericId, GenericValidator, ObjectType, OptionalProperty, PropertyValidators, VAny, VArray, VBoolean, VBytes, VFloat64, VId, VInt64, VLiteral, VNull, VObject, VOptional, VRecord, VString, VUnion, Validator } from "convex/values";
 import * as convex_server0 from "convex/server";
-import { ActionBuilder, ArgsArrayToObject, DefaultFunctionArgs, FunctionReference, FunctionReturnType, FunctionVisibility, GenericActionCtx, GenericDataModel, GenericDatabaseReader, GenericMutationCtx, GenericQueryCtx, MutationBuilder, QueryBuilder, RegisteredAction, RegisteredMutation, RegisteredQuery, SchemaDefinition, TableNamesInDataModel } from "convex/server";
+import { ActionBuilder, ArgsArrayToObject, DefaultFunctionArgs, FunctionReference, FunctionReturnType, FunctionVisibility, GenericActionCtx, GenericDataModel, GenericMutationCtx, GenericQueryCtx, MutationBuilder, QueryBuilder, RegisteredAction, RegisteredMutation, RegisteredQuery, TableNamesInDataModel } from "convex/server";
 import * as z$1 from "zod/v4";
 import * as zCore from "zod/v4/core";
 import { z } from "zod";
@@ -16,22 +17,6 @@ type EmptyObject = Record<string, never>;
  */
 type Expand<ObjectType extends Record<any, any>> = ObjectType extends Record<any, any> ? { [Key in keyof ObjectType]: ObjectType[Key] } : never;
 //#endregion
-//#region src/internal/upstream/validators.d.ts
-type NotUndefined$1<T> = Exclude<T, undefined>;
-/**
- * A type that converts an optional validator to a required validator.
- *
- * This is the inverse of `VOptional`. It takes a validator that may be optional
- * and returns the equivalent required validator type.
- *
- * @example
- * ```ts
- * type OptionalString = VOptional<VString<string, "required">>;
- * type RequiredString = VRequired<OptionalString>; // VString<string, "required">
- * ```
- */
-type VRequired<T extends Validator<any, OptionalProperty, any>> = T extends VId<infer Type, OptionalProperty> ? VId<NotUndefined$1<Type>, 'required'> : T extends VString<infer Type, OptionalProperty> ? VString<NotUndefined$1<Type>, 'required'> : T extends VFloat64<infer Type, OptionalProperty> ? VFloat64<NotUndefined$1<Type>, 'required'> : T extends VInt64<infer Type, OptionalProperty> ? VInt64<NotUndefined$1<Type>, 'required'> : T extends VBoolean<infer Type, OptionalProperty> ? VBoolean<NotUndefined$1<Type>, 'required'> : T extends VNull<infer Type, OptionalProperty> ? VNull<NotUndefined$1<Type>, 'required'> : T extends VAny<infer Type, OptionalProperty> ? VAny<NotUndefined$1<Type>, 'required'> : T extends VLiteral<infer Type, OptionalProperty> ? VLiteral<NotUndefined$1<Type>, 'required'> : T extends VBytes<infer Type, OptionalProperty> ? VBytes<NotUndefined$1<Type>, 'required'> : T extends VObject<infer Type, infer Fields, OptionalProperty, infer FieldPaths> ? VObject<NotUndefined$1<Type>, Fields, 'required', FieldPaths> : T extends VArray<infer Type, infer Element, OptionalProperty> ? VArray<NotUndefined$1<Type>, Element, 'required'> : T extends VRecord<infer Type, infer Key, infer Value, OptionalProperty, infer FieldPaths> ? VRecord<NotUndefined$1<Type>, Key, Value, 'required', FieldPaths> : T extends VUnion<infer Type, infer Members, OptionalProperty, infer FieldPaths> ? VUnion<NotUndefined$1<Type>, Members, 'required', FieldPaths> : never;
-//#endregion
 //#region src/internal/upstream/server/customFunctions.d.ts
 /**
  * A customization of a query, mutation, or action.

package/dist/rsc/index.d.ts

@@ -1,6 +1,6 @@
-import { o as Simplify, r as DistributiveOmit } from "../types-DwGkkq2s.js";
-import { C as HttpProcedure, G as DataTransformerOptions, V as UnsetMarker, d as CRPCHttpRouter, p as HttpRouterRecord } from "../http-types-BCf2wCgp.js";
-import { n as CRPCClient } from "../types-CIBGEYXq.js";
+import { o as Simplify, r as DistributiveOmit } from "../types-BTb_4BaU.js";
+import { C as HttpProcedure, G as DataTransformerOptions, V as UnsetMarker, d as CRPCHttpRouter, p as HttpRouterRecord } from "../http-types-BK7FuIcR.js";
+import { n as CRPCClient } from "../types-f53SgpBL.js";
 import { DefaultError, QueryFilters, UseMutationOptions, UseQueryOptions } from "@tanstack/react-query";
 import { z } from "zod";
 

package/dist/rsc/index.js

@@ -1,7 +1,7 @@
-import { n as defaultIsUnauthorized } from "../error-Be4OcwwD.js";
-import { n as getFuncRef, r as getFunctionMeta, t as buildMetaIndex } from "../meta-utils-DDVYp9Xf.js";
-import { i as decodeWire, s as getTransformer } from "../transformer-Dh0w2py0.js";
-import { n as convexInfiniteQueryOptions, r as convexQuery } from "../query-options-B0c1b6pZ.js";
+import { n as defaultIsUnauthorized } from "../error-CAGGSN5H.js";
+import { n as getFuncRef, r as getFunctionMeta, t as buildMetaIndex } from "../meta-utils-NRyocOSc.js";
+import { i as decodeWire, s as getTransformer } from "../transformer-ogg-4d78.js";
+import { n as convexInfiniteQueryOptions, r as convexQuery } from "../query-options-CSCmKYdJ.js";
 import { convexToJson } from "convex/values";
 import { getFunctionName } from "convex/server";
 import { fetchAction, fetchQuery } from "convex/nextjs";