refactor: remove dead orchestration entry points and no-op tests (#7060)

* refactor(orchestration): remove seven unreferenced perform* entry points

Each had exactly one declaration, a barrel re-export, and no caller anywhere
in the repo — no route, no application use case, no tool handler, no test.
Their Params/Result interfaces went with them where nothing else consumed
them; PerformCredentialResult, PerformUpdateWorkflowParams and
PerformUpdateWorkflowResult stay, since live functions still use them.

Removed: performDeleteCredential, performGetWorkspaceFileShare,
performUpsertWorkspaceFileShare, performMoveRenameWorkspaceFile,
performUpdateTableDescription, performUpdateWorkflow,
performUpdateWorkspaceFileContent.

* test: drop assertions that cannot fail

Four tests asserted nothing about the code under test:

- app/api/copilot/methods/route.test.ts was the directory's only file — it
  asserted expect(true).toBe(true) against a route that does not exist.
- tools/index.test.ts carried a block self-documented as existing "to
  maintain test count".
- mcp/storage/memory-cache.test.ts closed a delete-a-missing-key case with
  expect(true).toBe(true); it now asserts the call resolves without throwing.
- realtime/src/index.test.ts checked typeof roomManager.x === 'function' and
  typeof process.on === 'function', both of which tsc already proves.

Removing the realtime cases leaves a real gap: index.ts registers
uncaughtException, unhandledRejection, SIGINT and SIGTERM handlers with no
coverage. Better to have that gap visible than papered over by a test that
would pass with the handlers deleted.

Author: waleedlatif1

apps/realtime/src/index.test.ts

@@ -320,24 +320,9 @@ describe('Socket Server Index Integration', () => {
       expect(getWorkflowState).toBeTypeOf('function')
       expect(WorkflowOperationSchema).toBeDefined()
     })
-
-    it.concurrent('should maintain all original functionality after refactoring', async () => {
-      expect(httpServer).toBeDefined()
-      expect(io).toBeDefined()
-      expect(roomManager).toBeDefined()
-
-      expect(typeof roomManager.addUserToRoom).toBe('function')
-      expect(typeof roomManager.removeUserFromRoom).toBe('function')
-      expect(typeof roomManager.removeSocketFromAllRooms).toBe('function')
-      expect(typeof roomManager.broadcastPresenceUpdate).toBe('function')
-    })
   })
 
   describe('Error Handling', () => {
-    it('should have global error handlers configured', () => {
-      expect(typeof process.on).toBe('function')
-    })
-
     it('should handle server setup', () => {
       expect(httpServer).toBeDefined()
       expect(io).toBeDefined()

apps/sim/app/api/copilot/methods/route.test.ts

@@ -20,7 +20,6 @@ const mocks = vi.hoisted(() => ({
   updateWorkspaceFileFolder: vi.fn(),
   deleteWorkspaceFile: vi.fn(),
   renameWorkspaceFile: vi.fn(),
-  performMoveRenameWorkspaceFile: vi.fn(),
   performUpdateWorkspaceFileFolder: vi.fn(),
   performCreateFolder: vi.fn(),
   performUpdateFolder: vi.fn(),

apps/sim/lib/copilot/tools/handlers/vfs-mutate.test.ts

@@ -11,7 +11,7 @@ import { createLogger } from '@sim/logger'
 import { generateId } from '@sim/utils/id'
 import { and, eq, sql } from 'drizzle-orm'
 import type { NextRequest } from 'next/server'
-import { asOrchestrationError, OrchestrationError } from '@/lib/core/orchestration/types'
+import { OrchestrationError } from '@/lib/core/orchestration/types'
 import { decryptSecret } from '@/lib/core/security/encryption'
 import { listSlackCredentialGroupConfigurationsForBot } from '@/lib/credential-groups/provider-configuration'
 import {
@@ -45,7 +45,6 @@ import {
   SLACK_CUSTOM_BOT_PROVIDER_ID,
   SLACK_CUSTOM_BOT_SECRET_TYPE,
 } from '@/lib/oauth/types'
-import { captureServerEvent } from '@/lib/posthog/server'
 
 const logger = createLogger('CredentialOrchestration')
 type CredentialRow = typeof credential.$inferSelect
@@ -618,89 +617,3 @@ export async function deleteCredentialRecord(
     reason: params.reason,
   })
 }
-
-/** Preserves the legacy callers while application adapters migrate to the manager above. */
-export async function performDeleteCredential(
-  params: CredentialActorParams
-): Promise<PerformCredentialResult> {
-  try {
-    const access = await getCredentialActorContext(params.credentialId, params.userId)
-    if (!access.credential) {
-      return { success: false, error: 'Credential not found', errorCode: 'not_found' }
-    }
-    if (access.credential.type === 'managed_oauth') {
-      return { success: false, error: 'Credential not found', errorCode: 'not_found' }
-    }
-    if (!access.hasWorkspaceAccess || !access.isAdmin) {
-      return {
-        success: false,
-        error: 'Credential admin permission required',
-        errorCode: 'forbidden',
-      }
-    }
-    if (params.allowedTypes && !params.allowedTypes.includes(access.credential.type)) {
-      return {
-        success: false,
-        error: `Only ${params.allowedTypes.join(', ')} credentials can be managed with this tool.`,
-        errorCode: 'validation',
-      }
-    }
-
-    const reason = params.reason ?? 'user_delete'
-    await deleteCredentialRecord({ credential: access.credential, reason })
-
-    captureServerEvent(
-      params.userId,
-      'credential_deleted',
-      {
-        credential_type: access.credential.type,
-        provider_id:
-          access.credential.providerId ?? access.credential.envKey ?? params.credentialId,
-        workspace_id: access.credential.workspaceId,
-      },
-      { groups: { workspace: access.credential.workspaceId } }
-    )
-
-    const envDescription =
-      access.credential.type === 'env_personal'
-        ? `Deleted personal env credential "${access.credential.envKey}"`
-        : access.credential.type === 'env_workspace'
-          ? `Deleted workspace env credential "${access.credential.envKey}"`
-          : `Deleted ${access.credential.type} credential "${access.credential.displayName}" (${reason})`
-    recordAudit({
-      workspaceId: access.credential.workspaceId,
-      actorId: params.userId,
-      actorName: params.actorName ?? undefined,
-      actorEmail: params.actorEmail ?? undefined,
-      action: AuditAction.CREDENTIAL_DELETED,
-      resourceType: AuditResourceType.CREDENTIAL,
-      resourceId: params.credentialId,
-      resourceName: access.credential.displayName,
-      description: envDescription,
-      metadata: {
-        reason,
-        credentialType: access.credential.type,
-        providerId: access.credential.providerId,
-        accountId: access.credential.accountId,
-        envKey: access.credential.envKey,
-      },
-      request: params.request,
-    })
-
-    return { success: true, workspaceId: access.credential.workspaceId }
-  } catch (error) {
-    const orchestrationError = asOrchestrationError(error)
-    if (orchestrationError) {
-      if (orchestrationError.code !== 'not_found' && orchestrationError.code !== 'conflict') {
-        throw orchestrationError
-      }
-      return {
-        success: false,
-        error: orchestrationError.message,
-        errorCode: orchestrationError.code,
-      }
-    }
-    logger.error('Failed to delete credential', { error })
-    return { success: false, error: 'Internal server error', errorCode: 'internal' }
-  }
-}

apps/sim/lib/credentials/orchestration/index.ts

@@ -142,10 +142,7 @@ describe('MemoryMcpCache', () => {
     })
 
     it('does not throw for non-existent key', async () => {
-      // Should complete without throwing
-      await cache.delete('non-existent')
-      // If we get here, it worked
-      expect(true).toBe(true)
+      await expect(cache.delete('non-existent')).resolves.not.toThrow()
     })
 
     it('does not affect other entries', async () => {

apps/sim/lib/mcp/storage/memory-cache.test.ts

@@ -6,6 +6,5 @@ export {
   performDeleteTableRow,
   performMoveTableToFolder,
   performRenameTable,
-  performUpdateTableDescription,
   performUpdateTableLocks,
 } from './tables'

apps/sim/lib/table/orchestration/index.ts

@@ -10,13 +10,7 @@ import { generateRequestId } from '@/lib/core/utils/request'
 import { captureServerEvent } from '@/lib/posthog/server'
 import { TableLockedError } from '@/lib/table/mutation-locks'
 import { deleteRow } from '@/lib/table/rows/service'
-import {
-  deleteTable,
-  moveTableToFolder,
-  renameTable,
-  updateTableDescription,
-  updateTableLocks,
-} from '@/lib/table/service'
+import { deleteTable, moveTableToFolder, renameTable, updateTableLocks } from '@/lib/table/service'
 import {
   TABLE_LOCK_FLAGS,
   TABLE_LOCK_KINDS,
@@ -204,48 +198,6 @@ export async function performRenameTable(
   }
 }
 
-export interface PerformUpdateTableDescriptionParams {
-  table: TableDefinition
-  description: string | null
-  userId: string
-  requestId?: string
-  request?: OrchestrationRequestContext
-}
-
-/** Updates a table description and records the metadata change. */
-export async function performUpdateTableDescription(
-  params: PerformUpdateTableDescriptionParams
-): Promise<PerformTableMutationResult> {
-  const { table, description, userId, request } = params
-  const requestId = params.requestId ?? generateRequestId()
-  if (!table.workspaceId) {
-    return { success: false, error: 'Table is not in a workspace', errorCode: 'validation' }
-  }
-
-  try {
-    const updated = await updateTableDescription(
-      table.id,
-      table.workspaceId,
-      description,
-      requestId
-    )
-    recordAudit({
-      workspaceId: table.workspaceId,
-      actorId: userId,
-      action: AuditAction.TABLE_UPDATED,
-      resourceType: AuditResourceType.TABLE,
-      resourceId: table.id,
-      resourceName: updated.name,
-      description: `Updated description for table "${updated.name}"`,
-      metadata: { op: 'description' },
-      ...(request ? { request } : {}),
-    })
-    return { success: true }
-  } catch (error) {
-    return classifyTableMutation(error, requestId, table.id)
-  }
-}
-
 export interface PerformMoveTableParams {
   table: TableDefinition
   folderId: string | null

apps/sim/lib/table/orchestration/tables.ts

@@ -17,6 +17,5 @@ export {
   performCreateWorkflowTransition,
   performDeleteWorkflow,
   performRestoreWorkflow,
-  performUpdateWorkflow,
   updateWorkflowRecord,
 } from './workflow-lifecycle'

apps/sim/lib/workflows/orchestration/index.ts

@@ -9,7 +9,6 @@ import { and, eq, isNull, min, ne } from 'drizzle-orm'
 import type { OrchestrationErrorCode } from '@/lib/core/orchestration/types'
 import { generateRequestId } from '@/lib/core/utils/request'
 import type { DbOrTx } from '@/lib/db/types'
-import { captureServerEvent } from '@/lib/posthog/server'
 import { buildDefaultWorkflowArtifacts } from '@/lib/workflows/defaults'
 import { archiveWorkflow, restoreWorkflow } from '@/lib/workflows/lifecycle'
 import { saveWorkflowToNormalizedTables } from '@/lib/workflows/persistence/utils'
@@ -443,78 +442,6 @@ export async function updateWorkflowRecord(
   return { success: true, workflow: updatedWorkflow }
 }
 
-export async function performUpdateWorkflow(
-  params: PerformUpdateWorkflowParams
-): Promise<PerformUpdateWorkflowResult> {
-  const requestId = params.requestId ?? generateRequestId()
-
-  try {
-    const result = await updateWorkflowRecord({ ...params, requestId })
-    const updatedWorkflow = result.workflow
-    if (!result.success || !updatedWorkflow) return result
-
-    if (params.locked !== undefined && params.locked !== (params.currentLocked ?? false)) {
-      const workspaceId = updatedWorkflow.workspaceId
-      recordAudit({
-        workspaceId: workspaceId ?? null,
-        actorId: params.userId,
-        action: params.locked ? AuditAction.WORKFLOW_LOCKED : AuditAction.WORKFLOW_UNLOCKED,
-        resourceType: AuditResourceType.WORKFLOW,
-        resourceId: params.workflowId,
-        resourceName: updatedWorkflow.name,
-        description: `${params.locked ? 'Locked' : 'Unlocked'} workflow "${updatedWorkflow.name}"`,
-        metadata: { locked: params.locked },
-      })
-
-      captureServerEvent(
-        params.userId,
-        'workflow_lock_toggled',
-        {
-          workflow_id: params.workflowId,
-          ...(workspaceId ? { workspace_id: workspaceId } : {}),
-          locked: params.locked,
-        },
-        workspaceId ? { groups: { workspace: workspaceId } } : undefined
-      )
-    }
-
-    if (
-      params.forkSyncExcluded !== undefined &&
-      params.forkSyncExcluded !== (params.currentForkSyncExcluded ?? false)
-    ) {
-      const workspaceId = updatedWorkflow.workspaceId
-      recordAudit({
-        workspaceId: workspaceId ?? null,
-        actorId: params.userId,
-        action: params.forkSyncExcluded
-          ? AuditAction.WORKFLOW_FORK_SYNC_EXCLUDED
-          : AuditAction.WORKFLOW_FORK_SYNC_INCLUDED,
-        resourceType: AuditResourceType.WORKFLOW,
-        resourceId: params.workflowId,
-        resourceName: updatedWorkflow.name,
-        description: `${params.forkSyncExcluded ? 'Excluded' : 'Included'} workflow "${updatedWorkflow.name}" ${params.forkSyncExcluded ? 'from' : 'in'} fork sync`,
-        metadata: { forkSyncExcluded: params.forkSyncExcluded },
-      })
-
-      captureServerEvent(
-        params.userId,
-        'workflow_fork_sync_exclusion_toggled',
-        {
-          workflow_id: params.workflowId,
-          ...(workspaceId ? { workspace_id: workspaceId } : {}),
-          fork_sync_excluded: params.forkSyncExcluded,
-        },
-        workspaceId ? { groups: { workspace: workspaceId } } : undefined
-      )
-    }
-
-    return result
-  } catch (error) {
-    logger.error(`[${requestId}] Failed to update workflow ${params.workflowId}`, { error })
-    return { success: false, error: toError(error).message, errorCode: 'internal' }
-  }
-}
-
 export async function deleteWorkflowRecord(
   params: PerformDeleteWorkflowParams
 ): Promise<PerformDeleteWorkflowResult> {