react-embed-docs 0.1.0

package/dist/server/routes.js

@@ -0,0 +1,483 @@
+import { Hono } from 'hono';
+import { z } from 'zod';
+import { createDocumentSchema, updateDocumentSchema, uploadFileSchema } from '../shared/types.js';
+import { CollaborationService } from './CollaborationService.js';
+import { ExportService } from './ExportService.js';
+import { VersioningService } from './VersioningService.js';
+/**
+ * Document routes
+ * All routes are prefixed with /docs
+ */
+export function createRouter(docsService, filesService, db) {
+    const router = new Hono();
+    const exportService = new ExportService();
+    const collaborationService = new CollaborationService(db);
+    const versioningService = new VersioningService(db);
+    /**
+     * GET /docs
+     * List all documents with optional filtering
+     */
+    router.get('/', async (c) => {
+        const query = c.req.query();
+        const filters = {
+            search: query.search,
+            parentId: query.parentId === 'null' ? null : query.parentId,
+            isPublished: query.isPublished === 'true' ? true : query.isPublished === 'false' ? false : undefined,
+        };
+        console.log('filters', filters);
+        const options = {
+            offset: query.offset ? parseInt(query.offset, 10) : 0,
+            limit: query.limit ? parseInt(query.limit, 10) : 10,
+            sortBy: query.sortBy,
+            sortDir: query.sortDir,
+        };
+        const { documents, total } = await docsService.list(filters, options);
+        console.log('documents', documents);
+        return c.json({ items: documents, total });
+    });
+    /**
+     * GET /docs/search
+     * Search documents using text search
+     */
+    router.get('/search', async (c) => {
+        const query = c.req.query();
+        const searchQuery = query.q || query.query || '';
+        if (!searchQuery) {
+            return c.json({ results: [], total: 0 });
+        }
+        const options = {
+            limit: query.limit ? parseInt(query.limit, 10) : 20,
+            offset: query.offset ? parseInt(query.offset, 10) : 0,
+        };
+        const { results, total } = await docsService.searchText(searchQuery, options);
+        return c.json({ results, total });
+    });
+    /**
+     * GET /docs/tree
+     * Get all documents in tree structure
+     */
+    router.get('/tree', async (c) => {
+        const documents = await docsService.getTree();
+        return c.json({ items: documents });
+    });
+    /**
+     * GET /docs/:id
+     * Get a single document by ID or slug
+     * Tries ID first, then falls back to slug lookup
+     */
+    router.get('/:id', async (c) => {
+        const id = c.req.param('id');
+        // Try to find by ID first
+        let doc = await docsService.getById(id);
+        // If not found by ID, try by slug
+        if (!doc) {
+            doc = await docsService.getBySlug(id);
+        }
+        if (!doc) {
+            return c.json({ message: 'Document not found' }, 404);
+        }
+        return c.json(doc);
+    });
+    /**
+     * GET /docs/slug/:slug
+     * Get a single document by slug
+     */
+    router.get('/slug/:slug', async (c) => {
+        const slug = c.req.param('slug');
+        const doc = await docsService.getBySlug(slug);
+        if (!doc) {
+            return c.json({ message: 'Document not found' }, 404);
+        }
+        return c.json(doc);
+    });
+    /**
+     * POST /docs
+     * Create a new document
+     */
+    router.post('/', async (c) => {
+        const body = await c.req.json();
+        // Validate input
+        const result = createDocumentSchema.safeParse(body);
+        if (!result.success) {
+            return c.json({ message: 'Invalid input', errors: result.error.errors }, 400);
+        }
+        try {
+            const doc = await docsService.create(result.data);
+            return c.json(doc, 201);
+        }
+        catch (error) {
+            return c.json({ message: 'Failed to create document', error: error.message }, 500);
+        }
+    });
+    /**
+     * PUT /docs/:id
+     * Update an existing document
+     */
+    router.put('/:id', async (c) => {
+        const id = c.req.param('id');
+        const body = await c.req.json();
+        // Validate input
+        const result = updateDocumentSchema.safeParse(body);
+        if (!result.success) {
+            return c.json({ message: 'Invalid input', errors: result.error.errors }, 400);
+        }
+        const doc = await docsService.update(id, result.data);
+        if (!doc) {
+            return c.json({ message: 'Document not found' }, 404);
+        }
+        return c.json(doc);
+    });
+    /**
+     * DELETE /docs/:id
+     * Soft delete a document
+     */
+    router.delete('/:id', async (c) => {
+        const id = c.req.param('id');
+        const deleted = await docsService.delete(id);
+        if (!deleted) {
+            return c.json({ message: 'Document not found' }, 404);
+        }
+        return c.body(null, 204);
+    });
+    /**
+     * GET /docs/:id/children
+     * Get children of a document
+     */
+    router.get('/:id/children', async (c) => {
+        const id = c.req.param('id');
+        const children = await docsService.getChildren(id);
+        return c.json({ items: children });
+    });
+    /**
+     * GET /docs/:id/breadcrumbs
+     * Get breadcrumb path for a document (from root to document)
+     */
+    router.get('/:id/breadcrumbs', async (c) => {
+        const id = c.req.param('id');
+        const breadcrumbs = await docsService.getBreadcrumbs(id);
+        return c.json({ items: breadcrumbs });
+    });
+    /**
+     * POST /docs/:id/reorder
+     * Reorder a document within its parent or move to new parent
+     */
+    router.post('/:id/reorder', async (c) => {
+        const id = c.req.param('id');
+        const body = await c.req.json();
+        const reorderSchema = z.object({
+            parentId: z.string().nullable().optional(),
+            order: z.number(),
+        });
+        const result = reorderSchema.safeParse(body);
+        if (!result.success) {
+            return c.json({ message: 'Invalid input', errors: result.error.errors }, 400);
+        }
+        const { parentId, order } = result.data;
+        const doc = await docsService.reorder(id, parentId ?? null, order);
+        if (!doc) {
+            return c.json({ message: 'Document not found' }, 404);
+        }
+        return c.json(doc);
+    });
+    /**
+     * PATCH /docs/:id/order
+     * Update just the order field
+     */
+    router.patch('/:id/order', async (c) => {
+        const id = c.req.param('id');
+        const body = await c.req.json();
+        const orderSchema = z.object({
+            order: z.number(),
+        });
+        const result = orderSchema.safeParse(body);
+        if (!result.success) {
+            return c.json({ message: 'Invalid input', errors: result.error.errors }, 400);
+        }
+        const doc = await docsService.updateOrder(id, result.data.order);
+        if (!doc) {
+            return c.json({ message: 'Document not found' }, 404);
+        }
+        return c.json(doc);
+    });
+    /**
+     * POST /files
+     * Upload a file
+     */
+    router.post('/files', async (c) => {
+        console.log('uploading files');
+        const body = await c.req.json();
+        console.log('body', body);
+        // Validate input
+        const result = uploadFileSchema.safeParse(body);
+        if (!result.success) {
+            return c.json({ message: 'Invalid input', errors: result.error.errors }, 400);
+        }
+        const { filename, mimeType, content } = result.data;
+        // Validate base64 content
+        try {
+            // Check if content is empty
+            if (!content || content.length === 0) {
+                return c.json({ message: 'Empty file content' }, 400);
+            }
+            const decodedSize = Math.ceil(content.length * 0.75); // Approximate decoded size
+            const maxSize = 5 * 1024 * 1024; // 5MB limit
+            if (decodedSize > maxSize) {
+                return c.json({ message: 'File too large (max 5MB)' }, 413);
+            }
+            // Clean up base64 string - remove any whitespace or newlines
+            const cleanedContent = content.replace(/\s/g, '');
+            // Verify it is valid base64
+            try {
+                Buffer.from(cleanedContent, 'base64');
+            }
+            catch (e) {
+                return c.json({ message: 'Invalid base64 encoding' }, 400);
+            }
+            const file = await filesService.upload({
+                filename,
+                mimeType,
+                size: decodedSize,
+                content: cleanedContent,
+            });
+            return c.json({
+                id: file.id,
+                filename: file.filename,
+                mimeType: file.mimeType,
+                size: file.size,
+                url: `/api/docs/files/${file.id}`,
+            }, 201);
+        }
+        catch (error) {
+            console.error('File upload error:', error);
+            return c.json({ message: 'Failed to upload file' }, 500);
+        }
+    });
+    /**
+     * GET /files/:id
+     * Get a file by ID (returns binary content)
+     */
+    router.get('/files/:id', async (c) => {
+        const id = c.req.param('id');
+        const file = await filesService.getById(id);
+        if (!file) {
+            return c.json({ message: 'File not found' }, 404);
+        }
+        // Decode base64 and return binary
+        const buffer = Buffer.from(file.content, 'base64');
+        c.header('Content-Type', file.mimeType);
+        c.header('Content-Disposition', `inline; filename="${file.filename}"`);
+        return c.body(buffer);
+    });
+    /**
+     * GET /files/:id/meta
+     * Get file metadata without content
+     */
+    router.get('/files/:id/meta', async (c) => {
+        const id = c.req.param('id');
+        const file = await filesService.getById(id);
+        if (!file) {
+            return c.json({ message: 'File not found' }, 404);
+        }
+        return c.json({
+            id: file.id,
+            filename: file.filename,
+            mimeType: file.mimeType,
+            size: file.size,
+            createdAt: file.createdAt,
+        });
+    });
+    /**
+     * DELETE /files/:id
+     * Delete a file
+     */
+    router.delete('/files/:id', async (c) => {
+        const id = c.req.param('id');
+        try {
+            await filesService.delete(id);
+            return c.body(null, 204);
+        }
+        catch (error) {
+            return c.json({ message: 'File not found' }, 404);
+        }
+    });
+    /**
+     * GET /docs/:id/export
+     * Export a document to various formats (docx, pdf, html, md)
+     */
+    router.get('/:id/export', async (c) => {
+        const id = c.req.param('id');
+        const format = c.req.query('format') || 'docx';
+        // Try ID first, then slug
+        let doc = await docsService.getById(id);
+        if (!doc) {
+            doc = await docsService.getBySlug(id);
+        }
+        if (!doc) {
+            return c.json({ message: 'Document not found' }, 404);
+        }
+        try {
+            let result;
+            switch (format.toLowerCase()) {
+                case 'docx':
+                    result = await exportService.exportToDocx(doc);
+                    break;
+                case 'pdf':
+                    result = await exportService.exportToPdf(doc);
+                    break;
+                case 'html':
+                    result = await exportService.exportToHtml(doc);
+                    break;
+                case 'md':
+                case 'markdown':
+                    result = await exportService.exportToMarkdown(doc);
+                    break;
+                default:
+                    return c.json({ message: `Unsupported format: ${format}` }, 400);
+            }
+            c.header('Content-Type', result.mimeType);
+            c.header('Content-Disposition', `attachment; filename="${result.filename}"`);
+            // Convert Node Buffer to Uint8Array for proper binary response
+            const uint8Array = new Uint8Array(result.buffer);
+            return c.body(uint8Array);
+        }
+        catch (error) {
+            console.error('Export error:', error);
+            return c.json({
+                message: 'Export failed',
+                error: error.message
+            }, 500);
+        }
+    });
+    /**
+     * ============================================================================
+     * VERSIONING ROUTES
+     * ============================================================================
+     */
+    /**
+     * GET /docs/:id/versions
+     * List all versions of a document
+     */
+    router.get('/:id/versions', async (c) => {
+        const id = c.req.param('id');
+        const doc = await docsService.getById(id);
+        if (!doc) {
+            return c.json({ message: 'Document not found' }, 404);
+        }
+        const versions = await versioningService.listVersions(id);
+        return c.json({ items: versions, total: versions.length });
+    });
+    /**
+     * POST /docs/:id/versions
+     * Create a new version manually
+     */
+    router.post('/:id/versions', async (c) => {
+        const id = c.req.param('id');
+        const body = await c.req.json().catch(() => ({}));
+        const doc = await docsService.getById(id);
+        if (!doc) {
+            return c.json({ message: 'Document not found' }, 404);
+        }
+        try {
+            const version = await versioningService.createVersion(id, {
+                description: body.description,
+                createdBy: body.createdBy,
+                createdByName: body.createdByName,
+            });
+            return c.json(version, 201);
+        }
+        catch (error) {
+            return c.json({ message: 'Failed to create version' }, 500);
+        }
+    });
+    /**
+     * GET /docs/versions/:versionId
+     * Get a specific version
+     */
+    router.get('/versions/:versionId', async (c) => {
+        const versionId = c.req.param('versionId');
+        const version = await versioningService.getVersion(versionId);
+        if (!version) {
+            return c.json({ message: 'Version not found' }, 404);
+        }
+        return c.json(version);
+    });
+    /**
+     * POST /docs/:id/restore/:versionId
+     * Restore document to a specific version
+     */
+    router.post('/:id/restore/:versionId', async (c) => {
+        const id = c.req.param('id');
+        const versionId = c.req.param('versionId');
+        const body = await c.req.json().catch(() => ({}));
+        try {
+            const result = await versioningService.restoreVersion(id, versionId, {
+                restoredBy: body.restoredBy,
+                restoredByName: body.restoredByName,
+            });
+            return c.json(result);
+        }
+        catch (error) {
+            return c.json({ message: error.message }, 400);
+        }
+    });
+    /**
+     * GET /docs/:id/compare
+     * Compare two versions
+     */
+    router.get('/:id/compare', async (c) => {
+        const id = c.req.param('id');
+        const v1 = c.req.query('v1');
+        const v2 = c.req.query('v2');
+        if (!v1 || !v2) {
+            return c.json({ message: 'Missing version IDs (v1 and v2 required)' }, 400);
+        }
+        try {
+            const diff = await versioningService.compareVersions(v1, v2);
+            return c.json(diff);
+        }
+        catch (error) {
+            return c.json({ message: error.message }, 400);
+        }
+    });
+    /**
+     * DELETE /docs/versions/:versionId
+     * Delete a version
+     */
+    router.delete('/versions/:versionId', async (c) => {
+        const versionId = c.req.param('versionId');
+        try {
+            await versioningService.deleteVersion(versionId);
+            return c.body(null, 204);
+        }
+        catch (error) {
+            return c.json({ message: 'Failed to delete version' }, 500);
+        }
+    });
+    /**
+     * ============================================================================
+     * COLLABORATION ROUTES
+     * ============================================================================
+     */
+    /**
+     * GET /docs/:id/collaborators
+     * Get active collaborators for a document
+     */
+    router.get('/:id/collaborators', async (c) => {
+        const id = c.req.param('id');
+        const doc = await docsService.getById(id);
+        if (!doc) {
+            return c.json({ message: 'Document not found' }, 404);
+        }
+        const users = await collaborationService.getActiveUsers(id);
+        return c.json({ items: users });
+    });
+    /**
+     * POST /docs/:id/cleanup-presence
+     * Clean up stale presence records (admin/maintenance)
+     */
+    router.post('/cleanup-presence', async (c) => {
+        const count = await collaborationService.cleanupStalePresence();
+        return c.json({ removed: count });
+    });
+    return router;
+}