better-convex 0.8.4 → 0.9.0

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