Event System

type LogEntry struct {
    Level     LogLevel `json:"level"`      // "info", "warn", "error"
    Message   string   `json:"message"`    // Human-readable log message
    Timestamp string   `json:"timestamp"`  // RFC3339Nano UTC
}

import { Events } from '@wailsio/runtime'

Events.On('app:log', (event) => {
  const entry = event.data
  logs.value.push(entry)
})

CreateConnection: creating 'db1' (driver: mysql)
CreateConnection: 'db1' created successfully (id: abc123)
ExecPlugin: executing (driver: mysql, query: "SELECT * FROM users")
ExecPlugin: (driver: mysql) completed successfully

type ConnectionCreatedEvent struct {
    Connection Connection `json:"connection"`
}

emitConnectionCreated(s.app, conn)

Events.On('connection:created', (event) => {
  const conn = event.data.connection
  connections.value.push(conn)  // Add to list immediately, no refetch
})

type ConnectionDeletedEvent struct {
    ID string `json:"id"`  // UUID of deleted connection
}

emitConnectionDeleted(s.app, id)

Events.On('connection:deleted', (event) => {
  const id = event.data.id
  connections.value = connections.value.filter(c => c.id !== id)
})

Events.On('menu:logs-toggled', () => toggleFooter())

func (m *Manager) emitPluginsReady() {
    select {
    case <-m.appReadyCh:  // Wait for SetApp() to provide app reference
        m.app.Event.Emit(services.EventPluginsReady, nil)
    case <-time.After(10 * time.Second):
        return  // Give up if SetApp is never called
    }
}

Events.On('plugins:ready', async () => {
  plugins.value = await ListPlugins()  // Reload plugin list
})

const (
    EventAppLog              = "app:log"
    EventConnectionCreated   = "connection:created"
    EventConnectionDeleted   = "connection:deleted"
    EventMenuLogsToggled     = "menu:logs-toggled"
    EventConnectionsWindowClosed = "connections-window:closed"
    EventPluginsReady        = "plugins:ready"
)

// Start of operation
"CreateConnection: creating 'db1' (driver: mysql)"

// Success
"CreateConnection: 'db1' created successfully (id: abc123)"
"ListConnections: found 3 connection(s)"

// Error
"CreateConnection: failed to store credential for 'db1': permission denied"
"GetCredential: connection 'xyz' not found: sql: no rows in result set"

// services/connection.go:240
emitLog(s.app, LogLevelInfo, fmt.Sprintf("CreateConnection: creating '%s' (driver: %s)", name, driverType))

// services/connection.go:252
emitLog(s.app, LogLevelInfo, fmt.Sprintf("CreateConnection: '%s' created successfully (id: %s)", name, id))

// services/pluginmgr/pluginmgr.go:497
m.emitLog(services.LogLevelInfo, fmt.Sprintf("ExecPlugin: executing (driver: %s, query: %q)", name, logQuery))

type LogLevel string

const (
    LogLevelInfo  LogLevel = "info"
    LogLevelWarn  LogLevel = "warn"
    LogLevelError LogLevel = "error"
)

const emit = defineEmits(['tab-closed', 'refresh-tab'])

function closeTab(tabKey) {
  emit('tab-closed', tabKey)
}

func emitLog(app *application.App, level LogLevel, message string) {
    if app == nil {
        return  // No-op in tests
    }
    app.Event.Emit(EventAppLog, LogEntry{
        Level:     level,
        Message:   message,
        Timestamp: time.Now().UTC().Format(time.RFC3339Nano),
    })
}

emitLog(s.app, LogLevelInfo, fmt.Sprintf("ListConnections: found %d connection(s)", len(out)))

func emitConnectionCreated(app *application.App, conn Connection) {
    if app == nil {
        return
    }
    app.Event.Emit(EventConnectionCreated, ConnectionCreatedEvent{Connection: conn})
}

func emitConnectionDeleted(app *application.App, id string) {
    if app == nil {
        return
    }
    app.Event.Emit(EventConnectionDeleted, ConnectionDeletedEvent{ID: id})
}

import { Events } from '@wailsio/runtime'
import { onMounted, onUnmounted, ref } from 'vue'

const logs = ref([])
let offAppLog = null

onMounted(() => {
  offAppLog = Events.On('app:log', (event) => {
    logs.value.push(event.data)
  })
})

onUnmounted(() => {
  if (offAppLog) {
    offAppLog()  // Critical: prevents memory leaks
  }
})

// ❌ Don't do this
await CreateConnection(name, driver, cred)
connections.value = await ListConnections()  // Redundant refetch

// ✓ Do this
Events.On('connection:created', (event) => {
  connections.value.push(event.data.connection)  // Instant update
})

await CreateConnection(name, driver, cred)
// UI already updated via event—no refetch needed

emitLog(s.app, LogLevelInfo, "CreateConnection: 'db1' created successfully (id: abc123)")
emitConnectionCreated(s.app, conn)  // Emits connection:created

Events.On('*', (event) => {
  console.log('Event received:', event.name, event.data)
})

// ❌ Don't emit entire result set
app.Event.Emit("query:executed", ExecResponse{...})  // Could be MBs

// ✓ Emit summary, let frontend fetch details
app.Event.Emit("query:executed", QueryExecutedEvent{
    ConnectionID: id,
    RowCount:     len(rows),
})

import { throttle } from 'lodash-es'

const handleProgress = throttle((event) => {
  progress.value = event.data.percent
}, 100)  // Max 10 updates/sec

Events.On('query:progress', handleProgress)

// ❌ NEVER do this
emitConnectionCreated(s.app, Connection{
    Credential: credential,  // Exposes secrets to frontend logs!
})

// ✓ Only emit credential_key (reference)
emitConnectionCreated(s.app, Connection{
    CredentialKey: "connection:abc123",  // Safe
})

// ❌ Don't log raw credentials
emitLog(s.app, LogLevelInfo, fmt.Sprintf("Credential: %s", cred))

// ✓ Log only metadata
emitLog(s.app, LogLevelInfo, fmt.Sprintf("CreateConnection: creating '%s' (driver: %s)", name, driver))