@gokiteam/goki-dev 0.2.0

package/src/api/docs/Router.js

@@ -0,0 +1,12 @@
+import KoaRouter from 'koa-router'
+import { Controllers } from './Controllers.js'
+
+const Router = new KoaRouter()
+const v1 = new KoaRouter({ prefix: '/v1/docs' })
+
+v1.get('/', Controllers.resolve)
+v1.get('/(.*)', Controllers.resolve)
+
+Router.use(v1.routes())
+
+export { Router }

package/src/api/export/Controllers.js

@@ -0,0 +1,30 @@
+import { Logic } from './Logic.js'
+
+export const Controllers = {
+  async exportAll (ctx) {
+    const { traceId } = ctx.state
+    const result = await Logic.exportAll({ traceId })
+    ctx.reply(result)
+  },
+  async exportPubsub (ctx) {
+    const { traceId } = ctx.state
+    const result = await Logic.exportPubsub({ traceId })
+    ctx.reply(result)
+  },
+  async exportLogging (ctx) {
+    const { traceId } = ctx.state
+    const result = await Logic.exportLogging({ traceId })
+    ctx.reply(result)
+  },
+  async exportMqtt (ctx) {
+    const { traceId } = ctx.state
+    const result = await Logic.exportMqtt({ traceId })
+    ctx.reply(result)
+  },
+  async importAll (ctx) {
+    const { traceId } = ctx.state
+    const { data, clearExisting } = ctx.request.body
+    const result = await Logic.importAll({ data, clearExisting, traceId })
+    ctx.reply(result)
+  }
+}

package/src/api/export/Logic.js

@@ -0,0 +1,143 @@
+import { SqliteStore } from '../../singletons/SqliteStore.js'
+import {
+  PUBSUB_TOPICS,
+  PUBSUB_SUBSCRIPTIONS,
+  PUBSUB_MESSAGES,
+  LOGGING_ENTRIES,
+  MQTT_CLIENTS,
+  MQTT_MESSAGES
+} from '../../db/Tables.js'
+
+export const Logic = {
+  async exportAll (params) {
+    const { traceId } = params
+    const topics = SqliteStore.list(PUBSUB_TOPICS)
+    const subscriptions = SqliteStore.list(PUBSUB_SUBSCRIPTIONS)
+    const messages = SqliteStore.list(PUBSUB_MESSAGES)
+    const logEntries = SqliteStore.list(LOGGING_ENTRIES)
+    const mqttClients = SqliteStore.list(MQTT_CLIENTS)
+    const mqttMessages = SqliteStore.list(MQTT_MESSAGES)
+    return {
+      data: {
+        pubsub: {
+          topics: topics.data,
+          subscriptions: subscriptions.data,
+          messages: messages.data
+        },
+        logging: {
+          entries: logEntries.data
+        },
+        mqtt: {
+          clients: mqttClients.data,
+          messages: mqttMessages.data
+        },
+        exportedAt: new Date().toISOString()
+      },
+      traceId
+    }
+  },
+  async exportPubsub (params) {
+    const { traceId } = params
+    const topics = SqliteStore.list(PUBSUB_TOPICS)
+    const subscriptions = SqliteStore.list(PUBSUB_SUBSCRIPTIONS)
+    const messages = SqliteStore.list(PUBSUB_MESSAGES)
+    return {
+      data: {
+        topics: topics.data,
+        subscriptions: subscriptions.data,
+        messages: messages.data,
+        exportedAt: new Date().toISOString()
+      },
+      traceId
+    }
+  },
+  async exportLogging (params) {
+    const { traceId } = params
+    const logEntries = SqliteStore.list(LOGGING_ENTRIES)
+    return {
+      data: {
+        entries: logEntries.data,
+        exportedAt: new Date().toISOString()
+      },
+      traceId
+    }
+  },
+  async exportMqtt (params) {
+    const { traceId } = params
+    const mqttClients = SqliteStore.list(MQTT_CLIENTS)
+    const mqttMessages = SqliteStore.list(MQTT_MESSAGES)
+    return {
+      data: {
+        clients: mqttClients.data,
+        messages: mqttMessages.data,
+        exportedAt: new Date().toISOString()
+      },
+      traceId
+    }
+  },
+  async importAll (params) {
+    const { data, clearExisting = false, traceId } = params
+    const imported = {
+      topics: 0,
+      subscriptions: 0,
+      messages: 0,
+      logEntries: 0,
+      mqttClients: 0,
+      mqttMessages: 0
+    }
+    if (clearExisting) {
+      SqliteStore.clear('pubsub_topics')
+      SqliteStore.clear('pubsub_subscriptions')
+      SqliteStore.clear(PUBSUB_MESSAGES)
+      SqliteStore.clear(LOGGING_ENTRIES)
+      SqliteStore.clear(MQTT_CLIENTS)
+      SqliteStore.clear(MQTT_MESSAGES)
+    }
+    if (data.pubsub) {
+      if (data.pubsub.topics) {
+        for (const topic of data.pubsub.topics) {
+          SqliteStore.create('pubsub_topics', topic)
+          imported.topics++
+        }
+      }
+      if (data.pubsub.subscriptions) {
+        for (const subscription of data.pubsub.subscriptions) {
+          SqliteStore.create('pubsub_subscriptions', subscription)
+          imported.subscriptions++
+        }
+      }
+      if (data.pubsub.messages) {
+        for (const message of data.pubsub.messages) {
+          SqliteStore.create(PUBSUB_MESSAGES, message)
+          imported.messages++
+        }
+      }
+    }
+    if (data.logging && data.logging.entries) {
+      for (const entry of data.logging.entries) {
+        SqliteStore.create(LOGGING_ENTRIES, entry)
+        imported.logEntries++
+      }
+    }
+    if (data.mqtt) {
+      if (data.mqtt.clients) {
+        for (const client of data.mqtt.clients) {
+          SqliteStore.create(MQTT_CLIENTS, client)
+          imported.mqttClients++
+        }
+      }
+      if (data.mqtt.messages) {
+        for (const message of data.mqtt.messages) {
+          SqliteStore.create(MQTT_MESSAGES, message)
+          imported.mqttMessages++
+        }
+      }
+    }
+    SqliteStore.flushAll()
+    return {
+      message: 'Platform state imported successfully',
+      imported,
+      traceId
+    }
+  }
+}

package/src/api/export/Router.js

@@ -0,0 +1,18 @@
+import KoaRouter from 'koa-router'
+import { Controllers } from './Controllers.js'
+
+const Router = new KoaRouter()
+const v1Export = new KoaRouter({ prefix: '/v1/export' })
+const v1Import = new KoaRouter({ prefix: '/v1/import' })
+
+v1Export.post('/all', Controllers.exportAll)
+v1Export.post('/pubsub', Controllers.exportPubsub)
+v1Export.post('/logging', Controllers.exportLogging)
+v1Export.post('/mqtt', Controllers.exportMqtt)
+
+v1Import.post('/all', Controllers.importAll)
+
+Router.use(v1Export.routes())
+Router.use(v1Import.routes())
+
+export { Router }

package/src/api/export/Schemas.js

@@ -0,0 +1,104 @@
+import { Joi } from '@gokiteam/koa'
+
+export const Schemas = {
+  exportAll: {
+    request: {
+      body: {}
+    },
+    responses: {
+      success: {
+        data: Joi.object({
+          pubsub: Joi.object({
+            topics: Joi.array().required(),
+            subscriptions: Joi.array().required(),
+            messages: Joi.array().required()
+          }).required(),
+          logging: Joi.object({
+            entries: Joi.array().required()
+          }).required(),
+          mqtt: Joi.object({
+            clients: Joi.array().required(),
+            messages: Joi.array().required()
+          }).required(),
+          exportedAt: Joi.string().isoDate().required()
+        }).required()
+      }
+    }
+  },
+  exportPubsub: {
+    request: {
+      body: {}
+    },
+    responses: {
+      success: {
+        data: Joi.object({
+          topics: Joi.array().required(),
+          subscriptions: Joi.array().required(),
+          messages: Joi.array().required(),
+          exportedAt: Joi.string().isoDate().required()
+        }).required()
+      }
+    }
+  },
+  exportLogging: {
+    request: {
+      body: {}
+    },
+    responses: {
+      success: {
+        data: Joi.object({
+          entries: Joi.array().required(),
+          exportedAt: Joi.string().isoDate().required()
+        }).required()
+      }
+    }
+  },
+  exportMqtt: {
+    request: {
+      body: {}
+    },
+    responses: {
+      success: {
+        data: Joi.object({
+          clients: Joi.array().required(),
+          messages: Joi.array().required(),
+          exportedAt: Joi.string().isoDate().required()
+        }).required()
+      }
+    }
+  },
+  importAll: {
+    request: {
+      body: {
+        data: Joi.object({
+          pubsub: Joi.object({
+            topics: Joi.array().required(),
+            subscriptions: Joi.array().required(),
+            messages: Joi.array().required()
+          }),
+          logging: Joi.object({
+            entries: Joi.array().required()
+          }),
+          mqtt: Joi.object({
+            clients: Joi.array().required(),
+            messages: Joi.array().required()
+          })
+        }).required(),
+        clearExisting: Joi.boolean().default(false)
+      }
+    },
+    responses: {
+      success: {
+        message: Joi.string().required(),
+        imported: Joi.object({
+          topics: Joi.number().integer().min(0).required(),
+          subscriptions: Joi.number().integer().min(0).required(),
+          messages: Joi.number().integer().min(0).required(),
+          logEntries: Joi.number().integer().min(0).required(),
+          mqttClients: Joi.number().integer().min(0).required(),
+          mqttMessages: Joi.number().integer().min(0).required()
+        }).required()
+      }
+    }
+  }
+}

package/src/api/firestore/Controllers.js

@@ -0,0 +1,152 @@
+import { Logic } from './Logic.js'
+import { FirestoreBroadcaster } from '../../singletons/FirestoreBroadcaster.js'
+import { Application } from '../../configs/Application.js'
+
+export const Controllers = {
+  async listProjects (ctx) {
+    const { traceId } = ctx.state
+    const result = Logic.listProjects({ traceId })
+    ctx.reply(result)
+  },
+
+  async listCollections (ctx) {
+    const { traceId } = ctx.state
+    const { projectId } = ctx.request.body
+    const result = await Logic.listCollections({ projectId, traceId })
+    ctx.reply(result)
+  },
+
+  async listDocuments (ctx) {
+    const { traceId } = ctx.state
+    const { collectionPath, page, projectId } = ctx.request.body
+    const result = await Logic.listDocuments({ collectionPath, page, projectId, traceId })
+    ctx.reply(result)
+  },
+
+  async getDocument (ctx) {
+    const { traceId } = ctx.state
+    const { collectionPath, documentId, projectId } = ctx.request.body
+    const result = await Logic.getDocument({ collectionPath, documentId, projectId, traceId })
+    ctx.reply(result)
+  },
+
+  async createDocument (ctx) {
+    const { traceId } = ctx.state
+    const { collectionPath, documentId, fields, projectId } = ctx.request.body
+    const result = await Logic.createDocument({ collectionPath, documentId, fields, projectId, traceId })
+    ctx.reply(result)
+  },
+
+  async updateDocument (ctx) {
+    const { traceId } = ctx.state
+    const { collectionPath, documentId, fields, projectId } = ctx.request.body
+    const result = await Logic.updateDocument({ collectionPath, documentId, fields, projectId, traceId })
+    ctx.reply(result)
+  },
+
+  async deleteDocument (ctx) {
+    const { traceId } = ctx.state
+    const { collectionPath, documentId, projectId } = ctx.request.body
+    const result = await Logic.deleteDocument({ collectionPath, documentId, projectId, traceId })
+    ctx.reply(result)
+  },
+
+  async deleteByQuery (ctx) {
+    const { traceId } = ctx.state
+    const { collectionPath, where, projectId } = ctx.request.body
+    const result = await Logic.deleteByQuery({ collectionPath, where, projectId, traceId })
+    ctx.reply(result)
+  },
+
+  async deleteByPrefix (ctx) {
+    const { traceId } = ctx.state
+    const { collectionPath, prefix, projectId } = ctx.request.body
+    const result = await Logic.deleteByPrefix({ collectionPath, prefix, projectId, traceId })
+    ctx.reply(result)
+  },
+
+  async deleteBatch (ctx) {
+    const { traceId } = ctx.state
+    const { collectionPath, documentIds, projectId } = ctx.request.body
+    const result = await Logic.deleteBatch({ collectionPath, documentIds, projectId, traceId })
+    ctx.reply(result)
+  },
+
+  async executeQuery (ctx) {
+    const { traceId } = ctx.state
+    const { collectionPath, where, orderBy, limit, projectId } = ctx.request.body
+    const result = await Logic.executeQuery({ collectionPath, where, orderBy, limit, projectId, traceId })
+    ctx.reply(result)
+  },
+
+  async clearCollection (ctx) {
+    const { traceId } = ctx.state
+    const { collectionPath, projectId } = ctx.request.body
+    const result = await Logic.clearCollection({ collectionPath, projectId, traceId })
+    ctx.reply(result)
+  },
+
+  /**
+   * SSE streaming endpoint for real-time Firestore change updates
+   * GET /v1/firestore/changes/stream?projectId=X&collectionPath=Y
+   */
+  async streamChanges (ctx) {
+    const { traceId } = ctx.state
+    const { projectId, collectionPath } = ctx.query
+
+    // Validate required parameters
+    if (!collectionPath) {
+      ctx.status = 400
+      ctx.body = {
+        success: false,
+        status: 'error',
+        message: 'collectionPath is required',
+        traceId
+      }
+      return
+    }
+
+    const resolvedProjectId = projectId || Application.firestore.projectId
+
+    // 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,
+      projectId: resolvedProjectId,
+      collectionPath
+    })}\n\n`)
+
+    // Register client with broadcaster
+    const filters = {
+      projectId: resolvedProjectId,
+      collectionPath
+    }
+
+    FirestoreBroadcaster.addClient(traceId, ctx, filters)
+
+    // Wait indefinitely until client disconnects
+    // Heartbeat is handled by the shared FirestoreBroadcaster interval
+    await new Promise((resolve) => {
+      ctx.req.on('close', () => {
+        FirestoreBroadcaster.removeClient(traceId)
+        resolve()
+      })
+
+      ctx.req.on('error', () => {
+        FirestoreBroadcaster.removeClient(traceId)
+        resolve()
+      })
+    })
+  }
+}