fix(sanitize): repair malformed subblock states

icecrasher321 · icecrasher321 · commit 7175e0deee4b · 2026-05-07T00:21:38.000-07:00
diff --git a/apps/sim/lib/workflows/migrations/subblock-migrations.test.ts b/apps/sim/lib/workflows/migrations/subblock-migrations.test.ts
@@ -133,6 +133,50 @@ describe('migrateSubblockIds', () => {
     expect(blocks.b1.subBlocks.code.value).toBe('console.log("hi")')
   })
 
+  it('should repair malformed subBlocks for every block type without deleting values', () => {
+    const input: Record<string, BlockState> = {
+      b1: makeBlock({
+        type: 'function',
+        subBlocks: {
+          code: { id: 'code', type: 'unknown', value: 'console.log("hi")' },
+          undefined: { type: 'unknown', value: null },
+          noId: { type: 'short-input', value: 'stale' },
+          noType: { id: 'noType', value: 'stale' },
+          unknownType: { id: 'unknownType', type: 'unknown', value: 'preserved' },
+          notRecord: 'stale',
+          arrayValue: ['a', 'b'],
+        } as unknown as BlockState['subBlocks'],
+      }),
+    }
+
+    const { blocks, migrated } = migrateSubblockIds(input)
+
+    expect(migrated).toBe(true)
+    expect(blocks.b1.subBlocks.code).toEqual({
+      id: 'code',
+      type: 'code',
+      value: 'console.log("hi")',
+    })
+    expect(blocks.b1.subBlocks.undefined).toBeUndefined()
+    expect(blocks.b1.subBlocks.noId).toEqual({ id: 'noId', type: 'short-input', value: 'stale' })
+    expect(blocks.b1.subBlocks.noType).toEqual({
+      id: 'noType',
+      type: 'short-input',
+      value: 'stale',
+    })
+    expect(blocks.b1.subBlocks.unknownType).toBeUndefined()
+    expect(blocks.b1.subBlocks.notRecord).toEqual({
+      id: 'notRecord',
+      type: 'short-input',
+      value: 'stale',
+    })
+    expect(blocks.b1.subBlocks.arrayValue).toEqual({
+      id: 'arrayValue',
+      type: 'short-input',
+      value: ['a', 'b'],
+    })
+  })
+
   it('should migrate multiple blocks in one pass', () => {
     const input: Record<string, BlockState> = {
       b1: makeBlock({
diff --git a/apps/sim/lib/workflows/migrations/subblock-migrations.ts b/apps/sim/lib/workflows/migrations/subblock-migrations.ts
@@ -1,4 +1,5 @@
 import { createLogger } from '@sim/logger'
+import { sanitizeMalformedSubBlocks } from '@/lib/workflows/sanitization/subblocks'
 import {
   buildCanonicalIndex,
   buildSubBlockValues,
@@ -112,18 +113,28 @@ export function migrateSubblockIds(blocks: Record<string, BlockState>): {
   const result: Record<string, BlockState> = {}
 
   for (const [blockId, block] of Object.entries(blocks)) {
-    const renames = SUBBLOCK_ID_MIGRATIONS[block.type]
-    if (!renames || !block.subBlocks) {
+    if (!block.subBlocks) {
       result[blockId] = block
       continue
     }
 
-    const { subBlocks, migrated } = migrateBlockSubblockIds(block.subBlocks, renames)
-    if (migrated) {
-      logger.info('Migrated legacy subblock IDs', {
-        blockId: block.id,
-        blockType: block.type,
-      })
+    const sanitized = sanitizeMalformedSubBlocks(block)
+    const renames = SUBBLOCK_ID_MIGRATIONS[block.type]
+    if (!renames) {
+      result[blockId] = sanitized.changed ? { ...block, subBlocks: sanitized.subBlocks } : block
+      anyMigrated = anyMigrated || sanitized.changed
+      continue
+    }
+
+    const { subBlocks, migrated } = migrateBlockSubblockIds(sanitized.subBlocks, renames)
+    const blockMigrated = sanitized.changed || migrated
+    if (blockMigrated) {
+      if (migrated) {
+        logger.info('Migrated legacy subblock IDs', {
+          blockId: block.id,
+          blockType: block.type,
+        })
+      }
       anyMigrated = true
       result[blockId] = { ...block, subBlocks }
     } else {
diff --git a/apps/sim/lib/workflows/operations/import-export.test.ts b/apps/sim/lib/workflows/operations/import-export.test.ts
@@ -1,8 +1,83 @@
-/**
- * @vitest-environment node
- */
 import { describe, expect, it } from 'vitest'
-import { sanitizePathSegment } from '@/lib/workflows/operations/import-export'
+import {
+  extractWorkflowName,
+  parseWorkflowJson,
+  sanitizePathSegment,
+} from '@/lib/workflows/operations/import-export'
+
+function createLegacyState() {
+  return {
+    blocks: {
+      'start-1': {
+        id: 'start-1',
+        type: 'start_trigger',
+        name: 'Start',
+        position: { x: 0, y: 0 },
+        enabled: true,
+        subBlocks: {
+          inputFormat: {
+            id: 'inputFormat',
+            type: 'input-format',
+            value: [],
+          },
+          undefined: {
+            type: 'unknown',
+            value: 'stale duplicate',
+          },
+        },
+        outputs: {},
+        data: {},
+      },
+    },
+    edges: [],
+    loops: {},
+    parallels: {},
+    variables: {},
+    metadata: {
+      name: 'Wrapped Workflow',
+      color: '#FFBF00',
+    },
+  }
+}
+
+describe('workflow import/export parsing', () => {
+  it('parses workflow exports wrapped in an API data envelope', () => {
+    const content = JSON.stringify({
+      data: {
+        version: '1.0',
+        exportedAt: '2026-05-07T06:45:06.892Z',
+        workflow: {
+          name: 'Wrapped Workflow',
+        },
+        state: createLegacyState(),
+      },
+    })
+
+    const result = parseWorkflowJson(content, false)
+
+    expect(result.errors).toEqual([])
+    expect(result.data?.blocks['start-1']).toBeDefined()
+    expect(result.data?.blocks['start-1'].subBlocks.inputFormat).toEqual({
+      id: 'inputFormat',
+      type: 'input-format',
+      value: [],
+    })
+    expect(result.data?.blocks['start-1'].subBlocks.undefined).toBeUndefined()
+  })
+
+  it('extracts workflow names from wrapped exports', () => {
+    const content = JSON.stringify({
+      data: {
+        workflow: {
+          name: 'Wrapped Workflow',
+        },
+        state: createLegacyState(),
+      },
+    })
+
+    expect(extractWorkflowName(content, 'wf.json')).toBe('Wrapped Workflow')
+  })
+})
 
 describe('sanitizePathSegment', () => {
   it('should preserve ASCII alphanumeric characters', () => {
diff --git a/apps/sim/lib/workflows/operations/import-export.ts b/apps/sim/lib/workflows/operations/import-export.ts
@@ -13,11 +13,32 @@ import {
   type ExportWorkflowState,
   sanitizeForExport,
 } from '@/lib/workflows/sanitization/json-sanitizer'
+import { sanitizeMalformedSubBlocks } from '@/lib/workflows/sanitization/subblocks'
 import { regenerateWorkflowIds } from '@/stores/workflows/utils'
 import type { Variable, WorkflowState } from '@/stores/workflows/workflow/types'
 
 const logger = createLogger('WorkflowImportExport')
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function unwrapWorkflowExportEnvelope(data: unknown): unknown {
+  if (!isRecord(data)) {
+    return data
+  }
+
+  const envelopeData = data.data
+  if (
+    isRecord(envelopeData) &&
+    (envelopeData.state || envelopeData.version || envelopeData.workflow)
+  ) {
+    return envelopeData
+  }
+
+  return data
+}
+
 async function getJSZip() {
   const { default: JSZip } = await import('jszip')
   return JSZip
@@ -338,7 +359,7 @@ export interface WorkspaceImportMetadata {
 
 function extractSortOrder(content: string): number | undefined {
   try {
-    const parsed = JSON.parse(content)
+    const parsed = unwrapWorkflowExportEnvelope(JSON.parse(content)) as Record<string, any>
     return parsed.state?.metadata?.sortOrder ?? parsed.metadata?.sortOrder
   } catch {
     return undefined
@@ -418,11 +439,15 @@ export async function extractWorkflowsFromFiles(files: File[]): Promise<Imported
 
 export function extractWorkflowName(content: string, filename: string): string {
   try {
-    const parsed = JSON.parse(content)
+    const parsed = unwrapWorkflowExportEnvelope(JSON.parse(content)) as Record<string, any>
 
     if (parsed.state?.metadata?.name && typeof parsed.state.metadata.name === 'string') {
       return parsed.state.metadata.name.trim()
     }
+
+    if (parsed.workflow?.name && typeof parsed.workflow.name === 'string') {
+      return parsed.workflow.name.trim()
+    }
   } catch {
     // JSON parse failed, fall through to filename
   }
@@ -441,14 +466,12 @@ export function extractWorkflowName(content: string, filename: string): string {
 }
 
 /**
- * Normalize subblock values by converting empty strings to null and filtering out invalid subblocks.
+ * Normalize subblock values by converting empty strings to null and repairing invalid subblocks.
  * This provides backwards compatibility for workflows exported before the null sanitization fix,
  * preventing Zod validation errors like "Expected array, received string".
  *
- * Also filters out malformed subBlocks that may have been created by bugs in previous exports:
- * - SubBlocks with key "undefined" (caused by assigning to undefined key)
- * - SubBlocks missing required fields like `id`
- * - SubBlocks with `type: "unknown"` (indicates malformed data)
+ * Also filters out subBlocks with the literal key "undefined", which cannot be associated
+ * with a stable block field.
  */
 function normalizeSubblockValues(blocks: Record<string, any>): Record<string, any> {
   const normalizedBlocks: Record<string, any> = {}
@@ -457,47 +480,14 @@ function normalizeSubblockValues(blocks: Record<string, any>): Record<string, an
     const normalizedBlock = { ...block }
 
     if (block.subBlocks) {
-      const normalizedSubBlocks: Record<string, any> = {}
-
-      Object.entries(block.subBlocks).forEach(([subBlockId, subBlock]: [string, any]) => {
-        // Skip subBlocks with invalid keys (literal "undefined" string)
-        if (subBlockId === 'undefined') {
-          logger.warn(`Skipping malformed subBlock with key "undefined" in block ${blockId}`)
-          return
-        }
-
-        // Skip subBlocks that are null or not objects
-        if (!subBlock || typeof subBlock !== 'object') {
-          logger.warn(`Skipping invalid subBlock ${subBlockId} in block ${blockId}: not an object`)
-          return
-        }
-
-        // Skip subBlocks with type "unknown" (malformed data)
-        if (subBlock.type === 'unknown') {
-          logger.warn(
-            `Skipping malformed subBlock ${subBlockId} in block ${blockId}: type is "unknown"`
-          )
-          return
-        }
-
-        // Skip subBlocks missing required id field
-        if (!subBlock.id) {
-          logger.warn(
-            `Skipping malformed subBlock ${subBlockId} in block ${blockId}: missing id field`
-          )
-          return
-        }
-
-        const normalizedSubBlock = { ...subBlock }
-
-        // Convert empty strings to null for consistency
-        if (normalizedSubBlock.value === '') {
-          normalizedSubBlock.value = null
-        }
-
-        normalizedSubBlocks[subBlockId] = normalizedSubBlock
-      })
-
+      const { subBlocks: normalizedSubBlocks } = sanitizeMalformedSubBlocks(
+        {
+          id: typeof block.id === 'string' ? block.id : blockId,
+          type: typeof block.type === 'string' ? block.type : '',
+          subBlocks: block.subBlocks,
+        },
+        { convertEmptyStringToNull: true }
+      )
       normalizedBlock.subBlocks = normalizedSubBlocks
     }
 
@@ -538,6 +528,8 @@ export function parseWorkflowJson(
       return { data: null, errors }
     }
 
+    data = unwrapWorkflowExportEnvelope(data)
+
     // Handle new export format (version/exportedAt/state) or old format (blocks/edges at root)
     let workflowData: any
     if (data.version && data.state) {
diff --git a/apps/sim/lib/workflows/sanitization/subblocks.ts b/apps/sim/lib/workflows/sanitization/subblocks.ts
diff --git a/bun.lock b/bun.lock
