Cleanup

Author: max-lt

README.md

@@ -1,29 +1,52 @@
 # OpenWorkers API (Hono + Bun)
 
-Rewrite of dash-api using Hono framework and Bun runtime.
+Lightweight REST API for OpenWorkers platform using Hono framework and Bun runtime.
 
 ## Features
 
 - **Hono** - Ultra-fast web framework
 - **Bun native Postgres** - `Bun.sql()` for database access
+- **Zod validation** - Type-safe input/output validation
 - **Isolated services** - Easy to swap Postgres with gateway later
 - **Pure REST** - No GraphQL complexity
 - **JWT auth** - Using `hono/jwt`
+- **Standalone binary** - Compile to single executable
 
 ## Structure
 
 ```
 src/
 ├── services/
-│   ├── db.ts           - Database abstraction (Bun Postgres or Gateway)
-│   └── workers.ts      - Workers business logic
+│   ├── db/
+│   │   ├── client.ts        - Bun Postgres client
+│   │   ├── users.ts         - User DB queries
+│   │   ├── workers.ts       - Worker DB queries
+│   │   ├── crons.ts         - Cron DB queries
+│   │   ├── environments.ts  - Environment DB queries
+│   │   └── domains.ts       - Domain DB queries
+│   ├── auth.ts              - Authentication logic
+│   ├── workers.ts           - Workers business logic
+│   ├── crons.ts             - Crons business logic
+│   ├── environments.ts      - Environments business logic
+│   └── domains.ts           - Domains business logic
 ├── routes/
-│   └── workers.ts      - Workers REST endpoints
+│   ├── auth.ts              - Auth endpoints
+│   ├── users.ts             - User endpoints
+│   ├── workers.ts           - Workers endpoints
+│   ├── crons.ts             - Crons endpoints
+│   ├── environments.ts      - Environments endpoints
+│   └── domains.ts           - Domains endpoints
 ├── middlewares/
-│   └── auth.ts         - JWT authentication
+│   └── auth.ts              - JWT middleware
 ├── types/
-│   └── index.ts        - TypeScript types
-└── index.ts            - Main app
+│   ├── schemas/             - Zod validation schemas
+│   ├── validators.ts        - Schema validators
+│   └── index.ts             - Type exports
+├── utils/
+│   └── validate.ts          - Response validation helpers
+├── config/
+│   └── index.ts             - Configuration
+└── index.ts                 - Main app
 ```
 
 ## Quick Start
@@ -39,76 +62,109 @@ cp .env.example .env
 # Run development server (hot reload)
 bun run dev
 
-# Production
+# Production (run with Bun)
 bun run start
+
+# Compile standalone binary
+bun run compile
+# → Creates dist/openworkers-api (executable)
 ```
 
 ## API Endpoints
 
 ### Auth (Public)
 
-- `GET /login/github` - Redirect to GitHub OAuth
-- `GET /callback/github` - GitHub OAuth callback (creates JWT, redirects to dashboard)
-- `POST /refresh` - Refresh access token using refresh token
+- `POST /api/v1/openid/github` - Initiate GitHub OAuth flow
+- `GET /api/v1/callback/github` - GitHub OAuth callback (creates JWT)
+- `POST /api/v1/refresh` - Refresh access token using refresh token
+
+### Users (Protected)
+
+- `GET /api/v1/profile` - Get current user profile
 
 ### Workers (Protected)
 
-- `GET /api/workers` - List all workers
-- `GET /api/workers/:id` - Get single worker
-- `POST /api/workers` - Create worker
-- `PUT /api/workers/:id` - Update worker
-- `DELETE /api/workers/:id` - Delete worker
+- `GET /api/v1/workers` - List all workers
+- `GET /api/v1/workers/name-exists/:name` - Check if worker name exists
+- `GET /api/v1/workers/:id` - Get single worker
+- `POST /api/v1/workers` - Create worker
+- `PUT /api/v1/workers/:id` - Update worker
+- `POST /api/v1/workers/:id/crons` - Create cron for worker
+- `DELETE /api/v1/workers/:id` - Delete worker
+
+### Crons (Protected)
+
+- `POST /api/v1/crons` - Create cron
+- `PUT /api/v1/crons/:id` - Update cron
+- `DELETE /api/v1/crons/:id` - Delete cron
+
+### Environments (Protected)
+
+- `GET /api/v1/environments` - List all environments
+- `GET /api/v1/environments/:id` - Get environment by ID (includes values)
+- `POST /api/v1/environments` - Create environment
+- `PUT /api/v1/environments/:id` - Update environment (name/desc and/or values)
+- `DELETE /api/v1/environments/:id` - Delete environment
+
+### Domains (Protected)
+
+- `GET /api/v1/domains` - List all domains
+- `POST /api/v1/domains` - Create domain
+- `DELETE /api/v1/domains/:name` - Delete domain
 
 ### Authentication
 
-All `/api/*` endpoints require JWT Bearer token in `Authorization` header:
+All `/api/v1/*` endpoints (except auth endpoints) require JWT Bearer token in `Authorization` header:
 
 ```
 Authorization: Bearer <token>
 ```
 
 OAuth flow:
-1. User clicks "Login with GitHub" → `GET /login/github`
-2. GitHub redirects to → `GET /callback/github?code=...`
+
+1. User initiates login → `POST /api/v1/openid/github`
+2. GitHub redirects to → `GET /api/v1/callback/github?code=...`
 3. Server exchanges code for user profile
 4. Creates/finds user in DB
 5. Issues JWT tokens (access + refresh)
-6. Redirects to dashboard with token
+6. Returns tokens in response body + sets cookie
 
 ## Database Service Abstraction
 
 The `db.ts` service can be swapped between implementations:
 
 **Current**: Bun native Postgres
+
 ```typescript
-import { sql } from 'bun';
+import { sql } from "bun";
 ```
 
-**Future**: Postgres Gateway
+**Future**: Postgres Gateway (HTTP-based)
+
 ```typescript
 fetch('http://postgres-gateway:8080/query', ...)
 ```
 
-Change only happens in `src/services/db.ts` - all other code stays the same.
+Change only happens in `src/services/db/` - all other code stays the same.
 
-## TODO
+## Status
 
-- [ ] Auth routes (login, register, refresh)
-- [ ] Users routes
-- [ ] Environments routes
-- [ ] Domains routes
-- [ ] Crons routes
-- [ ] Server-Sent Events for logs
-- [ ] Input validation
-- [ ] Error handling middleware
-- [ ] Tests
+### ✅ Implemented
 
-## Migration from NestJS
+- [x] Auth routes (GitHub OAuth, refresh)
+- [x] Users routes (profile)
+- [x] Workers routes (CRUD + name uniqueness check)
+- [x] Environments routes (CRUD + values management)
+- [x] Domains routes (CRUD)
+- [x] Crons routes (CRUD)
+- [x] Zod input/output validation
+- [x] JWT authentication middleware
+- [x] Standalone binary compilation
 
-This replaces `openworkers-dash/dash-api` with simpler implementation:
+### 🚧 TODO
 
-- ✅ No NestJS boilerplate
-- ✅ ~90% less code
-- ✅ Faster startup (<50ms vs ~2s)
-- ✅ Native Bun performance
-- ✅ Easier to audit (~500 lines vs ~5000 lines)
+- [ ] Error handling middleware (standardized error responses)
+- [ ] Request validation middleware
+- [ ] Rate limiting
+- [ ] Tests (unit + integration)
+- [ ] API documentation (OpenAPI/Swagger)

examples/default-worker.txt

@@ -0,0 +1,37 @@
+addEventListener("fetch", (event: FetchEvent) => {
+  event.respondWith(
+    handleRequest(event.request).catch(
+      (err: Error) => new Response(err.stack, { status: 500 })
+    )
+  );
+});
+
+addEventListener("scheduled", (event: ScheduledEvent) => {
+  event.waitUntil(handleSchedule(event.scheduledTime));
+});
+
+async function handleSchedule(scheduledTime: number): Promise<void> {
+  console.log(`Scheduled event at ${new Date(scheduledTime).toISOString()}`);
+}
+
+// More examples available at: https://openworkers.com/docs
+async function handleRequest(request: Request): Promise<Response> {
+  const { pathname } = new URL(request.url);
+
+  // Return a 404 response for requests to /favicon.ico.
+  if (pathname.startsWith("/favicon.ico")) {
+    return new Response("Not found", { status: 404 });
+  }
+
+  // Return a JSON response for requests to /api containing the requested pathname.
+  if (pathname.startsWith("/api")) {
+    return new Response(JSON.stringify({ pathname }), {
+      headers: { "Content-Type": "application/json" },
+    });
+  }
+
+  // Return a HTML response for all other requests.
+  return new Response("<h3>Hello world!</h3>", {
+    headers: { "Content-Type": "text/html" },
+  });
+}

src/routes/auth.ts

@@ -78,8 +78,6 @@ auth.get("/callback/github", async (c) => {
       avatar_url: string;
     };
 
-    console.log("GitHub user:", githubUser);
-
     // Find or create user in our DB
     const user = await authService.findOrCreateGitHubUser(githubUser);
 

src/routes/crons.ts

@@ -1,74 +1,88 @@
-import { Hono } from 'hono';
-import { cronsService } from '../services/crons';
-import { workersService } from '../services/workers';
-import { CronCreateInputSchema, CronUpdateInputSchema, CronSchema } from '../types';
-import { jsonResponse } from '../utils/validate';
+import { Hono } from "hono";
+import { cronsService } from "../services/crons";
+import { workersService } from "../services/workers";
+import {
+  CronCreateInputSchema,
+  CronUpdateInputSchema,
+  CronSchema,
+  WorkerSchema,
+} from "../types";
+import { jsonResponse } from "../utils/validate";
 
 const crons = new Hono();
 
 // PUT /crons/:id - Update cron
-crons.put('/:id', async (c) => {
-    const userId = c.get('userId');
-    const id = c.req.param('id');
-    const body = await c.req.json();
+crons.put("/:id", async (c) => {
+  const userId = c.get("userId");
+  const id = c.req.param("id");
+  const body = await c.req.json();
 
-    try {
-        const payload = CronUpdateInputSchema.parse(body);
-        const cron = await cronsService.update(userId, id, payload);
+  try {
+    const payload = CronUpdateInputSchema.parse(body);
+    const cron = await cronsService.update(userId, id, payload);
 
-        return jsonResponse(c, CronSchema, cron);
-    } catch (error) {
-        console.error('Failed to update cron:', error);
-        return c.json({
-            error: 'Failed to update cron',
-            message: error instanceof Error ? error.message : 'Unknown error'
-        }, 500);
-    }
+    // Return updated worker
+    const updatedWorker = await workersService.findById(userId, cron.workerId);
+
+    return jsonResponse(c, WorkerSchema, updatedWorker);
+  } catch (error) {
+    console.error("Failed to update cron:", error);
+    return c.json(
+      {
+        error: "Failed to update cron",
+        message: error instanceof Error ? error.message : "Unknown error",
+      },
+      500
+    );
+  }
 });
 
 // DELETE /crons/:id - Delete cron
-crons.delete('/:id', async (c) => {
-    const userId = c.get('userId');
-    const id = c.req.param('id');
-
-    try {
-        // Get cron first to know which worker it belongs to
-        const cron = await cronsService.findById(userId, id);
-        if (!cron) {
-            return c.json({ error: 'Cron not found' }, 404);
-        }
+crons.delete("/:id", async (c) => {
+  const userId = c.get("userId");
+  const id = c.req.param("id");
 
-        const deleted = await cronsService.delete(userId, id);
+  try {
+    // Get cron first to know which worker it belongs to
+    const cron = await cronsService.findById(userId, id);
+    if (!cron) {
+      return c.json({ error: "Cron not found" }, 404);
+    }
 
-        if (deleted === 0) {
-            return c.json({ error: 'Cron not found' }, 404);
-        }
+    const deleted = await cronsService.delete(userId, id);
 
-        // Return updated worker
-        const updatedWorker = await workersService.findById(userId, cron.workerId);
-        return c.json(updatedWorker);
-    } catch (error) {
-        console.error('Failed to delete cron:', error);
-        return c.json({ error: 'Failed to delete cron' }, 500);
+    if (deleted === 0) {
+      return c.json({ error: "Cron not found" }, 404);
     }
+
+    // Return updated worker
+    const updatedWorker = await workersService.findById(userId, cron.workerId);
+    return c.json(updatedWorker);
+  } catch (error) {
+    console.error("Failed to delete cron:", error);
+    return c.json({ error: "Failed to delete cron" }, 500);
+  }
 });
 
 // POST /crons - Create cron
-crons.post('/', async (c) => {
-    const userId = c.get('userId');
-    const body = await c.req.json();
+crons.post("/", async (c) => {
+  const userId = c.get("userId");
+  const body = await c.req.json();
 
-    try {
-        const payload = CronCreateInputSchema.parse(body);
-        const cron = await cronsService.create(userId, payload);
-        return jsonResponse(c, CronSchema, cron, 201);
-    } catch (error) {
-        console.error('Failed to create cron:', error);
-        return c.json({
-            error: 'Failed to create cron',
-            message: error instanceof Error ? error.message : 'Unknown error'
-        }, 500);
-    }
+  try {
+    const payload = CronCreateInputSchema.parse(body);
+    const cron = await cronsService.create(userId, payload);
+    return jsonResponse(c, CronSchema, cron, 201);
+  } catch (error) {
+    console.error("Failed to create cron:", error);
+    return c.json(
+      {
+        error: "Failed to create cron",
+        message: error instanceof Error ? error.message : "Unknown error",
+      },
+      500
+    );
+  }
 });
 
 export default crons;