fix(tables): validate a conversion against the required flag the request sets

A single PATCH converting an optional column to select while also setting
required: true checked blanks against the column's CURRENT required flag, so
the conversion committed and the constraint write then failed — an error
response with the type change already persisted.

updateColumnType now takes the requested `required` and validates against the
constraint the column ends up with. Empty rows are also counted when the
target is required (they were skipped outright), so the null case fails
up-front too rather than at the constraint write.

Author: TheodoreSpeaks

apps/sim/app/api/table/[tableId]/columns/route.ts

@@ -144,6 +144,9 @@ export const PATCH = withRouteHandler(async (request: NextRequest, context: Colu
           newType: updates.type as NonNullable<typeof updates.type>,
           ...(updates.options !== undefined ? { options: updates.options } : {}),
           ...(updates.multiple !== undefined ? { multiple: updates.multiple } : {}),
+          // Forwarded so the conversion validates against the constraint this
+          // same request is about to set, not the column's current one.
+          ...(updates.required !== undefined ? { required: updates.required } : {}),
         },
         requestId
       )

apps/sim/app/api/v1/tables/[tableId]/columns/route.ts

@@ -173,6 +173,9 @@ export const PATCH = withRouteHandler(async (request: NextRequest, context: Colu
           newType: updates.type as NonNullable<typeof updates.type>,
           ...(updates.options !== undefined ? { options: updates.options } : {}),
           ...(updates.multiple !== undefined ? { multiple: updates.multiple } : {}),
+          // Forwarded so the conversion validates against the constraint this
+          // same request is about to set, not the column's current one.
+          ...(updates.required !== undefined ? { required: updates.required } : {}),
         },
         requestId
       )

apps/sim/lib/table/columns/service.ts

@@ -532,12 +532,21 @@ export async function updateColumnType(
     // once the column is text/number/etc. Check compatibility against the option
     // NAME — that's what the cell will actually become (migrated below).
     const convertingAwayFromSelect = column.type === 'select' && !isSelectType
+    // The constraint the column ends up with, which may be arriving in this same
+    // request. `updateColumnConstraints` runs as its own transaction afterwards,
+    // so validating against the column's CURRENT flag would let the conversion
+    // commit and only then fail the constraint.
+    const targetRequired = !!(data.required ?? column.required)
 
     let incompatibleCount = 0
+    let blankCount = 0
     for (const row of rows) {
       const rowData = row.data as RowData
       const value = rowData[columnKey]
-      if (value === null || value === undefined) continue
+      if (value === null || value === undefined) {
+        if (targetRequired) blankCount++
+        continue
+      }
 
       const effective = convertingAwayFromSelect ? selectValueForConversion(column, value) : value
 
@@ -547,13 +556,20 @@ export async function updateColumnType(
           data.newType,
           targetOptions,
           !!targetMultiple,
-          !!column.required
+          targetRequired
         )
       ) {
-        incompatibleCount++
+        if (effective === null || effective === '') blankCount++
+        else incompatibleCount++
       }
     }
 
+    if (blankCount > 0) {
+      throw new Error(
+        `Cannot change column "${column.name}" to a required "${data.newType}": ${blankCount} row(s) are empty. Fill them first, or apply the type change without making the column required.`
+      )
+    }
+
     if (incompatibleCount > 0) {
       throw new Error(
         `Cannot change column "${column.name}" to type "${data.newType}": ${incompatibleCount} row(s) have incompatible values. Fix or remove the incompatible values first.`

apps/sim/lib/table/types.ts

@@ -664,6 +664,13 @@ export interface UpdateColumnTypeData {
   options?: SelectOption[]
   /** Whether the `select` column accepts multiple options per cell. */
   multiple?: boolean
+  /**
+   * The `required` value the same request is about to set, when it changes type
+   * and constraints together. Those are separate transactions, so the
+   * conversion has to validate against the constraint the column will END UP
+   * with — otherwise it commits and the constraint write then fails.
+   */
+  required?: boolean
 }
 
 export interface UpdateColumnOptionsData {