ai-spec-dev 0.42.0 → 0.55.0

package/demo-backend/src/controllers/bookmark.controller.ts

@@ -1,187 +0,0 @@
-import { Request, Response, NextFunction } from 'express';
-import { AppError } from '../middleware/error.middleware';
-import * as bookmarkService from '../services/bookmark.service';
-
-interface BookmarkQueryParams {
-  limit?: string;
-  offset?: string;
-}
-
-interface CreateBookmarkBody {
-  title?: string;
-  url?: string;
-  tags?: string[];
-}
-
-interface UpdateBookmarkBody {
-  title?: string;
-  url?: string;
-  tags?: string[];
-}
-
-interface BookmarkParams {
-  id?: string;
-}
-
-export class BookmarkController {
-  static async getBookmarks(
-    req: Request<{}, {}, {}, BookmarkQueryParams>,
-    res: Response,
-    next: NextFunction
-  ) {
-    try {
-      const { limit: limitStr, offset: offsetStr } = req.query;
-      
-      const limit = limitStr ? parseInt(limitStr, 10) : 20;
-      const offset = offsetStr ? parseInt(offsetStr, 10) : 0;
-      
-      if (isNaN(limit) || limit <= 0) {
-        throw new AppError(400, '"limit" must be a positive integer');
-      }
-      
-      if (isNaN(offset) || offset < 0) {
-        throw new AppError(400, '"offset" must be a non-negative integer');
-      }
-      
-      const result = await bookmarkService.getBookmarks(limit, offset);
-      
-      res.status(200).json({
-        code: 200,
-        message: 'success',
-        data: {
-          bookmarks: result.bookmarks,
-          total: result.total
-        }
-      });
-    } catch (error) {
-      next(error);
-    }
-  }
-  
-  static async createBookmark(
-    req: Request<{}, {}, CreateBookmarkBody>,
-    res: Response,
-    next: NextFunction
-  ) {
-    try {
-      const { title, url, tags } = req.body;
-      
-      if (!title || typeof title !== 'string' || title.trim() === '') {
-        throw new AppError(400, '"title" is required and must be a non-empty string');
-      }
-      
-      if (!url || typeof url !== 'string') {
-        throw new AppError(400, '"url" is required and must be a string');
-      }
-      
-      try {
-        new URL(url);
-      } catch {
-        throw new AppError(400, '"url" must be a valid URL');
-      }
-      
-      if (tags !== undefined && !Array.isArray(tags)) {
-        throw new AppError(400, '"tags" must be an array of strings');
-      }
-      
-      if (tags && !tags.every(tag => typeof tag === 'string')) {
-        throw new AppError(400, '"tags" must be an array of strings');
-      }
-      
-      const bookmark = await bookmarkService.createBookmark({
-        title: title.trim(),
-        url: url.trim(),
-        tags: tags || []
-      });
-      
-      res.status(201).json({
-        code: 201,
-        message: 'success',
-        data: bookmark
-      });
-    } catch (error) {
-      next(error);
-    }
-  }
-  
-  static async updateBookmark(
-    req: Request<BookmarkParams, {}, UpdateBookmarkBody>,
-    res: Response,
-    next: NextFunction
-  ) {
-    try {
-      const { id } = req.params;
-      const { title, url, tags } = req.body;
-      
-      if (!id) {
-        throw new AppError(400, '"id" parameter is required');
-      }
-      
-      const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-      if (!uuidRegex.test(id)) {
-        throw new AppError(400, '"id" must be a valid UUID');
-      }
-      
-      if (!title || typeof title !== 'string' || title.trim() === '') {
-        throw new AppError(400, '"title" is required and must be a non-empty string');
-      }
-      
-      if (!url || typeof url !== 'string') {
-        throw new AppError(400, '"url" is required and must be a string');
-      }
-      
-      try {
-        new URL(url);
-      } catch {
-        throw new AppError(400, '"url" must be a valid URL');
-      }
-      
-      if (!tags || !Array.isArray(tags)) {
-        throw new AppError(400, '"tags" is required and must be an array of strings');
-      }
-      
-      if (!tags.every(tag => typeof tag === 'string')) {
-        throw new AppError(400, '"tags" must be an array of strings');
-      }
-      
-      const bookmark = await bookmarkService.updateBookmark(id, {
-        title: title.trim(),
-        url: url.trim(),
-        tags
-      });
-      
-      res.status(200).json({
-        code: 200,
-        message: 'success',
-        data: bookmark
-      });
-    } catch (error) {
-      next(error);
-    }
-  }
-  
-  static async deleteBookmark(
-    req: Request<BookmarkParams>,
-    res: Response,
-    next: NextFunction
-  ) {
-    try {
-      const { id } = req.params;
-      
-      if (!id) {
-        throw new AppError(400, '"id" parameter is required');
-      }
-      
-      const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-      if (!uuidRegex.test(id)) {
-        throw new AppError(400, '"id" must be a valid UUID');
-      }
-      
-      await bookmarkService.deleteBookmark(id);
-      
-      res.status(204).send();
-    } catch (error) {
-      next(error);
-    }
-  }
-}

package/demo-backend/src/index.ts

@@ -1,17 +0,0 @@
-import express from "express";
-import cors from "cors";
-
-const app = express();
-app.use(cors());
-app.use(express.json());
-
-app.get("/health", (_req, res) => {
-  res.json({ status: "ok" });
-});
-
-const PORT = process.env.PORT || 3001;
-app.listen(PORT, () => {
-  console.log(`Server running on http://localhost:${PORT}`);
-});
-
-export default app;

package/demo-backend/src/routes/bookmark.routes.test.ts

@@ -1,264 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import http from 'http';
-import { app } from '../app';
-
-let server: http.Server;
-let baseUrl: string;
-
-beforeAll(async () => {
-  server = app.listen(0);
-  const address = server.address();
-  if (typeof address === 'object' && address !== null) {
-    baseUrl = `http://localhost:${address.port}`;
-  } else {
-    throw new Error('Server address is not available');
-  }
-});
-
-afterAll(() => {
-  server.close();
-});
-
-function request(method: string, path: string, body?: any): Promise<{ statusCode: number; body: any }> {
-  return new Promise((resolve, reject) => {
-    const url = new URL(path, baseUrl);
-    const options = {
-      hostname: url.hostname,
-      port: url.port,
-      path: url.pathname + url.search,
-      method,
-      headers: {
-        'Content-Type': 'application/json',
-      },
-    };
-
-    const req = http.request(options, (res) => {
-      let data = '';
-      res.on('data', (chunk) => {
-        data += chunk;
-      });
-      res.on('end', () => {
-        try {
-          const parsedBody = data ? JSON.parse(data) : {};
-          resolve({ statusCode: res.statusCode || 500, body: parsedBody });
-        } catch (e) {
-          resolve({ statusCode: res.statusCode || 500, body: data });
-        }
-      });
-    });
-
-    req.on('error', reject);
-
-    if (body) {
-      req.write(JSON.stringify(body));
-    }
-
-    req.end();
-  });
-}
-
-describe('Bookmark API Endpoints', () => {
-  let createdBookmarkId: string;
-
-  describe('POST /api/v1/bookmarks', () => {
-    it('should create a new bookmark with valid data', async () => {
-      const bookmarkData = {
-        title: 'Test Bookmark',
-        url: 'https://example.com',
-        tags: ['test', 'example'],
-      };
-
-      const response = await request('POST', '/api/v1/bookmarks', bookmarkData);
-
-      expect(response.statusCode).toBe(201);
-      expect(response.body.code).toBe(201);
-      expect(response.body.message).toBe('success');
-      expect(response.body.data).toHaveProperty('id');
-      expect(response.body.data.title).toBe(bookmarkData.title);
-      expect(response.body.data.url).toBe(bookmarkData.url);
-      expect(response.body.data.tags).toEqual(bookmarkData.tags);
-      expect(response.body.data).toHaveProperty('createdAt');
-      expect(response.body.data).toHaveProperty('updatedAt');
-
-      createdBookmarkId = response.body.data.id;
-    });
-
-    it('should return 400 when title is missing', async () => {
-      const bookmarkData = {
-        url: 'https://example.com',
-      };
-
-      const response = await request('POST', '/api/v1/bookmarks', bookmarkData);
-
-      expect(response.statusCode).toBe(400);
-      expect(response.body.code).toBe(400);
-      expect(response.body.message).toBeDefined();
-    });
-
-    it('should return 400 when URL is invalid', async () => {
-      const bookmarkData = {
-        title: 'Invalid URL',
-        url: 'invalid-url',
-      };
-
-      const response = await request('POST', '/api/v1/bookmarks', bookmarkData);
-
-      expect(response.statusCode).toBe(400);
-      expect(response.body.code).toBe(400);
-      expect(response.body.message).toBeDefined();
-    });
-
-    it('should return 400 when URL is missing', async () => {
-      const bookmarkData = {
-        title: 'No URL',
-      };
-
-      const response = await request('POST', '/api/v1/bookmarks', bookmarkData);
-
-      expect(response.statusCode).toBe(400);
-      expect(response.body.code).toBe(400);
-      expect(response.body.message).toBeDefined();
-    });
-  });
-
-  describe('GET /api/v1/bookmarks', () => {
-    it('should return paginated list of bookmarks', async () => {
-      const response = await request('GET', '/api/v1/bookmarks?limit=10&offset=0');
-
-      expect(response.statusCode).toBe(200);
-      expect(response.body.code).toBe(200);
-      expect(response.body.message).toBe('success');
-      expect(response.body.data).toHaveProperty('bookmarks');
-      expect(Array.isArray(response.body.data.bookmarks)).toBe(true);
-      expect(response.body.data).toHaveProperty('total');
-      expect(typeof response.body.data.total).toBe('number');
-    });
-
-    it('should use default pagination when no parameters provided', async () => {
-      const response = await request('GET', '/api/v1/bookmarks');
-
-      expect(response.statusCode).toBe(200);
-      expect(response.body.code).toBe(200);
-      expect(response.body.message).toBe('success');
-      expect(response.body.data).toHaveProperty('bookmarks');
-      expect(response.body.data).toHaveProperty('total');
-    });
-
-    it('should return 400 for invalid limit parameter', async () => {
-      const response = await request('GET', '/api/v1/bookmarks?limit=invalid');
-
-      expect(response.statusCode).toBe(400);
-      expect(response.body.code).toBe(400);
-      expect(response.body.message).toBeDefined();
-    });
-
-    it('should return 400 for invalid offset parameter', async () => {
-      const response = await request('GET', '/api/v1/bookmarks?offset=-1');
-
-      expect(response.statusCode).toBe(400);
-      expect(response.body.code).toBe(400);
-      expect(response.body.message).toBeDefined();
-    });
-  });
-
-  describe('PUT /api/v1/bookmarks/:id', () => {
-    it('should update an existing bookmark', async () => {
-      if (!createdBookmarkId) {
-        throw new Error('No bookmark created to update');
-      }
-
-      const updateData = {
-        title: 'Updated Title',
-        url: 'https://updated-example.com',
-        tags: ['updated', 'test'],
-      };
-
-      const response = await request('PUT', `/api/v1/bookmarks/${createdBookmarkId}`, updateData);
-
-      expect(response.statusCode).toBe(200);
-      expect(response.body.code).toBe(200);
-      expect(response.body.message).toBe('success');
-      expect(response.body.data.id).toBe(createdBookmarkId);
-      expect(response.body.data.title).toBe(updateData.title);
-      expect(response.body.data.url).toBe(updateData.url);
-      expect(response.body.data.tags).toEqual(updateData.tags);
-    });
-
-    it('should return 404 for non-existent bookmark', async () => {
-      const nonExistentId = '00000000-0000-0000-0000-000000000000';
-      const updateData = {
-        title: 'Updated Title',
-        url: 'https://example.com',
-        tags: ['test'],
-      };
-
-      const response = await request('PUT', `/api/v1/bookmarks/${nonExistentId}`, updateData);
-
-      expect(response.statusCode).toBe(404);
-      expect(response.body.code).toBe(404);
-      expect(response.body.message).toBeDefined();
-    });
-
-    it('should return 400 for invalid bookmark ID format', async () => {
-      const invalidId = 'invalid-uuid';
-      const updateData = {
-        title: 'Updated Title',
-        url: 'https://example.com',
-        tags: ['test'],
-      };
-
-      const response = await request('PUT', `/api/v1/bookmarks/${invalidId}`, updateData);
-
-      expect(response.statusCode).toBe(400);
-      expect(response.body.code).toBe(400);
-      expect(response.body.message).toBeDefined();
-    });
-
-    it('should return 400 when required fields are missing', async () => {
-      if (!createdBookmarkId) {
-        throw new Error('No bookmark created to update');
-      }
-
-      const updateData = {
-        title: 'Updated Title',
-      };
-
-      const response = await request('PUT', `/api/v1/bookmarks/${createdBookmarkId}`, updateData);
-
-      expect(response.statusCode).toBe(400);
-      expect(response.body.code).toBe(400);
-      expect(response.body.message).toBeDefined();
-    });
-  });
-
-  describe('DELETE /api/v1/bookmarks/:id', () => {
-    it('should delete an existing bookmark', async () => {
-      if (!createdBookmarkId) {
-        throw new Error('No bookmark created to delete');
-      }
-
-      const response = await request('DELETE', `/api/v1/bookmarks/${createdBookmarkId}`);
-
-      expect(response.statusCode).toBe(204);
-      expect(response.body).toBe('');
-    });
-
-    it('should return 404 for non-existent bookmark', async () => {
-      const nonExistentId = '00000000-0000-0000-0000-000000000000';
-      const response = await request('DELETE', `/api/v1/bookmarks/${nonExistentId}`);
-
-      expect(response.statusCode).toBe(404);
-      expect(response.body.code).toBe(404);
-      expect(response.body.message).toBeDefined();
-    });
-
-    it('should return 400 for invalid bookmark ID format', async () => {
-      const invalidId = 'invalid-uuid';
-      const response = await request('DELETE', `/api/v1/bookmarks/${invalidId}`);
-
-      expect(response.statusCode).toBe(400);
-      expect(response.body.code).toBe(400);
-      expect(response.body.message).toBeDefined();
-    });
-  });
-});

package/demo-backend/src/routes/bookmark.routes.ts

@@ -1,11 +0,0 @@
-import { Router } from 'express';
-import { getBookmarks, createBookmark, updateBookmark, deleteBookmark } from '../controllers/bookmark.controller';
-
-const router = Router();
-
-router.get('/', getBookmarks);
-router.post('/', createBookmark);
-router.put('/:id', updateBookmark);
-router.delete('/:id', deleteBookmark);
-
-export default router;

package/demo-backend/src/routes/index.ts

@@ -1,8 +0,0 @@
-import { Router } from 'express';
-import bookmarkRoutes from './bookmark.routes';
-
-const router = Router();
-
-router.use('/api/v1/bookmarks', bookmarkRoutes);
-
-export default router;