@gokiteam/goki-dev 0.2.0

package/src/emulation/awsiot/Router.js

@@ -0,0 +1,19 @@
+import KoaRouter from 'koa-router'
+import { publish } from './Controllers.js'
+
+const router = new KoaRouter()
+
+/**
+ * AWS IoT Core HTTPS API emulation routes
+ *
+ * Mimics: https://docs.aws.amazon.com/iot/latest/developerguide/mqtt-publish-over-https.html
+ *
+ * POST /topics/:topicName?qos=1
+ * - Publishes a message to the specified MQTT topic
+ * - Binary payload in request body
+ * - Returns empty 200 response
+ */
+
+router.post('/topics/:topicName', publish)
+
+export { router as Router }

package/src/emulation/awsiot/Server.js

@@ -0,0 +1,100 @@
+import Koa from 'koa'
+import bodyParser from 'koa-bodyparser'
+import { Application } from '../../configs/Application.js'
+import { Logger } from '../../singletons/Logger.js'
+import { Router } from './Router.js'
+
+const { environment, runId, ports } = Application
+
+/**
+ * Start AWS IoT Core HTTPS API emulation server
+ *
+ * Mimics AWS IoT Core HTTPS publishing API
+ * POST /topics/{topicName}?qos=1
+ *
+ * This allows backend services (device-simulator, device-native) to publish
+ * messages to the MQTT broker using the same HTTPS API they use in production.
+ */
+export const startAwsIotServer = async () => {
+  try {
+    const app = new Koa()
+
+    // Error handler
+    app.use(async (ctx, next) => {
+      try {
+        await next()
+      } catch (error) {
+        Logger.log({
+          level: 'error',
+          message: 'AWS IoT server error',
+          data: { error: error.message, stack: error.stack, path: ctx.path }
+        })
+        ctx.status = error.status || 500
+        ctx.body = {
+          error: {
+            code: ctx.status,
+            message: error.message || 'Internal server error',
+            status: 'INTERNAL'
+          }
+        }
+      }
+    })
+
+    // Body parser with raw binary support
+    app.use(bodyParser({
+      enableTypes: ['json', 'form', 'text'],
+      extendTypes: {
+        text: ['application/octet-stream']
+      },
+      // Parse binary payloads as Buffer
+      onerror: (err, ctx) => {
+        Logger.log({
+          level: 'error',
+          message: 'Body parser error',
+          data: { error: err.message, path: ctx.path }
+        })
+        ctx.throw(422, 'Body parse error')
+      }
+    }))
+
+    // Custom middleware to handle raw binary payloads
+    app.use(async (ctx, next) => {
+      if (ctx.request.is('application/octet-stream') || ctx.path.startsWith('/topics/')) {
+        // Read raw body as Buffer
+        const chunks = []
+        for await (const chunk of ctx.req) {
+          chunks.push(chunk)
+        }
+        ctx.request.body = Buffer.concat(chunks)
+      }
+      await next()
+    })
+
+    // Register routes
+    app.use(Router.routes())
+    app.use(Router.allowedMethods())
+
+    // Start server
+    const server = app.listen(ports.awsIot, () => {
+      Logger.log({
+        level: 'info',
+        message: 'AWS IoT Core HTTPS API emulation server started',
+        data: {
+          port: ports.awsIot,
+          environment,
+          runId,
+          endpoint: `http://localhost:${ports.awsIot}/topics/:topicName?qos=1`
+        }
+      })
+    })
+
+    return server
+  } catch (error) {
+    Logger.log({
+      level: 'error',
+      message: 'Failed to start AWS IoT server',
+      data: { error: error.message, stack: error.stack }
+    })
+    throw error
+  }
+}

package/src/emulation/firestore/Server.js

@@ -0,0 +1,136 @@
+import { spawn } from 'child_process'
+import { Application } from '../../configs/Application.js'
+import { Logger } from '../../singletons/Logger.js'
+import { SqliteStore } from '../../singletons/SqliteStore.js'
+
+class FirestoreEmulatorClass {
+  constructor () {
+    this.process = null
+    this.isRunning = false
+    this.port = Application.ports.firestore || 8080
+    this.projectId = Application.firestore.projectId
+  }
+
+  async start () {
+    if (this.isRunning) {
+      Logger.log({
+        level: 'warn',
+        message: 'Firestore emulator already running'
+      })
+      return
+    }
+    this.registerStorageCollections()
+    return new Promise((resolve, reject) => {
+      this.process = spawn('firebase', [
+        'emulators:start',
+        '--only', 'firestore',
+        '--project', this.projectId
+      ], {
+        env: {
+          ...process.env,
+          FIRESTORE_EMULATOR_PORT: this.port
+        },
+        stdio: ['ignore', 'pipe', 'pipe']
+      })
+      const startupTimeout = setTimeout(() => {
+        if (!this.isRunning) {
+          Logger.log({
+            level: 'error',
+            message: 'Firestore emulator failed to start within 30 seconds'
+          })
+          reject(new Error('Firestore emulator startup timeout'))
+        }
+      }, 30000)
+      this.process.stdout.on('data', (data) => {
+        const message = data.toString()
+        if (message.includes('Firestore Emulator running') || message.includes('All emulators ready')) {
+          clearTimeout(startupTimeout)
+          this.isRunning = true
+          Logger.log({
+            level: 'info',
+            message: `Firestore emulator started on port ${this.port}`,
+            data: { port: this.port, projectId: this.projectId }
+          })
+          resolve()
+        }
+      })
+      this.process.stderr.on('data', (data) => {
+        const error = data.toString()
+        if (!this.isRunning && error.includes('error')) {
+          Logger.log({
+            level: 'error',
+            message: 'Firestore emulator error during startup',
+            data: { error }
+          })
+        }
+      })
+      this.process.on('error', (error) => {
+        clearTimeout(startupTimeout)
+        Logger.log({
+          level: 'error',
+          message: 'Failed to start Firestore emulator process',
+          data: { error: error.message }
+        })
+        reject(error)
+      })
+      this.process.on('exit', (code) => {
+        this.isRunning = false
+        if (code !== 0 && code !== null) {
+          Logger.log({
+            level: 'error',
+            message: 'Firestore emulator process exited unexpectedly',
+            data: { exitCode: code }
+          })
+        }
+      })
+    })
+  }
+
+  registerStorageCollections () {
+    // No-op for SQLite - tables created at DB initialization
+    Logger.log({
+      level: 'debug',
+      message: 'Firestore storage tables ready (SQLite)',
+      data: { tables: ['firestore_metadata'] }
+    })
+  }
+
+  async stop () {
+    if (!this.isRunning || !this.process) {
+      Logger.log({
+        level: 'warn',
+        message: 'Firestore emulator not running'
+      })
+      return
+    }
+    return new Promise((resolve) => {
+      this.process.on('close', () => {
+        this.isRunning = false
+        Logger.log({
+          level: 'info',
+          message: 'Firestore emulator stopped'
+        })
+        resolve()
+      })
+      this.process.kill('SIGTERM')
+      setTimeout(() => {
+        if (this.process && !this.process.killed) {
+          this.process.kill('SIGKILL')
+          resolve()
+        }
+      }, 5000)
+    })
+  }
+
+  getStatus () {
+    return {
+      running: this.isRunning,
+      port: this.port,
+      projectId: this.projectId
+    }
+  }
+}
+
+export const FirestoreEmulator = new FirestoreEmulatorClass()
+export const start = () => FirestoreEmulator.start()
+export const stop = () => FirestoreEmulator.stop()

package/src/emulation/logging/Controllers.js

@@ -0,0 +1,212 @@
+import { Logic } from './Logic.js'
+import {
+  WriteEntriesRequestSchema,
+  ListEntriesRequestSchema,
+  DeleteLogRequestSchema,
+  ListLogsRequestSchema
+} from './Schemas.js'
+import { Logger } from '../../singletons/Logger.js'
+
+export const Controllers = {
+  /**
+   * POST /v2/entries:write
+   * Write log entries
+   */
+  async writeEntries (ctx) {
+    const { traceId } = ctx.state
+
+    // Validate request body
+    const { error, value } = WriteEntriesRequestSchema.validate(ctx.request.body)
+    if (error) {
+      ctx.status = 400
+      ctx.body = {
+        error: {
+          code: 400,
+          message: 'Invalid request',
+          status: 'INVALID_ARGUMENT',
+          details: error.details.map(d => d.message)
+        }
+      }
+      return
+    }
+
+    try {
+      const result = await Logic.writeEntries({
+        traceId,
+        ...value
+      })
+
+      ctx.status = 200
+      ctx.body = result
+    } catch (error) {
+      Logger.log({
+        level: 'error',
+        message: 'Failed to write entries',
+        data: { traceId, error: error.message, stack: error.stack }
+      })
+
+      ctx.status = 500
+      ctx.body = {
+        error: {
+          code: 500,
+          message: 'Internal server error',
+          status: 'INTERNAL'
+        }
+      }
+    }
+  },
+
+  /**
+   * POST /v2/entries:list
+   * List log entries
+   */
+  async listEntries (ctx) {
+    const { traceId } = ctx.state
+
+    // Validate request body
+    const { error, value } = ListEntriesRequestSchema.validate(ctx.request.body)
+    if (error) {
+      ctx.status = 400
+      ctx.body = {
+        error: {
+          code: 400,
+          message: 'Invalid request',
+          status: 'INVALID_ARGUMENT',
+          details: error.details.map(d => d.message)
+        }
+      }
+      return
+    }
+
+    try {
+      const result = await Logic.listEntries({
+        traceId,
+        ...value
+      })
+
+      ctx.status = 200
+      ctx.body = result
+    } catch (error) {
+      Logger.log({
+        level: 'error',
+        message: 'Failed to list entries',
+        data: { traceId, error: error.message, stack: error.stack }
+      })
+
+      ctx.status = 500
+      ctx.body = {
+        error: {
+          code: 500,
+          message: 'Internal server error',
+          status: 'INTERNAL'
+        }
+      }
+    }
+  },
+
+  /**
+   * GET /v2/projects/{project}/logs
+   * List all logs for a project
+   */
+  async listLogs (ctx) {
+    const { traceId } = ctx.state
+    const { project } = ctx.params
+    const { pageSize, pageToken } = ctx.query
+
+    // Validate request
+    const { error, value } = ListLogsRequestSchema.validate({
+      project,
+      pageSize: pageSize ? parseInt(pageSize) : undefined,
+      pageToken
+    })
+    if (error) {
+      ctx.status = 400
+      ctx.body = {
+        error: {
+          code: 400,
+          message: 'Invalid request',
+          status: 'INVALID_ARGUMENT',
+          details: error.details.map(d => d.message)
+        }
+      }
+      return
+    }
+
+    try {
+      const result = await Logic.listLogs({
+        traceId,
+        ...value
+      })
+
+      ctx.status = 200
+      ctx.body = result
+    } catch (error) {
+      Logger.log({
+        level: 'error',
+        message: 'Failed to list logs',
+        data: { traceId, error: error.message, stack: error.stack }
+      })
+
+      ctx.status = 500
+      ctx.body = {
+        error: {
+          code: 500,
+          message: 'Internal server error',
+          status: 'INTERNAL'
+        }
+      }
+    }
+  },
+
+  /**
+   * DELETE /v2/projects/{project}/logs/{logId}
+   * Delete a log
+   */
+  async deleteLog (ctx) {
+    const { traceId } = ctx.state
+    const { project, logId } = ctx.params
+
+    // Validate request
+    const { error, value } = DeleteLogRequestSchema.validate({
+      project,
+      logId: decodeURIComponent(logId) // Log IDs may be URL-encoded
+    })
+    if (error) {
+      ctx.status = 400
+      ctx.body = {
+        error: {
+          code: 400,
+          message: 'Invalid request',
+          status: 'INVALID_ARGUMENT',
+          details: error.details.map(d => d.message)
+        }
+      }
+      return
+    }
+
+    try {
+      const result = await Logic.deleteLog({
+        traceId,
+        ...value
+      })
+
+      ctx.status = 200
+      ctx.body = result
+    } catch (error) {
+      Logger.log({
+        level: 'error',
+        message: 'Failed to delete log',
+        data: { traceId, error: error.message, stack: error.stack }
+      })
+
+      ctx.status = 500
+      ctx.body = {
+        error: {
+          code: 500,
+          message: 'Internal server error',
+          status: 'INTERNAL'
+        }
+      }
+    }
+  }
+}