fix(feature-flags): hardcode workflow-columns on, fix feature-flags tests

Author: TheodoreSpeaks

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/new-column-dropdown/new-column-dropdown.tsx

@@ -27,7 +27,6 @@ interface NewColumnDropdownProps {
   onPickType: (type: ColumnDefinition['type']) => void
   onPickWorkflow: () => void
   onPickEnrichment: () => void
-  workflowColumnsEnabled: boolean
 }
 
 /**
@@ -41,12 +40,7 @@ export function NewColumnDropdown({
   onPickType,
   onPickWorkflow,
   onPickEnrichment,
-  workflowColumnsEnabled,
 }: NewColumnDropdownProps) {
-  const visibleColumnTypeOptions = workflowColumnsEnabled
-    ? COLUMN_TYPE_OPTIONS
-    : COLUMN_TYPE_OPTIONS.filter((o) => o.type !== 'workflow')
-
   const menu = (
     <DropdownMenu>
       <DropdownMenuTrigger asChild>
@@ -68,16 +62,14 @@ export function NewColumnDropdown({
         )}
       </DropdownMenuTrigger>
       <DropdownMenuContent align='start' side='bottom' sideOffset={4}>
-        {workflowColumnsEnabled && (
-          <>
-            <DropdownMenuItem onSelect={onPickEnrichment}>
-              <Sparkles className='size-[14px] text-[var(--text-icon)]' />
-              Enrichments
-            </DropdownMenuItem>
-            <DropdownMenuSeparator />
-          </>
-        )}
-        {visibleColumnTypeOptions.map((option) => {
+        <>
+          <DropdownMenuItem onSelect={onPickEnrichment}>
+            <Sparkles className='size-[14px] text-[var(--text-icon)]' />
+            Enrichments
+          </DropdownMenuItem>
+          <DropdownMenuSeparator />
+        </>
+        {COLUMN_TYPE_OPTIONS.map((option) => {
           const Icon = option.icon
           const onSelect =
             option.type === 'workflow'

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

@@ -230,7 +230,6 @@ interface TableGridProps {
   pushTableRenameUndoSinkRef: React.MutableRefObject<
     ((previousName: string, newName: string) => void) | null
   >
-  workflowColumnsEnabled: boolean
 }
 
 /** Serialize a cell value to its tab-separated clipboard representation. */
@@ -301,7 +300,6 @@ export function TableGrid({
   afterDeleteAllSinkRef,
   confirmDeleteColumnsSinkRef,
   pushTableRenameUndoSinkRef,
-  workflowColumnsEnabled,
 }: TableGridProps) {
   const params = useParams()
   const workspaceId = propWorkspaceId || (params.workspaceId as string)
@@ -3740,7 +3738,6 @@ export function TableGrid({
                           onPickType={handleAddColumnOfType}
                           onPickWorkflow={handleAddWorkflowColumn}
                           onPickEnrichment={onOpenEnrichments}
-                          workflowColumnsEnabled={workflowColumnsEnabled}
                         />
                       )}
                     </tr>

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/page.tsx

@@ -1,17 +1,10 @@
 import type { Metadata } from 'next'
-import { headers } from 'next/headers'
-import { getSession } from '@/lib/auth'
-import { isFeatureEnabled } from '@/lib/core/config/feature-flags'
 import { Table } from './table'
 
 export const metadata: Metadata = {
   title: 'Table',
 }
 
-export default async function TablePage() {
-  const session = await getSession(await headers())
-  const workflowColumnsEnabled = await isFeatureEnabled('workflow-columns', {
-    userId: session?.user?.id,
-  })
-  return <Table workflowColumnsEnabled={workflowColumnsEnabled} />
+export default function TablePage() {
+  return <Table />
 }

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

@@ -64,8 +64,6 @@ interface TableProps {
   /** Identifiers — only set in embedded mode. Page mode reads from `useParams()`. */
   workspaceId?: string
   tableId?: string
-  /** Resolved server-side from the workflow-columns feature flag. */
-  workflowColumnsEnabled?: boolean
 }
 
 /**
@@ -118,7 +116,6 @@ export function Table({
   embedded,
   workspaceId: propWorkspaceId,
   tableId: propTableId,
-  workflowColumnsEnabled = false,
 }: TableProps = {}) {
   const params = useParams()
   const router = useRouter()
@@ -561,7 +558,6 @@ export function Table({
       onPickType={handleAddColumnOfType}
       onPickWorkflow={handleAddWorkflowColumn}
       onPickEnrichment={onOpenEnrichments}
-      workflowColumnsEnabled={workflowColumnsEnabled}
     />
   ) : null
 
@@ -695,7 +691,6 @@ export function Table({
         afterDeleteAllSinkRef={afterDeleteAllSinkRef}
         confirmDeleteColumnsSinkRef={confirmDeleteColumnsSinkRef}
         pushTableRenameUndoSinkRef={pushTableRenameUndoSinkRef}
-        workflowColumnsEnabled={workflowColumnsEnabled}
       />
       {userPermissions.canEdit && (
         <TableActionBar

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

@@ -2,11 +2,7 @@
  * @vitest-environment node
  */
 import { beforeEach, describe, expect, it, vi } from 'vitest'
-import type {
-  FeatureFlagContext,
-  FeatureFlagName,
-  FeatureFlagsConfig,
-} from '@/lib/core/config/feature-flags'
+import type { FeatureFlagContext, FeatureFlagName } from '@/lib/core/config/feature-flags'
 
 const { mockFetch, mockIsPlatformAdmin, envRef, flagRef } = vi.hoisted(() => ({
   mockFetch: vi.fn(),
@@ -23,6 +19,7 @@ vi.mock('@/lib/core/config/appconfig', () => ({
 }))
 
 vi.mock('@/lib/core/config/env', () => ({
+  isTruthy: (v: unknown) => Boolean(v),
   get env() {
     return envRef
   },
@@ -60,21 +57,22 @@ describe('getFeatureFlags', () => {
     flagRef.isAppConfigEnabled = false
   })
 
-  it('derives flags from fallback secrets (empty registry → empty) when AppConfig is disabled, without fetching', async () => {
-    expect(await getFeatureFlags()).toEqual<FeatureFlagsConfig>({ flags: {} })
+  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()
   })
 
   it('reads the feature-flags profile and normalizes the payload when enabled', async () => {
     withAppConfig({
-      flags: {
-        a: { enabled: true },
-        b: { orgIds: ['Org_1', ' org_1 ', '', 'org_2'], userIds: 'nope' },
-        c: 'not-an-object',
-      },
+      a: { enabled: true },
+      b: { orgIds: ['Org_1', ' org_1 ', '', 'org_2'], userIds: 'nope' },
+      c: 'not-an-object',
     })
 
-    const { flags } = await getFeatureFlags()
+    const flags = await getFeatureFlags()
     expect(flags.a).toEqual({ enabled: true })
     expect(flags.b).toEqual({ orgIds: ['Org_1', 'org_1', 'org_2'] })
     expect(flags.c).toBeUndefined()
@@ -87,14 +85,16 @@ describe('getFeatureFlags', () => {
   it('falls back to the secret-derived document when the fetch yields null', async () => {
     flagRef.isAppConfigEnabled = true
     mockFetch.mockResolvedValue(null)
-    expect(await getFeatureFlags()).toEqual<FeatureFlagsConfig>({ flags: {} })
+    const flags = await getFeatureFlags()
+    expect(flags['tables-fractional-ordering']).toEqual({ enabled: false })
+    expect(flags['mothership-beta']).toEqual({ enabled: false })
   })
 
   it('degrades gracefully on a malformed document', async () => {
-    withAppConfig({ flags: 'not-an-object' })
-    expect(await getFeatureFlags()).toEqual<FeatureFlagsConfig>({ flags: {} })
+    withAppConfig('not-an-object')
+    expect(await getFeatureFlags()).toMatchObject({})
     withAppConfig(null)
-    expect(await getFeatureFlags()).toEqual<FeatureFlagsConfig>({ flags: {} })
+    expect(await getFeatureFlags()).toMatchObject({})
   })
 })
 
@@ -105,31 +105,31 @@ describe('isFeatureEnabled', () => {
   })
 
   it('returns false for an unknown flag', async () => {
-    withAppConfig({ flags: {} })
+    withAppConfig({})
     expect(await enabled('missing', { userId: 'u1' })).toBe(false)
   })
 
   it('matches the global enabled clause', async () => {
-    withAppConfig({ flags: { f: { enabled: true } } })
+    withAppConfig({ f: { enabled: true } })
     expect(await enabled('f')).toBe(true)
   })
 
   it('matches the userId allowlist', async () => {
-    withAppConfig({ flags: { f: { userIds: ['u1'] } } })
+    withAppConfig({ f: { userIds: ['u1'] } })
     expect(await enabled('f', { userId: 'u1' })).toBe(true)
     expect(await enabled('f', { userId: 'u2' })).toBe(false)
     expect(await enabled('f', {})).toBe(false)
   })
 
   it('matches the orgId allowlist', async () => {
-    withAppConfig({ flags: { f: { orgIds: ['o1'] } } })
+    withAppConfig({ f: { orgIds: ['o1'] } })
     expect(await enabled('f', { orgId: 'o1' })).toBe(true)
     expect(await enabled('f', { orgId: 'o2' })).toBe(false)
   })
 
   describe('admin clause (lazy resolution)', () => {
-    it('resolves admin from userId when admins is the deciding clause', async () => {
-      withAppConfig({ flags: { f: { admins: true } } })
+    it('resolves admin from userId when adminEnabled is the deciding clause', async () => {
+      withAppConfig({ f: { adminEnabled: true } })
       mockIsPlatformAdmin.mockResolvedValue(true)
       expect(await enabled('f', { userId: 'u1' })).toBe(true)
       expect(mockIsPlatformAdmin).toHaveBeenCalledWith('u1')
@@ -139,28 +139,28 @@ describe('isFeatureEnabled', () => {
     })
 
     it('uses the isAdmin override without querying', async () => {
-      withAppConfig({ flags: { f: { admins: true } } })
+      withAppConfig({ f: { adminEnabled: true } })
       expect(await enabled('f', { userId: 'u1', isAdmin: true })).toBe(true)
       expect(mockIsPlatformAdmin).not.toHaveBeenCalled()
     })
 
     it('resolves to false without querying when userId is absent', async () => {
-      withAppConfig({ flags: { f: { admins: true } } })
+      withAppConfig({ f: { adminEnabled: true } })
       expect(await enabled('f', { orgId: 'o1' })).toBe(false)
       expect(mockIsPlatformAdmin).not.toHaveBeenCalled()
     })
 
     it('does not query when an earlier clause already matched', async () => {
-      withAppConfig({ flags: { f: { enabled: true, admins: true } } })
+      withAppConfig({ f: { enabled: true, adminEnabled: true } })
       expect(await enabled('f', { userId: 'u1' })).toBe(true)
 
-      withAppConfig({ flags: { g: { userIds: ['u1'], admins: true } } })
+      withAppConfig({ g: { userIds: ['u1'], adminEnabled: true } })
       expect(await enabled('g', { userId: 'u1' })).toBe(true)
       expect(mockIsPlatformAdmin).not.toHaveBeenCalled()
     })
 
-    it('does not query when the rule has no admins clause', async () => {
-      withAppConfig({ flags: { f: { userIds: ['u2'] } } })
+    it('does not query when the rule has no adminEnabled clause', async () => {
+      withAppConfig({ f: { userIds: ['u2'] } })
       expect(await enabled('f', { userId: 'u1' })).toBe(false)
       expect(mockIsPlatformAdmin).not.toHaveBeenCalled()
     })

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

@@ -71,10 +71,6 @@ const FEATURE_FLAGS = {
       'Mothership beta plan/changelog artifact surfaces in the copilot VFS and doc compiler',
     fallback: 'MOTHERSHIP_BETA_FEATURES',
   },
-  'workflow-columns': {
-    description: 'Workflow column type and enrichments in the table new-column dropdown',
-    fallback: 'NEXT_PUBLIC_WORKFLOW_COLUMNS_ENABLED',
-  },
 } satisfies Record<string, FeatureFlagDefinition>
 
 /**