@gokiteam/goki-dev 0.2.0

package/src/api/pubsub/Router.js

@@ -0,0 +1,41 @@
+import KoaRouter from 'koa-router'
+import { Controllers } from './Controllers.js'
+
+const Router = new KoaRouter()
+const v1 = new KoaRouter({ prefix: '/v1/pubsub' })
+
+// Topics
+v1.post('/topics/list', Controllers.listTopics)
+v1.post('/topics/create', Controllers.createTopic)
+v1.post('/topics/delete', Controllers.deleteTopic)
+v1.post('/topics/suggest', Controllers.suggestTopics)
+
+// Subscriptions
+v1.post('/subscriptions/list', Controllers.listSubscriptions)
+v1.post('/subscriptions/create', Controllers.createSubscription)
+v1.post('/subscriptions/delete', Controllers.deleteSubscription)
+
+// Messages
+v1.post('/messages/list', Controllers.listMessages)
+v1.post('/messages/publish', Controllers.publishMessage)
+v1.post('/messages/pull', Controllers.pullMessages)
+v1.get('/messages/stream', Controllers.streamMessages) // SSE endpoint
+v1.post('/messages/search', Controllers.searchMessages)
+
+// History
+v1.post('/messages/history', Controllers.getHistory)
+v1.post('/history/clear', Controllers.clearHistory)
+v1.post('/history/stats', Controllers.getHistoryStats)
+
+// Testing Helpers
+v1.post('/messages/wait-for', Controllers.waitForMessage)
+v1.post('/messages/assert-published', Controllers.assertMessagePublished)
+
+// Registry (persistent topic declarations)
+v1.post('/registry/register', Controllers.registerTopics)
+v1.post('/registry/list', Controllers.listRegistry)
+v1.post('/registry/unregister', Controllers.unregisterTopics)
+
+Router.use(v1.routes())
+
+export { Router }

package/src/api/pubsub/Schemas.js

@@ -0,0 +1,355 @@
+import { Joi } from '@gokiteam/koa'
+
+export const Schemas = {
+  listTopics: {
+    request: {
+      body: {
+        filter: Joi.object().optional(),
+        page: Joi.object({
+          limit: Joi.number().integer().min(1).max(1000).default(50),
+          offset: Joi.number().integer().min(0).default(0)
+        }).optional()
+      }
+    },
+    responses: {
+      success: {
+        topics: Joi.array().items(Joi.object()).required(),
+        total: Joi.number().integer().min(0).required()
+      }
+    }
+  },
+
+  createTopic: {
+    request: {
+      body: {
+        topicName: Joi.string().required()
+      }
+    },
+    responses: {
+      success: {
+        topic: Joi.object().required()
+      }
+    }
+  },
+
+  deleteTopic: {
+    request: {
+      body: {
+        topicName: Joi.string().required()
+      }
+    },
+    responses: {
+      success: {
+        message: Joi.string().required()
+      }
+    }
+  },
+
+  suggestTopics: {
+    request: {
+      body: {
+        query: Joi.string().allow('').default(''),
+        limit: Joi.number().integer().min(1).max(100).default(10)
+      }
+    },
+    responses: {
+      success: {
+        topics: Joi.array().items(
+          Joi.object({
+            name: Joi.string().required(),
+            messageCount: Joi.number().integer().min(0).required(),
+            lastPublishTime: Joi.string().isoDate().allow(null).optional()
+          })
+        ).required()
+      }
+    }
+  },
+
+  listSubscriptions: {
+    request: {
+      body: {
+        filter: Joi.object().optional(),
+        page: Joi.object({
+          limit: Joi.number().integer().min(1).max(1000).default(50),
+          offset: Joi.number().integer().min(0).default(0)
+        }).optional()
+      }
+    },
+    responses: {
+      success: {
+        subscriptions: Joi.array().items(Joi.object()).required(),
+        total: Joi.number().integer().min(0).required()
+      }
+    }
+  },
+
+  createSubscription: {
+    request: {
+      body: {
+        topicName: Joi.string().required(),
+        subscriptionName: Joi.string().required()
+      }
+    },
+    responses: {
+      success: {
+        subscription: Joi.object().required()
+      }
+    }
+  },
+
+  deleteSubscription: {
+    request: {
+      body: {
+        subscriptionName: Joi.string().required()
+      }
+    },
+    responses: {
+      success: {
+        message: Joi.string().required()
+      }
+    }
+  },
+
+  listMessages: {
+    request: {
+      body: {
+        filter: Joi.object().optional(),
+        page: Joi.object({
+          limit: Joi.number().integer().min(1).max(1000).default(50),
+          offset: Joi.number().integer().min(0).default(0)
+        }).optional()
+      }
+    },
+    responses: {
+      success: {
+        messages: Joi.array().items(Joi.object()).required(),
+        total: Joi.number().integer().min(0).required()
+      }
+    }
+  },
+
+  publishMessage: {
+    request: {
+      body: {
+        topicName: Joi.string().required(),
+        message: Joi.alternatives().try(Joi.string(), Joi.object()).required(),
+        attributes: Joi.object().optional()
+      }
+    },
+    responses: {
+      success: {
+        messageIds: Joi.array().items(Joi.string()).required()
+      }
+    }
+  },
+
+  pullMessages: {
+    request: {
+      body: {
+        subscriptionName: Joi.string().required(),
+        maxMessages: Joi.number().integer().min(1).max(1000).default(10)
+      }
+    },
+    responses: {
+      success: {
+        messages: Joi.array().items(Joi.object()).required()
+      }
+    }
+  },
+
+  getHistory: {
+    request: {
+      body: {
+        filter: Joi.object({
+          topic: Joi.string().optional(),
+          sender: Joi.string().optional(),
+          before: Joi.string().isoDate().optional(),
+          timeRange: Joi.object({
+            start: Joi.string().isoDate().required(),
+            end: Joi.string().isoDate().required()
+          }).optional()
+        }).optional(),
+        page: Joi.object({
+          limit: Joi.number().integer().min(1).max(1000).default(50),
+          offset: Joi.number().integer().min(0).default(0)
+        }).optional()
+      }
+    },
+    responses: {
+      success: {
+        messages: Joi.array().items(
+          Joi.object({
+            id: Joi.string().required(),
+            message_id: Joi.string().required(),
+            data: Joi.string().allow('').optional(),
+            attributes: Joi.object().optional(),
+            ordering_key: Joi.string().allow('').optional(),
+            publish_time: Joi.string().isoDate().required(),
+            topic: Joi.string().required(),
+            sender: Joi.string().allow(null).optional(),
+            view_count: Joi.number().integer().min(0).required(),
+            last_viewed_at: Joi.number().integer().allow(null).optional(),
+            created_at: Joi.number().integer().required()
+          })
+        ).required(),
+        total: Joi.number().integer().min(0).required()
+      }
+    }
+  },
+
+  searchMessages: {
+    request: {
+      body: {
+        query: Joi.string().required(),
+        searchIn: Joi.array().items(Joi.string().valid('data', 'attributes')).default(['data']),
+        filter: Joi.object({
+          topic: Joi.string().optional(),
+          sender: Joi.string().optional()
+        }).optional(),
+        page: Joi.object({
+          limit: Joi.number().integer().min(1).max(1000).default(50),
+          offset: Joi.number().integer().min(0).default(0)
+        }).optional()
+      }
+    },
+    responses: {
+      success: {
+        messages: Joi.array().items(Joi.object()).required(),
+        total: Joi.number().integer().min(0).required()
+      }
+    }
+  },
+
+  clearHistory: {
+    request: {
+      body: {
+        keepCount: Joi.number().integer().min(100).optional(),
+        topic: Joi.string().optional()
+      }
+    },
+    responses: {
+      success: {
+        deletedCount: Joi.number().integer().min(0).required()
+      }
+    }
+  },
+
+  getHistoryStats: {
+    request: {
+      body: {}
+    },
+    responses: {
+      success: {
+        totalMessages: Joi.number().integer().min(0).required(),
+        totalTopics: Joi.number().integer().min(0).required(),
+        oldestMessage: Joi.string().isoDate().allow(null).optional(),
+        newestMessage: Joi.string().isoDate().allow(null).optional(),
+        topTopics: Joi.array().items(
+          Joi.object({
+            topic: Joi.string().required(),
+            count: Joi.number().integer().min(0).required()
+          })
+        ).required()
+      }
+    }
+  },
+
+  waitForMessage: {
+    request: {
+      body: {
+        filter: Joi.object({
+          topic: Joi.string().required(),
+          predicate: Joi.object({
+            jsonPath: Joi.string().required(),
+            operator: Joi.string().valid('equals', 'notEquals', 'contains', 'greaterThan', 'lessThan').required(),
+            value: Joi.any().required()
+          }).optional(),
+          sender: Joi.string().optional()
+        }).required(),
+        timeout: Joi.number().integer().min(100).max(30000).default(5000),
+        traceId: Joi.string().optional()
+      }
+    },
+    responses: {
+      success: {
+        message: Joi.object().required(),
+        foundAt: Joi.number().integer().required(),
+        traceId: Joi.string().required()
+      }
+    }
+  },
+
+  assertMessagePublished: {
+    request: {
+      body: {
+        filter: Joi.object({
+          topic: Joi.string().required(),
+          since: Joi.string().isoDate().optional(),
+          dataContains: Joi.string().optional(),
+          attributesMatch: Joi.object().optional()
+        }).required(),
+        traceId: Joi.string().optional()
+      }
+    },
+    responses: {
+      success: {
+        found: Joi.boolean().required(),
+        count: Joi.number().integer().min(0).required(),
+        firstMatch: Joi.object().optional(),
+        traceId: Joi.string().required()
+      }
+    }
+  },
+
+  // Registry
+  registerTopics: {
+    request: {
+      body: {
+        projectName: Joi.string().required(),
+        topics: Joi.array().items(
+          Joi.alternatives().try(
+            Joi.string(),
+            Joi.object({
+              name: Joi.string().required(),
+              subscription: Joi.string().optional()
+            })
+          )
+        ).min(1).required()
+      }
+    },
+    responses: {
+      success: {
+        registered: Joi.array().items(Joi.object()).required(),
+        count: Joi.number().integer().min(0).required()
+      }
+    }
+  },
+
+  listRegistry: {
+    request: {
+      body: {
+        projectName: Joi.string().optional()
+      }
+    },
+    responses: {
+      success: {
+        entries: Joi.array().items(Joi.object()).required(),
+        total: Joi.number().integer().min(0).required()
+      }
+    }
+  },
+
+  unregisterTopics: {
+    request: {
+      body: {
+        projectName: Joi.string().required(),
+        topicNames: Joi.array().items(Joi.string()).min(1).required()
+      }
+    },
+    responses: {
+      success: {
+        removed: Joi.number().integer().min(0).required()
+      }
+    }
+  }
+}

package/src/api/redis/Controllers.js

@@ -0,0 +1,63 @@
+import { Logic } from './Logic.js'
+
+export const Controllers = {
+  async testConnection (ctx) {
+    const { traceId } = ctx.state
+    const result = await Logic.testConnection({ traceId })
+    ctx.reply(result)
+  },
+
+  async getInfo (ctx) {
+    const { traceId } = ctx.state
+    const result = await Logic.getInfo({ traceId })
+    ctx.reply(result)
+  },
+
+  async scanKeys (ctx) {
+    const { traceId } = ctx.state
+    const { pattern, cursor, count } = ctx.request.body
+    const result = await Logic.scanKeys({ pattern, cursor, count, traceId })
+    ctx.reply(result)
+  },
+
+  async getKey (ctx) {
+    const { traceId } = ctx.state
+    const { key } = ctx.request.body
+    const result = await Logic.getKey({ key, traceId })
+    ctx.reply(result)
+  },
+
+  async getKeyTtl (ctx) {
+    const { traceId } = ctx.state
+    const { key } = ctx.request.body
+    const result = await Logic.getKeyTtl({ key, traceId })
+    ctx.reply(result)
+  },
+
+  async deleteKey (ctx) {
+    const { traceId } = ctx.state
+    const { key } = ctx.request.body
+    const result = await Logic.deleteKey({ key, traceId })
+    ctx.reply(result)
+  },
+
+  async updateKey (ctx) {
+    const { traceId } = ctx.state
+    const { key, value, ttl } = ctx.request.body
+    const result = await Logic.updateKey({ key, value, ttl, traceId })
+    ctx.reply(result)
+  },
+
+  async deleteAll (ctx) {
+    const { traceId } = ctx.state
+    const result = await Logic.deleteAll({ traceId })
+    ctx.reply(result)
+  },
+
+  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/redis/Logic.js

@@ -0,0 +1,239 @@
+import { RedisClient } from '../../singletons/RedisClient.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 { traceId } = params
+    try {
+      const result = await RedisClient.testConnection()
+      return {
+        ...result,
+        traceId
+      }
+    } catch (error) {
+      return {
+        status: 'error',
+        message: error.message,
+        traceId
+      }
+    }
+  },
+
+  async getInfo (params) {
+    const { traceId } = params
+    try {
+      const info = await RedisClient.getInfo()
+      const dbSize = await RedisClient.getDbSize()
+      return {
+        info,
+        dbSize,
+        traceId
+      }
+    } catch (error) {
+      return {
+        status: 'error',
+        message: error.message,
+        traceId
+      }
+    }
+  },
+
+  async scanKeys (params) {
+    const { pattern = '*', cursor = '0', count = 100, traceId } = params
+    try {
+      const result = await RedisClient.scanKeys(pattern, cursor, count)
+      // Get type for each key
+      const keysWithTypes = await Promise.all(
+        result.keys.map(async (key) => {
+          const type = await RedisClient.getKeyType(key)
+          const ttl = await RedisClient.getKeyTtl(key)
+          return { key, type, ttl }
+        })
+      )
+      return {
+        keys: keysWithTypes,
+        cursor: result.cursor,
+        done: result.done,
+        traceId
+      }
+    } catch (error) {
+      return {
+        status: 'error',
+        message: error.message,
+        traceId
+      }
+    }
+  },
+
+  async getKey (params) {
+    const { key, traceId } = params
+    try {
+      if (!key) {
+        return {
+          status: 'error',
+          message: 'Key is required',
+          traceId
+        }
+      }
+      const result = await RedisClient.getKeyValue(key)
+      return {
+        ...result,
+        traceId
+      }
+    } catch (error) {
+      return {
+        status: 'error',
+        message: error.message,
+        traceId
+      }
+    }
+  },
+
+  async getKeyTtl (params) {
+    const { key, traceId } = params
+    try {
+      if (!key) {
+        return {
+          status: 'error',
+          message: 'Key is required',
+          traceId
+        }
+      }
+      const ttl = await RedisClient.getKeyTtl(key)
+      return {
+        key,
+        ttl,
+        traceId
+      }
+    } catch (error) {
+      return {
+        status: 'error',
+        message: error.message,
+        traceId
+      }
+    }
+  },
+
+  async deleteKey (params) {
+    const { key, traceId } = params
+    try {
+      if (!key) {
+        return {
+          status: 'error',
+          message: 'Key is required',
+          traceId
+        }
+      }
+      const deleted = await RedisClient.deleteKey(key)
+      return {
+        deleted: deleted === 1,
+        key,
+        traceId
+      }
+    } catch (error) {
+      return {
+        status: 'error',
+        message: error.message,
+        traceId
+      }
+    }
+  },
+
+  async updateKey (params) {
+    const { key, value, ttl, traceId } = params
+    try {
+      if (!key) {
+        return {
+          status: 'error',
+          message: 'Key is required',
+          traceId
+        }
+      }
+      if (value === undefined) {
+        return {
+          status: 'error',
+          message: 'Value is required',
+          traceId
+        }
+      }
+      await RedisClient.setKey(key, value, ttl)
+      return {
+        updated: true,
+        key,
+        traceId
+      }
+    } catch (error) {
+      return {
+        status: 'error',
+        message: error.message,
+        traceId
+      }
+    }
+  },
+
+  async deleteAll (params) {
+    const { traceId } = params
+    try {
+      const countBefore = await RedisClient.getDbSize()
+      await RedisClient.deleteAll()
+      return {
+        deleted: countBefore,
+        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) {
+        await RedisClient.connect()
+        const keyData = await RedisClient.getKeyValue(condition.key)
+        const actualValue = keyData.value
+        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/redis/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/redis' })
+
+v1.post('/connection/test', Controllers.testConnection)
+v1.post('/info', Controllers.getInfo)
+v1.post('/keys/scan', Controllers.scanKeys)
+v1.post('/keys/get', Controllers.getKey)
+v1.post('/keys/ttl', Controllers.getKeyTtl)
+v1.post('/keys/delete', Controllers.deleteKey)
+v1.post('/keys/update', Controllers.updateKey)
+v1.post('/keys/delete-all', Controllers.deleteAll)
+
+// Testing Helpers
+v1.post('/keys/wait-for', Controllers.waitForCondition)
+
+Router.use(v1.routes())
+
+export { Router }