better-convex 0.7.2 → 0.8.0

package/dist/text-enum-CFdcLUuw.js

@@ -0,0 +1,30 @@
+import { T as entityKind, w as ConvexColumnBuilder } from "./table-B7yzBihE.js";
+import { v } from "convex/values";
+
+//#region src/orm/builders/text-enum.ts
+var ConvexTextEnumBuilder = class extends ConvexColumnBuilder {
+	static [entityKind] = "ConvexTextEnumBuilder";
+	constructor(name, values) {
+		super(name, "string", "ConvexText");
+		this.config.values = [...values];
+	}
+	_enumValidator() {
+		const literals = this.config.values.map((value) => v.literal(value));
+		if (literals.length === 1) return literals[0];
+		return v.union(...literals);
+	}
+	get convexValidator() {
+		const base = this._enumValidator();
+		if (this.config.notNull) return base;
+		return v.optional(v.union(v.null(), base));
+	}
+	build() {
+		return this.convexValidator;
+	}
+};
+function textEnum(values) {
+	return new ConvexTextEnumBuilder("", values);
+}
+
+//#endregion
+export { textEnum as t };

package/dist/{types-CIBGEYXq.d.ts → types-f53SgpBL.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-BTb_4BaU.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/validators-BcQFm1oY.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/{customFunctions-CZnCwoR3.js → validators-D_i3BK7v.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/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-BIjTkVVJ.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-BTb_4BaU.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";
@@ -336,6 +336,11 @@ type OrmTableDeleteConfig = {
   mode: OrmDeleteMode;
   delayMs?: number;
 };
+type OrmSchemaPlugin = {
+  key: string;
+  tableNames: readonly string[];
+  inject: <TSchema extends Record<string, unknown>>(schema: TSchema) => TSchema & Record<string, unknown>;
+};
 declare const TableName: unique symbol;
 declare const Columns: unique symbol;
 declare const Brand: unique symbol;
@@ -343,6 +348,7 @@ declare const RlsPolicies: unique symbol;
 declare const EnableRLS: unique symbol;
 declare const TableDeleteConfig: unique symbol;
 declare const OrmSchemaDefinition: unique symbol;
+declare const OrmSchemaPluginTables: unique symbol;
 //#endregion
 //#region src/orm/filter-expression.d.ts
 /**
@@ -2071,6 +2077,19 @@ declare function bytes<TName extends string>(name: TName): ConvexBytesBuilderIni
 //#endregion
 //#region src/orm/builders/custom.d.ts
 type AnyValidator = Validator<any, any, any>;
+type AnyColumnBuilder = ColumnBuilder<any, any, any>;
+interface NestedShapeInput {
+  [key: string]: NestedInput;
+}
+type NestedInput = AnyValidator | AnyColumnBuilder | NestedShapeInput;
+type InferBuilderNestedValue<TBuilder extends AnyColumnBuilder> = TBuilder['_'] extends {
+  $type: infer TType;
+} ? TType : TBuilder['_'] extends {
+  data: infer TData;
+} ? TData : never;
+type InferValidatorNestedValue<TValidator extends AnyValidator> = Exclude<TValidator['type'], undefined>;
+type InferNestedValue<TInput extends NestedInput> = TInput extends AnyColumnBuilder ? InferBuilderNestedValue<TInput> : TInput extends AnyValidator ? InferValidatorNestedValue<TInput> : TInput extends NestedShapeInput ? InferObjectShape<TInput> : never;
+type InferObjectShape<TShape extends NestedShapeInput> = { [K in keyof TShape]: InferNestedValue<TShape[K]> };
 type ConvexCustomBuilderInitial<TName extends string, TValidator extends AnyValidator> = ConvexCustomBuilder<{
   name: TName;
   dataType: 'any';
@@ -2089,6 +2108,18 @@ declare class ConvexCustomBuilder<T extends ColumnBuilderBaseConfig<'any', 'Conv
 }
 declare function custom<TValidator extends AnyValidator>(validator: TValidator): ConvexCustomBuilderInitial<'', TValidator>;
 declare function custom<TName extends string, TValidator extends AnyValidator>(name: TName, validator: TValidator): ConvexCustomBuilderInitial<TName, TValidator>;
+/**
+ * Creates an array column from a nested validator or builder.
+ *
+ * Values in nested arrays are always compiled as required validators.
+ */
+declare function arrayOf<TElement extends NestedInput>(element: TElement): $Type<ConvexCustomBuilderInitial<"", convex_values0.VArray<any[], AnyValidator, "required">>, InferNestedValue<TElement>[]>;
+/**
+ * Creates an object column from a nested shape of validators/builders.
+ *
+ * Fields in nested objects are always compiled as required validators.
+ */
+declare function objectOf<TShape extends NestedShapeInput>(shape: TShape): $Type<ConvexCustomBuilderInitial<"", AnyValidator>, InferObjectShape<TShape>>;
 /**
  * Convenience wrapper for Convex "JSON" values.
  *
@@ -3195,6 +3226,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 +3415,7 @@ type OrmFunctions = {
   scheduledMutationBatch: SchedulableFunctionReference;
   scheduledDelete: SchedulableFunctionReference;
   aggregateBackfillChunk?: SchedulableFunctionReference;
+  migrationRunChunk?: SchedulableFunctionReference;
   resetChunk?: SchedulableFunctionReference;
 };
 type CreateOrmOptions = CreateDatabaseOptions;
@@ -3314,6 +3444,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 +3460,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>;
 };
@@ -3418,6 +3553,7 @@ declare function desc<TBuilder extends ColumnBuilder<any, any, any>>(builder: TB
 type BetterConvexSchemaOptions<StrictTableNameTypes extends boolean> = DefineSchemaOptions<StrictTableNameTypes> & {
   strict?: boolean;
   defaults?: OrmRuntimeDefaults;
+  plugins?: readonly OrmSchemaPlugin[];
 };
 /**
  * Better Convex schema definition
@@ -3460,4 +3596,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 $, CountResult as $n, startsWith as $r, TableRelationalConfig as $t, MigrationRunArgs as A, ConvexVectorIndexConfig as An, LogicalExpression as Ar, ConvexCustomBuilderInitial as At, MigrationMigrateOne as B, ConvexForeignKeyConfig as Bn, ilike as Br, boolean as Bt, OrmBeforeResult as C, ConvexRankIndexBuilder as Cn, VectorQueryConfig as Cr, ConvexIdBuilderInitial as Ct, OrmTriggers as D, ConvexSearchIndexConfig as Dn, ExpressionVisitor as Dr, ConvexDateMode as Dt, OrmTriggerContext as E, ConvexSearchIndexBuilderOn as En, BinaryExpression as Er, ConvexDateBuilderInitial as Et, MigrationDirection as F, uniqueIndex as Fn, endsWith as Fr, ConvexBytesBuilder as Ft, MigrationStep as G, foreignKey as Gn, like as Gr, CountBackfillKickoffArgs as Gt, MigrationRunStatus as H, ConvexUniqueConstraintBuilderOn as Hn, isFieldReference as Hr, ConvexBigIntBuilderInitial as Ht, MigrationDoc as I, vectorIndex as In, eq as Ir, ConvexBytesBuilderInitial as It, buildMigrationPlan as J, AggregateFieldValue as Jn, ne as Jr, ManyConfig as Jt, MigrationTableName as K, unique as Kn, lt as Kr, CountBackfillStatusArgs as Kt, MigrationDocContext as L, ConvexCheckBuilder as Ln, fieldRef as Lr, bytes as Lt, MigrationStatusArgs as M, index as Mn, and as Mr, custom as Mt, MigrationAppliedState as N, rankIndex as Nn, between as Nr, json as Nt, defineTriggers as O, ConvexVectorIndexBuilder as On, FieldReference as Or, date as Ot, MigrationDefinition as P, searchIndex as Pn, contains as Pr, objectOf as Pt, DatabaseWithMutations as Q, CountConfig as Qn, or as Qr, RelationsBuilderColumnConfig as Qt, MigrationDriftIssue as R, ConvexCheckConfig as Rn, gt as Rr, ConvexBooleanBuilder as Rt, scheduledDeleteFactory as S, ConvexIndexBuilderOn as Sn, UpdateSet as Sr, ConvexIdBuilder as St, OrmTriggerChange as T, ConvexSearchIndexBuilder as Tn, unsetToken as Tr, ConvexDateBuilder as Tt, MigrationSet as U, ConvexUniqueConstraintConfig as Un, isNotNull as Ur, bigint as Ut, MigrationPlan as V, ConvexUniqueConstraintBuilder as Vn, inArray as Vr, ConvexBigIntBuilder as Vt, MigrationStateMap as W, check as Wn, isNull as Wr, CountBackfillChunkArgs as Wt, defineMigrationSet as X, BuildQueryResult as Xn, notBetween as Xr, RelationsBuilder as Xt, defineMigration as Y, AggregateResult as Yn, not as Yr, OneConfig as Yt, detectMigrationDrift as Z, BuildRelationResult as Zn, notInArray as Zr, RelationsBuilderColumnBase as Zt, OrmWriterCtx as _, NotNull as _i, RlsRoleConfig as _n, PaginatedResult as _r, ConvexTextBuilderInitial as _t, TableConfigResult as a, SystemFields as ai, ConvexTable as an, InferSelectModel as ar, extractRelationsConfig as at, scheduledMutationBatchFactory as b, ConvexAggregateIndexBuilderOn as bn, ReturningResult as br, ConvexNumberBuilderInitial as bt, OrmNotFoundError as c, ColumnBuilderBaseConfig as ci, OrmLifecycleOperation as cn, MutationExecuteResult as cr, vector as ct, GenericOrmCtx as d, ColumnBuilderWithTableName as di, deletion as dn, MutationPaginatedResult as dr, ConvexTimestampMode as dt, Brand as ei, TablesRelationalConfig as en, DBQueryConfig as er, OrmReader as et, OrmApiResult as f, ColumnDataType as fi, RlsPolicy as fn, MutationResult as fr, timestamp as ft, OrmReaderCtx as g, IsUnique as gi, RlsRole as gn, OrderDirection as gr, ConvexTextBuilder as gt, OrmFunctions as h, IsPrimaryKey as hi, rlsPolicy as hn, OrderByClause as hr, textEnum as ht, desc as i, TableName as ii, ConvexDeletionConfig as in, InferModelFromColumns as ir, EdgeMetadata as it, MigrationRunChunkArgs as j, aggregateIndex as jn, UnaryExpression as jr, arrayOf as jt, MigrationCancelArgs as k, ConvexVectorIndexBuilderOn as kn, FilterExpression$1 as kr, ConvexCustomBuilder as kt, CreateOrmOptions as l, ColumnBuilderRuntimeConfig as li, TableConfig as ln, MutationExecutionMode as lr, ConvexTimestampBuilder as lt, OrmClientWithApi as m, HasDefault as mi, RlsPolicyToOption as mn, MutationRunMode as mr, ConvexTextEnumBuilderInitial as mt, defineSchema$1 as n, OrmSchemaPlugin as ni, defineRelationsPart as nn, GetColumnData as nr, RlsContext as nt, getTableColumns as o, AnyColumn as oi, ConvexTableWithColumns as on, InsertValue as or, ConvexVectorBuilder as ot, OrmClientBase as p, DrizzleEntity as pi, RlsPolicyConfig as pn, MutationReturning as pr, ConvexTextEnumBuilder as pt, MigrationWriteMode as q, AggregateConfig as qn, lte as qr, ExtractTablesWithRelations as qt, asc as r, OrmSchemaPluginTables as ri, ConvexDeletionBuilder as rn, InferInsertModel as rr, RlsMode as rt, getTableConfig as s, ColumnBuilder as si, OrmLifecycleChange as sn, MutationExecuteConfig as sr, ConvexVectorBuilderInitial as st, WhereClauseResult as t, Columns as ti, defineRelations as tn, FilterOperators as tr, OrmWriter as tt, GenericOrm as u, ColumnBuilderTypeConfig as ui, convexTable as un, MutationPaginateConfig as ur, ConvexTimestampBuilderInitial as ut, createOrm as v, rlsRole as vn, PredicateWhereIndexConfig as vr, text as vt, OrmTableTriggers as w, ConvexRankIndexBuilderOn as wn, VectorSearchProvider as wr, id as wt, ScheduledDeleteArgs as x, ConvexIndexBuilder as xn, ReturningSelection as xr, integer as xt, ScheduledMutationBatchArgs as y, ConvexAggregateIndexBuilder as yn, ReturningAll as yr, ConvexNumberBuilder as yt, MigrationManifestEntry as z, ConvexForeignKeyBuilder as zn, gte as zr, ConvexBooleanBuilderInitial as zt };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "better-convex",
-  "version": "0.7.2",
+  "version": "0.8.0",
   "description": "Better Convex - React Query integration and CLI tools for Convex",
   "keywords": [
     "convex",
@@ -20,6 +20,9 @@
     "./auth/nextjs": "./dist/auth/nextjs/index.js",
     "./crpc": "./dist/crpc/index.js",
     "./orm": "./dist/orm/index.js",
+    "./plugins": "./dist/plugins/index.js",
+    "./plugins/ratelimit": "./dist/plugins/ratelimit/index.js",
+    "./plugins/ratelimit/react": "./dist/plugins/ratelimit/react/index.js",
     "./react": "./dist/react/index.js",
     "./rsc": "./dist/rsc/index.js",
     "./server": "./dist/server/index.js",