better-convex 0.8.3 → 0.9.0

package/dist/orm/index.js

@@ -1,9 +1,9 @@
-import { t as DirectAggregate } from "../runtime-C0WcYGY0.js";
-import { C as integer, S as createSystemFields, T as entityKind, _ as rankIndex, a as EnableRLS, b as vectorIndex, c as OrmSchemaOptions, d as TableDeleteConfig, f as TableName, g as index, h as aggregateIndex, i as Columns, l as OrmSchemaPluginTables, m as rlsPolicy, n as deletion, o as OrmContext, p as RlsPolicy, r as Brand, s as OrmSchemaDefinition, t as convexTable, u as RlsPolicies, v as searchIndex, w as ConvexColumnBuilder, x as text, y as uniqueIndex } from "../table-B7yzBihE.js";
-import { a as AGGREGATE_EXTREMA_TABLE, c as aggregatePlugin, i as AGGREGATE_BUCKET_TABLE, l as boolean, n as MIGRATION_STATE_TABLE, o as AGGREGATE_MEMBER_TABLE, r as migrationPlugin, s as AGGREGATE_STATE_TABLE, t as MIGRATION_RUN_TABLE } from "../schema-Bx6j2doh.js";
+import { t as DirectAggregate } from "../runtime-B20PP4Qr.js";
+import { C as text, D as entityKind, E as ConvexColumnBuilder, S as vectorIndex, T as integer, _ as aggregateIndex, a as Columns, b as searchIndex, c as OrmSchemaDefinition, d as RlsPolicies, f as TableDeleteConfig, g as rlsPolicy, h as RlsPolicy, i as Brand, l as OrmSchemaOptions, m as TablePolymorphic, n as deletion, o as EnableRLS, p as TableName, r as discriminator, s as OrmContext, t as convexTable, u as OrmSchemaPluginTables, v as index, w as createSystemFields, x as uniqueIndex, y as rankIndex } from "../table-Bxqm450r.js";
+import { a as AGGREGATE_EXTREMA_TABLE, c as aggregatePlugin, i as AGGREGATE_BUCKET_TABLE, l as boolean, n as MIGRATION_STATE_TABLE, o as AGGREGATE_MEMBER_TABLE, r as migrationPlugin, s as AGGREGATE_STATE_TABLE, t as MIGRATION_RUN_TABLE } from "../schema-Cw5-LWTg.js";
 import { a as pretendRequired, i as pretend, n as deprecated } from "../validators-D_i3BK7v.js";
-import { a as objectOf, i as json, n as arrayOf, r as custom, t as id } from "../id-BcBb900m.js";
-import { t as textEnum } from "../text-enum-CFdcLUuw.js";
+import { a as objectOf, i as json, n as arrayOf, r as custom, t as id } from "../id-BF_SaWhQ.js";
+import { t as textEnum } from "../text-enum-KyijdQ8Q.js";
 import { A as ne, C as inArray, D as like, E as isNull, F as notLike, I as or, L as startsWith, M as notBetween, N as notIlike, O as lt, P as notInArray, S as ilike, T as isNotNull, _ as endsWith, a as mergedStream, b as gt, c as isUnsetToken, d as arrayContained, f as arrayContains, g as contains, h as column, i as getIndexFields, j as not, k as lte, l as unsetToken, m as between, n as EmptyStream, o as stream, p as arrayOverlaps, r as QueryStream, s as streamIndexRange, t as getByIdWithOrmQueryFallback, u as and, v as eq, w as isFieldReference, x as gte, y as fieldRef } from "../query-context-DEUFBhXS.js";
 import { v } from "convex/values";
 import { defineSchema as defineSchema$1, internalActionGeneric, internalMutationGeneric } from "convex/server";
@@ -2485,6 +2485,36 @@ function getColumnName$1(column) {
 function getTableColumns$2(table) {
 	return table[Columns] ?? {};
 }
+function getTablePolymorphicConfigs(table) {
+	const fromMethod = table.getPolymorphicConfigs?.();
+	if (Array.isArray(fromMethod)) return fromMethod;
+	const fromSymbol = table[TablePolymorphic];
+	return Array.isArray(fromSymbol) ? fromSymbol : [];
+}
+function enforcePolymorphicWrite(table, candidate, options) {
+	const configs = getTablePolymorphicConfigs(table);
+	if (configs.length === 0) return;
+	for (const config of configs) {
+		const changedFields = options?.changedFields;
+		const discriminatorChanged = !changedFields || changedFields.has(config.discriminator);
+		const generatedFieldChanged = !changedFields || config.generatedFieldNames.some((fieldName) => changedFields.has(fieldName));
+		if (!discriminatorChanged && !generatedFieldChanged) continue;
+		const discriminatorValue = candidate[config.discriminator];
+		if (typeof discriminatorValue !== "string" || !Object.hasOwn(config.variants, discriminatorValue)) throw new Error(`Invalid discriminator '${config.discriminator}' on '${getTableName(table)}'. Expected one of: ${Object.keys(config.variants).join(", ")}.`);
+		const activeVariant = config.variants[discriminatorValue];
+		if (!activeVariant) throw new Error(`Invalid discriminator '${config.discriminator}' value '${discriminatorValue}' on '${getTableName(table)}'.`);
+		for (const requiredFieldName of activeVariant.requiredFieldNames) {
+			const value = candidate[requiredFieldName];
+			if (value === null || value === void 0) throw new Error(`discriminator branch '${discriminatorValue}' requires '${requiredFieldName}' on '${getTableName(table)}'.`);
+		}
+		const activeFieldSet = new Set(activeVariant.fieldNames);
+		for (const generatedFieldName of config.generatedFieldNames) {
+			if (activeFieldSet.has(generatedFieldName)) continue;
+			const value = candidate[generatedFieldName];
+			if (value !== null && value !== void 0) throw new Error(`discriminator branch '${discriminatorValue}' cannot set '${generatedFieldName}' on '${getTableName(table)}' because it belongs to another variant.`);
+		}
+	}
+}
 function getColumnConfig(table, columnName) {
 	const builder = getTableColumns$2(table)[columnName];
 	if (!builder) return null;
@@ -2494,8 +2524,20 @@ function applyDefaults(table, value) {
 	const columns = table[Columns];
 	if (!columns) return value;
 	const result = { ...value };
+	const polymorphicConfigs = getTablePolymorphicConfigs(table);
+	const activeGeneratedFields = /* @__PURE__ */ new Set();
+	const generatedFields = /* @__PURE__ */ new Set();
+	for (const config of polymorphicConfigs) {
+		for (const fieldName of config.generatedFieldNames) generatedFields.add(fieldName);
+		const discriminatorValue = result[config.discriminator];
+		if (typeof discriminatorValue !== "string") continue;
+		const activeVariant = config.variants[discriminatorValue];
+		if (!activeVariant) continue;
+		for (const fieldName of activeVariant.fieldNames) activeGeneratedFields.add(fieldName);
+	}
 	for (const [columnName, builder] of Object.entries(columns)) {
 		if (result[columnName] !== void 0) continue;
+		if (generatedFields.has(columnName) && !activeGeneratedFields.has(columnName)) continue;
 		const config = builder.config;
 		if (!config) continue;
 		if (typeof config.defaultFn === "function") {
@@ -4816,85 +4858,57 @@ var GelRelationalQuery = class extends QueryPromise {
 		return filtered;
 	}
 	_resolvePolymorphicFinalizeState() {
-		const rawPolymorphic = this.config.polymorphic;
-		if (rawPolymorphic === void 0) return null;
-		if (!this._isRecord(rawPolymorphic)) throw new Error("polymorphic must be an object.");
-		const discriminator = rawPolymorphic.discriminator;
-		if (typeof discriminator !== "string" || discriminator.length === 0) throw new Error("polymorphic.discriminator must be a non-empty string.");
-		const aliasRaw = rawPolymorphic.as;
-		const alias = aliasRaw === void 0 ? "target" : typeof aliasRaw === "string" && aliasRaw.length > 0 ? aliasRaw : null;
-		if (!alias) throw new Error("polymorphic.as must be a non-empty string when set.");
-		const schema = rawPolymorphic.schema;
-		if (!schema || typeof schema.safeParse !== "function" && typeof schema.parse !== "function") throw new Error("polymorphic.schema must provide safeParse() or parse().");
-		const rawCases = rawPolymorphic.cases;
-		if (!this._isRecord(rawCases) || Object.keys(rawCases).length === 0) throw new Error("polymorphic.cases must be a non-empty object of discriminator-to-relation mappings.");
-		const cases = {};
-		for (const [caseKey, caseRelation] of Object.entries(rawCases)) {
-			if (typeof caseRelation !== "string" || caseRelation.length === 0) throw new Error(`polymorphic.cases.${caseKey} must be a relation name string.`);
-			const relation = this.tableConfig.relations[caseRelation];
-			if (!relation) throw new Error(`polymorphic.cases.${caseKey} references unknown relation '${caseRelation}' on '${this.tableConfig.name}'.`);
-			if (relation.relationType !== "one") throw new Error(`polymorphic.cases.${caseKey} must map to a one() relation; received '${caseRelation}'.`);
-			cases[caseKey] = caseRelation;
-		}
-		const requestedWith = this.config.with;
-		const effectiveWith = requestedWith ? { ...requestedWith } : {};
-		const autoLoadedCaseRelations = /* @__PURE__ */ new Set();
-		for (const relationName of new Set(Object.values(cases))) if (effectiveWith[relationName] === void 0) {
-			effectiveWith[relationName] = true;
-			autoLoadedCaseRelations.add(relationName);
-		}
-		return {
-			requestedWith,
-			effectiveWith: Object.keys(effectiveWith).length ? effectiveWith : void 0,
-			autoLoadedCaseRelations,
-			discriminator,
-			alias,
-			cases,
-			schema
-		};
-	}
-	_extractPolymorphicSchemaErrorMessage(error) {
-		if (!error || typeof error !== "object") return String(error);
-		const issueMessage = error.issues?.[0]?.message;
-		if (issueMessage) return issueMessage;
-		return error.message ?? String(error);
-	}
-	_synthesizePolymorphicRows(rows, config) {
-		for (const row of rows) {
+		const configs = this.tableConfig.polymorphic;
+		if (!configs || configs.length === 0) return null;
+		return { configs };
+	}
+	_resolveWithVariantsState(requestedWith, polymorphicState) {
+		const withVariants = this.config.withVariants;
+		if (withVariants === void 0 || withVariants === false) return { effectiveWith: requestedWith };
+		if (withVariants !== true) throw new Error("withVariants currently supports only `true`.");
+		if (!polymorphicState) throw new Error(`withVariants is only available on tables with discriminator(...) columns ('${this.tableConfig.name}').`);
+		const oneRelations = Object.entries(this.tableConfig.relations).filter(([, relation]) => relation.relationType === "one");
+		if (oneRelations.length === 0) return { effectiveWith: requestedWith };
+		const autoWith = Object.fromEntries(oneRelations.map(([relationName]) => [relationName, true]));
+		return { effectiveWith: requestedWith ? {
+			...autoWith,
+			...requestedWith
+		} : autoWith };
+	}
+	_assertPolymorphicAliasCollisions(configs, requestedWith, resolvedExtras) {
+		const tableColumns = this._getColumns(this.tableConfig);
+		const extras = this._isRecord(resolvedExtras) ? resolvedExtras : void 0;
+		for (const config of configs) {
+			if (config.alias in tableColumns) throw new Error(`discriminator alias '${config.alias}' on '${this.tableConfig.name}' conflicts with an existing column.`);
+			if (config.alias in this.tableConfig.relations) throw new Error(`discriminator alias '${config.alias}' on '${this.tableConfig.name}' conflicts with a relation.`);
+			if (requestedWith && config.alias in requestedWith) throw new Error(`discriminator alias '${config.alias}' on '${this.tableConfig.name}' conflicts with with.${config.alias}.`);
+			if (extras && config.alias in extras) throw new Error(`discriminator alias '${config.alias}' on '${this.tableConfig.name}' conflicts with extras.${config.alias}.`);
+		}
+	}
+	_synthesizePolymorphicRows(rows, configs) {
+		for (const row of rows) for (const config of configs) {
 			const discriminatorValue = row[config.discriminator];
 			const caseKey = String(discriminatorValue);
-			const relationName = config.cases[caseKey];
-			if (!relationName) throw new Error(`polymorphic discriminator '${config.discriminator}' value '${caseKey}' has no matching case mapping.`);
-			const targetValue = row[relationName];
-			if (targetValue === null || targetValue === void 0) throw new Error(`polymorphic case '${caseKey}' resolved relation '${relationName}' but no target row was loaded.`);
-			row[config.alias] = targetValue;
-			const payload = {
-				[config.discriminator]: discriminatorValue,
-				[config.alias]: targetValue
-			};
-			if (typeof config.schema.safeParse === "function") {
-				const result = config.schema.safeParse(payload);
-				if (!result.success) throw new Error(`polymorphic schema parse failed: ${this._extractPolymorphicSchemaErrorMessage(result.error)}`);
-			} else if (typeof config.schema.parse === "function") try {
-				config.schema.parse(payload);
-			} catch (error) {
-				throw new Error(`polymorphic schema parse failed: ${this._extractPolymorphicSchemaErrorMessage(error)}`);
-			}
-		}
-		for (const relationName of config.autoLoadedCaseRelations) {
-			if (relationName === config.alias) continue;
-			for (const row of rows) delete row[relationName];
+			const variant = config.variants[caseKey];
+			if (!variant) throw new Error(`discriminator '${config.discriminator}' value '${caseKey}' has no matching variant on '${this.tableConfig.name}'.`);
+			const nested = {};
+			for (const fieldName of variant.fieldNames) nested[fieldName] = row[fieldName];
+			row[config.alias] = nested;
 		}
 	}
 	async _finalizeRows(rows) {
 		const polymorphicState = this._resolvePolymorphicFinalizeState();
-		const requestedWith = polymorphicState?.requestedWith ?? this.config.with;
-		const effectiveWith = polymorphicState?.effectiveWith ?? this.config.with;
+		const requestedWith = this.config.with;
+		const effectiveWith = this._resolveWithVariantsState(requestedWith, polymorphicState).effectiveWith;
+		const tableColumns = this._getColumns(this.tableConfig);
+		const extrasConfig = this.config.extras;
+		const resolvedExtras = typeof extrasConfig === "function" ? extrasConfig(tableColumns) : extrasConfig;
+		if (polymorphicState) this._assertPolymorphicAliasCollisions(polymorphicState.configs, requestedWith, resolvedExtras);
 		let rowsWithRelations = rows;
 		if (effectiveWith) rowsWithRelations = await this._loadRelations(rowsWithRelations, effectiveWith, 0, 3, this.edgeMetadata, this.tableConfig);
-		if (polymorphicState) this._synthesizePolymorphicRows(rowsWithRelations, polymorphicState);
-		if (this.config.extras) rowsWithRelations = this._applyExtras(rowsWithRelations, this.config.extras, this._getColumns(this.tableConfig), requestedWith, this.tableConfig.name, this.tableConfig);
-		return this._selectColumns(rowsWithRelations, this.config.columns, this._getColumns(this.tableConfig), this.tableConfig);
+		if (polymorphicState) this._synthesizePolymorphicRows(rowsWithRelations, polymorphicState.configs);
+		if (resolvedExtras) rowsWithRelations = this._applyExtras(rowsWithRelations, resolvedExtras, tableColumns, effectiveWith, this.tableConfig.name, this.tableConfig);
+		return this._selectColumns(rowsWithRelations, this.config.columns, tableColumns, this.tableConfig);
 	}
 	_getSchemaDefinitionOrThrow() {
 		const schemaDefinition = this.schema[OrmSchemaDefinition];
@@ -6036,7 +6050,6 @@ var GelRelationalQuery = class extends QueryPromise {
 			if (config.with !== void 0) throw new Error("pipeline cannot be combined with with in findMany().");
 			if (config.extras !== void 0) throw new Error("pipeline cannot be combined with extras in findMany().");
 			if (config.columns !== void 0) throw new Error("pipeline cannot be combined with columns in findMany().");
-			if (config.polymorphic !== void 0) throw new Error("pipeline cannot be combined with polymorphic in findMany().");
 		}
 		if (pageByKey) {
 			if (this.mode !== "many") throw new Error("pageByKey is only supported on findMany().");
@@ -7534,6 +7547,7 @@ var ConvexInsertBuilder = class extends QueryPromise {
 		const results = [];
 		for (const value of this.valuesList) {
 			const preparedValue = normalizeDateFieldsForWrite(this.table, applyDefaults(this.table, value));
+			enforcePolymorphicWrite(this.table, preparedValue);
 			const rls = ormContext?.rls;
 			const tableName = getTableName(this.table);
 			if (!await canInsertRow({
@@ -8265,27 +8279,18 @@ var RelationalQueryBuilder = class RelationalQueryBuilder {
 		return new GelRankQuery(this.db, this.tableConfig, indexName, config, this.rls);
 	}
 	findMany(config) {
-		if (config && config.pipeline !== void 0) {
-			if (config.polymorphic !== void 0) throw new Error("polymorphic cannot be combined with pipeline in findMany().");
-			throw new Error("findMany({ pipeline }) is removed; use db.query.<table>.select() chain instead");
-		}
+		if (config && config.pipeline !== void 0) throw new Error("findMany({ pipeline }) is removed; use db.query.<table>.select() chain instead");
 		return this.createQuery(config ? config : {}, "many");
 	}
 	findFirst(config) {
-		if (config && config.pipeline !== void 0) {
-			if (config.polymorphic !== void 0) throw new Error("polymorphic cannot be combined with pipeline in findFirst().");
-			throw new Error("findMany({ pipeline }) is removed; use db.query.<table>.select() chain instead");
-		}
+		if (config && config.pipeline !== void 0) throw new Error("findMany({ pipeline }) is removed; use db.query.<table>.select() chain instead");
 		return this.createQuery({
 			...config ? config : {},
 			limit: 1
 		}, "first");
 	}
 	findFirstOrThrow(config) {
-		if (config && config.pipeline !== void 0) {
-			if (config.polymorphic !== void 0) throw new Error("polymorphic cannot be combined with pipeline in findFirstOrThrow().");
-			throw new Error("findMany({ pipeline }) is removed; use db.query.<table>.select() chain instead");
-		}
+		if (config && config.pipeline !== void 0) throw new Error("findMany({ pipeline }) is removed; use db.query.<table>.select() chain instead");
 		return this.createQuery({
 			...config ? config : {},
 			limit: 1
@@ -8593,6 +8598,7 @@ var ConvexUpdateBuilder = class extends QueryPromise {
 		const fkBatchSize = isPaginated ? pagination.limit : batchSize;
 		for (const { row, updatedRow, decision } of updates) {
 			if (!decision.allowed) continue;
+			enforcePolymorphicWrite(this.table, updatedRow, { changedFields: new Set(Object.keys(effectiveSet)) });
 			enforceCheckConstraints(this.table, updatedRow);
 			await enforceForeignKeys(this.db, this.table, updatedRow, { changedFields: new Set(Object.keys(effectiveSet)) });
 			await applyIncomingForeignKeyActionsOnUpdate(this.db, this.table, row, updatedRow, {
@@ -9974,6 +9980,7 @@ function buildRelations(tables, config, strict, defaults) {
 	for (const [tsName, table] of Object.entries(tables)) tablesConfig[tsName] = {
 		table,
 		name: tsName,
+		polymorphic: table[TablePolymorphic],
 		relations: config[tsName] ?? {},
 		strict,
 		defaults
@@ -9987,6 +9994,7 @@ function buildRelationsParts(tables, config, strict, defaults) {
 		tablesConfig[tsName] = {
 			table: tables[tsName],
 			name: tsName,
+			polymorphic: tables[tsName][TablePolymorphic],
 			relations,
 			strict,
 			defaults
@@ -10234,4 +10242,4 @@ function defineSchema(schema, options) {
 }
 
 //#endregion
-export { Brand, Columns, OrmNotFoundError, OrmSchemaPluginTables, RlsPolicy, RlsRole, TableName, aggregateIndex, and, arrayOf, asc, between, bigint, boolean, buildMigrationPlan, bytes, check, contains, convexTable, createOrm, custom, date, defineMigration, defineMigrationSet, defineRelations, defineRelationsPart, defineSchema, defineTriggers, deletion, deprecated, desc, detectMigrationDrift, endsWith, eq, extractRelationsConfig, fieldRef, foreignKey, getByIdWithOrmQueryFallback, getTableColumns, getTableConfig, gt, gte, id, ilike, inArray, index, integer, isFieldReference, isNotNull, isNull, json, like, lt, lte, ne, not, notBetween, notInArray, objectOf, or, pretend, pretendRequired, rankIndex, rlsPolicy, rlsRole, scheduledDeleteFactory, scheduledMutationBatchFactory, searchIndex, startsWith, text, textEnum, timestamp, unique, uniqueIndex, unsetToken, vector, vectorIndex };
+export { Brand, Columns, OrmNotFoundError, OrmSchemaPluginTables, RlsPolicy, RlsRole, TableName, aggregateIndex, and, arrayOf, asc, between, bigint, boolean, buildMigrationPlan, bytes, check, contains, convexTable, createOrm, custom, date, defineMigration, defineMigrationSet, defineRelations, defineRelationsPart, defineSchema, defineTriggers, deletion, deprecated, desc, detectMigrationDrift, discriminator, endsWith, eq, extractRelationsConfig, fieldRef, foreignKey, getByIdWithOrmQueryFallback, getTableColumns, getTableConfig, gt, gte, id, ilike, inArray, index, integer, isFieldReference, isNotNull, isNull, json, like, lt, lte, ne, not, notBetween, notInArray, objectOf, or, pretend, pretendRequired, rankIndex, rlsPolicy, rlsRole, scheduledDeleteFactory, scheduledMutationBatchFactory, searchIndex, startsWith, text, textEnum, timestamp, unique, uniqueIndex, unsetToken, vector, vectorIndex };

package/dist/plugins/index.d.ts

@@ -1,8 +1,8 @@
-import "../validators-BcQFm1oY.js";
-import { k as migrationPlugin, ri as OrmSchemaPlugin } from "../where-clause-compiler-m-GQNB_K.js";
-import "../query-context-ji7By8u0.js";
-import "../orm/index.js";
+import { ii as OrmSchemaPlugin } from "../where-clause-compiler-UavDdMUX.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

package/dist/plugins/index.js

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

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

@@ -1,7 +1,4 @@
-import "../../validators-BcQFm1oY.js";
-import { ri as OrmSchemaPlugin } from "../../where-clause-compiler-m-GQNB_K.js";
-import "../../query-context-ji7By8u0.js";
-import "../../orm/index.js";
+import { ii as OrmSchemaPlugin } from "../../where-clause-compiler-UavDdMUX.js";
 import * as convex_server0 from "convex/server";
 
 //#region src/plugins/ratelimit/duration.d.ts

package/dist/plugins/ratelimit/index.js

@@ -1,5 +1,5 @@
-import { C as integer, g as index, t as convexTable, x as text } from "../../table-B7yzBihE.js";
-import { t as textEnum } from "../../text-enum-CFdcLUuw.js";
+import { C as text, T as integer, t as convexTable, v as index } from "../../table-Bxqm450r.js";
+import { t as textEnum } from "../../text-enum-KyijdQ8Q.js";
 import { v } from "convex/values";
 import { mutationGeneric, queryGeneric } from "convex/server";
 

package/dist/{runtime-C0WcYGY0.js → runtime-B20PP4Qr.js}

@@ -1,5 +1,5 @@
-import { C as integer, g as index, t as convexTable, x as text } from "./table-B7yzBihE.js";
-import { r as custom, t as id } from "./id-BcBb900m.js";
+import { C as text, T as integer, t as convexTable, v as index } from "./table-Bxqm450r.js";
+import { r as custom, t as id } from "./id-BF_SaWhQ.js";
 import { ConvexError, convexToJson, jsonToConvex, v } from "convex/values";
 
 //#region src/aggregate-core/compare.ts

package/dist/{schema-Bx6j2doh.js → schema-Cw5-LWTg.js}

@@ -1,5 +1,5 @@
-import { C as integer, T as entityKind, g as index, t as convexTable, w as ConvexColumnBuilder, x as text } from "./table-B7yzBihE.js";
-import { r as custom, t as id } from "./id-BcBb900m.js";
+import { C as text, D as entityKind, E as ConvexColumnBuilder, T as integer, t as convexTable, v as index } from "./table-Bxqm450r.js";
+import { r as custom, t as id } from "./id-BF_SaWhQ.js";
 import { v } from "convex/values";
 
 //#region src/orm/builders/boolean.ts

package/dist/server/index.d.ts

@@ -1,4 +1,3 @@
-import "../validators-BcQFm1oY.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-DYjpq7rG.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-BK7FuIcR.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/{table-B7yzBihE.js → table-Bxqm450r.js}

@@ -529,6 +529,7 @@ const OrmContext = Symbol.for("better-convex:OrmContext");
 const RlsPolicies = Symbol.for("better-convex:RlsPolicies");
 const EnableRLS = Symbol.for("better-convex:EnableRLS");
 const TableDeleteConfig = Symbol.for("better-convex:TableDeleteConfig");
+const TablePolymorphic = Symbol.for("better-convex:TablePolymorphic");
 const OrmSchemaOptions = Symbol.for("better-convex:OrmSchemaOptions");
 const OrmSchemaDefinition = Symbol.for("better-convex:OrmSchemaDefinition");
 const OrmSchemaPluginTables = Symbol.for("better-convex:OrmSchemaPluginTables");
@@ -544,6 +545,8 @@ const RESERVED_COLUMN_NAMES = new Set([
 	"_id",
 	"_creationTime"
 ]);
+const DEFAULT_POLYMORPHIC_ALIAS = "details";
+const CONVEX_TABLE_FIELD_LIMIT = 1024;
 /**
 * Valid table name pattern: starts with letter/underscore, contains only alphanumeric and underscore
 */
@@ -568,6 +571,21 @@ function createValidatorFromColumns(columns) {
 	const validatorFields = Object.fromEntries(Object.entries(columns).map(([key, builder]) => [key, builder.convexValidator]));
 	return v.object(validatorFields);
 }
+function discriminator(config) {
+	if (!config || typeof config !== "object") throw new Error("discriminator(...) requires a config object.");
+	if (!config.variants || typeof config.variants !== "object" || Object.keys(config.variants).length === 0) throw new Error("discriminator(...).variants must contain at least one case.");
+	if (config.as !== void 0 && (typeof config.as !== "string" || config.as.length === 0)) throw new Error("discriminator(...).as must be a non-empty string when set.");
+	const builder = text().notNull();
+	builder.__polymorphic = {
+		as: config.as ?? DEFAULT_POLYMORPHIC_ALIAS,
+		variants: config.variants
+	};
+	builder.config.discriminator = {
+		as: config.as,
+		variants: config.variants
+	};
+	return builder;
+}
 var ConvexDeletionBuilder = class {
 	static [entityKind] = "ConvexDeletionBuilder";
 	[entityKind] = "ConvexDeletionBuilder";
@@ -699,6 +717,86 @@ function assertRankOrderFieldType(column, indexName) {
 	].includes(columnType)) throw new Error(`rankIndex '${indexName}' orderBy() supports integer()/timestamp()/date() columns only. Field '${getColumnName(column)}' is type '${columnType}'.`);
 }
 const dedupeFieldNames = (fields) => [...new Set(fields)];
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isColumnBuilder = (value) => isRecord(value) && typeof value.build === "function";
+const getDiscriminatorConfig = (value) => {
+	if (!isColumnBuilder(value)) return;
+	const discriminator = value.config?.discriminator;
+	if (!discriminator) return;
+	return discriminator;
+};
+const getPolymorphicFieldSignature = (column) => {
+	const validator = column.convexValidator ?? column.build();
+	return JSON.stringify({
+		columnType: column.config?.columnType,
+		validator: validator?.json
+	});
+};
+function resolveTableColumns(tableName, columns) {
+	const resolvedColumns = {};
+	const pendingPolymorphic = [];
+	for (const [columnName, rawBuilder] of Object.entries(columns)) {
+		if (!isColumnBuilder(rawBuilder)) throw new Error(`Column '${columnName}' on '${tableName}' must be a column builder.`);
+		resolvedColumns[columnName] = rawBuilder;
+		const discriminatorConfig = getDiscriminatorConfig(rawBuilder);
+		if (!discriminatorConfig) continue;
+		if (!isRecord(discriminatorConfig.variants) || Object.keys(discriminatorConfig.variants).length === 0) throw new Error(`discriminator('${tableName}.${columnName}') requires at least one variant.`);
+		const alias = discriminatorConfig.as === void 0 ? DEFAULT_POLYMORPHIC_ALIAS : discriminatorConfig.as;
+		if (typeof alias !== "string" || alias.length === 0) throw new Error(`discriminator('${tableName}.${columnName}').as must be a non-empty string.`);
+		pendingPolymorphic.push({
+			discriminator: columnName,
+			alias,
+			variants: discriminatorConfig.variants
+		});
+	}
+	if (pendingPolymorphic.length > 1) throw new Error(`Only one discriminator(...) column is currently supported on '${tableName}'.`);
+	const polymorphicConfigs = [];
+	for (const pending of pendingPolymorphic) {
+		if (pending.alias in resolvedColumns) throw new Error(`discriminator('${tableName}.${pending.discriminator}') alias '${pending.alias}' collides with an existing column.`);
+		const generatedFieldMap = /* @__PURE__ */ new Map();
+		const variantRuntime = {};
+		for (const [variantKey, rawVariantColumns] of Object.entries(pending.variants)) {
+			if (!isRecord(rawVariantColumns)) throw new Error(`discriminator('${tableName}.${pending.discriminator}') variant '${variantKey}' must be an object.`);
+			const fieldNames = [];
+			const requiredFieldNames = [];
+			for (const [fieldName, rawFieldBuilder] of Object.entries(rawVariantColumns)) {
+				if (!isColumnBuilder(rawFieldBuilder)) throw new Error(`discriminator('${tableName}.${pending.discriminator}').variants.${variantKey}.${fieldName} must be a column builder.`);
+				if (fieldName in resolvedColumns) throw new Error(`discriminator('${tableName}.${pending.discriminator}').variants.${variantKey}.${fieldName} collides with an existing table column.`);
+				const fieldBuilder = rawFieldBuilder;
+				const fieldConfig = fieldBuilder.config;
+				const isRequiredForVariant = fieldConfig?.notNull === true && fieldConfig.hasDefault !== true && typeof fieldConfig.defaultFn !== "function";
+				const signature = getPolymorphicFieldSignature(fieldBuilder);
+				const existing = generatedFieldMap.get(fieldName);
+				if (existing && existing.signature !== signature) throw new Error(`discriminator('${tableName}.${pending.discriminator}') field '${fieldName}' has conflicting builder signatures across variants.`);
+				if (!existing) {
+					if (fieldConfig) fieldConfig.notNull = false;
+					generatedFieldMap.set(fieldName, {
+						builder: fieldBuilder,
+						signature
+					});
+				}
+				fieldNames.push(fieldName);
+				if (isRequiredForVariant) requiredFieldNames.push(fieldName);
+			}
+			variantRuntime[variantKey] = {
+				fieldNames,
+				requiredFieldNames
+			};
+		}
+		for (const [fieldName, { builder }] of generatedFieldMap.entries()) resolvedColumns[fieldName] = builder;
+		polymorphicConfigs.push({
+			discriminator: pending.discriminator,
+			alias: pending.alias,
+			generatedFieldNames: Object.freeze([...generatedFieldMap.keys()]),
+			variants: Object.freeze(variantRuntime)
+		});
+	}
+	if (Object.keys(resolvedColumns).length > CONVEX_TABLE_FIELD_LIMIT) throw new Error(`Table '${tableName}' exceeds Convex field count limit (${CONVEX_TABLE_FIELD_LIMIT}) after discriminator expansion.`);
+	return {
+		columns: resolvedColumns,
+		polymorphicConfigs
+	};
+}
 function applyExtraConfig(table, config) {
 	if (!config) return;
 	const entries = Array.isArray(config) ? config : Object.values(config);
@@ -920,11 +1018,12 @@ var ConvexTableImpl = class {
 	[EnableRLS] = false;
 	[RlsPolicies] = [];
 	[TableDeleteConfig];
+	[TablePolymorphic];
 	/**
 	* Public tableName for convenience
 	*/
 	tableName;
-	constructor(name, columns) {
+	constructor(name, columns, polymorphicConfigs) {
 		validateTableName(name);
 		for (const columnName of Object.keys(columns)) if (RESERVED_COLUMN_NAMES.has(columnName)) throw new Error(`Column name '${columnName}' is reserved. System fields are managed by Convex ORM.`);
 		this[TableName] = name;
@@ -936,6 +1035,7 @@ var ConvexTableImpl = class {
 		}));
 		this[Columns] = namedColumns;
 		this.tableName = name;
+		if (polymorphicConfigs && polymorphicConfigs.length > 0) this[TablePolymorphic] = polymorphicConfigs;
 		this.validator = createValidatorFromColumns(namedColumns);
 		for (const [columnName, builder] of Object.entries(namedColumns)) {
 			const config = builder.config;
@@ -958,6 +1058,9 @@ var ConvexTableImpl = class {
 			});
 		}
 	}
+	getPolymorphicConfigs() {
+		return this[TablePolymorphic];
+	}
 	/**
 	* Internal: add index to table from builder extraConfig
 	*
@@ -1163,7 +1266,8 @@ var ConvexTableImpl = class {
 	}
 };
 const convexTableInternal = (name, columns, extraConfig) => {
-	const rawTable = new ConvexTableImpl(name, columns);
+	const expanded = resolveTableColumns(name, columns);
+	const rawTable = new ConvexTableImpl(name, expanded.columns, expanded.polymorphicConfigs);
 	const systemFields = createSystemFields(name);
 	for (const builder of Object.values(systemFields)) builder.config.table = rawTable;
 	const table = Object.assign(rawTable, systemFields, rawTable[Columns]);
@@ -1192,4 +1296,4 @@ const convexTableWithRLS = (name, columns, extraConfig) => {
 const convexTable = Object.assign(convexTableInternal, { withRLS: convexTableWithRLS });
 
 //#endregion
-export { integer as C, createSystemFields as S, entityKind as T, rankIndex as _, EnableRLS as a, vectorIndex as b, OrmSchemaOptions as c, TableDeleteConfig as d, TableName as f, index as g, aggregateIndex as h, Columns as i, OrmSchemaPluginTables as l, rlsPolicy as m, deletion as n, OrmContext as o, RlsPolicy as p, Brand as r, OrmSchemaDefinition as s, convexTable as t, RlsPolicies as u, searchIndex as v, ConvexColumnBuilder as w, text as x, uniqueIndex as y };
+export { text as C, entityKind as D, ConvexColumnBuilder as E, vectorIndex as S, integer as T, aggregateIndex as _, Columns as a, searchIndex as b, OrmSchemaDefinition as c, RlsPolicies as d, TableDeleteConfig as f, rlsPolicy as g, RlsPolicy as h, Brand as i, OrmSchemaOptions as l, TablePolymorphic as m, deletion as n, EnableRLS as o, TableName as p, discriminator as r, OrmContext as s, convexTable as t, OrmSchemaPluginTables as u, index as v, createSystemFields as w, uniqueIndex as x, rankIndex as y };

package/dist/{text-enum-CFdcLUuw.js → text-enum-KyijdQ8Q.js}

@@ -1,4 +1,4 @@
-import { T as entityKind, w as ConvexColumnBuilder } from "./table-B7yzBihE.js";
+import { D as entityKind, E as ConvexColumnBuilder } from "./table-Bxqm450r.js";
 import { v } from "convex/values";
 
 //#region src/orm/builders/text-enum.ts