@gokiteam/goki-dev 0.2.0

package/src/singletons/FunctionTriggerDispatcher.js

@@ -0,0 +1,456 @@
+import { v4 as uuid } from 'uuid'
+import cron from 'node-cron'
+import { SqliteStore } from './SqliteStore.js'
+import { FunctionsService } from './FunctionsService.js'
+import { Logger } from './Logger.js'
+import { CLOUD_FUNCTIONS, CLOUD_FUNCTION_INVOCATIONS } from '../db/Tables.js'
+import { FunctionTriggerTypes } from '../enums/FunctionTriggerTypes.js'
+
+// Lazy import to avoid circular dependency (FirestoreBroadcaster → FunctionTriggerDispatcher → FirestoreBroadcaster)
+let _firestoreBroadcaster = null
+async function getFirestoreBroadcaster () {
+  if (!_firestoreBroadcaster) {
+    const mod = await import('./FirestoreBroadcaster.js')
+    _firestoreBroadcaster = mod.FirestoreBroadcaster
+  }
+  return _firestoreBroadcaster
+}
+
+/**
+ * Event router singleton. Hooks into event sources (Pub/Sub, Firestore, Scheduler)
+ * and forwards CloudEvents to matching Cloud Functions.
+ */
+class FunctionTriggerDispatcherClass {
+  constructor () {
+    this.cronJobs = new Map()
+    this.isRunning = false
+  }
+
+  async start () {
+    const schedulerFunctions = SqliteStore.find(CLOUD_FUNCTIONS, {
+      triggerType: FunctionTriggerTypes.SCHEDULER,
+      enabled: 1
+    })
+    for (const fn of schedulerFunctions) {
+      try {
+        this.startCronJob(fn)
+      } catch (error) {
+        Logger.log({
+          level: 'error',
+          message: `Failed to start cron job for function: ${fn.name}`,
+          data: { error: error.message }
+        })
+      }
+    }
+    const firestoreFunctions = SqliteStore.find(CLOUD_FUNCTIONS, {
+      triggerType: FunctionTriggerTypes.FIRESTORE,
+      enabled: 1
+    })
+    for (const fn of firestoreFunctions) {
+      try {
+        this.startFirestoreListener(fn)
+      } catch (error) {
+        Logger.log({
+          level: 'error',
+          message: `Failed to start Firestore listener for function: ${fn.name}`,
+          data: { error: error.message }
+        })
+      }
+    }
+    this.isRunning = true
+    Logger.log({
+      level: 'info',
+      message: 'FunctionTriggerDispatcher started',
+      data: { cronJobs: this.cronJobs.size, firestoreListeners: firestoreFunctions.length }
+    })
+  }
+
+  stop () {
+    for (const [, task] of this.cronJobs) {
+      task.stop()
+    }
+    this.cronJobs.clear()
+    this.isRunning = false
+    Logger.log({ level: 'info', message: 'FunctionTriggerDispatcher stopped' })
+  }
+
+  registerFunction (fn) {
+    if (fn.triggerType === FunctionTriggerTypes.SCHEDULER) {
+      this.startCronJob(fn)
+    }
+    if (fn.triggerType === FunctionTriggerTypes.FIRESTORE) {
+      this.startFirestoreListener(fn)
+    }
+  }
+
+  unregisterFunction (fn) {
+    if (fn.triggerType === FunctionTriggerTypes.SCHEDULER) {
+      this.stopCronJob(fn.id)
+    }
+    if (fn.triggerType === FunctionTriggerTypes.FIRESTORE) {
+      this.stopFirestoreListener(fn)
+    }
+  }
+
+  // --- Event Handlers ---
+
+  async onPubSubMessage (message, topicFullName) {
+    if (!this.isRunning) return
+    try {
+      const functions = SqliteStore.find(CLOUD_FUNCTIONS, {
+        triggerType: FunctionTriggerTypes.PUBSUB,
+        enabled: 1
+      })
+      const shortName = topicFullName.split('/').pop()
+      for (const fn of functions) {
+        const config = typeof fn.triggerConfig === 'string'
+          ? JSON.parse(fn.triggerConfig)
+          : fn.triggerConfig || {}
+        if (!config.topic) continue
+        if (config.topic !== topicFullName && config.topic !== shortName) continue
+        const cloudEvent = this.buildPubSubCloudEvent(fn, message, topicFullName)
+        this.invokeFunction(fn, cloudEvent, `pubsub:${topicFullName}`).catch(err => {
+          Logger.log({
+            level: 'error',
+            message: `Pub/Sub invocation failed for ${fn.name}`,
+            data: { error: err.message }
+          })
+        })
+      }
+    } catch (error) {
+      Logger.log({
+        level: 'error',
+        message: 'Error processing Pub/Sub message for Cloud Functions',
+        data: { error: error.message, topic: topicFullName }
+      })
+    }
+  }
+
+  async onFirestoreChange (changeEvent) {
+    if (!this.isRunning) return
+    try {
+      const functions = SqliteStore.find(CLOUD_FUNCTIONS, {
+        triggerType: FunctionTriggerTypes.FIRESTORE,
+        enabled: 1
+      })
+      for (const fn of functions) {
+        const config = typeof fn.triggerConfig === 'string'
+          ? JSON.parse(fn.triggerConfig)
+          : fn.triggerConfig || {}
+        if (!this.matchesFirestoreTrigger(config, changeEvent)) continue
+        const cloudEvent = this.buildFirestoreCloudEvent(fn, changeEvent)
+        this.invokeFunction(fn, cloudEvent, `firestore:${changeEvent.collectionPath}/${changeEvent.documentId}`).catch(err => {
+          Logger.log({
+            level: 'error',
+            message: `Firestore invocation failed for ${fn.name}`,
+            data: { error: err.message }
+          })
+        })
+      }
+    } catch (error) {
+      Logger.log({
+        level: 'error',
+        message: 'Error processing Firestore change for Cloud Functions',
+        data: { error: error.message }
+      })
+    }
+  }
+
+  // --- CloudEvent Builders ---
+
+  buildPubSubCloudEvent (fn, message, topic) {
+    return {
+      specversion: '1.0',
+      id: uuid(),
+      type: 'google.cloud.pubsub.topic.v1.messagePublished',
+      source: `//pubsub.googleapis.com/${topic}`,
+      time: new Date().toISOString(),
+      data: {
+        message: {
+          messageId: message.messageId,
+          publishTime: message.publishTime || new Date().toISOString(),
+          data: message.data || '',
+          attributes: message.attributes || {}
+        },
+        subscription: `projects/dev-tools/subscriptions/${fn.name}-sub`
+      }
+    }
+  }
+
+  buildFirestoreCloudEvent (fn, changeEvent) {
+    const changeTypeMap = {
+      added: 'google.cloud.firestore.document.v1.created',
+      modified: 'google.cloud.firestore.document.v1.updated',
+      removed: 'google.cloud.firestore.document.v1.deleted'
+    }
+    const config = typeof fn.triggerConfig === 'string'
+      ? JSON.parse(fn.triggerConfig)
+      : fn.triggerConfig || {}
+    let eventType = changeTypeMap[changeEvent.changeType]
+    if (config.eventType === 'write') {
+      eventType = 'google.cloud.firestore.document.v1.written'
+    }
+    const projectId = changeEvent.projectId || 'dev-tools'
+    return {
+      specversion: '1.0',
+      id: uuid(),
+      type: eventType,
+      source: `//firestore.googleapis.com/projects/${projectId}/databases/(default)`,
+      time: changeEvent.timestamp || new Date().toISOString(),
+      data: {
+        value: changeEvent.document || null,
+        oldValue: null,
+        updateMask: null
+      }
+    }
+  }
+
+  buildSchedulerCloudEvent (fn) {
+    const config = typeof fn.triggerConfig === 'string'
+      ? JSON.parse(fn.triggerConfig)
+      : fn.triggerConfig || {}
+    return {
+      specversion: '1.0',
+      id: uuid(),
+      type: 'google.cloud.scheduler.job.v1.executed',
+      source: `//cloudscheduler.googleapis.com/projects/dev-tools/locations/local/jobs/${fn.name}`,
+      time: new Date().toISOString(),
+      data: config.payload || {}
+    }
+  }
+
+  buildManualCloudEvent (payload) {
+    return {
+      specversion: '1.0',
+      id: uuid(),
+      type: 'dev-tools.manual.invoke',
+      source: '//dev-tools/manual',
+      time: new Date().toISOString(),
+      data: payload || {}
+    }
+  }
+
+  // --- Core Invocation ---
+
+  async invokeFunction (fn, cloudEvent, triggerSource) {
+    const endpointUrl = FunctionsService.getEndpointUrl(fn.name)
+    if (!endpointUrl) {
+      Logger.log({
+        level: 'warn',
+        message: `Function not running, skipping invocation: ${fn.name}`,
+        data: { triggerSource }
+      })
+      return
+    }
+    const startedAt = new Date().toISOString()
+    const invocationId = uuid()
+    let responseStatus = null
+    let responseBody = null
+    let responseTimeMs = null
+    let errorText = null
+    const startMs = Date.now()
+    try {
+      const timeoutMs = (fn.timeoutSeconds || 60) * 1000
+      const response = await fetch(endpointUrl, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/cloudevents+json',
+          'ce-id': cloudEvent.id,
+          'ce-type': cloudEvent.type,
+          'ce-source': cloudEvent.source,
+          'ce-specversion': cloudEvent.specversion,
+          'ce-time': cloudEvent.time
+        },
+        body: JSON.stringify(cloudEvent),
+        signal: AbortSignal.timeout(timeoutMs)
+      })
+      responseTimeMs = Date.now() - startMs
+      responseStatus = response.status
+      try {
+        responseBody = await response.text()
+      } catch {
+        responseBody = null
+      }
+    } catch (error) {
+      responseTimeMs = Date.now() - startMs
+      errorText = error.message
+      Logger.log({
+        level: 'error',
+        message: `Function invocation failed: ${fn.name}`,
+        data: { error: error.message, triggerSource }
+      })
+    }
+    // Record invocation
+    try {
+      SqliteStore.create(CLOUD_FUNCTION_INVOCATIONS, {
+        id: invocationId,
+        functionId: fn.id,
+        functionName: fn.name,
+        triggerType: fn.triggerType,
+        triggerSource: triggerSource || null,
+        cloudEvent: JSON.stringify(cloudEvent),
+        responseStatus,
+        responseBody,
+        responseTimeMs,
+        error: errorText,
+        startedAt,
+        completedAt: new Date().toISOString()
+      })
+    } catch (error) {
+      Logger.log({
+        level: 'warn',
+        message: 'Failed to record function invocation',
+        data: { functionName: fn.name, error: error.message }
+      })
+    }
+    // Update function stats
+    try {
+      SqliteStore.update(CLOUD_FUNCTIONS, fn.id, {
+        invocationCount: (fn.invocationCount || 0) + 1,
+        lastInvokedAt: new Date().toISOString(),
+        lastStatus: responseStatus
+      })
+    } catch (error) {
+      Logger.log({
+        level: 'warn',
+        message: 'Failed to update function stats',
+        data: { functionName: fn.name, error: error.message }
+      })
+    }
+    // Broadcast invocation to SSE clients
+    const invocation = {
+      id: invocationId,
+      functionId: fn.id,
+      functionName: fn.name,
+      triggerType: fn.triggerType,
+      triggerSource,
+      responseStatus,
+      responseTimeMs,
+      error: errorText,
+      startedAt,
+      completedAt: new Date().toISOString()
+    }
+    FunctionsService.broadcastInvocation(invocation)
+    return invocation
+  }
+
+  // --- Cron Methods ---
+
+  startCronJob (fn) {
+    const config = typeof fn.triggerConfig === 'string'
+      ? JSON.parse(fn.triggerConfig)
+      : fn.triggerConfig || {}
+    const cronExpression = config.schedule || config.cronExpression
+    if (!cronExpression) {
+      Logger.log({
+        level: 'warn',
+        message: `No cron expression for scheduler function: ${fn.name}`
+      })
+      return
+    }
+    if (!cron.validate(cronExpression)) {
+      Logger.log({
+        level: 'error',
+        message: `Invalid cron expression for function: ${fn.name}`,
+        data: { cronExpression }
+      })
+      return
+    }
+    if (this.cronJobs.has(fn.id)) {
+      this.stopCronJob(fn.id)
+    }
+    const task = cron.schedule(cronExpression, () => {
+      const cloudEvent = this.buildSchedulerCloudEvent(fn)
+      this.invokeFunction(fn, cloudEvent, `scheduler:${cronExpression}`).catch(err => {
+        Logger.log({
+          level: 'error',
+          message: `Scheduled invocation failed for ${fn.name}`,
+          data: { error: err.message }
+        })
+      })
+    })
+    this.cronJobs.set(fn.id, task)
+    Logger.log({
+      level: 'info',
+      message: `Cron job started for function: ${fn.name}`,
+      data: { cronExpression }
+    })
+  }
+
+  stopCronJob (functionId) {
+    const task = this.cronJobs.get(functionId)
+    if (task) {
+      task.stop()
+      this.cronJobs.delete(functionId)
+    }
+  }
+
+  // --- Firestore Listener Methods ---
+
+  async startFirestoreListener (fn) {
+    const config = typeof fn.triggerConfig === 'string'
+      ? JSON.parse(fn.triggerConfig)
+      : fn.triggerConfig || {}
+    if (!config.collectionPath) {
+      Logger.log({
+        level: 'warn',
+        message: `No collectionPath for Firestore function: ${fn.name}`
+      })
+      return
+    }
+    const projectId = config.projectId || 'tipi-development'
+    try {
+      const broadcaster = await getFirestoreBroadcaster()
+      broadcaster.startCollectionListener(projectId, config.collectionPath)
+      Logger.log({
+        level: 'info',
+        message: `Firestore listener started for function: ${fn.name}`,
+        data: { projectId, collectionPath: config.collectionPath }
+      })
+    } catch (error) {
+      Logger.log({
+        level: 'error',
+        message: `Failed to start Firestore listener for function: ${fn.name}`,
+        data: { error: error.message }
+      })
+    }
+  }
+
+  async stopFirestoreListener (fn) {
+    const config = typeof fn.triggerConfig === 'string'
+      ? JSON.parse(fn.triggerConfig)
+      : fn.triggerConfig || {}
+    if (!config.collectionPath) return
+    const projectId = config.projectId || 'tipi-development'
+    try {
+      const broadcaster = await getFirestoreBroadcaster()
+      broadcaster.stopCollectionListener(projectId, config.collectionPath)
+    } catch (error) {
+      Logger.log({
+        level: 'warn',
+        message: `Failed to stop Firestore listener for function: ${fn.name}`,
+        data: { error: error.message }
+      })
+    }
+  }
+
+  // --- Helpers ---
+
+  matchesFirestoreTrigger (config, changeEvent) {
+    if (!config.collectionPath) return false
+    if (config.collectionPath !== changeEvent.collectionPath) return false
+    if (config.projectId && config.projectId !== changeEvent.projectId) return false
+    if (config.eventType && config.eventType !== 'write') {
+      const eventTypeMap = {
+        created: 'added',
+        updated: 'modified',
+        deleted: 'removed'
+      }
+      const expectedChangeType = eventTypeMap[config.eventType]
+      if (expectedChangeType && expectedChangeType !== changeEvent.changeType) return false
+    }
+    return true
+  }
+}
+
+export const FunctionTriggerDispatcher = new FunctionTriggerDispatcherClass()