v0.5.62: webhook bug fixes, seeding default subblock values, block selection fixes

* feat(logs-context-menu): consolidated logs utils and types, added logs record context menu (#2659)

* feat(email): welcome email; improvement(emails): ui/ux (#2658)

* feat(email): welcome email; improvement(emails): ui/ux

* improvement(emails): links, accounts, preview

* refactor(emails): file structure and wrapper components

* added envvar for personal emails sent, added isHosted gate

* fixed failing tests, added env mock

* fix: removed comment

---------

Co-authored-by: waleed <walif6@gmail.com>

* fix(logging): hitl + trigger dev crash protection (#2664)

* hitl gaps

* deal with trigger worker crashes

* cleanup import strcuture

* feat(imap): added support for imap trigger (#2663)

* feat(tools): added support for imap trigger

* feat(imap): added parity, tested

* ack PR comments

* final cleanup

* feat(i18n): update translations (#2665)

Co-authored-by: waleedlatif1 <waleedlatif1@users.noreply.github.com>

* fix(grain): updated grain trigger to auto-establish trigger (#2666)

Co-authored-by: aadamgough <adam@sim.ai>

* feat(admin): routes to manage deployments (#2667)

* feat(admin): routes to manage deployments

* fix naming fo deployed by

* feat(time-picker): added timepicker emcn component, added to playground, added searchable prop for dropdown, added more timezones for schedule, updated license and notice date (#2668)

* feat(time-picker): added timepicker emcn component, added to playground, added searchable prop for dropdown, added more timezones for schedule, updated license and notice date

* removed unused params, cleaned up redundant utils

* improvement(invite): aligned styling (#2669)

* improvement(invite): aligned with rest of app

* fix(invite): error handling

* fix: addressed comments

---------

Co-authored-by: Emir Karabeg <78010029+emir-karabeg@users.noreply.github.com>
Co-authored-by: Vikhyath Mondreti <vikhyathvikku@gmail.com>
Co-authored-by: waleedlatif1 <waleedlatif1@users.noreply.github.com>
Co-authored-by: Adam Gough <77861281+aadamgough@users.noreply.github.com>
Co-authored-by: aadamgough <adam@sim.ai>

apps/sim/executor/variables/resolvers/block.test.ts

@@ -6,14 +6,10 @@ import type { ResolutionContext } from './reference'
 
 vi.mock('@sim/logger', () => loggerMock)
 
-function createTestWorkflow(
-  blocks: Array<{
-    id: string
-    name?: string
-    type?: string
-    outputs?: Record<string, any>
-  }> = []
-) {
+/**
+ * Creates a minimal workflow for testing.
+ */
+function createTestWorkflow(blocks: Array<{ id: string; name?: string; type?: string }> = []) {
   return {
     version: '1.0',
     blocks: blocks.map((b) => ({
@@ -21,7 +17,7 @@ function createTestWorkflow(
       position: { x: 0, y: 0 },
       config: { tool: b.type ?? 'function', params: {} },
       inputs: {},
-      outputs: b.outputs ?? {},
+      outputs: {},
       metadata: { id: b.type ?? 'function', name: b.name ?? b.id },
       enabled: true,
     })),
@@ -130,7 +126,7 @@ describe('BlockResolver', () => {
       expect(resolver.resolve('<source.items.1.id>', ctx)).toBe(2)
     })
 
-    it.concurrent('should return undefined for non-existent path when no schema defined', () => {
+    it.concurrent('should return undefined for non-existent path', () => {
       const workflow = createTestWorkflow([{ id: 'source' }])
       const resolver = new BlockResolver(workflow)
       const ctx = createTestContext('current', {
@@ -140,48 +136,6 @@ describe('BlockResolver', () => {
       expect(resolver.resolve('<source.nonexistent>', ctx)).toBeUndefined()
     })
 
-    it.concurrent('should throw error for path not in output schema', () => {
-      const workflow = createTestWorkflow([
-        {
-          id: 'source',
-          outputs: {
-            validField: { type: 'string', description: 'A valid field' },
-            nested: {
-              child: { type: 'number', description: 'Nested child' },
-            },
-          },
-        },
-      ])
-      const resolver = new BlockResolver(workflow)
-      const ctx = createTestContext('current', {
-        source: { validField: 'value', nested: { child: 42 } },
-      })
-
-      expect(() => resolver.resolve('<source.invalidField>', ctx)).toThrow(
-        /"invalidField" doesn't exist on block "source"/
-      )
-      expect(() => resolver.resolve('<source.invalidField>', ctx)).toThrow(/Available fields:/)
-    })
-
-    it.concurrent('should return undefined for path in schema but missing in data', () => {
-      const workflow = createTestWorkflow([
-        {
-          id: 'source',
-          outputs: {
-            requiredField: { type: 'string', description: 'Always present' },
-            optionalField: { type: 'string', description: 'Sometimes missing' },
-          },
-        },
-      ])
-      const resolver = new BlockResolver(workflow)
-      const ctx = createTestContext('current', {
-        source: { requiredField: 'value' },
-      })
-
-      expect(resolver.resolve('<source.requiredField>', ctx)).toBe('value')
-      expect(resolver.resolve('<source.optionalField>', ctx)).toBeUndefined()
-    })
-
     it.concurrent('should return undefined for non-existent block', () => {
       const workflow = createTestWorkflow([{ id: 'existing' }])
       const resolver = new BlockResolver(workflow)

apps/sim/executor/variables/resolvers/block.ts

@@ -9,75 +9,14 @@ import {
   type ResolutionContext,
   type Resolver,
 } from '@/executor/variables/resolvers/reference'
-import type { SerializedBlock, SerializedWorkflow } from '@/serializer/types'
-
-function isPathInOutputSchema(
-  outputs: Record<string, any> | undefined,
-  pathParts: string[]
-): boolean {
-  if (!outputs || pathParts.length === 0) {
-    return true
-  }
-
-  let current: any = outputs
-  for (let i = 0; i < pathParts.length; i++) {
-    const part = pathParts[i]
-
-    if (/^\d+$/.test(part)) {
-      continue
-    }
-
-    if (current === null || current === undefined) {
-      return false
-    }
-
-    if (part in current) {
-      current = current[part]
-      continue
-    }
-
-    if (current.properties && part in current.properties) {
-      current = current.properties[part]
-      continue
-    }
-
-    if (current.type === 'array' && current.items) {
-      if (current.items.properties && part in current.items.properties) {
-        current = current.items.properties[part]
-        continue
-      }
-      if (part in current.items) {
-        current = current.items[part]
-        continue
-      }
-    }
-
-    if ('type' in current && typeof current.type === 'string') {
-      if (!current.properties && !current.items) {
-        return false
-      }
-    }
-
-    return false
-  }
-
-  return true
-}
-
-function getSchemaFieldNames(outputs: Record<string, any> | undefined): string[] {
-  if (!outputs) return []
-  return Object.keys(outputs)
-}
+import type { SerializedWorkflow } from '@/serializer/types'
 
 export class BlockResolver implements Resolver {
   private nameToBlockId: Map<string, string>
-  private blockById: Map<string, SerializedBlock>
 
   constructor(private workflow: SerializedWorkflow) {
     this.nameToBlockId = new Map()
-    this.blockById = new Map()
     for (const block of workflow.blocks) {
-      this.blockById.set(block.id, block)
       if (block.metadata?.name) {
         this.nameToBlockId.set(normalizeName(block.metadata.name), block.id)
       }
@@ -108,9 +47,7 @@ export class BlockResolver implements Resolver {
       return undefined
     }
 
-    const block = this.blockById.get(blockId)
     const output = this.getBlockOutput(blockId, context)
-
     if (output === undefined) {
       return undefined
     }
@@ -126,6 +63,9 @@ export class BlockResolver implements Resolver {
       return result
     }
 
+    // If failed, check if we should try backwards compatibility fallback
+    const block = this.workflow.blocks.find((b) => b.id === blockId)
+
     // Response block backwards compatibility:
     // Old: <responseBlock.response.data> -> New: <responseBlock.data>
     // Only apply fallback if:
@@ -168,14 +108,6 @@ export class BlockResolver implements Resolver {
       }
     }
 
-    const schemaFields = getSchemaFieldNames(block?.outputs)
-    if (schemaFields.length > 0 && !isPathInOutputSchema(block?.outputs, pathParts)) {
-      throw new Error(
-        `"${pathParts.join('.')}" doesn't exist on block "${blockName}". ` +
-          `Available fields: ${schemaFields.join(', ')}`
-      )
-    }
-
     return undefined
   }