better-convex 0.7.2 → 0.8.0

package/dist/plugins/index.d.ts

@@ -0,0 +1,9 @@
+import { ni as OrmSchemaPlugin } from "../where-clause-compiler-BIjTkVVJ.js";
+
+//#region src/orm/migrations/schema.d.ts
+declare function migrationPlugin(): OrmSchemaPlugin;
+//#endregion
+//#region src/orm/aggregate-index/schema.d.ts
+declare function aggregatePlugin(): OrmSchemaPlugin;
+//#endregion
+export { aggregatePlugin, migrationPlugin };

package/dist/plugins/index.js

@@ -0,0 +1,3 @@
+import { c as aggregatePlugin, r as migrationPlugin } from "../schema-Bx6j2doh.js";
+
+export { aggregatePlugin, migrationPlugin };

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

@@ -0,0 +1,222 @@
+import { ni as OrmSchemaPlugin } from "../../where-clause-compiler-BIjTkVVJ.js";
+import * as convex_server0 from "convex/server";
+
+//#region src/plugins/ratelimit/duration.d.ts
+type DurationUnit = 'ms' | 's' | 'm' | 'h' | 'd';
+type DurationString = `${number} ${DurationUnit}` | `${number}${DurationUnit}`;
+type Duration = number | DurationString;
+declare function toMs(duration: Duration): number;
+//#endregion
+//#region src/plugins/ratelimit/types.d.ts
+type RatelimitReason = 'timeout' | 'cacheBlock' | 'denyList';
+type RatelimitResponse = {
+  success: boolean;
+  ok: boolean;
+  limit: number;
+  remaining: number;
+  reset: number;
+  pending: Promise<unknown>;
+  reason?: RatelimitReason;
+  deniedValue?: string;
+};
+type RemainingResponse = {
+  remaining: number;
+  reset: number;
+  limit: number;
+};
+type DynamicLimitResponse = {
+  dynamicLimit: number | null;
+};
+type RateLimitState = {
+  value: number;
+  ts: number;
+  auxValue?: number;
+  auxTs?: number;
+};
+type RateLimitSnapshot = {
+  value: number;
+  ts: number;
+  shard: number;
+  config: ResolvedAlgorithm;
+};
+type BaseAlgorithmOptions = {
+  shards?: number;
+  maxReserved?: number;
+};
+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 AlgorithmOptions = BaseAlgorithmOptions & {
+  capacity?: number;
+  start?: number;
+};
+type LimitRequest = {
+  rate?: number;
+  count?: number;
+  reserve?: boolean;
+  ip?: string;
+  userAgent?: string;
+  country?: string;
+  geo?: unknown;
+};
+type CheckRequest = Omit<LimitRequest, 'reserve'> & {
+  reserve?: boolean;
+};
+type FailureMode = 'closed' | 'open';
+type ProtectionLists = {
+  identifiers?: readonly string[];
+  ips?: readonly string[];
+  userAgents?: readonly string[];
+  countries?: readonly string[];
+};
+type RatelimitConfig = {
+  db?: ConvexRateLimitDbReader | ConvexRateLimitDbWriter;
+  limiter: ResolvedAlgorithm;
+  prefix?: string;
+  dynamicLimits?: boolean;
+  ephemeralCache?: Map<string, number> | false;
+  timeout?: number;
+  failureMode?: FailureMode;
+  enableProtection?: boolean;
+  denyListThreshold?: number;
+  denyList?: ProtectionLists;
+};
+type RateLimitRow = {
+  _id: string;
+  _creationTime?: number;
+  name: string;
+  key?: string;
+  shard: number;
+  value: number;
+  ts: number;
+  auxValue?: number;
+  auxTs?: number;
+};
+type ConvexQueryBuilder = {
+  withIndex: (name: any, cb: any) => {
+    unique: () => Promise<any>;
+    collect: () => Promise<any[]>;
+  };
+};
+type ConvexRateLimitDbReader = {
+  query: (tableName: string) => ConvexQueryBuilder;
+};
+type ConvexRateLimitDbWriter = ConvexRateLimitDbReader & {
+  insert: (...args: any[]) => Promise<any>;
+  patch: (...args: any[]) => Promise<void>;
+  delete: (...args: any[]) => Promise<void>;
+};
+type HookAPIOptions = {
+  identifier?: string | ((ctx: unknown, fromClient?: string) => string | Promise<string>);
+  sampleShards?: number;
+};
+type HookCheckValue = {
+  value: number;
+  ts: number;
+  config: ResolvedAlgorithm;
+  shard: number;
+  ok: boolean;
+  retryAt?: number;
+};
+//#endregion
+//#region src/plugins/ratelimit/core/algorithms.d.ts
+declare function fixedWindow(limit: number, window: Duration, options?: AlgorithmOptions): FixedWindowAlgorithm;
+declare function slidingWindow(limit: number, window: Duration, options?: AlgorithmOptions): SlidingWindowAlgorithm;
+declare function tokenBucket(refillRate: number, interval: Duration, maxTokens: number, options?: AlgorithmOptions): TokenBucketAlgorithm;
+declare function applyDynamicLimit(algorithm: ResolvedAlgorithm, dynamicLimit: number | null): ResolvedAlgorithm;
+//#endregion
+//#region src/plugins/ratelimit/core/calculate-rate-limit.d.ts
+type EvaluationResult = {
+  state: RateLimitState;
+  retryAfter?: number;
+  remaining: number;
+  reset: number;
+  limit: number;
+};
+declare function calculateRateLimit(state: RateLimitState | null, algorithm: ResolvedAlgorithm, now: number, count: number): EvaluationResult;
+//#endregion
+//#region src/plugins/ratelimit/ratelimit.d.ts
+declare class Ratelimit {
+  private readonly config;
+  static fixedWindow: typeof fixedWindow;
+  static slidingWindow: typeof slidingWindow;
+  static tokenBucket: typeof tokenBucket;
+  private readonly store;
+  private readonly prefix;
+  private readonly timeout;
+  private readonly dynamicLimits;
+  private readonly failureMode;
+  private readonly enableProtection;
+  private readonly denyListThreshold;
+  private readonly denyList?;
+  private readonly limiter;
+  private readonly blockCache?;
+  private readonly blockCacheSource?;
+  private readonly checkCache;
+  constructor(config: RatelimitConfig);
+  limit(identifier: string, request?: LimitRequest): Promise<RatelimitResponse>;
+  check(identifier: string, request?: CheckRequest): Promise<RatelimitResponse>;
+  blockUntilReady(identifier: string, timeoutMs: number): Promise<RatelimitResponse>;
+  resetUsedTokens(identifier: string): Promise<void>;
+  getRemaining(identifier: string): Promise<RemainingResponse>;
+  getValue(identifier: string, options?: {
+    sampleShards?: number;
+  }): Promise<RateLimitSnapshot>;
+  setDynamicLimit(options: {
+    limit: number | false;
+  }): Promise<void>;
+  getDynamicLimit(): Promise<DynamicLimitResponse>;
+  hookAPI(options?: HookAPIOptions): {
+    getRateLimit: convex_server0.RegisteredQuery<"public", {
+      identifier?: string | undefined;
+      sampleShards?: number | undefined;
+    }, Promise<RateLimitSnapshot>>;
+    getServerTime: convex_server0.RegisteredMutation<"public", {}, Promise<number>>;
+  };
+  private withDb;
+  private evaluate;
+  private evaluateCandidates;
+  private resolveAlgorithm;
+  private rawLimit;
+  private runWithTimeout;
+  private timeoutResponse;
+}
+//#endregion
+//#region src/plugins/ratelimit/schema.d.ts
+declare function ratelimitPlugin(): OrmSchemaPlugin;
+//#endregion
+//#region src/plugins/ratelimit/store/convex-store.d.ts
+declare const RATE_LIMIT_STATE_TABLE = "ratelimit_state";
+declare const RATE_LIMIT_DYNAMIC_TABLE = "ratelimit_dynamic_limit";
+declare const RATE_LIMIT_HIT_TABLE = "ratelimit_protection_hit";
+//#endregion
+//#region src/plugins/ratelimit/index.d.ts
+declare const SECOND = 1000;
+declare const MINUTE: number;
+declare const HOUR: number;
+declare const DAY: number;
+declare const WEEK: number;
+//#endregion
+export { type CheckRequest, type ConvexQueryBuilder, type ConvexRateLimitDbReader, type ConvexRateLimitDbWriter, DAY, type Duration, type DurationString, type DurationUnit, type DynamicLimitResponse, type FixedWindowAlgorithm, HOUR, type HookAPIOptions, type HookCheckValue, type LimitRequest, MINUTE, RATE_LIMIT_DYNAMIC_TABLE, RATE_LIMIT_HIT_TABLE, RATE_LIMIT_STATE_TABLE, type RateLimitRow, type RateLimitSnapshot, type RateLimitState, Ratelimit, type RatelimitConfig, type RatelimitReason, type RatelimitResponse, type RemainingResponse, type ResolvedAlgorithm, SECOND, type SlidingWindowAlgorithm, type TokenBucketAlgorithm, WEEK, applyDynamicLimit, calculateRateLimit, fixedWindow, ratelimitPlugin, slidingWindow, toMs, tokenBucket };