better-convex 0.7.2 → 0.7.3

package/dist/{procedure-caller-CcjtUFvL.d.ts → procedure-caller-Cj_lgUev.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-BDrWGp4M.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-BsnDV7Je.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-kgwiK-xe.js";
+import { C as HttpProcedure, G as DataTransformerOptions, V as UnsetMarker, d as CRPCHttpRouter, p as HttpRouterRecord } from "../http-types-BsnDV7Je.js";
+import { n as CRPCClient } from "../types-DZFvhoPJ.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-C7AOPlv2.js";
+import { n as getFuncRef, r as getFunctionMeta, t as buildMetaIndex } from "../meta-utils-C9_6WIzj.js";
+import { i as decodeWire, s as getTransformer } from "../transformer-BsX4RWes.js";
+import { n as convexInfiniteQueryOptions, r as convexQuery } from "../query-options-Bjo6j5cC.js";
 import { convexToJson } from "convex/values";
 import { getFunctionName } from "convex/server";
 import { fetchAction, fetchQuery } from "convex/nextjs";

package/dist/server/index.d.ts

@@ -1,3 +1,3 @@
-import { $ as QueryProcedureBuilder, A as GenericCtx, B as ConvexContext, C as CRPC_ERROR_CODE_TO_HTTP, Ct as zodToConvex, D as toCRPCError, E as isCRPCError, F as isRunMutationCtx, G as CallerOpts, H as LazyCaller, I as requireActionCtx, J as createApiLeaf, K as ServerCaller, L as requireMutationCtx, M as isActionCtx, N as isMutationCtx, O as CreateEnvOptions, P as isQueryCtx, Q as ProcedureBuilder, R as requireQueryCtx, S as CRPC_ERROR_CODES_BY_KEY, St as zodOutputToConvexFields, T as getHTTPStatusCodeFromError, U as createLazyCaller, V as createCallerFactory, W as CallerMeta, X as CRPCFunctionTypeHint, Y as ActionProcedureBuilder, Z as MutationProcedureBuilder, _ as WithHttpRouter, _t as zCustomAction, a as ProcedureCaller, at as handleHttpError, b as CRPCError, bt as zid, c as ProcedureFromFunctionReference, ct as ConvexValidatorFromZodOutput, d as createGenericCallerFactory, dt as Zid, et as createMiddlewareFactory, f as createGenericHandlerFactory, ft as ZodFromValidatorBase, g as typedProcedureResolver, gt as withSystemFields, h as defineProcedure, ht as convexToZodFields, i as ProcedureActionCallerFromRegistry, it as extractPathParams, j as RunMutationCtx, k as createEnv, l as ProcedureSchedulableCallerFromRegistry, lt as CustomBuilder, m as createProcedureHandlerFactory, mt as convexToZod, n as GeneratedProcedureRegistry, nt as HttpProcedureBuilder, o as ProcedureCallerFromRegistry, ot as matchPathParams, p as createProcedureCallerFactory, pt as ZodValidatorFromConvex, q as createServerCaller, r as GeneratedProcedureRegistryEntry, rt as createHttpProcedureBuilder, s as ProcedureDefinition, st as ConvexValidatorFromZod, t as CreateProcedureCallerFactoryOptions, tt as initCRPC, u as ProcedureScheduleCallerFromRegistry, ut as ZCustomCtx, v as inferApiInputs, vt as zCustomMutation, w as getCRPCErrorFromUnknown, wt as zodToConvexFields, x as CRPCErrorCode, xt as zodOutputToConvex, y as inferApiOutputs, yt as zCustomQuery, z as requireRunMutationCtx } from "../procedure-caller-CcjtUFvL.js";
-import { A as GetRawInputFn, B as Simplify, C as HttpProcedure, D as ProcedureMeta, E as InferHttpInput, F as MiddlewareMarker, I as MiddlewareNext, L as MiddlewareResult, M as MergeZodObjects, N as MiddlewareBuilder, O as AnyMiddleware, P as MiddlewareFunction, R as Overwrite, S as HttpMethod, T as HttpRouteDefinition, V as UnsetMarker, _ as extractRouteMap, b as HttpActionHandler, d as CRPCHttpRouter, f as HttpRouterDef, g as createHttpRouterFactory, h as createHttpRouter, j as IntersectIfDefined, k as AnyMiddlewareBuilder, m as HttpRouterWithHono, p as HttpRouterRecord, v as CRPCHonoHandler, w as HttpProcedureBuilderDef, x as HttpHandlerOpts, y as HttpActionConstructor, z as ResolveIfSet } from "../http-types-BCf2wCgp.js";
+import { $ as QueryProcedureBuilder, A as GenericCtx, B as ConvexContext, C as CRPC_ERROR_CODE_TO_HTTP, Ct as zodToConvex, D as toCRPCError, E as isCRPCError, F as isRunMutationCtx, G as CallerOpts, H as LazyCaller, I as requireActionCtx, J as createApiLeaf, K as ServerCaller, L as requireMutationCtx, M as isActionCtx, N as isMutationCtx, O as CreateEnvOptions, P as isQueryCtx, Q as ProcedureBuilder, R as requireQueryCtx, S as CRPC_ERROR_CODES_BY_KEY, St as zodOutputToConvexFields, T as getHTTPStatusCodeFromError, U as createLazyCaller, V as createCallerFactory, W as CallerMeta, X as CRPCFunctionTypeHint, Y as ActionProcedureBuilder, Z as MutationProcedureBuilder, _ as WithHttpRouter, _t as zCustomAction, a as ProcedureCaller, at as handleHttpError, b as CRPCError, bt as zid, c as ProcedureFromFunctionReference, ct as ConvexValidatorFromZodOutput, d as createGenericCallerFactory, dt as Zid, et as createMiddlewareFactory, f as createGenericHandlerFactory, ft as ZodFromValidatorBase, g as typedProcedureResolver, gt as withSystemFields, h as defineProcedure, ht as convexToZodFields, i as ProcedureActionCallerFromRegistry, it as extractPathParams, j as RunMutationCtx, k as createEnv, l as ProcedureSchedulableCallerFromRegistry, lt as CustomBuilder, m as createProcedureHandlerFactory, mt as convexToZod, n as GeneratedProcedureRegistry, nt as HttpProcedureBuilder, o as ProcedureCallerFromRegistry, ot as matchPathParams, p as createProcedureCallerFactory, pt as ZodValidatorFromConvex, q as createServerCaller, r as GeneratedProcedureRegistryEntry, rt as createHttpProcedureBuilder, s as ProcedureDefinition, st as ConvexValidatorFromZod, t as CreateProcedureCallerFactoryOptions, tt as initCRPC, u as ProcedureScheduleCallerFromRegistry, ut as ZCustomCtx, v as inferApiInputs, vt as zCustomMutation, w as getCRPCErrorFromUnknown, wt as zodToConvexFields, x as CRPCErrorCode, xt as zodOutputToConvex, y as inferApiOutputs, yt as zCustomQuery, z as requireRunMutationCtx } from "../procedure-caller-Cj_lgUev.js";
+import { A as GetRawInputFn, B as Simplify, C as HttpProcedure, D as ProcedureMeta, E as InferHttpInput, F as MiddlewareMarker, I as MiddlewareNext, L as MiddlewareResult, M as MergeZodObjects, N as MiddlewareBuilder, O as AnyMiddleware, P as MiddlewareFunction, R as Overwrite, S as HttpMethod, T as HttpRouteDefinition, V as UnsetMarker, _ as extractRouteMap, b as HttpActionHandler, d as CRPCHttpRouter, f as HttpRouterDef, g as createHttpRouterFactory, h as createHttpRouter, j as IntersectIfDefined, k as AnyMiddlewareBuilder, m as HttpRouterWithHono, p as HttpRouterRecord, v as CRPCHonoHandler, w as HttpProcedureBuilderDef, x as HttpHandlerOpts, y as HttpActionConstructor, z as ResolveIfSet } from "../http-types-BsnDV7Je.js";
 export { ActionProcedureBuilder, AnyMiddleware, AnyMiddlewareBuilder, CRPCError, CRPCErrorCode, CRPCFunctionTypeHint, CRPCHonoHandler, CRPCHttpRouter, CRPC_ERROR_CODES_BY_KEY, CRPC_ERROR_CODE_TO_HTTP, CallerMeta, CallerOpts, ConvexContext, ConvexValidatorFromZod, ConvexValidatorFromZodOutput, CreateEnvOptions, CreateProcedureCallerFactoryOptions, CustomBuilder, GeneratedProcedureRegistry, GeneratedProcedureRegistryEntry, GenericCtx, GetRawInputFn, HttpActionConstructor, HttpActionHandler, HttpHandlerOpts, HttpMethod, HttpProcedure, HttpProcedureBuilder, HttpProcedureBuilderDef, HttpRouteDefinition, HttpRouterDef, HttpRouterRecord, HttpRouterWithHono, InferHttpInput, IntersectIfDefined, LazyCaller, MergeZodObjects, MiddlewareBuilder, MiddlewareFunction, MiddlewareMarker, MiddlewareNext, MiddlewareResult, MutationProcedureBuilder, Overwrite, ProcedureActionCallerFromRegistry, ProcedureBuilder, ProcedureCaller, ProcedureCallerFromRegistry, ProcedureDefinition, ProcedureFromFunctionReference, ProcedureMeta, ProcedureSchedulableCallerFromRegistry, ProcedureScheduleCallerFromRegistry, QueryProcedureBuilder, ResolveIfSet, RunMutationCtx, ServerCaller, Simplify, UnsetMarker, WithHttpRouter, ZCustomCtx, Zid, ZodFromValidatorBase, ZodValidatorFromConvex, convexToZod, convexToZodFields, createApiLeaf, createCallerFactory, createEnv, createGenericCallerFactory, createGenericHandlerFactory, createHttpProcedureBuilder, createHttpRouter, createHttpRouterFactory, createLazyCaller, createMiddlewareFactory, createProcedureCallerFactory, createProcedureHandlerFactory, createServerCaller, defineProcedure, extractPathParams, extractRouteMap, getCRPCErrorFromUnknown, getHTTPStatusCodeFromError, handleHttpError, inferApiInputs, inferApiOutputs, initCRPC, isActionCtx, isCRPCError, isMutationCtx, isQueryCtx, isRunMutationCtx, matchPathParams, requireActionCtx, requireMutationCtx, requireQueryCtx, requireRunMutationCtx, toCRPCError, typedProcedureResolver, withSystemFields, zCustomAction, zCustomMutation, zCustomQuery, zid, zodOutputToConvex, zodOutputToConvexFields, zodToConvex, zodToConvexFields };

package/dist/server/index.js

@@ -1,6 +1,7 @@
-import { c as isMutationCtx, d as requireActionCtx, f as requireMutationCtx, g as pick, i as addFieldsToValidator, l as isQueryCtx, m as requireRunMutationCtx, n as customCtx, o as vRequired, p as requireQueryCtx, s as isActionCtx, t as NoOp, u as isRunMutationCtx } from "../customFunctions-CZnCwoR3.js";
-import { i as decodeWire, o as encodeWire, s as getTransformer } from "../transformer-Dh0w2py0.js";
-import { n as createLazyCaller, r as createServerCaller, t as createCallerFactory } from "../caller-factory-D3OuR1eI.js";
+import { l as pick, o as vRequired, t as addFieldsToValidator } from "../validators-B7oIJCAp.js";
+import { a as isMutationCtx, c as requireActionCtx, d as requireRunMutationCtx, i as isActionCtx, l as requireMutationCtx, n as customCtx, o as isQueryCtx, s as isRunMutationCtx, t as NoOp, u as requireQueryCtx } from "../customFunctions-C_i_0joT.js";
+import { i as decodeWire, o as encodeWire, s as getTransformer } from "../transformer-BsX4RWes.js";
+import { n as createLazyCaller, r as createServerCaller, t as createCallerFactory } from "../caller-factory-4uND4vnj.js";
 import { ConvexError, v } from "convex/values";
 import { HttpRouter, actionGeneric, getFunctionName, httpActionGeneric, internalActionGeneric, internalMutationGeneric, internalQueryGeneric, makeFunctionReference, mutationGeneric, queryGeneric } from "convex/server";
 import * as z$1 from "zod/v4";

package/dist/{types-CIBGEYXq.d.ts → types-DZFvhoPJ.d.ts}

@@ -1,4 +1,4 @@
-import { n as DeepPartial, o as Simplify, r as DistributiveOmit } from "./types-DwGkkq2s.js";
+import { n as DeepPartial, o as Simplify, r as DistributiveOmit } from "./types-kgwiK-xe.js";
 import { FunctionArgs, FunctionReference, FunctionReturnType } from "convex/server";
 import { DefaultError, QueryFilters, SkipToken, UseMutationOptions, UseQueryOptions } from "@tanstack/react-query";
 import { Watch, WatchQueryOptions } from "convex/react";

package/dist/{customFunctions-CZnCwoR3.js → validators-B7oIJCAp.js}

@@ -82,29 +82,6 @@ function assert(value, message) {
 	if (!value) throw new Error(typeof message === "function" ? message() : message);
 }
 
-//#endregion
-//#region src/server/context-utils.ts
-const isQueryCtx = (ctx) => "db" in ctx;
-const isMutationCtx = (ctx) => "db" in ctx && "scheduler" in ctx;
-const isActionCtx = (ctx) => "runAction" in ctx;
-const isRunMutationCtx = (ctx) => "runMutation" in ctx;
-const requireQueryCtx = (ctx) => {
-	if (!isQueryCtx(ctx)) throw new Error("Query context required");
-	return ctx;
-};
-const requireMutationCtx = (ctx) => {
-	if (!isMutationCtx(ctx)) throw new Error("Mutation context required");
-	return ctx;
-};
-const requireActionCtx = (ctx) => {
-	if (!isActionCtx(ctx)) throw new Error("Action context required");
-	return ctx;
-};
-const requireRunMutationCtx = (ctx) => {
-	if (!isRunMutationCtx(ctx)) throw new Error("Mutation or action context required");
-	return ctx;
-};
-
 //#endregion
 //#region src/internal/upstream/validators.ts
 function partial(fieldsOrObjOrUnion) {
@@ -193,6 +170,72 @@ function intersectValidators(fields, fields2) {
 }
 /** Mark fields as deprecated with this permissive validator typed as null */
 const deprecated = v.optional(v.any());
+/** A maximally permissive validator that type checks as a given validator.
+*
+* If you want to have types that match some validator but you have invalid data
+* and you want to temporarily not validate schema for this field,
+* you can use this function to cast the permissive validator.
+*
+* Example in a schema:
+* ```ts
+* export default defineSchema({
+*   myTable: defineTable({
+*    myString: pretend(v.array(v.string())),
+*   }),
+* });
+* //...in some mutation
+* ctx.db.insert("myTable", { myString: 123 as any }); // no runtime error
+* ```
+* Example in function argument validation:
+* ```ts
+* const myQuery = defineQuery({
+*   args: { myNumber: pretend(v.number()) },
+*   handler: async (ctx, args) => {
+*     // args.myNumber is typed as number, but it's not validated.
+*     const num = typeof args.myNumber === "number" ?
+*       args.myNumber : Number(args.myNumber);
+*   },
+* });
+*/
+const pretend = (_typeToImmitate) => v.optional(v.any());
+/** A validator that validates as optional but type checks as required.
+*
+* If you want to assume a field is set for type checking, but your data may not
+* actually have it set for all documents (e.g. when adding a new field),
+* you can use this function to allow the field to be unset at runtime.
+* This is unsafe, but can be convenient in these situations:
+*
+* 1. You are developing locally and want to add a required field and write
+*   code assuming it is set. Once you push the code & schema, you can update
+*   the data to match before running your code.
+* 2. You are going to run a migration right after pushing code, and are ok with
+*   and you don't want to edit your code to handle the field being unset,
+*   your app being in an inconsistent state until the migration completes.
+*
+* This differs from {@link pretend} in that it type checks the inner validator,
+* if the value is provided.
+*
+* Example in a schema:
+* ```ts
+* export default defineSchema({
+*   myTable: defineTable({
+*    myString: pretendRequired(v.array(v.string())),
+*   }),
+* });
+* //...in some mutation
+* ctx.db.insert("myTable", { myString: undefined }); // no runtime error
+* ```
+* Example in function argument validation:
+* ```ts
+* const myQuery = defineQuery({
+*   args: { myNumber: pretendRequired(v.number()) },
+*   handler: async (ctx, args) => {
+*     // args.myNumber is typed as number, but it might be undefined
+*     const num = args.myNumber || 0;
+*   },
+* });
+*/
+const pretendRequired = (optionalType) => v.optional(optionalType);
 /**
 * Converts an optional validator to a required validator.
 *
@@ -233,145 +276,4 @@ function vRequired(validator) {
 }
 
 //#endregion
-//#region src/internal/upstream/server/customFunctions.ts
-/**
-* A helper for defining a Customization when your mod doesn't need to add or remove
-* anything from args.
-* @param modifyCtx A function that defines how to modify the ctx.
-* @returns A ctx delta to be applied to the original ctx.
-*/
-function customCtx(modifyCtx) {
-	return {
-		args: {},
-		input: async (ctx, _, extra) => ({
-			ctx: await modifyCtx(ctx, extra),
-			args: {}
-		})
-	};
-}
-/**
-* A Customization that doesn't add or remove any context or args.
-*/
-const NoOp = {
-	args: {},
-	input() {
-		return {
-			args: {},
-			ctx: {}
-		};
-	}
-};
-/**
-* customMutation helps define custom behavior on top of `mutation`
-* or `internalMutation` by passing a function that modifies the ctx and args.
-*
-* Example usage:
-* ```js
-* const myMutationBuilder = customMutation(mutation, {
-*   args: { sessionId: v.id("sessions") },
-*   input: async (ctx, args) => {
-*     const user = await getUserOrNull(ctx);
-*     const session = await db.get(sessionId);
-*     const db = wrapDatabaseReader({ user }, ctx.db, rlsRules);
-*     return {
-*       ctx: { db, user, session },
-*       args: {},
-*       onSuccess: ({ result }) => {
-*         // Optional callback that runs after the function executes
-*         // Has access to resources created during input processing
-*         console.log(`User ${user.name} returned:`, result);
-*       }
-*     };
-*   },
-* });
-*
-* // Using the custom builder
-* export const setSomeData = myMutationBuilder({
-*   args: { someArg: v.string() },
-*   handler: async (ctx, args) => {
-*     const { db, user, session, scheduler } = ctx;
-*     const { someArg } = args;
-*     // ...
-*   }
-* });
-* ```
-*
-* Simple usage only modifying ctx:
-* ```js
-* const myUserMutation = customMutation(
-*   mutation,
-*   customCtx(async (ctx) => {
-*     return {
-*       // Throws an exception if the user isn't logged in
-*       user: await getUserByTokenIdentifier(ctx),
-*     };
-*   })
-* );
-*
-* // Using it
-* export const setMyName = myUserMutation({
-*   args: { name: v.string() },
-*   handler: async (ctx, args) => {
-*     await ctx.db.patch(ctx.user._id, { name: args.name });
-*   },
-* });
-*
-* @param mutation The mutation to be modified. Usually `mutation` or `internalMutation`
-*   from `_generated/server`.
-* @param customization The modifier to be applied to the mutation, changing ctx and args.
-* @returns A new mutation builder to define queries with modified ctx and args.
-*/
-function customMutation(mutation, customization) {
-	return customFnBuilder(mutation, customization);
-}
-function customFnBuilder(builder, customization) {
-	const customInput = customization.input ?? NoOp.input;
-	const inputArgs = customization.args ?? NoOp.args;
-	return function customBuilder(fn) {
-		const { args, handler = fn, returns, ...extra } = fn;
-		if (args) return builder({
-			args: addFieldsToValidator(args, inputArgs),
-			returns,
-			handler: async (ctx, allArgs) => {
-				const added = await customInput(ctx, pick(allArgs, Object.keys(inputArgs)), extra);
-				const args = omit(allArgs, Object.keys(inputArgs));
-				const result = await handler({
-					...ctx,
-					...added.ctx
-				}, {
-					...args,
-					...added.args
-				});
-				if (added.onSuccess) await added.onSuccess({
-					ctx,
-					args,
-					result
-				});
-				return result;
-			}
-		});
-		if (Object.keys(inputArgs).length > 0) throw new Error("If you're using a custom function with arguments for the input customization, you must declare the arguments for the function too.");
-		return builder({
-			returns: fn.returns,
-			handler: async (ctx, args) => {
-				const added = await customInput(ctx, args, extra);
-				const result = await handler({
-					...ctx,
-					...added.ctx
-				}, {
-					...args,
-					...added.args
-				});
-				if (added.onSuccess) await added.onSuccess({
-					ctx,
-					args,
-					result
-				});
-				return result;
-			}
-		});
-	};
-}
-
-//#endregion
-export { partial as a, isMutationCtx as c, requireActionCtx as d, requireMutationCtx as f, pick as g, asyncMap as h, addFieldsToValidator as i, isQueryCtx as l, requireRunMutationCtx as m, customCtx as n, vRequired as o, requireQueryCtx as p, customMutation as r, isActionCtx as s, NoOp as t, isRunMutationCtx as u };
+export { pretendRequired as a, omit as c, pretend as i, pick as l, deprecated as n, vRequired as o, partial as r, asyncMap as s, addFieldsToValidator as t };

package/dist/validators-BDrWGp4M.d.ts

@@ -0,0 +1,88 @@
+import { 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 { GenericDataModel, GenericDatabaseReader, SchemaDefinition, TableNamesInDataModel } from "convex/server";
+
+//#region src/internal/upstream/validators.d.ts
+/** Mark fields as deprecated with this permissive validator typed as null */
+declare const deprecated: Validator<null, "optional">;
+/** A maximally permissive validator that type checks as a given validator.
+ *
+ * If you want to have types that match some validator but you have invalid data
+ * and you want to temporarily not validate schema for this field,
+ * you can use this function to cast the permissive validator.
+ *
+ * Example in a schema:
+ * ```ts
+ * export default defineSchema({
+ *   myTable: defineTable({
+ *    myString: pretend(v.array(v.string())),
+ *   }),
+ * });
+ * //...in some mutation
+ * ctx.db.insert("myTable", { myString: 123 as any }); // no runtime error
+ * ```
+ * Example in function argument validation:
+ * ```ts
+ * const myQuery = defineQuery({
+ *   args: { myNumber: pretend(v.number()) },
+ *   handler: async (ctx, args) => {
+ *     // args.myNumber is typed as number, but it's not validated.
+ *     const num = typeof args.myNumber === "number" ?
+ *       args.myNumber : Number(args.myNumber);
+ *   },
+ * });
+ */
+declare const pretend: <T extends GenericValidator>(_typeToImmitate: T) => T;
+/** A validator that validates as optional but type checks as required.
+ *
+ * If you want to assume a field is set for type checking, but your data may not
+ * actually have it set for all documents (e.g. when adding a new field),
+ * you can use this function to allow the field to be unset at runtime.
+ * This is unsafe, but can be convenient in these situations:
+ *
+ * 1. You are developing locally and want to add a required field and write
+ *   code assuming it is set. Once you push the code & schema, you can update
+ *   the data to match before running your code.
+ * 2. You are going to run a migration right after pushing code, and are ok with
+ *   and you don't want to edit your code to handle the field being unset,
+ *   your app being in an inconsistent state until the migration completes.
+ *
+ * This differs from {@link pretend} in that it type checks the inner validator,
+ * if the value is provided.
+ *
+ * Example in a schema:
+ * ```ts
+ * export default defineSchema({
+ *   myTable: defineTable({
+ *    myString: pretendRequired(v.array(v.string())),
+ *   }),
+ * });
+ * //...in some mutation
+ * ctx.db.insert("myTable", { myString: undefined }); // no runtime error
+ * ```
+ * Example in function argument validation:
+ * ```ts
+ * const myQuery = defineQuery({
+ *   args: { myNumber: pretendRequired(v.number()) },
+ *   handler: async (ctx, args) => {
+ *     // args.myNumber is typed as number, but it might be undefined
+ *     const num = args.myNumber || 0;
+ *   },
+ * });
+ */
+declare const pretendRequired: <T extends Validator<any, "required", any>>(optionalType: T) => T;
+type NotUndefined<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<Type>, 'required'> : T extends VString<infer Type, OptionalProperty> ? VString<NotUndefined<Type>, 'required'> : T extends VFloat64<infer Type, OptionalProperty> ? VFloat64<NotUndefined<Type>, 'required'> : T extends VInt64<infer Type, OptionalProperty> ? VInt64<NotUndefined<Type>, 'required'> : T extends VBoolean<infer Type, OptionalProperty> ? VBoolean<NotUndefined<Type>, 'required'> : T extends VNull<infer Type, OptionalProperty> ? VNull<NotUndefined<Type>, 'required'> : T extends VAny<infer Type, OptionalProperty> ? VAny<NotUndefined<Type>, 'required'> : T extends VLiteral<infer Type, OptionalProperty> ? VLiteral<NotUndefined<Type>, 'required'> : T extends VBytes<infer Type, OptionalProperty> ? VBytes<NotUndefined<Type>, 'required'> : T extends VObject<infer Type, infer Fields, OptionalProperty, infer FieldPaths> ? VObject<NotUndefined<Type>, Fields, 'required', FieldPaths> : T extends VArray<infer Type, infer Element, OptionalProperty> ? VArray<NotUndefined<Type>, Element, 'required'> : T extends VRecord<infer Type, infer Key, infer Value, OptionalProperty, infer FieldPaths> ? VRecord<NotUndefined<Type>, Key, Value, 'required', FieldPaths> : T extends VUnion<infer Type, infer Members, OptionalProperty, infer FieldPaths> ? VUnion<NotUndefined<Type>, Members, 'required', FieldPaths> : never;
+//#endregion
+export { pretendRequired as i, deprecated as n, pretend as r, VRequired as t };

package/dist/watcher.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { n as getConvexConfig, t as generateMeta } from "./codegen-Cz1idI3-.mjs";
+import { n as getConvexConfig, t as generateMeta } from "./codegen-BS36cYTH.mjs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 

package/dist/{where-clause-compiler-CRP-i1Qa.d.ts → where-clause-compiler-HUa2223D.d.ts}

@@ -1,4 +1,4 @@
-import { a as ReturnTypeOrValue, i as KnownKeysOnly, o as Simplify, t as Assume } from "./types-DwGkkq2s.js";
+import { a as ReturnTypeOrValue, i as KnownKeysOnly, o as Simplify, t as Assume } from "./types-kgwiK-xe.js";
 import * as convex_values0 from "convex/values";
 import { GenericId, Validator, Value } from "convex/values";
 import { DefineSchemaOptions, FilterExpression, GenericDatabaseReader, GenericDatabaseWriter, GenericIndexFields, GenericSchema, GenericTableIndexes, GenericTableSearchIndexes, GenericTableVectorIndexes, IndexRange, IndexRangeBuilder, SchedulableFunctionReference, Scheduler, SchemaDefinition, TableDefinition, VectorFilterBuilder, internalActionGeneric, internalMutationGeneric } from "convex/server";
@@ -3195,6 +3195,104 @@ type CreateDatabaseOptions = {
   };
 };
 //#endregion
+//#region src/orm/migrations/definitions.d.ts
+type MigrationDirection = 'up' | 'down';
+type MigrationRunStatus = 'pending' | 'running' | 'completed' | 'failed' | 'canceled' | 'dry_run' | 'noop';
+type MigrationWriteMode = 'safe_bypass' | 'normal';
+type MigrationTableName<TSchema extends TablesRelationalConfig = TablesRelationalConfig> = { [K in keyof TSchema]-?: TSchema[K] extends TableRelationalConfig ? TSchema[K]['name'] : never }[keyof TSchema] & string;
+type MigrationTableConfigByName<TSchema extends TablesRelationalConfig, TTableName extends MigrationTableName<TSchema>> = { [K in keyof TSchema]-?: TSchema[K] extends TableRelationalConfig ? TSchema[K]['name'] extends TTableName ? TSchema[K] : never : never }[keyof TSchema];
+type MigrationDoc<TSchema extends TablesRelationalConfig = TablesRelationalConfig, TTableName extends MigrationTableName<TSchema> = MigrationTableName<TSchema>> = MigrationTableConfigByName<TSchema, TTableName> extends TableRelationalConfig ? Partial<InferSelectModel<MigrationTableConfigByName<TSchema, TTableName>['table']>> & Record<string, unknown> : Record<string, unknown>;
+type MigrationDocContext<TSchema extends TablesRelationalConfig = TablesRelationalConfig> = {
+  db: GenericDatabaseWriter<any>;
+  orm: OrmWriter<TSchema>;
+  migrationId: string;
+  runId: string;
+  direction: MigrationDirection;
+  dryRun: boolean;
+  writeMode: MigrationWriteMode;
+};
+type MigrationMigrateOne<TSchema extends TablesRelationalConfig = TablesRelationalConfig, TTableName extends MigrationTableName<TSchema> = MigrationTableName<TSchema>> = (ctx: MigrationDocContext<TSchema>, doc: MigrationDoc<TSchema, TTableName>) => Promise<unknown> | unknown;
+type MigrationStepByTable<TSchema extends TablesRelationalConfig = TablesRelationalConfig, TTableName extends MigrationTableName<TSchema> = MigrationTableName<TSchema>> = {
+  table: TTableName;
+  batchSize?: number;
+  writeMode?: MigrationWriteMode;
+  migrateOne: MigrationMigrateOne<TSchema, TTableName>;
+};
+type MigrationStep<TSchema extends TablesRelationalConfig = TablesRelationalConfig> = { [TTableName in MigrationTableName<TSchema>]: MigrationStepByTable<TSchema, TTableName> }[MigrationTableName<TSchema>];
+type MigrationDefinition<TSchema extends TablesRelationalConfig = TablesRelationalConfig> = {
+  id: string;
+  name?: string;
+  description?: string;
+  up: MigrationStep<TSchema>;
+  down?: MigrationStep<TSchema>;
+  checksum?: string;
+};
+type MigrationManifestEntry<TSchema extends TablesRelationalConfig = TablesRelationalConfig> = MigrationDefinition<TSchema> & {
+  checksum: string;
+};
+type MigrationSet<TSchema extends TablesRelationalConfig = TablesRelationalConfig> = {
+  migrations: readonly MigrationManifestEntry<TSchema>[];
+  ids: readonly string[];
+  byId: Readonly<Record<string, MigrationManifestEntry<TSchema>>>;
+};
+type MigrationAppliedState = {
+  applied: boolean;
+  checksum?: string;
+  cursor?: string | null;
+  processed?: number;
+};
+type MigrationStateMap = Readonly<Record<string, MigrationAppliedState>>;
+type MigrationDriftIssue = {
+  kind: 'missing_from_manifest';
+  migrationId: string;
+  message: string;
+} | {
+  kind: 'checksum_mismatch';
+  migrationId: string;
+  message: string;
+  expectedChecksum: string;
+  actualChecksum: string;
+};
+type MigrationPlan<TSchema extends TablesRelationalConfig = TablesRelationalConfig> = {
+  direction: MigrationDirection;
+  migrations: readonly MigrationManifestEntry<TSchema>[];
+};
+declare function defineMigration<TSchema extends TablesRelationalConfig = TablesRelationalConfig>(migration: MigrationDefinition<TSchema>): MigrationDefinition<TSchema>;
+declare function defineMigrationSet<TSchema extends TablesRelationalConfig = TablesRelationalConfig>(migrations: readonly MigrationDefinition<TSchema>[]): MigrationSet<TSchema>;
+declare function detectMigrationDrift<TSchema extends TablesRelationalConfig = TablesRelationalConfig>(params: {
+  migrationSet: MigrationSet<TSchema>;
+  appliedState: MigrationStateMap;
+}): MigrationDriftIssue[];
+declare function buildMigrationPlan<TSchema extends TablesRelationalConfig = TablesRelationalConfig>(params: {
+  direction: MigrationDirection;
+  migrationSet: MigrationSet<TSchema>;
+  appliedState: MigrationStateMap;
+  steps?: number;
+  to?: string;
+}): MigrationPlan<TSchema>;
+//#endregion
+//#region src/orm/migrations/runtime.d.ts
+type MigrationRunArgs = {
+  direction?: MigrationDirection;
+  steps?: number;
+  to?: string;
+  dryRun?: boolean;
+  allowDrift?: boolean;
+  batchSize?: number;
+  restart?: boolean;
+};
+type MigrationRunChunkArgs = {
+  runId: string;
+  batchSize?: number;
+};
+type MigrationStatusArgs = {
+  runId?: string;
+  limit?: number;
+};
+type MigrationCancelArgs = {
+  runId?: string;
+};
+//#endregion
 //#region src/orm/triggers.d.ts
 type MaybePromise<T> = T | Promise<T>;
 type AnyRecord = Record<string, unknown>;
@@ -3286,6 +3384,7 @@ type OrmFunctions = {
   scheduledMutationBatch: SchedulableFunctionReference;
   scheduledDelete: SchedulableFunctionReference;
   aggregateBackfillChunk?: SchedulableFunctionReference;
+  migrationRunChunk?: SchedulableFunctionReference;
   resetChunk?: SchedulableFunctionReference;
 };
 type CreateOrmOptions = CreateDatabaseOptions;
@@ -3314,6 +3413,7 @@ type GenericOrmCtx<Ctx extends {
 type CreateOrmConfigBase<TSchema extends TablesRelationalConfig> = {
   schema: TSchema;
   triggers?: OrmTriggers<TSchema, any>;
+  migrations?: MigrationSet<any>;
   internalMutation?: typeof internalMutationGeneric;
 };
 type CreateOrmConfigWithFunctions<TSchema extends TablesRelationalConfig> = CreateOrmConfigBase<TSchema> & {
@@ -3329,6 +3429,10 @@ type OrmApiResult = {
   aggregateBackfill: ReturnType<typeof internalMutationGeneric>;
   aggregateBackfillChunk: ReturnType<typeof internalMutationGeneric>;
   aggregateBackfillStatus: ReturnType<typeof internalMutationGeneric>;
+  migrationRun: ReturnType<typeof internalMutationGeneric>;
+  migrationRunChunk: ReturnType<typeof internalMutationGeneric>;
+  migrationStatus: ReturnType<typeof internalMutationGeneric>;
+  migrationCancel: ReturnType<typeof internalMutationGeneric>;
   resetChunk: ReturnType<typeof internalMutationGeneric>;
   reset: ReturnType<typeof internalActionGeneric>;
 };
@@ -3460,4 +3564,4 @@ interface IndexLike {
   indexName: string;
 }
 //#endregion
-export { ConvexIdBuilder as $, VectorSearchProvider as $n, ConvexRankIndexBuilderOn as $t, DatabaseWithQuery as A, FilterOperators as An, Columns as Ar, defineRelations as At, ConvexTimestampBuilder as B, MutationPaginatedResult as Bn, DrizzleEntity as Br, deletion as Bt, OrmBeforeResult as C, AggregateFieldValue as Cn, ne as Cr, ManyConfig as Ct, OrmTriggers as D, CountConfig as Dn, or as Dr, RelationsBuilderColumnConfig as Dt, OrmTriggerContext as E, BuildRelationResult as En, notInArray as Er, RelationsBuilderColumnBase as Et, EdgeMetadata as F, InsertValue as Fn, ColumnBuilderBaseConfig as Fr, ConvexTableWithColumns as Ft, ConvexTextEnumBuilderInitial as G, OrderDirection as Gn, RlsRole as Gt, ConvexTimestampMode as H, MutationReturning as Hn, IsPrimaryKey as Hr, RlsPolicyConfig as Ht, extractRelationsConfig as I, MutationExecuteConfig as In, ColumnBuilderRuntimeConfig as Ir, OrmLifecycleChange as It, ConvexTextBuilderInitial as J, ReturningAll as Jn, ConvexAggregateIndexBuilder as Jt, textEnum as K, PaginatedResult as Kn, RlsRoleConfig as Kt, ConvexVectorBuilder as L, MutationExecuteResult as Ln, ColumnBuilderTypeConfig as Lr, OrmLifecycleOperation as Lt, OrmWriter as M, InferInsertModel as Mn, SystemFields as Mr, ConvexDeletionBuilder as Mt, RlsContext as N, InferModelFromColumns as Nn, AnyColumn as Nr, ConvexDeletionConfig as Nt, defineTriggers as O, CountResult as On, startsWith as Or, TableRelationalConfig as Ot, RlsMode as P, InferSelectModel as Pn, ColumnBuilder as Pr, ConvexTable as Pt, integer as Q, VectorQueryConfig as Qn, ConvexRankIndexBuilder as Qt, ConvexVectorBuilderInitial as R, MutationExecutionMode as Rn, ColumnBuilderWithTableName as Rr, TableConfig as Rt, scheduledDeleteFactory as S, AggregateConfig as Sn, lte as Sr, ExtractTablesWithRelations as St, OrmTriggerChange as T, BuildQueryResult as Tn, notBetween as Tr, RelationsBuilder as Tt, timestamp as U, MutationRunMode as Un, IsUnique as Ur, RlsPolicyToOption as Ut, ConvexTimestampBuilderInitial as V, MutationResult as Vn, HasDefault as Vr, RlsPolicy as Vt, ConvexTextEnumBuilder as W, OrderByClause as Wn, NotNull as Wr, rlsPolicy as Wt, ConvexNumberBuilder as X, ReturningSelection as Xn, ConvexIndexBuilder as Xt, text as Y, ReturningResult as Yn, ConvexAggregateIndexBuilderOn as Yt, ConvexNumberBuilderInitial as Z, UpdateSet as Zn, ConvexIndexBuilderOn as Zt, OrmWriterCtx as _, ConvexUniqueConstraintBuilderOn as _n, isFieldReference as _r, ConvexBigIntBuilderInitial as _t, TableConfigResult as a, ConvexVectorIndexConfig as an, LogicalExpression as ar, date as at, scheduledMutationBatchFactory as b, foreignKey as bn, like as br, CountBackfillKickoffArgs as bt, OrmNotFoundError as c, rankIndex as cn, between as cr, custom as ct, GenericOrmCtx as d, vectorIndex as dn, eq as dr, ConvexBytesBuilderInitial as dt, ConvexSearchIndexBuilder as en, unsetToken as er, ConvexIdBuilderInitial as et, OrmApiResult as f, ConvexCheckBuilder as fn, fieldRef as fr, bytes as ft, OrmReaderCtx as g, ConvexUniqueConstraintBuilder as gn, inArray as gr, ConvexBigIntBuilder as gt, OrmFunctions as h, ConvexForeignKeyConfig as hn, ilike as hr, boolean as ht, desc as i, ConvexVectorIndexBuilderOn as in, FilterExpression$1 as ir, ConvexDateMode as it, OrmReader as j, GetColumnData as jn, TableName as jr, defineRelationsPart as jt, DatabaseWithMutations as k, DBQueryConfig as kn, Brand as kr, TablesRelationalConfig as kt, CreateOrmOptions as l, searchIndex as ln, contains as lr, json as lt, OrmClientWithApi as m, ConvexForeignKeyBuilder as mn, gte as mr, ConvexBooleanBuilderInitial as mt, defineSchema$1 as n, ConvexSearchIndexConfig as nn, ExpressionVisitor as nr, ConvexDateBuilder as nt, getTableColumns as o, aggregateIndex as on, UnaryExpression as or, ConvexCustomBuilder as ot, OrmClientBase as p, ConvexCheckConfig as pn, gt as pr, ConvexBooleanBuilder as pt, ConvexTextBuilder as q, PredicateWhereIndexConfig as qn, rlsRole as qt, asc as r, ConvexVectorIndexBuilder as rn, FieldReference as rr, ConvexDateBuilderInitial as rt, getTableConfig as s, index as sn, and as sr, ConvexCustomBuilderInitial as st, WhereClauseResult as t, ConvexSearchIndexBuilderOn as tn, BinaryExpression as tr, id as tt, GenericOrm as u, uniqueIndex as un, endsWith as ur, ConvexBytesBuilder as ut, createOrm as v, ConvexUniqueConstraintConfig as vn, isNotNull as vr, bigint as vt, OrmTableTriggers as w, AggregateResult as wn, not as wr, OneConfig as wt, ScheduledDeleteArgs as x, unique as xn, lt as xr, CountBackfillStatusArgs as xt, ScheduledMutationBatchArgs as y, check as yn, isNull as yr, CountBackfillChunkArgs as yt, vector as z, MutationPaginateConfig as zn, ColumnDataType as zr, convexTable as zt };
+export { DatabaseWithQuery as $, FilterOperators as $n, Columns as $r, defineRelations as $t, MigrationRunArgs as A, index as An, and as Ar, ConvexCustomBuilderInitial as At, MigrationMigrateOne as B, ConvexUniqueConstraintBuilderOn as Bn, isFieldReference as Br, ConvexBigIntBuilderInitial as Bt, OrmBeforeResult as C, ConvexSearchIndexBuilder as Cn, unsetToken as Cr, ConvexIdBuilderInitial as Ct, OrmTriggers as D, ConvexVectorIndexBuilderOn as Dn, FilterExpression$1 as Dr, ConvexDateMode as Dt, OrmTriggerContext as E, ConvexVectorIndexBuilder as En, FieldReference as Er, ConvexDateBuilderInitial as Et, MigrationDirection as F, ConvexCheckBuilder as Fn, fieldRef as Fr, bytes as Ft, MigrationStep as G, AggregateConfig as Gn, lte as Gr, ExtractTablesWithRelations as Gt, MigrationRunStatus as H, check as Hn, isNull as Hr, CountBackfillChunkArgs as Ht, MigrationDoc as I, ConvexCheckConfig as In, gt as Ir, ConvexBooleanBuilder as It, buildMigrationPlan as J, BuildQueryResult as Jn, notBetween as Jr, RelationsBuilder as Jt, MigrationTableName as K, AggregateFieldValue as Kn, ne as Kr, ManyConfig as Kt, MigrationDocContext as L, ConvexForeignKeyBuilder as Ln, gte as Lr, ConvexBooleanBuilderInitial as Lt, MigrationStatusArgs as M, searchIndex as Mn, contains as Mr, json as Mt, MigrationAppliedState as N, uniqueIndex as Nn, endsWith as Nr, ConvexBytesBuilder as Nt, defineTriggers as O, ConvexVectorIndexConfig as On, LogicalExpression as Or, date as Ot, MigrationDefinition as P, vectorIndex as Pn, eq as Pr, ConvexBytesBuilderInitial as Pt, DatabaseWithMutations as Q, DBQueryConfig as Qn, Brand as Qr, TablesRelationalConfig as Qt, MigrationDriftIssue as R, ConvexForeignKeyConfig as Rn, ilike as Rr, boolean as Rt, scheduledDeleteFactory as S, ConvexRankIndexBuilderOn as Sn, VectorSearchProvider as Sr, ConvexIdBuilder as St, OrmTriggerChange as T, ConvexSearchIndexConfig as Tn, ExpressionVisitor as Tr, ConvexDateBuilder as Tt, MigrationSet as U, foreignKey as Un, like as Ur, CountBackfillKickoffArgs as Ut, MigrationPlan as V, ConvexUniqueConstraintConfig as Vn, isNotNull as Vr, bigint as Vt, MigrationStateMap as W, unique as Wn, lt as Wr, CountBackfillStatusArgs as Wt, defineMigrationSet as X, CountConfig as Xn, or as Xr, RelationsBuilderColumnConfig as Xt, defineMigration as Y, BuildRelationResult as Yn, notInArray as Yr, RelationsBuilderColumnBase as Yt, detectMigrationDrift as Z, CountResult as Zn, startsWith as Zr, TableRelationalConfig as Zt, OrmWriterCtx as _, ConvexAggregateIndexBuilder as _n, ReturningAll as _r, ConvexTextBuilderInitial as _t, TableConfigResult as a, ColumnBuilderRuntimeConfig as ai, OrmLifecycleChange as an, MutationExecuteConfig as ar, extractRelationsConfig as at, scheduledMutationBatchFactory as b, ConvexIndexBuilderOn as bn, UpdateSet as br, ConvexNumberBuilderInitial as bt, OrmNotFoundError as c, ColumnDataType as ci, convexTable as cn, MutationPaginateConfig as cr, vector as ct, GenericOrmCtx as d, IsPrimaryKey as di, RlsPolicyConfig as dn, MutationReturning as dr, ConvexTimestampMode as dt, TableName as ei, defineRelationsPart as en, GetColumnData as er, OrmReader as et, OrmApiResult as f, IsUnique as fi, RlsPolicyToOption as fn, MutationRunMode as fr, timestamp as ft, OrmReaderCtx as g, rlsRole as gn, PredicateWhereIndexConfig as gr, ConvexTextBuilder as gt, OrmFunctions as h, RlsRoleConfig as hn, PaginatedResult as hr, textEnum as ht, desc as i, ColumnBuilderBaseConfig as ii, ConvexTableWithColumns as in, InsertValue as ir, EdgeMetadata as it, MigrationRunChunkArgs as j, rankIndex as jn, between as jr, custom as jt, MigrationCancelArgs as k, aggregateIndex as kn, UnaryExpression as kr, ConvexCustomBuilder as kt, CreateOrmOptions as l, DrizzleEntity as li, deletion as ln, MutationPaginatedResult as lr, ConvexTimestampBuilder as lt, OrmClientWithApi as m, RlsRole as mn, OrderDirection as mr, ConvexTextEnumBuilderInitial as mt, defineSchema$1 as n, AnyColumn as ni, ConvexDeletionConfig as nn, InferModelFromColumns as nr, RlsContext as nt, getTableColumns as o, ColumnBuilderTypeConfig as oi, OrmLifecycleOperation as on, MutationExecuteResult as or, ConvexVectorBuilder as ot, OrmClientBase as p, NotNull as pi, rlsPolicy as pn, OrderByClause as pr, ConvexTextEnumBuilder as pt, MigrationWriteMode as q, AggregateResult as qn, not as qr, OneConfig as qt, asc as r, ColumnBuilder as ri, ConvexTable as rn, InferSelectModel as rr, RlsMode as rt, getTableConfig as s, ColumnBuilderWithTableName as si, TableConfig as sn, MutationExecutionMode as sr, ConvexVectorBuilderInitial as st, WhereClauseResult as t, SystemFields as ti, ConvexDeletionBuilder as tn, InferInsertModel as tr, OrmWriter as tt, GenericOrm as u, HasDefault as ui, RlsPolicy as un, MutationResult as ur, ConvexTimestampBuilderInitial as ut, createOrm as v, ConvexAggregateIndexBuilderOn as vn, ReturningResult as vr, text as vt, OrmTableTriggers as w, ConvexSearchIndexBuilderOn as wn, BinaryExpression as wr, id as wt, ScheduledDeleteArgs as x, ConvexRankIndexBuilder as xn, VectorQueryConfig as xr, integer as xt, ScheduledMutationBatchArgs as y, ConvexIndexBuilder as yn, ReturningSelection as yr, ConvexNumberBuilder as yt, MigrationManifestEntry as z, ConvexUniqueConstraintBuilder as zn, inArray as zr, ConvexBigIntBuilder as zt };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "better-convex",
-  "version": "0.7.2",
+  "version": "0.7.3",
   "description": "Better Convex - React Query integration and CLI tools for Convex",
   "keywords": [
     "convex",