chore(tables): remove tables-fractional-ordering feature flag

Author: TheodoreSpeaks

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

@@ -74,7 +74,6 @@ async function handleBatchInsert(
         rows,
         workspaceId: validated.workspaceId,
         userId,
-        positions: validated.positions,
         orderKeys: validated.orderKeys,
       },
       table,

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/table-grid.tsx

@@ -2732,7 +2732,7 @@ export function TableGrid({
 
       if (createBatchRows.length > 0) {
         batchCreateRef.current(
-          { rows: createBatchRows, positions: createBatchPositions },
+          { rows: createBatchRows },
           {
             onSuccess: (response) => {
               const createdRows = response?.data?.rows ?? []

apps/sim/hooks/queries/tables.ts

@@ -779,7 +779,7 @@ type BatchCreateTableRowsParams = Omit<BatchInsertTableRowsBodyInput, 'workspace
 type BatchCreateTableRowsResponse = ContractJsonResponse<typeof batchCreateTableRowsContract>
 
 /**
- * Batch create rows in a table. Supports optional per-row positions for undo restore.
+ * Batch create rows in a table. Supports optional per-row order keys for undo restore.
  */
 export function useBatchCreateTableRows({ workspaceId, tableId }: RowMutationContext) {
   const queryClient = useQueryClient()
@@ -793,7 +793,6 @@ export function useBatchCreateTableRows({ workspaceId, tableId }: RowMutationCon
         body: {
           workspaceId,
           rows: variables.rows as RowData[],
-          positions: variables.positions,
           orderKeys: variables.orderKeys,
         },
       })

apps/sim/hooks/use-table-undo.ts

@@ -136,12 +136,11 @@ export function useTableUndo({
               deleteRowMutation.mutate(action.rowId)
             } else {
               // Redo via the batch path so the saved orderKey restores exact placement.
-              // The single-insert API has no orderKey field, and under the fractional-ordering
-              // flag its `position` is read as a rank — a gappy saved position misplaces.
+              // The single-insert API has no orderKey field, and order_key is authoritative —
+              // a gappy saved position would misplace the row.
               batchCreateRowsMutation.mutate(
                 {
                   rows: [action.data ?? {}],
-                  positions: [action.position],
                   orderKeys: action.orderKey ? [action.orderKey] : undefined,
                 },
                 {
@@ -169,7 +168,6 @@ export function useTableUndo({
               batchCreateRowsMutation.mutate(
                 {
                   rows: action.rows.map((r) => r.data),
-                  positions: action.rows.map((r) => r.position),
                   orderKeys: action.rows.every((r) => r.orderKey)
                     ? action.rows.map((r) => r.orderKey as string)
                     : undefined,
@@ -194,7 +192,6 @@ export function useTableUndo({
               batchCreateRowsMutation.mutate(
                 {
                   rows: action.rows.map((row) => row.data),
-                  positions: action.rows.map((row) => row.position),
                   orderKeys: action.rows.every((row) => row.orderKey)
                     ? action.rows.map((row) => row.orderKey as string)
                     : undefined,

apps/sim/lib/api/contracts/tables.ts

@@ -197,16 +197,9 @@ export const batchInsertTableRowsBodySchema = z
         TABLE_LIMITS.MAX_BATCH_INSERT_SIZE,
         `Cannot insert more than ${TABLE_LIMITS.MAX_BATCH_INSERT_SIZE} rows per batch`
       ),
-    positions: z.array(z.number().int().min(0)).max(TABLE_LIMITS.MAX_BATCH_INSERT_SIZE).optional(),
-    /** Fractional ordering: exact per-row order keys (undo restore). Takes precedence over `positions`. */
+    /** Fractional ordering: exact per-row order keys (undo restore). */
     orderKeys: z.array(z.string().min(1)).max(TABLE_LIMITS.MAX_BATCH_INSERT_SIZE).optional(),
   })
-  .refine((data) => !data.positions || data.positions.length === data.rows.length, {
-    message: 'positions array length must match rows array length',
-  })
-  .refine((data) => !data.positions || new Set(data.positions).size === data.positions.length, {
-    message: 'positions must not contain duplicates',
-  })
   .refine((data) => !data.orderKeys || data.orderKeys.length === data.rows.length, {
     message: 'orderKeys array length must match rows array length',
   })

apps/sim/lib/copilot/tools/server/table/user-table.ts

@@ -361,20 +361,6 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
             return { success: false, message: 'Workspace ID is required' }
           }
 
-          const positions = args.positions as number[] | undefined
-          if (positions !== undefined && positions.length !== args.rows.length) {
-            return {
-              success: false,
-              message: `positions length (${positions.length}) must match rows length (${args.rows.length})`,
-            }
-          }
-          if (positions !== undefined && new Set(positions).size !== positions.length) {
-            return {
-              success: false,
-              message: 'positions must not contain duplicate values',
-            }
-          }
-
           const table = await getTableById(args.tableId)
           if (!table || table.workspaceId !== workspaceId) {
             return { success: false, message: `Table not found: ${args.tableId}` }
@@ -390,7 +376,6 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
               rows: args.rows.map((r: RowData) => rowDataNameToId(r, idByName)),
               workspaceId,
               userId: context.userId,
-              positions,
             },
             table,
             requestId

apps/sim/lib/core/config/env.ts

@@ -72,7 +72,6 @@ export const env = createEnv({
     ENTERPRISE_STORAGE_LIMIT_GB:           z.number().optional().default(500),     // Default storage limit in GB for enterprise tier (can be overridden per org)
     BILLING_ENABLED:                       z.boolean().optional(),                 // Enable billing enforcement and usage tracking
     FREE_API_DEPLOYMENT_GATE_ENABLED:      z.boolean().optional(),                 // Block free-plan accounts from programmatic execution (API/MCP/A2A/generic webhooks/chat embeds). Requires BILLING_ENABLED. Off by default for dark rollout
-    TABLES_FRACTIONAL_ORDERING:            z.boolean().optional(),                 // Order table rows by fractional order_key (O(1) insert/delete) instead of integer position
 
     // Table feature limits (per plan). Apply when billing is disabled (free tier defaults) or for billed plans.
     FREE_TABLES_LIMIT:                     z.number().optional(),                  // Max user tables per workspace on free tier (default: 3)

apps/sim/lib/core/config/feature-flags.test.ts

@@ -44,9 +44,9 @@ function withAppConfig(doc: unknown) {
 }
 
 /**
- * `isFeatureEnabled` only accepts registered `FeatureFlagName`s. The registry is
- * empty in this PR, so tests reference flags through the AppConfig document and
- * cast their throwaway names through this helper.
+ * `isFeatureEnabled` only accepts registered `FeatureFlagName`s. These tests
+ * exercise the evaluation logic with throwaway flag names supplied through the
+ * AppConfig document, cast to `FeatureFlagName` through this helper.
  */
 const enabled = (flag: string, ctx?: FeatureFlagContext) =>
   isFeatureEnabled(flag as FeatureFlagName, ctx)
@@ -60,7 +60,6 @@ describe('getFeatureFlags', () => {
   it('derives flags from fallback secrets when AppConfig is disabled, without fetching', async () => {
     const flags = await getFeatureFlags()
     // All registered flags should be present, disabled (env vars unset in test env)
-    expect(flags['tables-fractional-ordering']).toEqual({ enabled: false })
     expect(flags['mothership-beta']).toEqual({ enabled: false })
     expect(mockFetch).not.toHaveBeenCalled()
   })
@@ -86,7 +85,6 @@ describe('getFeatureFlags', () => {
     flagRef.isAppConfigEnabled = true
     mockFetch.mockResolvedValue(null)
     const flags = await getFeatureFlags()
-    expect(flags['tables-fractional-ordering']).toEqual({ enabled: false })
     expect(flags['mothership-beta']).toEqual({ enabled: false })
   })
 

apps/sim/lib/core/config/feature-flags.ts

@@ -62,10 +62,6 @@ interface FeatureFlagDefinition {
 
 /** The single registry of known flags. To add a flag, add one entry here. */
 const FEATURE_FLAGS = {
-  'tables-fractional-ordering': {
-    description: 'Order table rows by fractional order_key instead of legacy integer position',
-    fallback: 'TABLES_FRACTIONAL_ORDERING',
-  },
   'mothership-beta': {
     description:
       'Mothership beta plan/changelog artifact surfaces in the copilot VFS and doc compiler. ' +

apps/sim/lib/table/__tests__/update-row.test.ts

@@ -16,12 +16,6 @@ import { getUniqueColumns } from '@/lib/table/validation'
 
 vi.mock('@sim/db', () => dbChainMock)
 
-// These suites assert flag-off position-shift semantics; pin the flag so they're
-// deterministic regardless of a local TABLES_FRACTIONAL_ORDERING env value.
-vi.mock('@/lib/core/config/feature-flags', () => ({
-  isFeatureEnabled: vi.fn().mockResolvedValue(false),
-}))
-
 vi.mock('@/lib/table/validation', () => ({
   validateRowSize: vi.fn(() => ({ valid: true, errors: [] })),
   validateRowAgainstSchema: vi.fn(() => ({ valid: true, errors: [] })),
@@ -177,29 +171,17 @@ describe('insertRow — position race safety (migration 0198 + advisory lock)',
     expect(findExecutedSqlContaining('hashtextextended')).toBe(true)
   })
 
-  it('explicit-position inserts also acquire the advisory lock to serialize position shifts', async () => {
-    dbChainMockFns.limit.mockResolvedValueOnce([])
-    dbChainMockFns.returning.mockResolvedValueOnce([
-      {
-        id: 'row-1',
-        tableId: 'tbl-1',
-        workspaceId: 'ws-1',
-        data: { name: 'a' },
-        position: 5,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-      },
-    ])
-
-    await insertRow(
-      { tableId: 'tbl-1', data: { name: 'a' }, workspaceId: 'ws-1', position: 5 },
-      TABLE,
-      'req-1'
-    )
+  it('explicit-position inserts also acquire the advisory lock to serialize order-key minting', async () => {
+    await expect(
+      insertRow(
+        { tableId: 'tbl-1', data: { name: 'a' }, workspaceId: 'ws-1', position: 5 },
+        TABLE,
+        'req-1'
+      )
+    ).rejects.toBeDefined()
 
-    // `(table_id, position)` index is non-unique, so concurrent explicit-position
-    // inserts at the same slot could both skip the shift and duplicate — lock
-    // serializes them.
+    // A position-based insert resolves its order_key from the neighbor at that
+    // rank; the lock serializes concurrent minting at the same slot.
     expect(findExecutedSqlContaining('pg_advisory_xact_lock')).toBe(true)
   })
 
@@ -215,42 +197,6 @@ describe('insertRow — position race safety (migration 0198 + advisory lock)',
     expect(findExecutedSqlContaining('pg_advisory_xact_lock')).toBe(true)
   })
 
-  it('batchInsertRows with explicit positions acquires the advisory lock', async () => {
-    dbChainMockFns.returning.mockResolvedValueOnce([
-      {
-        id: 'row-1',
-        tableId: 'tbl-1',
-        workspaceId: 'ws-1',
-        data: { name: 'a' },
-        position: 3,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-      },
-      {
-        id: 'row-2',
-        tableId: 'tbl-1',
-        workspaceId: 'ws-1',
-        data: { name: 'b' },
-        position: 4,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-      },
-    ])
-
-    await batchInsertRows(
-      {
-        tableId: 'tbl-1',
-        rows: [{ name: 'a' }, { name: 'b' }],
-        workspaceId: 'ws-1',
-        positions: [3, 4],
-      },
-      TABLE,
-      'req-1'
-    )
-
-    expect(findExecutedSqlContaining('pg_advisory_xact_lock')).toBe(true)
-  })
-
   it('upsertRow skips the advisory lock on the update path (match found)', async () => {
     vi.mocked(getUniqueColumns).mockReturnValue([{ name: 'name', type: 'string', unique: true }])
     dbChainMockFns.limit.mockResolvedValueOnce([