@gokiteam/goki-dev 0.2.0

package/src/api/postgres/Controllers.js

@@ -0,0 +1,97 @@
+import { Logic } from './Logic.js'
+import { PostgresBroadcaster } from '../../singletons/PostgresBroadcaster.js'
+
+export const Controllers = {
+  async testConnection (ctx) {
+    const { traceId } = ctx.state
+    const { database } = ctx.request.body
+    const result = await Logic.testConnection({ database, traceId })
+    ctx.reply(result)
+  },
+
+  async listDatabases (ctx) {
+    const { traceId } = ctx.state
+    const result = await Logic.listDatabases({ traceId })
+    ctx.reply(result)
+  },
+
+  async listSchemas (ctx) {
+    const { traceId } = ctx.state
+    const { database } = ctx.request.body
+    const result = await Logic.listSchemas({ database, traceId })
+    ctx.reply(result)
+  },
+
+  async listTables (ctx) {
+    const { traceId } = ctx.state
+    const { schema, database } = ctx.request.body
+    const result = await Logic.listTables({ schema, database, traceId })
+    ctx.reply(result)
+  },
+
+  async listColumns (ctx) {
+    const { traceId } = ctx.state
+    const { schema, table, database } = ctx.request.body
+    const result = await Logic.listColumns({ schema, table, database, traceId })
+    ctx.reply(result)
+  },
+
+  async listRows (ctx) {
+    const { traceId } = ctx.state
+    const { schema, table, limit, offset, database } = ctx.request.body
+    const result = await Logic.listRows({ schema, table, limit, offset, database, traceId })
+    ctx.reply(result)
+  },
+
+  async executeQuery (ctx) {
+    const { traceId } = ctx.state
+    const { sql, database } = ctx.request.body
+    const result = await Logic.executeQuery({ sql, database, traceId })
+    ctx.reply(result)
+  },
+
+  async streamChanges (ctx) {
+    const { traceId } = ctx.state
+    const { database, schema, table } = ctx.query
+    if (!database || !table) {
+      ctx.status = 400
+      ctx.body = { success: false, status: 'error', message: 'database and table are required query parameters', traceId }
+      return
+    }
+    const resolvedSchema = schema || 'public'
+    ctx.set({
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      Connection: 'keep-alive',
+      'X-Accel-Buffering': 'no'
+    })
+    ctx.status = 200
+    ctx.respond = false
+    ctx.res.write(`event: connected\ndata: ${JSON.stringify({
+      connected: true,
+      traceId,
+      database,
+      schema: resolvedSchema,
+      table
+    })}\n\n`)
+    const filters = { database, schema: resolvedSchema, table }
+    PostgresBroadcaster.addClient(traceId, ctx, filters)
+    await new Promise((resolve) => {
+      ctx.req.on('close', () => {
+        PostgresBroadcaster.removeClient(traceId)
+        resolve()
+      })
+      ctx.req.on('error', () => {
+        PostgresBroadcaster.removeClient(traceId)
+        resolve()
+      })
+    })
+  },
+
+  async waitForCondition (ctx) {
+    const { traceId } = ctx.state
+    const { condition, timeout, pollInterval } = ctx.request.body
+    const result = await Logic.waitForCondition({ condition, timeout, pollInterval, traceId })
+    ctx.reply(result)
+  }
+}

package/src/api/postgres/Logic.js

@@ -0,0 +1,221 @@
+import { PostgresClient } from '../../singletons/PostgresClient.js'
+import { PostgresBroadcaster } from '../../singletons/PostgresBroadcaster.js'
+
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms))
+
+const deepEqual = (a, b) => {
+  if (a === b) return true
+  if (a == null || b == null) return false
+  if (typeof a !== 'object' || typeof b !== 'object') return false
+  const keysA = Object.keys(a)
+  const keysB = Object.keys(b)
+  if (keysA.length !== keysB.length) return false
+  for (const key of keysA) {
+    if (!keysB.includes(key)) return false
+    if (!deepEqual(a[key], b[key])) return false
+  }
+  return true
+}
+
+export const Logic = {
+  async testConnection (params) {
+    const { database, traceId } = params
+    try {
+      const result = await PostgresClient.testConnection(database)
+      return {
+        ...result,
+        traceId
+      }
+    } catch (error) {
+      return {
+        status: 'error',
+        message: error.message,
+        traceId
+      }
+    }
+  },
+
+  async listDatabases (params) {
+    const { traceId } = params
+    try {
+      const databases = await PostgresClient.getDatabases()
+      return {
+        databases,
+        total: databases.length,
+        traceId
+      }
+    } catch (error) {
+      return {
+        status: 'error',
+        message: error.message,
+        traceId
+      }
+    }
+  },
+
+  async listSchemas (params) {
+    const { database, traceId } = params
+    try {
+      const schemas = await PostgresClient.getSchemas(database)
+      return {
+        schemas,
+        total: schemas.length,
+        traceId
+      }
+    } catch (error) {
+      return {
+        status: 'error',
+        message: error.message,
+        traceId
+      }
+    }
+  },
+
+  async listTables (params) {
+    const { schema = 'public', database, traceId } = params
+    try {
+      const tables = await PostgresClient.getTables(schema, database)
+      return {
+        tables,
+        total: tables.length,
+        schema,
+        traceId
+      }
+    } catch (error) {
+      return {
+        status: 'error',
+        message: error.message,
+        traceId
+      }
+    }
+  },
+
+  async listColumns (params) {
+    const { schema = 'public', table, database, traceId } = params
+    try {
+      if (!table) {
+        return {
+          status: 'error',
+          message: 'Table name is required',
+          traceId
+        }
+      }
+      const columns = await PostgresClient.getColumns(schema, table, database)
+      return {
+        columns,
+        total: columns.length,
+        schema,
+        table,
+        traceId
+      }
+    } catch (error) {
+      return {
+        status: 'error',
+        message: error.message,
+        traceId
+      }
+    }
+  },
+
+  async listRows (params) {
+    const { schema = 'public', table, limit = 50, offset = 0, database, traceId } = params
+    try {
+      if (!table) {
+        return {
+          status: 'error',
+          message: 'Table name is required',
+          traceId
+        }
+      }
+      const result = await PostgresClient.getRows(schema, table, limit, offset, database)
+      return {
+        rows: result.rows,
+        total: result.total,
+        fields: result.fields,
+        schema,
+        table,
+        limit,
+        offset,
+        traceId
+      }
+    } catch (error) {
+      return {
+        status: 'error',
+        message: error.message,
+        traceId
+      }
+    }
+  },
+
+  async executeQuery (params) {
+    const { sql, database, traceId } = params
+    try {
+      if (!sql) {
+        return {
+          status: 'error',
+          message: 'SQL query is required',
+          traceId
+        }
+      }
+      const start = performance.now()
+      const result = await PostgresClient.executeQuery(sql, database)
+      const executionTime = Math.round(performance.now() - start)
+      // Notify SSE clients after write queries so other tabs refresh immediately
+      const firstWord = sql.trim().split(/\s/)[0].toUpperCase()
+      if (['INSERT', 'UPDATE', 'DELETE'].includes(firstWord)) {
+        const tableMatch = sql.match(/(?:INTO|UPDATE|FROM)\s+"?(\w+)"?/i)
+        const table = tableMatch?.[1]
+        PostgresBroadcaster.notifyChange(database, table ? 'public' : null, table || null)
+      }
+      return {
+        rows: result.rows,
+        rowCount: result.rowCount,
+        fields: result.fields,
+        executionTime,
+        traceId
+      }
+    } catch (error) {
+      return {
+        status: 'error',
+        message: error.message,
+        traceId
+      }
+    }
+  },
+
+  async waitForCondition (params) {
+    const { condition, timeout = 5000, pollInterval = 100, traceId } = params
+    const startTime = Date.now()
+    try {
+      while (Date.now() - startTime < timeout) {
+        const result = await PostgresClient.query(
+          condition.query,
+          condition.params || [],
+          condition.database
+        )
+        const actualValue = result.rows
+        const met = deepEqual(actualValue, condition.expect)
+        if (met) {
+          return {
+            met: true,
+            foundAt: Date.now() - startTime,
+            actualValue,
+            traceId
+          }
+        }
+        await sleep(pollInterval)
+      }
+      return {
+        status: 'error',
+        message: 'Timeout waiting for condition',
+        traceId
+      }
+    } catch (error) {
+      return {
+        status: 'error',
+        message: error.message,
+        traceId
+      }
+    }
+  }
+}

package/src/api/postgres/Router.js

@@ -0,0 +1,21 @@
+import KoaRouter from 'koa-router'
+import { Controllers } from './Controllers.js'
+
+const Router = new KoaRouter()
+const v1 = new KoaRouter({ prefix: '/v1/postgres' })
+
+v1.post('/connection/test', Controllers.testConnection)
+v1.post('/databases/list', Controllers.listDatabases)
+v1.post('/schemas/list', Controllers.listSchemas)
+v1.post('/tables/list', Controllers.listTables)
+v1.post('/columns/list', Controllers.listColumns)
+v1.post('/rows/list', Controllers.listRows)
+v1.post('/query/execute', Controllers.executeQuery)
+v1.get('/changes/stream', Controllers.streamChanges)
+
+// Testing Helpers
+v1.post('/rows/wait-for', Controllers.waitForCondition)
+
+Router.use(v1.routes())
+
+export { Router }

package/src/api/pubsub/Controllers.js

@@ -0,0 +1,236 @@
+import { Logic } from './Logic.js'
+import { MessageBroadcaster } from '../../singletons/MessageBroadcaster.js'
+
+export const Controllers = {
+  async listTopics (ctx) {
+    const { traceId } = ctx.state
+    const { filter, page } = ctx.request.body
+    const result = await Logic.listTopics({ filter, page, traceId })
+    ctx.reply(result)
+  },
+  async createTopic (ctx) {
+    const { traceId } = ctx.state
+    const { topicName } = ctx.request.body
+    const result = await Logic.createTopic({ topicName, traceId })
+    ctx.reply(result)
+  },
+  async deleteTopic (ctx) {
+    const { traceId } = ctx.state
+    const { topicName } = ctx.request.body
+    const result = await Logic.deleteTopic({ topicName, traceId })
+    ctx.reply(result)
+  },
+  async listSubscriptions (ctx) {
+    const { traceId } = ctx.state
+    const { filter, page } = ctx.request.body
+    const result = await Logic.listSubscriptions({ filter, page, traceId })
+    ctx.reply(result)
+  },
+  async createSubscription (ctx) {
+    const { traceId } = ctx.state
+    const { topicName, subscriptionName } = ctx.request.body
+    const result = await Logic.createSubscription({ topicName, subscriptionName, traceId })
+    ctx.reply(result)
+  },
+  async deleteSubscription (ctx) {
+    const { traceId } = ctx.state
+    const { subscriptionName } = ctx.request.body
+    const result = await Logic.deleteSubscription({ subscriptionName, traceId })
+    ctx.reply(result)
+  },
+  async listMessages (ctx) {
+    const { traceId } = ctx.state
+    const { filter, page } = ctx.request.body
+    const result = await Logic.listMessages({ filter, page, traceId })
+    ctx.reply(result)
+  },
+  async publishMessage (ctx) {
+    const { traceId } = ctx.state
+    const { topicName, message, attributes } = ctx.request.body
+    const result = await Logic.publishMessage({ topicName, message, attributes, traceId })
+    ctx.reply(result)
+  },
+  async pullMessages (ctx) {
+    const { traceId } = ctx.state
+    const { subscriptionName, maxMessages } = ctx.request.body
+    const result = await Logic.pullMessages({ subscriptionName, maxMessages, traceId })
+    ctx.reply(result)
+  },
+
+  /**
+   * SSE streaming endpoint for real-time message updates
+   * GET /v1/pubsub/messages/stream?topic=X&sender=Y&startTime=ISO
+   */
+  async streamMessages (ctx) {
+    const { traceId } = ctx.state
+    const { topic, sender, startTime } = ctx.query
+
+    // Set SSE headers
+    ctx.set({
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      Connection: 'keep-alive',
+      'X-Accel-Buffering': 'no' // Disable Nginx buffering
+    })
+
+    ctx.status = 200
+    ctx.respond = false // Tell Koa not to auto-finish the response
+
+    // Send initial connection event
+    ctx.res.write(`event: connected\ndata: ${JSON.stringify({ connected: true, traceId })}\n\n`)
+
+    // Register client with broadcaster
+    const filters = {}
+    if (topic) filters.topic = topic
+    if (sender) filters.sender = sender
+
+    MessageBroadcaster.addClient(traceId, ctx, filters)
+
+    // Send historical messages if startTime provided
+    if (startTime) {
+      try {
+        const history = await Logic.getHistory({
+          filter: {
+            topic,
+            sender,
+            timeRange: {
+              start: startTime,
+              end: new Date().toISOString()
+            }
+          },
+          page: { limit: 100 },
+          traceId
+        })
+
+        for (const msg of history.messages) {
+          ctx.res.write(`event: history\ndata: ${JSON.stringify(msg)}\n\n`)
+        }
+      } catch (error) {
+        ctx.res.write(`event: error\ndata: ${JSON.stringify({ error: error.message })}\n\n`)
+      }
+    }
+
+    // Wait indefinitely until client disconnects
+    // Heartbeat is handled by the shared MessageBroadcaster interval
+    await new Promise((resolve) => {
+      ctx.req.on('close', () => {
+        MessageBroadcaster.removeClient(traceId)
+        resolve()
+      })
+
+      ctx.req.on('error', () => {
+        MessageBroadcaster.removeClient(traceId)
+        resolve()
+      })
+    })
+  },
+
+  /**
+   * Query message history with filters
+   * POST /v1/pubsub/messages/history
+   */
+  async getHistory (ctx) {
+    const { traceId } = ctx.state
+    const { filter, page } = ctx.request.body
+    const result = await Logic.getHistory({ filter, page, traceId })
+    ctx.reply(result)
+  },
+
+  /**
+   * Auto-suggest topics based on query
+   * POST /v1/pubsub/topics/suggest
+   */
+  async suggestTopics (ctx) {
+    const { traceId } = ctx.state
+    const { query, limit } = ctx.request.body
+    const result = await Logic.suggestTopics({ query, limit, traceId })
+    ctx.reply(result)
+  },
+
+  /**
+   * Search messages by content
+   * POST /v1/pubsub/messages/search
+   */
+  async searchMessages (ctx) {
+    const { traceId } = ctx.state
+    const { query, searchIn, filter, page } = ctx.request.body
+    const result = await Logic.searchMessages({ query, searchIn, filter, page, traceId })
+    ctx.reply(result)
+  },
+
+  /**
+   * Clear message history
+   * POST /v1/pubsub/history/clear
+   */
+  async clearHistory (ctx) {
+    const { traceId } = ctx.state
+    const { keepCount, topic } = ctx.request.body
+    const result = await Logic.clearHistory({ keepCount, topic, traceId })
+    ctx.reply(result)
+  },
+
+  /**
+   * Get message history statistics
+   * POST /v1/pubsub/history/stats
+   */
+  async getHistoryStats (ctx) {
+    const { traceId } = ctx.state
+    const result = await Logic.getHistoryStats({ traceId })
+    ctx.reply(result)
+  },
+
+  /**
+   * Wait for a message matching filter criteria
+   * POST /v1/pubsub/messages/wait-for
+   */
+  async waitForMessage (ctx) {
+    const { traceId } = ctx.state
+    const { filter, timeout } = ctx.request.body
+    const result = await Logic.waitForMessage({ filter, timeout, traceId })
+    ctx.reply(result)
+  },
+
+  /**
+   * Assert that a message was published with specific criteria
+   * POST /v1/pubsub/messages/assert-published
+   */
+  async assertMessagePublished (ctx) {
+    const { traceId } = ctx.state
+    const { filter } = ctx.request.body
+    const result = await Logic.assertMessagePublished({ filter, traceId })
+    ctx.reply(result)
+  },
+
+  /**
+   * Register topics in the persistent registry
+   * POST /v1/pubsub/registry/register
+   */
+  async registerTopics (ctx) {
+    const { traceId } = ctx.state
+    const { projectName, topics } = ctx.request.body
+    const result = await Logic.registerTopics({ projectName, topics, traceId })
+    ctx.reply(result)
+  },
+
+  /**
+   * List registered topics from the persistent registry
+   * POST /v1/pubsub/registry/list
+   */
+  async listRegistry (ctx) {
+    const { traceId } = ctx.state
+    const { projectName } = ctx.request.body
+    const result = await Logic.listRegistry({ projectName, traceId })
+    ctx.reply(result)
+  },
+
+  /**
+   * Unregister topics for a project
+   * POST /v1/pubsub/registry/unregister
+   */
+  async unregisterTopics (ctx) {
+    const { traceId } = ctx.state
+    const { projectName, topicNames } = ctx.request.body
+    const result = await Logic.unregisterTopics({ projectName, topicNames, traceId })
+    ctx.reply(result)
+  }
+}