@bbki.ng/backend 0.3.6 → 0.3.9

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # backend
 
+## 0.3.9
+
+### Patch Changes
+
+- 282af74: update ui components
+- 558e40b: update compoennts
+
+## 0.3.8
+
+### Patch Changes
+
+- 21296f0: update backend
+
+## 0.3.7
+
+### Patch Changes
+
+- 796a37a: remove unused code
+
 ## 0.3.6
 
 ### Patch Changes

package/README.md

@@ -17,5 +17,5 @@ Pass the `CloudflareBindings` as generics when instantiation `Hono`:
 
 ```ts
 // src/index.ts
-const app = new Hono<{ Bindings: CloudflareBindings }>()
+const app = new Hono<{ Bindings: CloudflareBindings }>();
 ```

package/eslint.config.js

@@ -6,7 +6,4 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-export default [
-  includeIgnoreFile(path.resolve(__dirname, '.gitignore')),
-  ...cloudflareConfig,
-];
+export default [includeIgnoreFile(path.resolve(__dirname, '.gitignore')), ...cloudflareConfig];

package/migrations/001_add_posts.sql

@@ -0,0 +1,13 @@
+-- posts table for blog articles
+CREATE TABLE IF NOT EXISTS posts (
+  id TEXT PRIMARY KEY,
+  title TEXT NOT NULL UNIQUE,
+  content TEXT NOT NULL,
+  author TEXT DEFAULT 'bbki.ng',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+-- indexes for common queries
+CREATE INDEX IF NOT EXISTS idx_posts_created_at ON posts(created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_posts_title ON posts(title);

package/migrations/002_seed_test_data.sql

@@ -0,0 +1,15 @@
+-- Seed test data for local development
+INSERT INTO posts (id, title, content, author, created_at, updated_at) VALUES
+('test-post-001', 'Hello World', 'This is a test post for local development. Welcome to bbki.ng!', 'bbki.ng', datetime('now'), datetime('now')),
+('test-post-002', 'Second Post', 'Another test post to verify the posts list is working correctly.', 'bbki.ng', datetime('now', '-1 day'), datetime('now', '-1 day')),
+('test-post-003', 'Testing Markdown', '# Markdown Test
+
+This post tests **bold** and *italic* text.
+
+## Code Block
+```javascript
+const hello = "world";
+console.log(hello);
+```
+
+> A blockquote for testing.', 'bbki.ng', datetime('now', '-2 days'), datetime('now', '-2 days'));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bbki.ng/backend",
-  "version": "0.3.6",
+  "version": "0.3.9",
   "type": "module",
   "dependencies": {
     "@simplewebauthn/server": "13.2.2",
@@ -20,7 +20,7 @@
     "prettier": "^3.2.0",
     "typescript": "^5.3.0",
     "wrangler": "^4.58.0",
-    "@bbki.ng/config": "1.0.4"
+    "@bbki.ng/config": "1.0.6"
   },
   "prettier": "@bbki.ng/config/prettier",
   "scripts": {

package/src/config/app.config.ts

@@ -1,6 +1,6 @@
-import { Hono } from "hono";
-import type { D1Database } from "@cloudflare/workers-types";
-import { cors } from "hono/cors";
+import { Hono } from 'hono';
+import type { D1Database } from '@cloudflare/workers-types';
+import { cors } from 'hono/cors';
 
 type Bindings = {
   DB: D1Database;
@@ -10,10 +10,10 @@ type Bindings = {
 const app = new Hono<{ Bindings: Bindings }>();
 
 app.use(
-  "*",
+  '*',
   cors({
-    origin: ["https://bbki.ng"],
-  }),
+    origin: ['https://bbki.ng'],
+  })
 );
 
 export default app;

package/src/controllers/comment/add.controller.ts

@@ -1,24 +1,24 @@
-import { Context } from "hono";
+import { Context } from 'hono';
 
 export const addComment = async (c: Context) => {
   const { articleId, author, content } = await c.req.json();
 
   try {
     let { results } = await c.env.DB.prepare(
-      "INSERT INTO comment (article_id, author, content, created_at) VALUES (?, ?, ?, ?);",
+      'INSERT INTO comment (article_id, author, content, created_at) VALUES (?, ?, ?, ?);'
     )
       .bind(articleId, author, content, new Date().toISOString())
       .run();
 
     return c.json({
-      status: "success",
-      message: "Comment added successfully",
+      status: 'success',
+      message: 'Comment added successfully',
       results,
     });
   } catch (error: any) {
     return c.json({
-      status: "error",
-      message: "Failed to add comment",
+      status: 'error',
+      message: 'Failed to add comment',
       error: error.message,
     });
   }

package/src/controllers/posts/add.controller.ts

@@ -0,0 +1,90 @@
+import { Context } from 'hono';
+import { HTTPException } from 'hono/http-exception';
+
+interface AddPostRequest {
+  title: string;
+  content: string;
+  author?: string;
+}
+
+const MAX_TITLE_LENGTH = 200;
+const MAX_CONTENT_LENGTH = 100000;
+
+export const addPost = async (c: Context) => {
+  try {
+    // Parse and validate request body
+    const body = await c.req.json<AddPostRequest>();
+
+    if (!body.title || typeof body.title !== 'string') {
+      throw new HTTPException(400, { message: 'Title is required' });
+    }
+
+    if (!body.content || typeof body.content !== 'string') {
+      throw new HTTPException(400, { message: 'Content is required' });
+    }
+
+    const title = body.title.trim();
+    const content = body.content.trim();
+
+    if (title.length === 0) {
+      throw new HTTPException(400, { message: 'Title cannot be empty' });
+    }
+
+    if (title.length > MAX_TITLE_LENGTH) {
+      throw new HTTPException(413, { message: `Title exceeds ${MAX_TITLE_LENGTH} chars` });
+    }
+
+    if (content.length === 0) {
+      throw new HTTPException(400, { message: 'Content cannot be empty' });
+    }
+
+    if (content.length > MAX_CONTENT_LENGTH) {
+      throw new HTTPException(413, { message: `Content exceeds ${MAX_CONTENT_LENGTH} chars` });
+    }
+
+    const author = (body.author ?? 'bbki.ng').trim();
+
+    // Check database availability
+    if (!c.env?.DB) {
+      throw new HTTPException(503, { message: 'Database unavailable' });
+    }
+
+    // Insert post
+    const id = crypto.randomUUID();
+    const now = new Date().toISOString();
+
+    try {
+      await c.env.DB.prepare(
+        'INSERT INTO posts (id, title, content, author, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)'
+      )
+        .bind(id, title, content, author, now, now)
+        .run();
+    } catch (dbError: any) {
+      if (dbError.message?.includes('UNIQUE')) {
+        throw new HTTPException(409, { message: 'Post with this title already exists' });
+      }
+      throw dbError;
+    }
+
+    return c.json(
+      {
+        status: 'success',
+        data: { id, title, content, author, createdAt: now, updatedAt: now },
+      },
+      201
+    );
+  } catch (error) {
+    if (error instanceof HTTPException) {
+      return c.json({ status: 'error', message: error.message }, error.status);
+    }
+
+    console.error('Unexpected error:', error);
+    return c.json(
+      {
+        status: 'error',
+        message: 'Internal server error',
+      },
+      500
+    );
+  }
+};

package/src/controllers/posts/get.controller.ts

@@ -0,0 +1,42 @@
+import { Context } from 'hono';
+import { HTTPException } from 'hono/http-exception';
+
+export const getPost = async (c: Context) => {
+  try {
+    const title = c.req.param('title');
+
+    if (!title) {
+      throw new HTTPException(400, { message: 'Title is required' });
+    }
+
+    const result = await c.env.DB.prepare(
+      `SELECT id, title, content, author, created_at as createdAt, updated_at as updatedAt
+       FROM posts
+       WHERE title = ?`
+    )
+      .bind(title)
+      .first();
+
+    if (!result) {
+      throw new HTTPException(404, { message: 'Post not found' });
+    }
+
+    return c.json({
+      status: 'success',
+      data: result,
+    });
+  } catch (error) {
+    if (error instanceof HTTPException) {
+      return c.json({ status: 'error', message: error.message }, error.status);
+    }
+
+    console.error('Unexpected error:', error);
+    return c.json(
+      {
+        status: 'error',
+        message: 'Internal server error',
+      },
+      500
+    );
+  }
+};

package/src/controllers/posts/list.controller.ts

@@ -0,0 +1,25 @@
+import { Context } from 'hono';
+
+export const listPosts = async (c: Context) => {
+  try {
+    const { results } = await c.env.DB.prepare(
+      `SELECT id, title, content, author, created_at as createdAt, updated_at as updatedAt
+       FROM posts
+       ORDER BY created_at DESC`
+    ).all();
+
+    return c.json({
+      status: 'success',
+      data: results,
+    });
+  } catch (error: any) {
+    return c.json(
+      {
+        status: 'error',
+        message: 'Failed to fetch posts',
+        error: error.message,
+      },
+      500
+    );
+  }
+};

package/src/controllers/posts/remove.controller.ts

@@ -0,0 +1,47 @@
+import { Context } from 'hono';
+import { HTTPException } from 'hono/http-exception';
+
+export const removePost = async (c: Context) => {
+  try {
+    const id = c.req.param('id');
+
+    if (!id) {
+      throw new HTTPException(400, { message: 'Post ID is required' });
+    }
+
+    // Check database availability
+    if (!c.env?.DB) {
+      throw new HTTPException(503, { message: 'Database unavailable' });
+    }
+
+    // Check if post exists
+    const existingPost = await c.env.DB.prepare('SELECT id FROM posts WHERE id = ?')
+      .bind(id)
+      .first();
+
+    if (!existingPost) {
+      throw new HTTPException(404, { message: 'Post not found' });
+    }
+
+    // Delete post
+    await c.env.DB.prepare('DELETE FROM posts WHERE id = ?').bind(id).run();
+
+    return c.json({
+      status: 'success',
+      message: 'Post deleted successfully',
+    });
+  } catch (error) {
+    if (error instanceof HTTPException) {
+      return c.json({ status: 'error', message: error.message }, error.status);
+    }
+
+    console.error('Unexpected error:', error);
+    return c.json(
+      {
+        status: 'error',
+        message: 'Internal server error',
+      },
+      500
+    );
+  }
+};

package/src/controllers/posts/update.controller.ts

@@ -0,0 +1,101 @@
+import { Context } from 'hono';
+import { HTTPException } from 'hono/http-exception';
+
+interface UpdatePostRequest {
+  title: string;
+  content: string;
+  author?: string;
+}
+
+const MAX_TITLE_LENGTH = 200;
+const MAX_CONTENT_LENGTH = 100000;
+
+export const updatePost = async (c: Context) => {
+  try {
+    const id = c.req.param('id');
+
+    if (!id) {
+      throw new HTTPException(400, { message: 'Post ID is required' });
+    }
+
+    // Parse and validate request body
+    const body = await c.req.json<UpdatePostRequest>();
+
+    if (!body.title || typeof body.title !== 'string') {
+      throw new HTTPException(400, { message: 'Title is required' });
+    }
+
+    if (!body.content || typeof body.content !== 'string') {
+      throw new HTTPException(400, { message: 'Content is required' });
+    }
+
+    const title = body.title.trim();
+    const content = body.content.trim();
+
+    if (title.length === 0) {
+      throw new HTTPException(400, { message: 'Title cannot be empty' });
+    }
+
+    if (title.length > MAX_TITLE_LENGTH) {
+      throw new HTTPException(413, { message: `Title exceeds ${MAX_TITLE_LENGTH} chars` });
+    }
+
+    if (content.length === 0) {
+      throw new HTTPException(400, { message: 'Content cannot be empty' });
+    }
+
+    if (content.length > MAX_CONTENT_LENGTH) {
+      throw new HTTPException(413, { message: `Content exceeds ${MAX_CONTENT_LENGTH} chars` });
+    }
+
+    const author = (body.author ?? 'bbki.ng').trim();
+
+    // Check database availability
+    if (!c.env?.DB) {
+      throw new HTTPException(503, { message: 'Database unavailable' });
+    }
+
+    // Check if post exists
+    const existingPost = await c.env.DB.prepare('SELECT id FROM posts WHERE id = ?')
+      .bind(id)
+      .first();
+
+    if (!existingPost) {
+      throw new HTTPException(404, { message: 'Post not found' });
+    }
+
+    // Update post
+    const now = new Date().toISOString();
+
+    try {
+      await c.env.DB.prepare(
+        'UPDATE posts SET title = ?, content = ?, author = ?, updated_at = ? WHERE id = ?'
+      )
+        .bind(title, content, author, now, id)
+        .run();
+    } catch (dbError: any) {
+      if (dbError.message?.includes('UNIQUE')) {
+        throw new HTTPException(409, { message: 'Post with this title already exists' });
+      }
+      throw dbError;
+    }
+
+    return c.json({
+      status: 'success',
+      data: { id, title, content, author, updatedAt: now },
+    });
+  } catch (error) {
+    if (error instanceof HTTPException) {
+      return c.json({ status: 'error', message: error.message }, error.status);
+    }
+
+    console.error('Unexpected error:', error);
+    return c.json(
+      {
+        status: 'error',
+        message: 'Internal server error',
+      },
+      500
+    );
+  }
+};

package/src/controllers/streaming/add.controller.ts

@@ -1,5 +1,5 @@
-import { Context } from "hono";
-import { HTTPException } from "hono/http-exception";
+import { Context } from 'hono';
+import { HTTPException } from 'hono/http-exception';
 
 interface AddStreamingRequest {
   author?: string;
@@ -25,25 +25,25 @@ export const addStreaming = async (c: Context) => {
     const streamApiKey = c.env?.STREAM_API_KEY;
     if (!streamApiKey) {
       console.error('STREAM_API_KEY not configured in environment');
-      throw new HTTPException(500, { message: "Server configuration error" });
+      throw new HTTPException(500, { message: 'Server configuration error' });
     }
 
     // 1. 认证（Header 方式）
     const apiKey = c.req.header('x-api-key');
     if (!apiKey || !timingSafeEqual(apiKey, streamApiKey)) {
-      throw new HTTPException(401, { message: "Invalid API key" });
+      throw new HTTPException(401, { message: 'Invalid API key' });
     }
 
     // 2. 解析与验证
     const body = await c.req.json<AddStreamingRequest>();
-    
-    if (!body.content || typeof body.content !== "string") {
-      throw new HTTPException(400, { message: "Content is required" });
+
+    if (!body.content || typeof body.content !== 'string') {
+      throw new HTTPException(400, { message: 'Content is required' });
     }
-    
+
     const content = body.content.trim();
     if (content.length === 0) {
-      throw new HTTPException(400, { message: "Content cannot be empty" });
+      throw new HTTPException(400, { message: 'Content cannot be empty' });
     }
     if (content.length > MAX_CONTENT_LENGTH) {
       throw new HTTPException(413, { message: `Content exceeds ${MAX_CONTENT_LENGTH} chars` });
@@ -51,17 +51,17 @@ export const addStreaming = async (c: Context) => {
 
     const author = (body.author ?? 'bbki.ng').trim();
     if (author.length > 50) {
-      throw new HTTPException(400, { message: "Author too long" });
+      throw new HTTPException(400, { message: 'Author too long' });
     }
 
     const type = body.type?.trim();
-    if (type && !ALLOWED_TYPES.includes(type as typeof ALLOWED_TYPES[number])) {
-      throw new HTTPException(400, { message: "Invalid type" });
+    if (type && !ALLOWED_TYPES.includes(type as (typeof ALLOWED_TYPES)[number])) {
+      throw new HTTPException(400, { message: 'Invalid type' });
     }
 
     // 3. 数据库检查
     if (!c.env?.DB) {
-      throw new HTTPException(503, { message: "Database unavailable" });
+      throw new HTTPException(503, { message: 'Database unavailable' });
     }
 
     // 4. 写入
@@ -70,31 +70,36 @@ export const addStreaming = async (c: Context) => {
 
     try {
       await c.env.DB.prepare(
-        "INSERT INTO streaming (id, author, content, type, created_at) VALUES (?, ?, ?, ?, ?)"
+        'INSERT INTO streaming (id, author, content, type, created_at) VALUES (?, ?, ?, ?, ?)'
       )
         .bind(id, author, content, type || null, createdAt)
         .run();
     } catch (dbError) {
       if (dbError instanceof Error && dbError.message.includes('UNIQUE')) {
-        throw new HTTPException(409, { message: "Duplicate entry" });
+        throw new HTTPException(409, { message: 'Duplicate entry' });
       }
       throw dbError;
     }
 
-    return c.json({
-      status: "success",
-      data: { id, author, content, type, createdAt }
-    }, 201);
-
+    return c.json(
+      {
+        status: 'success',
+        data: { id, author, content, type, createdAt },
+      },
+      201
+    );
   } catch (error) {
     if (error instanceof HTTPException) {
-      return c.json({ status: "error", message: error.message }, error.status);
+      return c.json({ status: 'error', message: error.message }, error.status);
     }
-    
+
     console.error('Unexpected error:', error);
-    return c.json({ 
-      status: "error", 
-      message: "Internal server error" 
-    }, 500);
+    return c.json(
+      {
+        status: 'error',
+        message: 'Internal server error',
+      },
+      500
+    );
   }
-};
+};

package/src/controllers/streaming/list.controller.ts

@@ -1,4 +1,4 @@
-import { Context } from "hono";
+import { Context } from 'hono';
 
 export const listStreaming = async (c: Context) => {
   try {
@@ -6,9 +6,9 @@ export const listStreaming = async (c: Context) => {
     // 'before' - fetch records older than this ID (for pagination / next page)
     // 'after' - fetch records newer than this ID (for polling / new messages)
     // 'offset' - number of records to fetch (default: 8, max: 100)
-    const before = c.req.query("before");
-    const after = c.req.query("after");
-    const offset = Math.min(parseInt(c.req.query("offset") || "8", 10), 100);
+    const before = c.req.query('before');
+    const after = c.req.query('after');
+    const offset = Math.min(parseInt(c.req.query('offset') || '8', 10), 100);
 
     let results;
 
@@ -20,7 +20,9 @@ export const listStreaming = async (c: Context) => {
          WHERE created_at < (SELECT created_at FROM streaming WHERE id = ?)
          ORDER BY created_at DESC
          LIMIT ?`
-      ).bind(before, offset).all();
+      )
+        .bind(before, offset)
+        .all();
       results = cursorResults;
     } else if (after) {
       // Fetch records newer than the specified id (polling - new messages)
@@ -31,7 +33,9 @@ export const listStreaming = async (c: Context) => {
          WHERE created_at > (SELECT created_at FROM streaming WHERE id = ?)
          ORDER BY created_at ASC
          LIMIT ?`
-      ).bind(after, offset).all();
+      )
+        .bind(after, offset)
+        .all();
       results = cursorResults;
     } else {
       // Fetch the most recent records
@@ -40,19 +44,24 @@ export const listStreaming = async (c: Context) => {
          FROM streaming
          ORDER BY created_at DESC
          LIMIT ?`
-      ).bind(offset).all();
+      )
+        .bind(offset)
+        .all();
       results = recentResults;
     }
 
     return c.json({
-      status: "success",
+      status: 'success',
       data: results,
     });
   } catch (error: any) {
-    return c.json({
-      status: "error",
-      message: "Failed to fetch streaming",
-      error: error.message,
-    }, 500);
+    return c.json(
+      {
+        status: 'error',
+        message: 'Failed to fetch streaming',
+        error: error.message,
+      },
+      500
+    );
   }
 };