chore: 2.5.0 add functions, fixed minor bugs

Author: LemonHX

CHANGELOG.md

@@ -5,6 +5,43 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.5.0] - 2025-08-03
+
+### 🚀 Function Management System
+
+### Added
+
+- 🎯 **Function Management API** - Complete CRUD operations for serverless functions
+  - `POST /admin-api/v2/functions` - Create new functions with code and permissions
+  - `GET /admin-api/v2/functions` - List all functions
+  - `GET /admin-api/v2/functions/{name}` - Get specific function details
+  - `PUT /admin-api/v2/functions/{name}` - Update existing functions
+  - `DELETE /admin-api/v2/functions/{name}` - Delete functions
+- 🔄 **Function Execution Engine** - Execute functions in isolated Deno workers
+  - `POST /functions/v2/{name}` - Execute functions with parameters
+  - Support for both streaming (generators) and non-streaming responses
+  - Proper error handling and timeout management
+  - Configurable execution timeout via database config
+- 💾 **Database Schema Enhancement** - New functions table with comprehensive metadata
+  - Function code storage in database
+  - Permissions management (read, write, env, run)
+  - Enable/disable function toggle
+  - Creation and update timestamps
+- 🛡️ **Security & Isolation** - Functions run in sandboxed Deno workers
+  - Granular permission control per function
+  - Isolated execution environment
+  - Resource cleanup and timeout protection
+- 📊 **Streaming Support** - Generator functions for real-time data streaming
+  - Server-sent events (SSE) for streaming responses
+  - Progress tracking for long-running operations
+  - Proper stream lifecycle management
+
+### Enhanced
+
+- 🔧 **Database Configuration** - Added `function_execution_timeout` setting
+- 📚 **OpenAPI Documentation** - Complete API documentation for function management
+- 🧪 **Test Coverage** - Comprehensive unit and integration tests for function system
+
 ## [2.1.0] - 2025-08-01
 
 ### 🎨 Frontend Hosting Feature

README.md

@@ -1,4 +1,4 @@
-# 🚀 NanoEdgeRT v2.1
+# 🚀 NanoEdgeRT v2.5
 
 [![CI](https://github.com/LemonHX/NanoEdgeRT/actions/workflows/ci.yml/badge.svg)](https://github.com/LemonHX/NanoEdgeRT/actions/workflows/ci.yml)
 [![Deno](https://img.shields.io/badge/Deno-000000?style=for-the-badge&logo=deno&logoColor=white)](https://deno.land/)
@@ -7,13 +7,14 @@
 
 **Next-Generation Edge Function Runtime** - A lightweight, high-performance platform built with Deno and SQLite for deploying and managing serverless functions at the edge with enterprise-grade security and developer experience.
 
-> 🏆 **Enterprise Ready**: Sub-millisecond response times, 5,000+ ops/sec throughput, JWT authentication, versioned APIs, frontend hosting, and auto-generated documentation!
+> 🏆 **Enterprise Ready**: Sub-millisecond response times, 5,000+ ops/sec throughput, JWT authentication, versioned APIs, serverless functions, frontend hosting, and auto-generated documentation!
 
 ## ✨ Key Features
 
 ### 🔗 Versioned API Architecture
 
 - **Service API**: `/api/v2/{serviceName}/*` - Public service endpoints
+- **Function API**: `/functions/v2/{functionName}` - Serverless function execution
 - **Admin API**: `/admin-api/v2/*` - JWT-protected administrative operations
 - **Documentation API**: `/api/docs/{serviceName}` - Service-specific documentation
 
@@ -47,6 +48,15 @@
 - **Custom Server Logic** - JavaScript server files handle dynamic routing
 - **Static Asset Serving** - Optimized static file serving with proper MIME types
 
+### ⚡ Function Management
+
+- **Serverless Functions** - Deploy and execute JavaScript functions on-demand
+- **Generator Support** - Built-in support for streaming responses with generator functions
+- **Isolated Execution** - Functions run in secure Deno Workers with configurable permissions
+- **Database-Driven** - Functions stored and managed in SQLite database
+- **Real-time Streaming** - Support for both regular and streaming function responses
+- **Error Handling** - Comprehensive error handling and timeout protection
+
 ## 🏗️ Architecture Overview
 
 ```mermaid
@@ -55,6 +65,7 @@ graph TB
     Gateway --> Auth{JWT Auth Required?}
     Auth -->|Admin API| JWT[JWT Validation]
     Auth -->|Service API| ServiceRouter[Service Router]
+    Auth -->|Function API| FunctionRouter[Function Router]
     Auth -->|Public| PublicRouter[Public Routes]
     JWT -->|Valid| AdminRouter[Admin Router]
     JWT -->|Invalid| Error[401 Unauthorized]
@@ -65,26 +76,38 @@ graph TB
     PublicRouter --> Static["/static"]
     
     AdminRouter --> AdminAPI["/admin-api/v2/*"]
+    AdminRouter --> FunctionAdmin["/admin-api/v2/functions/*"]
     ServiceRouter --> ServiceAPI["/api/v2/*"]
     ServiceRouter --> ServiceDocs["/api/docs/*"]
+    FunctionRouter --> FunctionAPI["/functions/v2/*"]
     
     AdminAPI --> Database[(SQLite Database)]
     ServiceAPI --> ServiceManager[Service Manager]
+    FunctionAPI --> FunctionManager[Function Manager]
     ServiceDocs --> SwaggerUI[Swagger UI]
     
     ServiceManager --> Worker1[Service Worker :8001]
     ServiceManager --> Worker2[Service Worker :8002]
     ServiceManager --> WorkerN[Service Worker :800N]
     
+    FunctionManager --> FuncWorker1[Function Worker]
+    FunctionManager --> FuncWorker2[Function Worker]
+    FunctionManager --> FuncWorkerN[Function Worker]
+    
     subgraph "Database Layer"
         Database --> Services[Services Table]
+        Database --> Functions[Functions Table]
         Database --> Config[Config Table]
         Database --> Ports[Ports Table]
     end
     
     Worker1 --> ServiceInstance1[hello service]
     Worker2 --> ServiceInstance2[calculator service]
     WorkerN --> ServiceInstanceN[custom services...]
+    
+    FuncWorker1 --> FunctionInstance1[serverless function]
+    FuncWorker2 --> FunctionInstance2[generator function]
+    FuncWorkerN --> FunctionInstanceN[custom functions...]
 ```
 
 ## 🚀 Quick Start
@@ -163,6 +186,17 @@ export JWT_TOKEN="your-admin-jwt-token"
 | `/admin-api/v2/services/{name}` | DELETE | Delete service              | `curl -X DELETE -H "Authorization: Bearer $JWT_TOKEN" http://localhost:8000/admin-api/v2/services/my-service` |
 | `/admin-api/v2/host-frontend`   | POST   | Deploy frontend application | See [Frontend Hosting](#-frontend-hosting-deployment)                                                         |
 
+#### Function Management
+
+| Endpoint                         | Method | Description           | Example                                                                                                                |
+| -------------------------------- | ------ | --------------------- | ---------------------------------------------------------------------------------------------------------------------- |
+| `/admin-api/v2/functions`        | GET    | List all functions    | `curl -H "Authorization: Bearer $JWT_TOKEN" http://localhost:8000/admin-api/v2/functions`                              |
+| `/admin-api/v2/functions`        | POST   | Create new function   | See [Function Creation](#-function-creation)                                                                           |
+| `/admin-api/v2/functions/{name}` | GET    | Get specific function | `curl -H "Authorization: Bearer $JWT_TOKEN" http://localhost:8000/admin-api/v2/functions/my-function`                  |
+| `/admin-api/v2/functions/{name}` | PUT    | Update function       | See [Function Updates](#-function-updates)                                                                             |
+| `/admin-api/v2/functions/{name}` | DELETE | Delete function       | `curl -X DELETE -H "Authorization: Bearer $JWT_TOKEN" http://localhost:8000/admin-api/v2/functions/my-function`        |
+| `/functions/v2/{name}`           | POST   | Execute function      | `curl -X POST -H "Content-Type: application/json" -d '{"key":"value"}' http://localhost:8000/functions/v2/my-function` |
+
 #### Configuration Management
 
 | Endpoint                     | Method | Description           | Example                                                                                          |
@@ -287,11 +321,93 @@ curl -X PUT \
 | `available_port_end`   | number | Service port range end   | 8999                       |
 | `jwt_secret`           | string | JWT signing secret       | "default-secret-change-me" |
 
+## ⚡ Function Management
+
+### 🆕 Function Creation
+
+Create serverless functions that execute on-demand with configurable permissions and isolation.
+
+```bash
+curl -X POST \
+  -H "Authorization: Bearer $JWT_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "name": "hello-function",
+    "code": "export default function(input) { return { message: `Hello, ${input.name || \"World\"}!` }; }",
+    "enabled": true,
+    "permissions": {
+      "read": [],
+      "write": [],
+      "env": [],
+      "run": []
+    },
+    "description": "Simple greeting function"
+  }' \
+  http://localhost:8000/admin-api/v2/functions
+```
+
+### 🔄 Function Updates
+
+```bash
+curl -X PUT \
+  -H "Authorization: Bearer $JWT_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "code": "export default function(input) { return { message: `Updated: Hello, ${input.name}!` }; }",
+    "enabled": true,
+    "description": "Updated greeting function"
+  }' \
+  http://localhost:8000/admin-api/v2/functions/hello-function
+```
+
+### 🚀 Function Execution
+
+Execute functions with JSON payload:
+
+```bash
+# Regular function execution
+curl -X POST \
+  -H "Content-Type: application/json" \
+  -d '{"name": "Alice"}' \
+  http://localhost:8000/functions/v2/hello-function
+
+# Generator function with streaming response
+curl -X POST \
+  -H "Content-Type: application/json" \
+  -d '{}' \
+  http://localhost:8000/functions/v2/streaming-function
+```
+
+### 🎯 Generator Functions
+
+Functions can be generator functions for streaming responses:
+
+```javascript
+export default function* streamingFunction() {
+  yield "Starting process...";
+  yield "Processing data...";
+  yield "Almost done...";
+  return "Completed!";
+}
+```
+
+The response will be a Server-Sent Events stream:
+
+```
+data: "Starting process..."
+
+data: "Processing data..."
+
+data: "Almost done..."
+
+data: [DONE]"Completed!"
+```
+
 ## 🌐 Frontend Hosting Deployment
 
 ### 🚀 Deploy Frontend Applications
 
-NanoEdgeRT v2.1 introduces powerful frontend hosting capabilities, allowing you to deploy full-stack applications with custom server logic and static assets.
+NanoEdgeRT v2.5 introduces powerful frontend hosting capabilities, allowing you to deploy full-stack applications with custom server logic and static assets.
 
 #### How It Works
 

database/api.function.ts

@@ -0,0 +1,144 @@
+import type { Context } from "hono";
+import type { Hono } from "hono";
+import {
+  createFunction,
+  DatabaseContext,
+  deleteFunction,
+  getAllFunctions,
+  getFunction,
+  updateFunction,
+} from "./dto.ts";
+
+// Setup function API routes
+export function setupFunctionAPIRoutes(app: Hono, _dbContext: DatabaseContext) {
+  // Functions routes
+  app.get("/functions", getAllFunctionsHandler);
+  app.get("/functions/:name", getFunctionHandler);
+  app.post("/functions", createFunctionHandler);
+  app.put("/functions/:name", updateFunctionHandler);
+  app.delete("/functions/:name", deleteFunctionHandler);
+}
+
+// Function handlers
+async function getAllFunctionsHandler(c: Context): Promise<Response> {
+  const dbContext = c.get("dbContext");
+  try {
+    const functions = await getAllFunctions(dbContext);
+    return c.json({ functions });
+  } catch (error) {
+    console.error("Get all functions error:", error);
+    return c.json(
+      {
+        error: "Failed to get functions",
+        message: error instanceof Error ? error.message : String(error),
+      },
+      500,
+    );
+  }
+}
+
+async function getFunctionHandler(c: Context): Promise<Response> {
+  const dbContext = c.get("dbContext");
+  const functionName = c.req.param("name");
+
+  try {
+    const func = await getFunction(dbContext, functionName);
+    if (!func) {
+      return c.json({ error: "Function not found" }, 404);
+    }
+    return c.json(func);
+  } catch (error) {
+    console.error("Get function error:", error);
+    return c.json(
+      {
+        error: "Failed to get function",
+        message: error instanceof Error ? error.message : String(error),
+      },
+      500,
+    );
+  }
+}
+
+async function createFunctionHandler(c: Context): Promise<Response> {
+  const dbContext = c.get("dbContext");
+
+  try {
+    const body = await c.req.json();
+    const { name, code, enabled = true, permissions, description } = body;
+
+    if (!name || !code) {
+      return c.json({ error: "Name and code are required" }, 400);
+    }
+
+    await createFunction(dbContext, {
+      name,
+      code,
+      enabled,
+      permissions: permissions || {
+        read: [],
+        write: [],
+        env: [],
+        run: [],
+      },
+      description,
+    });
+
+    return c.json({ message: "Function created successfully", name }, 201);
+  } catch (error) {
+    console.error("Create function error:", error);
+    return c.json(
+      {
+        error: "Failed to create function",
+        message: error instanceof Error ? error.message : String(error),
+      },
+      500,
+    );
+  }
+}
+
+async function updateFunctionHandler(c: Context): Promise<Response> {
+  const dbContext = c.get("dbContext");
+  const functionName = c.req.param("name");
+
+  try {
+    const body = await c.req.json();
+    const { code, enabled, permissions, description } = body;
+
+    await updateFunction(dbContext, functionName, {
+      code,
+      enabled,
+      permissions,
+      description,
+    });
+
+    return c.json({ message: "Function updated successfully", ...body });
+  } catch (error) {
+    console.error("Update function error:", error);
+    return c.json(
+      {
+        error: "Failed to update function",
+        message: error instanceof Error ? error.message : String(error),
+      },
+      500,
+    );
+  }
+}
+
+async function deleteFunctionHandler(c: Context): Promise<Response> {
+  const dbContext = c.get("dbContext");
+  const functionName = c.req.param("name");
+
+  try {
+    await deleteFunction(dbContext, functionName);
+    return c.json({ message: "Function deleted successfully" });
+  } catch (error) {
+    console.error("Delete function error:", error);
+    return c.json(
+      {
+        error: "Failed to delete function",
+        message: error instanceof Error ? error.message : String(error),
+      },
+      500,
+    );
+  }
+}