@gokiteam/goki-dev 0.2.0

package/src/api/functions/Router.js

@@ -0,0 +1,50 @@
+import KoaRouter from 'koa-router'
+import { Controllers } from './Controllers.js'
+
+export const Router = new KoaRouter({ prefix: '/v1/functions' })
+
+// CRUD
+Router.post('/create', Controllers.create)
+Router.post('/list', Controllers.list)
+Router.post('/details', Controllers.details)
+Router.post('/update', Controllers.update)
+Router.post('/delete', Controllers.delete)
+
+// Lifecycle
+Router.post('/start', Controllers.start)
+Router.post('/stop', Controllers.stop)
+Router.post('/restart', Controllers.restart)
+
+// Source management
+Router.post('/source/read', Controllers.readSource)
+Router.post('/source/update', Controllers.updateSource)
+
+// Dependencies management
+Router.post('/dependencies/read', Controllers.readDependencies)
+Router.post('/dependencies/update', Controllers.updateDependencies)
+
+// File management
+Router.post('/files/list', Controllers.listFiles)
+Router.post('/files/read', Controllers.readFile)
+Router.post('/files/write', Controllers.writeFile)
+Router.post('/files/delete', Controllers.deleteFile)
+
+// Invocation
+Router.post('/invoke', Controllers.invoke)
+
+// Invocation history
+Router.post('/invocations/list', Controllers.listInvocations)
+Router.post('/invocations/details', Controllers.invocationDetails)
+Router.post('/invocations/clear', Controllers.clearInvocations)
+
+// Stats
+Router.post('/stats', Controllers.stats)
+
+// SSE streams
+Router.get('/logs/stream', Controllers.streamLogs)
+Router.get('/invocations/stream', Controllers.streamInvocations)
+Router.get('/files/stream', Controllers.streamFileChanges)
+
+// HTTP trigger endpoint
+Router.all('/call/:functionName', Controllers.callHttpFunction)
+Router.all('/call/:functionName/(.*)', Controllers.callHttpFunction)

package/src/api/functions/Schemas.js

@@ -0,0 +1,193 @@
+import Joi from 'joi'
+
+export const Schemas = {
+  create: {
+    body: Joi.object({
+      name: Joi.string().pattern(/^[a-zA-Z0-9-_]+$/).required()
+        .description('Unique function name (alphanumeric, hyphens, underscores)'),
+      source: Joi.string().optional()
+        .description('Inline function source code (used when sourcePath is not provided)'),
+      sourcePath: Joi.string().optional()
+        .description('Absolute path to the function source directory'),
+      entryPoint: Joi.string().required()
+        .description('Name of the exported function to invoke'),
+      triggerType: Joi.string().valid('http', 'pubsub', 'firestore', 'scheduler').required()
+        .description('How the function is triggered'),
+      triggerConfig: Joi.object().optional().default({})
+        .description('Trigger-specific configuration (e.g. { topic: "myTopic" } for pubsub)'),
+      signatureType: Joi.string().valid('cloudevent', 'http').optional().default('cloudevent')
+        .description('Function signature type for the functions-framework'),
+      runtime: Joi.string().optional().default('nodejs20')
+        .description('Runtime identifier'),
+      environmentVariables: Joi.object().optional().default({})
+        .description('Environment variables to pass to the function process'),
+      timeoutSeconds: Joi.number().integer().min(1).max(540).optional().default(60)
+        .description('Maximum execution time in seconds'),
+      description: Joi.string().optional().allow('')
+        .description('Human-readable description of the function')
+    })
+  },
+
+  list: {
+    body: Joi.object({
+      filter: Joi.object({
+        triggerType: Joi.string().valid('http', 'pubsub', 'firestore', 'scheduler').optional(),
+        status: Joi.string().valid('stopped', 'starting', 'running', 'error').optional(),
+        enabled: Joi.boolean().optional()
+      }).optional(),
+      limit: Joi.number().integer().min(0).optional(),
+      offset: Joi.number().integer().min(0).optional()
+    })
+  },
+
+  details: {
+    body: Joi.object({
+      id: Joi.string().optional(),
+      name: Joi.string().optional()
+    }).or('id', 'name')
+  },
+
+  update: {
+    body: Joi.object({
+      id: Joi.string().optional(),
+      name: Joi.string().optional(),
+      description: Joi.string().optional().allow(''),
+      triggerConfig: Joi.object().optional(),
+      enabled: Joi.boolean().optional(),
+      environmentVariables: Joi.object().optional(),
+      timeoutSeconds: Joi.number().integer().min(1).max(540).optional(),
+      entryPoint: Joi.string().optional(),
+      signatureType: Joi.string().valid('cloudevent', 'http').optional()
+    }).or('id', 'name')
+  },
+
+  delete: {
+    body: Joi.object({
+      id: Joi.string().optional(),
+      name: Joi.string().optional()
+    }).or('id', 'name')
+  },
+
+  start: {
+    body: Joi.object({
+      id: Joi.string().optional(),
+      name: Joi.string().optional()
+    }).or('id', 'name')
+  },
+
+  stop: {
+    body: Joi.object({
+      id: Joi.string().optional(),
+      name: Joi.string().optional()
+    }).or('id', 'name')
+  },
+
+  restart: {
+    body: Joi.object({
+      id: Joi.string().optional(),
+      name: Joi.string().optional()
+    }).or('id', 'name')
+  },
+
+  readSource: {
+    body: Joi.object({
+      id: Joi.string().optional(),
+      name: Joi.string().optional()
+    }).or('id', 'name')
+  },
+
+  updateSource: {
+    body: Joi.object({
+      id: Joi.string().optional(),
+      name: Joi.string().optional(),
+      content: Joi.string().required()
+        .description('New source code content')
+    }).or('id', 'name')
+  },
+
+  readDependencies: {
+    body: Joi.object({
+      id: Joi.string().optional(),
+      name: Joi.string().optional()
+    }).or('id', 'name')
+  },
+
+  updateDependencies: {
+    body: Joi.object({
+      id: Joi.string().optional(),
+      name: Joi.string().optional(),
+      packageJson: Joi.string().required()
+        .description('Full package.json content as a JSON string'),
+      install: Joi.boolean().optional().default(true)
+        .description('Whether to run npm install after writing')
+    }).or('id', 'name')
+  },
+
+  listFiles: {
+    body: Joi.object({
+      id: Joi.string().optional(),
+      name: Joi.string().optional()
+    }).or('id', 'name')
+  },
+
+  readFile: {
+    body: Joi.object({
+      id: Joi.string().optional(),
+      name: Joi.string().optional(),
+      filePath: Joi.string().required()
+        .description('Relative file path within the function source directory')
+    }).or('id', 'name')
+  },
+
+  writeFile: {
+    body: Joi.object({
+      id: Joi.string().optional(),
+      name: Joi.string().optional(),
+      filePath: Joi.string().required()
+        .description('Relative file path within the function source directory'),
+      content: Joi.string().required()
+        .description('File content to write')
+    }).or('id', 'name')
+  },
+
+  deleteFile: {
+    body: Joi.object({
+      id: Joi.string().optional(),
+      name: Joi.string().optional(),
+      filePath: Joi.string().required()
+        .description('Relative file path within the function source directory')
+    }).or('id', 'name')
+  },
+
+  invoke: {
+    body: Joi.object({
+      id: Joi.string().optional(),
+      name: Joi.string().optional(),
+      payload: Joi.any().optional()
+        .description('Payload to pass to the function as CloudEvent data')
+    }).or('id', 'name')
+  },
+
+  listInvocations: {
+    body: Joi.object({
+      functionId: Joi.string().optional(),
+      functionName: Joi.string().optional(),
+      triggerType: Joi.string().optional(),
+      limit: Joi.number().integer().min(0).optional().default(50),
+      offset: Joi.number().integer().min(0).optional().default(0)
+    })
+  },
+
+  invocationDetails: {
+    body: Joi.object({
+      id: Joi.string().required()
+    })
+  },
+
+  clearInvocations: {
+    body: Joi.object({
+      functionId: Joi.string().optional()
+        .description('Clear invocations for a specific function, or all if omitted')
+    })
+  }
+}

package/src/api/gateway/Controllers.js

@@ -0,0 +1,72 @@
+import { Logic } from './Logic.js'
+
+export const Controllers = {
+  async start (ctx) {
+    const { traceId } = ctx.state
+    const result = await Logic.start({ traceId })
+    if (!result.success) {
+      ctx.status = 400
+      ctx.body = {
+        success: false,
+        status: 400,
+        message: result.message,
+        traceId: result.traceId
+      }
+      return
+    }
+    ctx.reply({
+      gateway: result.gateway,
+      traceId: result.traceId
+    })
+  },
+
+  async stop (ctx) {
+    const { traceId } = ctx.state
+    const result = await Logic.stop({ traceId })
+    if (!result.success) {
+      ctx.status = 400
+      ctx.body = {
+        success: false,
+        status: 400,
+        message: result.message,
+        traceId: result.traceId
+      }
+      return
+    }
+    ctx.reply({
+      message: result.message,
+      traceId: result.traceId
+    })
+  },
+
+  async status (ctx) {
+    const { traceId } = ctx.state
+    const result = Logic.status({ traceId })
+    ctx.reply(result)
+  },
+
+  async triggerScan (ctx) {
+    const { traceId } = ctx.state
+    const result = await Logic.triggerScan({ traceId })
+    if (!result.success) {
+      ctx.status = 400
+      ctx.body = {
+        success: false,
+        status: 400,
+        message: result.message,
+        traceId: result.traceId
+      }
+      return
+    }
+    ctx.reply({
+      message: result.message,
+      traceId: result.traceId
+    })
+  },
+
+  async healthCheck (ctx) {
+    const { traceId } = ctx.state
+    const result = await Logic.healthCheck({ traceId })
+    ctx.reply(result)
+  }
+}

package/src/api/gateway/Logic.js

@@ -0,0 +1,74 @@
+import { AppGatewayService } from '../../services/AppGatewayService.js'
+
+export const Logic = {
+  async start (params) {
+    const { traceId } = params
+    const result = await AppGatewayService.start()
+    // Service returns { success, message, gateway? }
+    if (!result.success) {
+      return {
+        success: false,
+        message: result.message,
+        traceId
+      }
+    }
+    return {
+      success: true,
+      gateway: result.gateway,
+      traceId
+    }
+  },
+
+  async stop (params) {
+    const { traceId } = params
+    const result = await AppGatewayService.stop()
+    if (!result.success) {
+      return {
+        success: false,
+        message: result.message,
+        traceId
+      }
+    }
+    return {
+      success: true,
+      message: result.message,
+      traceId
+    }
+  },
+
+  status (params) {
+    const { traceId } = params
+    const status = AppGatewayService.getStatus()
+    // Return status directly, no extra wrapping
+    return {
+      ...status,
+      traceId
+    }
+  },
+
+  async triggerScan (params) {
+    const { traceId } = params
+    const result = await AppGatewayService.triggerScan()
+    if (!result.success) {
+      return {
+        success: false,
+        message: result.message,
+        traceId
+      }
+    }
+    return {
+      success: true,
+      message: result.message,
+      traceId
+    }
+  },
+
+  async healthCheck (params) {
+    const { traceId } = params
+    const health = await AppGatewayService.checkDependencyHealth()
+    return {
+      ...health,
+      traceId
+    }
+  }
+}

package/src/api/gateway/Router.js

@@ -0,0 +1,10 @@
+import KoaRouter from 'koa-router'
+import { Controllers } from './Controllers.js'
+
+export const Router = new KoaRouter({ prefix: '/v1/gateway' })
+
+Router.post('/start', Controllers.start)
+Router.post('/stop', Controllers.stop)
+Router.post('/status', Controllers.status)
+Router.post('/triggerScan', Controllers.triggerScan)
+Router.post('/healthCheck', Controllers.healthCheck)

package/src/api/gateway/Schemas.js

@@ -0,0 +1,19 @@
+import Joi from 'joi'
+
+export const Schemas = {
+  start: {
+    body: Joi.object({}).optional()
+  },
+  stop: {
+    body: Joi.object({}).optional()
+  },
+  status: {
+    body: Joi.object({}).optional()
+  },
+  triggerScan: {
+    body: Joi.object({}).optional()
+  },
+  healthCheck: {
+    body: Joi.object({}).optional()
+  }
+}

package/src/api/health/Controllers.js

@@ -0,0 +1,14 @@
+import { Logic } from './Logic.js'
+
+export const Controllers = {
+  async liveness (ctx) {
+    const { traceId } = ctx.state
+    const result = await Logic.liveness({ traceId })
+    ctx.reply(result)
+  },
+  async readiness (ctx) {
+    const { traceId } = ctx.state
+    const result = await Logic.readiness({ traceId })
+    ctx.reply(result)
+  }
+}

package/src/api/health/Logic.js

@@ -0,0 +1,24 @@
+import { Application } from '../../configs/Application.js'
+import { SqliteStore } from '../../singletons/SqliteStore.js'
+
+export const Logic = {
+  async liveness (params) {
+    const { traceId } = params
+    return {
+      status: 'ok',
+      timestamp: new Date().toISOString(),
+      traceId
+    }
+  },
+  async readiness (params) {
+    const { traceId } = params
+    const isStoreInitialized = SqliteStore.isInitialized
+    return {
+      status: isStoreInitialized ? 'ready' : 'not_ready',
+      timestamp: new Date().toISOString(),
+      environment: Application.environment,
+      runId: Application.runId,
+      traceId
+    }
+  }
+}

package/src/api/health/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/health' })
+
+v1.get('/liveness', Controllers.liveness)
+v1.get('/readiness', Controllers.readiness)
+
+Router.use(v1.routes())
+
+export { Router }

package/src/api/httpTraffic/Controllers.js

@@ -0,0 +1,29 @@
+import { Logic } from './Logic.js'
+
+export const Controllers = {
+  async list (ctx) {
+    const { traceId } = ctx.state
+    const { filter, limit, offset } = ctx.request.body
+    const result = Logic.list({ filter, limit, offset, traceId })
+    ctx.reply(result)
+  },
+
+  async details (ctx) {
+    const { traceId } = ctx.state
+    const { id } = ctx.request.body
+    const result = Logic.details({ id, traceId })
+    ctx.reply(result)
+  },
+
+  async clear (ctx) {
+    const { traceId } = ctx.state
+    const result = Logic.clear({ traceId })
+    ctx.reply(result)
+  },
+
+  async stats (ctx) {
+    const { traceId } = ctx.state
+    const result = Logic.stats({ traceId })
+    ctx.reply(result)
+  }
+}

package/src/api/httpTraffic/Logic.js

@@ -0,0 +1,33 @@
+import { HttpProxy } from '../../singletons/HttpProxy.js'
+
+export const Logic = {
+  list (params) {
+    const { filter, limit = 50, offset = 0, traceId } = params
+    const { data, total } = HttpProxy.listTraffic({ filter, limit, offset })
+    return { entries: data, total, limit, offset, traceId }
+  },
+
+  details (params) {
+    const { id, traceId } = params
+    if (!id) {
+      return { success: false, message: 'id is required', traceId }
+    }
+    const entry = HttpProxy.getTrafficEntry(id)
+    if (!entry) {
+      return { success: false, message: 'Traffic entry not found', traceId }
+    }
+    return { entry, traceId }
+  },
+
+  clear (params) {
+    const { traceId } = params
+    HttpProxy.clearTraffic()
+    return { message: 'All HTTP traffic records cleared', traceId }
+  },
+
+  stats (params) {
+    const { traceId } = params
+    const stats = HttpProxy.getStats()
+    return { ...stats, traceId }
+  }
+}

package/src/api/httpTraffic/Router.js

@@ -0,0 +1,9 @@
+import KoaRouter from 'koa-router'
+import { Controllers } from './Controllers.js'
+
+export const Router = new KoaRouter({ prefix: '/v1/http-traffic' })
+
+Router.post('/list', Controllers.list)
+Router.post('/details', Controllers.details)
+Router.post('/clear', Controllers.clear)
+Router.post('/stats', Controllers.stats)

package/src/api/httpTraffic/Schemas.js

@@ -0,0 +1,23 @@
+import Joi from 'joi'
+
+export const Schemas = {
+  list: Joi.object({
+    filter: Joi.object({
+      method: Joi.string().valid('GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'),
+      targetHost: Joi.string(),
+      sourceService: Joi.string(),
+      statusCode: Joi.number().integer(),
+      traceId: Joi.string()
+    }).optional(),
+    limit: Joi.number().integer().min(1).max(500).default(50),
+    offset: Joi.number().integer().min(0).default(0)
+  }),
+
+  details: Joi.object({
+    id: Joi.string().required()
+  }),
+
+  clear: Joi.object({}),
+
+  stats: Joi.object({})
+}

package/src/api/logging/Controllers.js

@@ -0,0 +1,80 @@
+import { Logic } from './Logic.js'
+import { LogBroadcaster } from '../../singletons/LogBroadcaster.js'
+
+export const Controllers = {
+  async listServices (ctx) {
+    const { traceId } = ctx.state
+    const result = await Logic.listServices({ traceId })
+    ctx.reply(result)
+  },
+  async listEntries (ctx) {
+    const { traceId } = ctx.state
+    const { filter, page, compact } = ctx.request.body
+    const result = await Logic.listEntries({ filter, page, compact, traceId })
+    ctx.reply(result)
+  },
+  async getEntriesById (ctx) {
+    const { traceId } = ctx.state
+    const { ids } = ctx.request.body
+    const result = await Logic.getEntriesById({ ids, traceId })
+    ctx.reply(result)
+  },
+  async clearEntries (ctx) {
+    const { traceId } = ctx.state
+    const result = await Logic.clearEntries({ traceId })
+    ctx.reply(result)
+  },
+  async exportEntries (ctx) {
+    const { traceId } = ctx.state
+    const result = await Logic.exportEntries({ traceId })
+    ctx.reply(result)
+  },
+  async getTrace (ctx) {
+    const traceId = ctx.params.traceId
+    const result = await Logic.getTrace({ traceId })
+    ctx.reply(result)
+  },
+  async waitForLog (ctx) {
+    const { traceId } = ctx.state
+    const { filter, timeout } = ctx.request.body
+    const result = await Logic.waitForLog({ filter, timeout, traceId })
+    ctx.reply(result)
+  },
+  async assertNoErrors (ctx) {
+    const { traceId } = ctx.state
+    const { traceId: targetTraceId, sinceTimestamp } = ctx.request.body
+    const result = await Logic.assertNoErrors({ targetTraceId, sinceTimestamp, traceId })
+    ctx.reply(result)
+  },
+  async streamLogs (ctx) {
+    const connectionId = ctx.query.connectionId || `log-${Date.now()}`
+    // Parse optional filter from query param (JSON-encoded MongoDB-style filter)
+    let filter = null
+    if (ctx.query.filter) {
+      try {
+        filter = JSON.parse(ctx.query.filter)
+        if (Object.keys(filter).length === 0) filter = null
+      } catch {
+        // Ignore malformed filter — stream all entries
+      }
+    }
+    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, connectionId })}\n\n`)
+    LogBroadcaster.addClient(connectionId, ctx, filter)
+    ctx.req.on('close', () => {
+      LogBroadcaster.removeClient(connectionId)
+    })
+  },
+  async getQueueStats (ctx) {
+    const { traceId } = ctx.state
+    const result = await Logic.getQueueStats({ traceId })
+    ctx.reply(result)
+  }
+}