@gokiteam/goki-dev 0.2.0

package/src/emulation/pubsub/Logic.js

@@ -0,0 +1,427 @@
+import { v4 as uuid } from 'uuid'
+import { SqliteStore } from '../../singletons/SqliteStore.js'
+import { MessageBroadcaster } from '../../singletons/MessageBroadcaster.js'
+
+/**
+ * Extract sender from message attributes
+ * @param {Object} attributes - Message attributes
+ * @returns {string|null} - Sender identifier
+ */
+const extractSender = attributes => {
+  if (!attributes) return null
+  return attributes.sender || attributes.source || attributes.userId || null
+}
+
+/**
+ * Check if a message has meaningful data worth storing in history.
+ * Filters out empty payloads like {} or empty strings that show as
+ * unknown items in the UI.
+ * @param {string} data - Base64-encoded message data
+ * @returns {boolean} - true if the message has meaningful content
+ */
+const hasMeaningfulData = data => {
+  if (!data) return false
+  try {
+    const decoded = Buffer.from(data, 'base64').toString('utf-8')
+    const trimmed = decoded.trim()
+    if (!trimmed || trimmed === '{}' || trimmed === '""' || trimmed === 'null') return false
+    return true
+  } catch {
+    return !!data
+  }
+}
+
+/**
+ * Create a new topic
+ */
+export const CreateTopic = params => {
+  const { projectId, topicId } = params
+
+  const topicName = `projects/${projectId}/topics/${topicId}`
+
+  // Check if topic already exists
+  const existingTopic = SqliteStore.get('pubsub_topics', topicName, 'name')
+  if (existingTopic) {
+    return {
+      isSuccessful: false,
+      errorCode: 'ALREADY_EXISTS',
+      errorMessage: 'Topic already exists'
+    }
+  }
+
+  const topic = {
+    name: topicName,
+    labels: {},
+    messageStoragePolicy: {},
+    kmsKeyName: '',
+    schemaSettings: null,
+    satisfiesPzs: false,
+    messageRetentionDuration: '604800s'
+  }
+
+  SqliteStore.create('pubsub_topics', topic)
+
+  return {
+    isSuccessful: true,
+    topic
+  }
+}
+
+/**
+ * Get a topic
+ */
+export const GetTopic = params => {
+  const { projectId, topicId } = params
+  const topicName = `projects/${projectId}/topics/${topicId}`
+
+  const topic = SqliteStore.get('pubsub_topics', topicName, 'name')
+
+  if (!topic) {
+    return {
+      isSuccessful: false,
+      errorCode: 'NOT_FOUND',
+      errorMessage: 'Topic not found'
+    }
+  }
+
+  return {
+    isSuccessful: true,
+    topic
+  }
+}
+
+/**
+ * List topics in a project
+ */
+export const ListTopics = params => {
+  const { projectId, pageSize = 50, pageToken } = params
+
+  const result = SqliteStore.list('pubsub_topics', {
+    filter: topic => topic.name.startsWith(`projects/${projectId}/topics/`),
+    limit: pageSize,
+    offset: pageToken ? parseInt(pageToken, 10) : 0
+  })
+
+  return {
+    isSuccessful: true,
+    topics: result.data,
+    nextPageToken: result.data.length === pageSize ? String(result.data.length) : undefined
+  }
+}
+
+/**
+ * Delete a topic
+ */
+export const DeleteTopic = params => {
+  const { projectId, topicId } = params
+  const topicName = `projects/${projectId}/topics/${topicId}`
+
+  try {
+    SqliteStore.delete('pubsub_topics', topicName, 'name')
+
+    // Also delete all subscriptions for this topic
+    const subscriptions = SqliteStore.find('pubsub_subscriptions', sub => sub.topic === topicName)
+    subscriptions.forEach(sub => {
+      SqliteStore.delete('pubsub_subscriptions', sub.name, 'name')
+    })
+
+    return {
+      isSuccessful: true
+    }
+  } catch (error) {
+    return {
+      isSuccessful: false,
+      errorCode: 'NOT_FOUND',
+      errorMessage: 'Topic not found'
+    }
+  }
+}
+
+/**
+ * Publish messages to a topic
+ * Auto-creates the topic if it doesn't exist (dev-tools convenience feature)
+ */
+export const PublishMessages = params => {
+  const { projectId, topicId, messages } = params
+  const topicName = `projects/${projectId}/topics/${topicId}`
+
+  // Auto-create topic if it doesn't exist (dev-tools convenience feature)
+  const existingTopic = SqliteStore.get('pubsub_topics', topicName, 'name')
+  if (!existingTopic) {
+    const topic = {
+      name: topicName,
+      labels: {},
+      messageStoragePolicy: {},
+      kmsKeyName: '',
+      schemaSettings: null,
+      satisfiesPzs: false,
+      messageRetentionDuration: '604800s'
+    }
+    SqliteStore.create('pubsub_topics', topic)
+  }
+
+  const messageIds = []
+  const publishTime = new Date().toISOString()
+
+  // Store each message
+  for (const message of messages) {
+    const messageId = uuid()
+    const storedMessage = {
+      id: messageId,
+      data: message.data,
+      attributes: message.attributes || {},
+      orderingKey: message.orderingKey || '',
+      publishTime,
+      topic: topicName,
+      ackId: null,
+      deliveryAttempt: 0
+    }
+
+    // Store in ephemeral messages table (for pull/ack)
+    SqliteStore.create('pubsub_messages', storedMessage)
+
+    // Only store messages with meaningful data in history
+    if (hasMeaningfulData(message.data)) {
+      const historyRecord = {
+        id: uuid(),
+        message_id: messageId,
+        data: message.data,
+        attributes: message.attributes || {},
+        ordering_key: message.orderingKey || '',
+        publish_time: publishTime,
+        topic: topicName,
+        sender: extractSender(message.attributes),
+        view_count: 0,
+        last_viewed_at: null
+      }
+      SqliteStore.create('pubsub_message_history', historyRecord)
+
+      // Broadcast to SSE clients
+      MessageBroadcaster.broadcast({
+        messageId,
+        topic: topicName,
+        data: message.data,
+        attributes: message.attributes || {},
+        publishTime,
+        sender: extractSender(message.attributes)
+      })
+    }
+
+    messageIds.push(messageId)
+  }
+
+  return {
+    isSuccessful: true,
+    messageIds
+  }
+}
+
+/**
+ * Create a subscription
+ */
+export const CreateSubscription = params => {
+  const { projectId, subscriptionId, topic, ackDeadlineSeconds = 10, pushConfig = {} } = params
+
+  const subscriptionName = `projects/${projectId}/subscriptions/${subscriptionId}`
+
+  // Check if subscription already exists
+  const existingSubscription = SqliteStore.get('pubsub_subscriptions', subscriptionName, 'name')
+  if (existingSubscription) {
+    return {
+      isSuccessful: false,
+      errorCode: 'ALREADY_EXISTS',
+      errorMessage: 'Subscription already exists'
+    }
+  }
+
+  // Validate that topic exists
+  const topicExists = SqliteStore.get('pubsub_topics', topic, 'name')
+  if (!topicExists) {
+    return {
+      isSuccessful: false,
+      errorCode: 'NOT_FOUND',
+      errorMessage: 'Topic not found'
+    }
+  }
+
+  const subscription = {
+    name: subscriptionName,
+    topic,
+    pushConfig,
+    ackDeadlineSeconds,
+    retainAckedMessages: false,
+    messageRetentionDuration: '604800s',
+    labels: {},
+    enableMessageOrdering: false,
+    expirationPolicy: {
+      ttl: '2678400s'
+    },
+    filter: '',
+    deadLetterPolicy: null,
+    retryPolicy: null,
+    detached: false,
+    enableExactlyOnceDelivery: false,
+    topicMessageRetentionDuration: '604800s',
+    state: 'ACTIVE'
+  }
+
+  SqliteStore.create('pubsub_subscriptions', subscription)
+
+  return {
+    isSuccessful: true,
+    subscription
+  }
+}
+
+/**
+ * Get a subscription
+ */
+export const GetSubscription = params => {
+  const { projectId, subscriptionId } = params
+  const subscriptionName = `projects/${projectId}/subscriptions/${subscriptionId}`
+
+  const subscription = SqliteStore.get('pubsub_subscriptions', subscriptionName, 'name')
+
+  if (!subscription) {
+    return {
+      isSuccessful: false,
+      errorCode: 'NOT_FOUND',
+      errorMessage: 'Subscription not found'
+    }
+  }
+
+  return {
+    isSuccessful: true,
+    subscription
+  }
+}
+
+/**
+ * List subscriptions
+ */
+export const ListSubscriptions = params => {
+  const { projectId, pageSize = 50, pageToken } = params
+
+  const result = SqliteStore.list('pubsub_subscriptions', {
+    filter: sub => sub.name.startsWith(`projects/${projectId}/subscriptions/`),
+    limit: pageSize,
+    offset: pageToken ? parseInt(pageToken, 10) : 0
+  })
+
+  return {
+    isSuccessful: true,
+    subscriptions: result.data,
+    nextPageToken: result.data.length === pageSize ? String(result.data.length) : undefined
+  }
+}
+
+/**
+ * Delete a subscription
+ */
+export const DeleteSubscription = params => {
+  const { projectId, subscriptionId } = params
+  const subscriptionName = `projects/${projectId}/subscriptions/${subscriptionId}`
+
+  try {
+    SqliteStore.delete('pubsub_subscriptions', subscriptionName, 'name')
+    return {
+      isSuccessful: true
+    }
+  } catch (error) {
+    return {
+      isSuccessful: false,
+      errorCode: 'NOT_FOUND',
+      errorMessage: 'Subscription not found'
+    }
+  }
+}
+
+/**
+ * Pull messages from a subscription
+ */
+export const PullMessages = params => {
+  const { projectId, subscriptionId, maxMessages = 100, returnImmediately = false } = params
+  const subscriptionName = `projects/${projectId}/subscriptions/${subscriptionId}`
+
+  // Check if subscription exists
+  const subscription = SqliteStore.get('pubsub_subscriptions', subscriptionName, 'name')
+  if (!subscription) {
+    return {
+      isSuccessful: false,
+      errorCode: 'NOT_FOUND',
+      errorMessage: 'Subscription not found'
+    }
+  }
+
+  // Get messages for this subscription's topic that haven't been acknowledged
+  const messages = SqliteStore.find('pubsub_messages', msg =>
+    msg.topic === subscription.topic && !msg.ackId
+  )
+
+  // Limit to maxMessages
+  const messagesToReturn = messages.slice(0, maxMessages)
+
+  // Generate ack IDs and mark messages as pending acknowledgment
+  const receivedMessages = messagesToReturn.map(msg => {
+    const ackId = uuid()
+
+    // Update message with ackId
+    SqliteStore.update('pubsub_messages', msg.id, {
+      ackId,
+      deliveryAttempt: msg.deliveryAttempt + 1,
+      lastDeliveryTime: new Date().toISOString()
+    })
+
+    return {
+      ackId,
+      message: {
+        data: msg.data,
+        attributes: msg.attributes,
+        messageId: msg.id,
+        publishTime: msg.publishTime,
+        orderingKey: msg.orderingKey
+      }
+    }
+  })
+
+  return {
+    isSuccessful: true,
+    receivedMessages
+  }
+}
+
+/**
+ * Acknowledge messages
+ */
+export const AcknowledgeMessages = params => {
+  const { projectId, subscriptionId, ackIds } = params
+  const subscriptionName = `projects/${projectId}/subscriptions/${subscriptionId}`
+
+  // Check if subscription exists
+  const subscription = SqliteStore.get('pubsub_subscriptions', subscriptionName, 'name')
+  if (!subscription) {
+    return {
+      isSuccessful: false,
+      errorCode: 'NOT_FOUND',
+      errorMessage: 'Subscription not found'
+    }
+  }
+
+  // Delete messages with matching ackIds
+  const allMessages = SqliteStore.find('pubsub_messages', () => true)
+
+  for (const ackId of ackIds) {
+    const messageToAck = allMessages.find(msg => msg.ackId === ackId)
+    if (messageToAck) {
+      try {
+        SqliteStore.delete('pubsub_messages', messageToAck.id)
+      } catch (error) {
+        // Message might have already been deleted, ignore
+      }
+    }
+  }
+
+  return {
+    isSuccessful: true
+  }
+}