@happyvertical/smrt-core 0.40.69 → 0.41.0

package/dist/registry/schema-builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema-builder.d.ts","sourceRoot":"","sources":["../../src/registry/schema-builder.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE3D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAK7D,OAAO,KAAK,EACV,gBAAgB,EAEhB,gBAAgB,EAChB,WAAW,EACZ,MAAM,oBAAoB,CAAC;AA6I5B;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAIpE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE,cAAc,GACtB,MAAM,GAAG,SAAS,CAWpB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAkB7D;AAyCD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAC3B,MAAM,CAAC,EAAE,cAAc,GACtB,MAAM,CAAC,MAAM,EAAE;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CA+OxE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,IAAI,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CA2K7E;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,EACzC,KAAK,UAAQ,EACb,MAAM,CAAC,EAAE,cAAc,GACtB,MAAM,CAwDR;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAEvE;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,GACnC,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAgFlC;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,eAAe,CAAC,MAAM,CAAC,GACjC,WAAW,CAqBb"}
+{"version":3,"file":"schema-builder.d.ts","sourceRoot":"","sources":["../../src/registry/schema-builder.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAG3D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAM7D,OAAO,KAAK,EACV,gBAAgB,EAEhB,gBAAgB,EAChB,WAAW,EACZ,MAAM,oBAAoB,CAAC;AAmL5B;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAIpE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE,cAAc,GACtB,MAAM,GAAG,SAAS,CAWpB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAkB7D;AAwTD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAC3B,MAAM,CAAC,EAAE,cAAc,GACtB,MAAM,CAAC,MAAM,EAAE;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAmFxE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,IAAI,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAsC7E;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,EACzC,KAAK,UAAQ,EACb,MAAM,CAAC,EAAE,cAAc,GACtB,MAAM,CAwDR;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAEvE;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;;;;;;;OAQG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,EACpC,OAAO,CAAC,EAAE,sBAAsB,GAC/B,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAwFlC;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,eAAe,CAAC,MAAM,CAAC,GACjC,WAAW,CAqBb"}

package/dist/registry/schema-builder.js

@@ -1,9 +1,12 @@
+import { classnameToTablename, toSnakeCase } from "../utils/naming.js";
 import { formatDefaultValue as formatDefaultValue$1, quoteIdentifier } from "../schema/sql-identifiers.js";
+import { shortenIdentifier } from "../schema/index-utils.js";
 import { getDDLStrategy } from "../schema/ddl/index.js";
 import { getClasses, getCollectionTableNames } from "./shared-state.js";
 import { findClass } from "./name-resolver.js";
-import { classnameToTablename, toSnakeCase } from "../utils/naming.js";
+import { conflictIndexName } from "../schema/conflict-target.js";
 import "../utils.js";
+import { readFieldAttribute } from "./manifest-field-merge.js";
 import { isCollectionRegistration } from "./collection-resolution.js";
 import { ObjectRegistry } from "../registry.js";
 //#region src/registry/schema-builder.ts
@@ -34,10 +37,10 @@ function applyDecoratorSqlTypeOverrides(className, columns) {
 	}
 	return columns;
 }
-function mergeRuntimeFieldColumns(className, schemaColumns, fields) {
+function mergeRuntimeFieldColumns(className, schemaColumns, fields, options) {
 	const columnsToUse = { ...schemaColumns || {} };
 	if (fields.size > 0) {
-		const fieldColumns = fieldsToColumns(fields);
+		const fieldColumns = fieldsToColumns(fields, options);
 		for (const [columnName, columnDef] of Object.entries(fieldColumns)) if (!columnsToUse[columnName]) columnsToUse[columnName] = columnDef;
 		for (const [fieldName, fieldDef] of fields) {
 			const columnName = toSnakeCase(fieldName);
@@ -60,24 +63,58 @@ function getReferenceKind(fieldDef) {
 	if (fieldDef.type === "foreignKey") return "foreignKey";
 	if (fieldDef.type === "crossPackageRef") return "crossPackageRef";
 }
-function shouldEmitDefault(fieldDef, sqlType) {
-	return !(getReferenceKind(fieldDef) === "tenantId" && sqlType === "UUID" && fieldDef.default === "");
+function shouldEmitDefault(fieldDef, sqlType, defaultValue) {
+	return !(getReferenceKind(fieldDef) === "tenantId" && sqlType === "UUID" && defaultValue === "");
 }
-function createBaseColumns(registered) {
-	return {
+/**
+* Fallback base columns for a table whose contributing class carries no
+* manifest columns.
+*
+* These mirror what the manifest schema generators emit for the same table
+* (`generateSchemaFromManifest` / `generateSTISchemaFromManifest`), so a table
+* assembled from runtime field metadata alone has the same NOT NULL and
+* DEFAULT shape as one assembled from a manifest. Divergence here is what made
+* the merged table shape depend on which class registered first (#2372).
+*/
+function createBaseColumns(registered, isSTI) {
+	const baseColumns = {
 		id: {
 			type: registered.config?.idType === "text" ? "TEXT" : "UUID",
 			primaryKey: true,
+			notNull: true,
 			referenceKind: "id"
 		},
 		slug: {
 			type: "TEXT",
 			notNull: true
 		},
-		context: { type: "TEXT" },
-		created_at: { type: "TIMESTAMP" },
-		updated_at: { type: "TIMESTAMP" }
+		context: {
+			type: "TEXT",
+			notNull: true,
+			defaultValue: ""
+		},
+		created_at: {
+			type: "TIMESTAMP",
+			notNull: true,
+			defaultValue: "current_timestamp"
+		},
+		updated_at: {
+			type: "TIMESTAMP",
+			notNull: true,
+			defaultValue: "current_timestamp"
+		}
 	};
+	if (isSTI) {
+		baseColumns._meta_type = {
+			type: "TEXT",
+			notNull: true
+		};
+		baseColumns._meta_data = {
+			type: "JSON",
+			notNull: false
+		};
+	}
+	return baseColumns;
 }
 /**
 * Get cached schema definition for a registered class
@@ -139,14 +176,151 @@ function getTableName(name) {
 }
 function withConflictIndex(tableName, columns, indexes, conflictColumns) {
 	if (conflictColumns.length === 0 || !conflictColumns.every((column) => columns[column])) return indexes;
+	const primaryKeyColumns = Object.entries(columns).filter(([, column]) => column.primaryKey === true).map(([name]) => name);
+	if (primaryKeyColumns.length > 0 && primaryKeyColumns.length === conflictColumns.length && primaryKeyColumns.every((column) => conflictColumns.includes(column))) return indexes;
 	if (indexes.some((index) => index.unique === true && !index.where && !index.jsonPath && index.columns.length === conflictColumns.length && index.columns.every((column) => conflictColumns.includes(column)))) return indexes;
-	const preferredName = `${tableName}_${(conflictColumns.length > 2 ? conflictColumns.slice(0, 2) : conflictColumns).join("_")}_idx`;
-	const name = indexes.some((index) => index.name === preferredName) ? `${preferredName}_unique` : preferredName;
-	return [...indexes, {
+	const tenantColumn = Object.entries(columns).find(([, column]) => column.referenceKind === "tenantId")?.[0];
+	const name = shortenIdentifier(conflictIndexName(tableName, conflictColumns, tenantColumn));
+	const conflictIndex = {
 		name,
 		columns: conflictColumns,
 		unique: true
-	}];
+	};
+	if (indexes.some((index) => index.name === name)) return indexes.map((index) => index.name === name ? conflictIndex : index);
+	return [...indexes, conflictIndex];
+}
+/**
+* Resolve the physical table a registered class writes to.
+*
+* STI subclasses are folded onto their base's table. Returns `undefined` when
+* the class has no table (for example an unresolvable manifest stub).
+*
+* R5-canon: STI lookups use the qualified key so a colliding simple name in
+* another package cannot yield the wrong table strategy or STI base and move
+* this class's columns under that other package's table.
+*/
+function resolveContributorTable(registered, fallbackName) {
+	const simpleName = registered.name || fallbackName;
+	const qualifiedName = registered.qualifiedName ?? simpleName;
+	if (!registered.schema?.tableName && registered.extends) {
+		if (ObjectRegistry.getTableStrategy(qualifiedName) === "sti") {
+			const stiBaseName = ObjectRegistry.getSTIBase(qualifiedName);
+			if (stiBaseName && stiBaseName !== qualifiedName) {
+				const stiBaseClass = findClass(stiBaseName);
+				if (stiBaseClass?.schema?.tableName) {
+					if (!registered.schema) registered.schema = {
+						tableName: "",
+						ddl: "",
+						columns: {},
+						indexes: [],
+						triggers: [],
+						foreignKeys: [],
+						dependencies: [],
+						version: ""
+					};
+					registered.schema.tableName = stiBaseClass.schema.tableName;
+				}
+			}
+		}
+	}
+	if (!registered.schema?.tableName) return;
+	let tableName = registered.schema.tableName;
+	const isSTI = ObjectRegistry.getTableStrategy(qualifiedName) === "sti";
+	let isSTIBase = isSTI;
+	let conflictKey = qualifiedName;
+	if (isSTI) {
+		const stiBaseName = ObjectRegistry.getSTIBase(qualifiedName);
+		if (stiBaseName) {
+			conflictKey = stiBaseName;
+			if (stiBaseName !== qualifiedName) {
+				isSTIBase = false;
+				const stiBaseClass = findClass(stiBaseName);
+				if (stiBaseClass?.schema?.tableName) tableName = stiBaseClass.schema.tableName;
+			}
+		}
+	}
+	return {
+		tableName,
+		contributor: {
+			registered,
+			simpleName,
+			qualifiedName,
+			isSTI,
+			isSTIBase,
+			depth: ObjectRegistry.getInheritanceChain(qualifiedName).length,
+			conflictKey
+		}
+	};
+}
+/**
+* Order the classes that share one table deterministically.
+*
+* The first contributor seeds the table: it supplies the base columns, the
+* `idType`, the conflict columns and the cached DDL, and its columns win every
+* merge conflict. Registration order must not decide that, or the same
+* hierarchy yields a different table shape depending on which class a manifest
+* happens to list first — child-first dropped NOT NULL and DEFAULT from the
+* base columns (#2372).
+*
+* Order: the STI base first, then ancestors before descendants, then by
+* qualified name so the result is a total order.
+*/
+function sortTableContributors(contributors) {
+	return [...contributors].sort((a, b) => {
+		if (a.isSTIBase !== b.isSTIBase) return a.isSTIBase ? -1 : 1;
+		if (a.depth !== b.depth) return a.depth - b.depth;
+		return a.qualifiedName.localeCompare(b.qualifiedName);
+	});
+}
+/**
+* Assemble every physical table from the classes that contribute to it.
+*
+* Shared by {@link getAllSchemas} and {@link getAllSchemasAsDefinitions} so
+* both produce the same merged shape. The result depends only on what is
+* registered, never on the order it was registered in.
+*/
+function buildMergedTableSchemas() {
+	const contributorsByTable = /* @__PURE__ */ new Map();
+	for (const [className, registered] of getClasses()) {
+		if (isCollectionRegistration(className, registered, collectionRegistrationLookup)) continue;
+		const resolved = resolveContributorTable(registered, className);
+		if (!resolved) continue;
+		const existing = contributorsByTable.get(resolved.tableName);
+		if (existing) existing.push(resolved.contributor);
+		else contributorsByTable.set(resolved.tableName, [resolved.contributor]);
+	}
+	const tableSchemas = {};
+	for (const [tableName, contributors] of contributorsByTable) for (const contributor of sortTableContributors(contributors)) {
+		const { registered, simpleName, isSTI } = contributor;
+		const columnsToUse = mergeRuntimeFieldColumns(simpleName, registered.schema?.columns, registered.fields, { stiUnionColumns: isSTI });
+		let tableSchema = tableSchemas[tableName];
+		if (!tableSchema) {
+			tableSchema = {
+				tableName,
+				columns: {
+					...createBaseColumns(registered, isSTI),
+					...columnsToUse
+				},
+				indexes: [],
+				ddl: registered.schema?.ddl || "",
+				isSTI,
+				conflictColumns: ObjectRegistry.getConflictColumns(contributor.conflictKey)
+			};
+			tableSchemas[tableName] = tableSchema;
+		} else for (const [colName, colDef] of Object.entries(columnsToUse)) if (!tableSchema.columns[colName]) tableSchema.columns[colName] = colDef;
+		const schemaIndexes = registered.schema?.indexes;
+		if (schemaIndexes && schemaIndexes.length > 0) {
+			const existingNames = new Set(tableSchema.indexes.map((index) => index.name));
+			for (const index of schemaIndexes) {
+				if (typeof index === "string") continue;
+				if (!existingNames.has(index.name)) {
+					tableSchema.indexes.push(index);
+					existingNames.add(index.name);
+				}
+			}
+		}
+	}
+	return tableSchemas;
 }
 /**
 * Get all pre-generated schemas for explicit adapter bootstrap paths.
@@ -164,81 +338,7 @@ function withConflictIndex(tableName, columns, indexes, conflictColumns) {
 * ```
 */
 function getAllSchemas(engine) {
-	const tableSchemas = {};
-	for (const [_className, registered] of getClasses()) {
-		if (isCollectionRegistration(_className, registered, collectionRegistrationLookup)) continue;
-		const simpleName = registered.name || _className;
-		if (!registered.schema?.tableName && registered.extends) {
-			const qualifiedName = registered.qualifiedName ?? simpleName;
-			const lookupKey = qualifiedName;
-			if (ObjectRegistry.getTableStrategy(lookupKey) === "sti") {
-				const stiBaseName = ObjectRegistry.getSTIBase(lookupKey);
-				if (stiBaseName && stiBaseName !== qualifiedName) {
-					const stiBaseClass = findClass(stiBaseName);
-					if (stiBaseClass?.schema?.tableName) {
-						if (!registered.schema) registered.schema = {
-							tableName: "",
-							ddl: "",
-							columns: {},
-							indexes: [],
-							triggers: [],
-							foreignKeys: [],
-							dependencies: [],
-							version: ""
-						};
-						registered.schema.tableName = stiBaseClass.schema.tableName;
-					}
-				}
-			}
-		}
-		if (registered.schema?.tableName) {
-			let tableName = registered.schema.tableName;
-			const qualifiedName = registered.qualifiedName ?? simpleName;
-			const lookupKey = qualifiedName;
-			const tableStrategy = ObjectRegistry.getTableStrategy(lookupKey);
-			if (tableStrategy === "sti") {
-				const stiBaseName = ObjectRegistry.getSTIBase(lookupKey);
-				if (stiBaseName && stiBaseName !== qualifiedName) {
-					const stiBaseClass = findClass(stiBaseName);
-					if (stiBaseClass?.schema?.tableName) tableName = stiBaseClass.schema.tableName;
-				}
-			}
-			const columnsToUse = mergeRuntimeFieldColumns(simpleName, registered.schema.columns, registered.fields);
-			if (!tableSchemas[tableName]) {
-				const baseColumns = createBaseColumns(registered);
-				const isSTI = tableStrategy === "sti";
-				if (isSTI) {
-					baseColumns._meta_type = {
-						type: "TEXT",
-						notNull: true,
-						defaultValue: ""
-					};
-					baseColumns._meta_data = { type: "JSON" };
-				}
-				tableSchemas[tableName] = {
-					tableName,
-					columns: {
-						...baseColumns,
-						...columnsToUse
-					},
-					indexes: [],
-					ddl: registered.schema.ddl || "",
-					isSTI,
-					conflictColumns: ObjectRegistry.getConflictColumns(isSTI ? ObjectRegistry.getSTIBase(lookupKey) || lookupKey : lookupKey)
-				};
-			} else for (const [colName, colDef] of Object.entries(columnsToUse)) if (!tableSchemas[tableName].columns[colName]) tableSchemas[tableName].columns[colName] = colDef;
-			if (registered.schema.indexes && registered.schema.indexes.length > 0) {
-				const existingNames = new Set(tableSchemas[tableName].indexes.map((idx) => typeof idx === "string" ? idx : idx.name));
-				for (const idx of registered.schema.indexes) {
-					const indexName = typeof idx === "string" ? idx : idx.name;
-					if (!existingNames.has(indexName)) if (typeof idx === "string") {} else {
-						tableSchemas[tableName].indexes.push(idx);
-						existingNames.add(idx.name);
-					}
-				}
-			}
-		}
-	}
+	const tableSchemas = buildMergedTableSchemas();
 	const schemas = {};
 	for (const [tableName, tableSchema] of Object.entries(tableSchemas)) {
 		const engineIndexes = engine ? withConflictIndex(tableName, tableSchema.columns, tableSchema.indexes, tableSchema.conflictColumns) : tableSchema.indexes;
@@ -285,77 +385,7 @@ function getAllSchemas(engine) {
 * @returns Map of tableName to SchemaDefinition
 */
 function getAllSchemasAsDefinitions() {
-	const tableSchemas = {};
-	for (const [_className, registered] of getClasses()) {
-		if (isCollectionRegistration(_className, registered, collectionRegistrationLookup)) continue;
-		const simpleName = registered.name || _className;
-		if (!registered.schema?.tableName && registered.extends) {
-			const qualifiedName = registered.qualifiedName ?? simpleName;
-			const lookupKey = qualifiedName;
-			if (ObjectRegistry.getTableStrategy(lookupKey) === "sti") {
-				const stiBaseName = ObjectRegistry.getSTIBase(lookupKey);
-				if (stiBaseName && stiBaseName !== qualifiedName) {
-					const stiBaseClass = findClass(stiBaseName);
-					if (stiBaseClass?.schema?.tableName) {
-						if (!registered.schema) registered.schema = {
-							tableName: "",
-							ddl: "",
-							columns: {},
-							indexes: [],
-							triggers: [],
-							foreignKeys: [],
-							dependencies: [],
-							version: ""
-						};
-						registered.schema.tableName = stiBaseClass.schema.tableName;
-					}
-				}
-			}
-		}
-		if (registered.schema?.tableName) {
-			let tableName = registered.schema.tableName;
-			const qualifiedName = registered.qualifiedName ?? simpleName;
-			const lookupKey = qualifiedName;
-			const tableStrategy = ObjectRegistry.getTableStrategy(lookupKey);
-			if (tableStrategy === "sti") {
-				const stiBaseName = ObjectRegistry.getSTIBase(lookupKey);
-				if (stiBaseName && stiBaseName !== qualifiedName) {
-					const stiBaseClass = findClass(stiBaseName);
-					if (stiBaseClass?.schema?.tableName) tableName = stiBaseClass.schema.tableName;
-				}
-			}
-			const columnsToUse = mergeRuntimeFieldColumns(simpleName, registered.schema.columns, registered.fields);
-			if (!tableSchemas[tableName]) {
-				const baseColumns = createBaseColumns(registered);
-				const isSTI = tableStrategy === "sti";
-				if (isSTI) {
-					baseColumns._meta_type = {
-						type: "TEXT",
-						notNull: true,
-						defaultValue: ""
-					};
-					baseColumns._meta_data = { type: "JSON" };
-				}
-				tableSchemas[tableName] = {
-					tableName,
-					columns: {
-						...baseColumns,
-						...columnsToUse
-					},
-					indexes: [],
-					isSTI,
-					conflictColumns: ObjectRegistry.getConflictColumns(isSTI ? ObjectRegistry.getSTIBase(lookupKey) || lookupKey : lookupKey)
-				};
-			} else for (const [colName, colDef] of Object.entries(columnsToUse)) if (!tableSchemas[tableName].columns[colName]) tableSchemas[tableName].columns[colName] = colDef;
-			if (registered.schema.indexes && registered.schema.indexes.length > 0) {
-				const existingNames = new Set(tableSchemas[tableName].indexes.map((idx) => idx.name));
-				for (const idx of registered.schema.indexes) if (!existingNames.has(idx.name)) {
-					tableSchemas[tableName].indexes.push(idx);
-					existingNames.add(idx.name);
-				}
-			}
-		}
-	}
+	const tableSchemas = buildMergedTableSchemas();
 	const schemas = {};
 	for (const [tableName, tableSchema] of Object.entries(tableSchemas)) {
 		if (Object.keys(tableSchema.columns).length === 0) continue;
@@ -427,11 +457,17 @@ function formatDefaultValue(value, type) {
 * Used by getAllSchemas() to generate columns from fields when a class
 * has no pre-generated schema (e.g., STI subclasses registered from manifest).
 *
+* `required`, `default`, and `description` are read from either the top level
+* or `_meta`: registry-sourced fields normalize them into `_meta`, so reading
+* only the top level dropped NOT NULL and DEFAULT for every such field
+* (#2372).
+*
 * @param fields - Map of field name to field definition
+* @param options - Table-shape options (see {@link FieldsToColumnsOptions})
 * @returns Record of column name to column definition
 * @private
 */
-function fieldsToColumns(fields) {
+function fieldsToColumns(fields, options) {
 	const columns = {};
 	for (const [fieldName, fieldDef] of fields) {
 		if (fieldName === "id" || fieldName === "created_at" || fieldName === "updated_at" || fieldName === "slug" || fieldName === "context") continue;
@@ -440,14 +476,18 @@ function fieldsToColumns(fields) {
 		if (fieldDef.type === "meta") continue;
 		const sqlType = fieldDef._meta?.sqlType || (fieldDef.type === "crossPackageRef" && (fieldDef._meta?.idType === "text" || fieldDef.idType === "text") ? "TEXT" : mapFieldTypeToSQL(fieldDef.type));
 		const normalizedSqlType = String(sqlType).toUpperCase();
+		const referenceKind = getReferenceKind(fieldDef);
+		const required = readFieldAttribute(fieldDef, "required");
+		const defaultValue = readFieldAttribute(fieldDef, "default");
+		const description = readFieldAttribute(fieldDef, "description");
 		const column = {
 			type: normalizedSqlType,
-			referenceKind: getReferenceKind(fieldDef),
-			notNull: fieldDef._meta?.nullable ? false : fieldDef.required || false,
+			referenceKind,
+			notNull: options?.stiUnionColumns ? false : fieldDef._meta?.nullable ? false : Boolean(required),
 			unique: fieldDef._meta?.unique || false,
-			description: fieldDef.description
+			description
 		};
-		if (fieldDef.default !== void 0 && shouldEmitDefault(fieldDef, normalizedSqlType)) column.defaultValue = fieldDef.default;
+		if (defaultValue !== void 0 && shouldEmitDefault(fieldDef, normalizedSqlType, defaultValue)) column.defaultValue = defaultValue;
 		if (fieldDef.type === "foreignKey" && fieldDef.related) {
 			const [table, columnName = "id"] = fieldDef.related.split(".");
 			const fieldMeta = fieldDef._meta;