pxlr-cms 1.0.0

package/templates/blog/pxlr-cms/packages/api/src/modules/media/routes.ts

@@ -0,0 +1,312 @@
+import { FastifyPluginAsync } from 'fastify';
+import { z } from 'zod';
+import { v4 as uuid } from 'uuid';
+import * as Minio from 'minio';
+import sharp from 'sharp';
+import { db } from '../../database/index.js';
+import { config } from '../../config.js';
+
+// Initialize MinIO client
+const minioClient = new Minio.Client({
+  endPoint: config.minio.endpoint,
+  port: config.minio.port,
+  useSSL: config.minio.useSSL,
+  accessKey: config.minio.accessKey,
+  secretKey: config.minio.secretKey,
+});
+
+const updateMediaSchema = z.object({
+  altText: z.string().optional(),
+  caption: z.string().optional(),
+  folder: z.string().optional(),
+});
+
+const querySchema = z.object({
+  folder: z.string().optional(),
+  mimeType: z.string().optional(),
+  page: z.coerce.number().min(1).default(1),
+  limit: z.coerce.number().min(1).max(100).default(20),
+  search: z.string().optional(),
+});
+
+// Ensure bucket exists with public read policy
+async function ensureBucket() {
+  const exists = await minioClient.bucketExists(config.minio.bucket);
+  if (!exists) {
+    await minioClient.makeBucket(config.minio.bucket);
+  }
+  
+  // Always ensure public read policy is set
+  const policy = {
+    Version: '2012-10-17',
+    Statement: [
+      {
+        Effect: 'Allow',
+        Principal: { AWS: ['*'] },
+        Action: ['s3:GetObject'],
+        Resource: [`arn:aws:s3:::${config.minio.bucket}/*`],
+      },
+    ],
+  };
+  
+  try {
+    await minioClient.setBucketPolicy(config.minio.bucket, JSON.stringify(policy));
+  } catch (err) {
+    console.log('Bucket policy already set or error:', err);
+  }
+}
+
+export const mediaRoutes: FastifyPluginAsync = async (fastify) => {
+  // Ensure bucket on startup
+  await ensureBucket();
+
+  // List media files
+  fastify.get('/', {
+    schema: {
+      tags: ['Media'],
+      summary: 'List media files with filtering',
+    },
+  }, async (request) => {
+    const query = querySchema.parse(request.query);
+    const offset = (query.page - 1) * query.limit;
+
+    let whereClause = 'WHERE 1=1';
+    const params: any[] = [];
+    let paramIndex = 1;
+
+    if (query.folder) {
+      whereClause += ` AND folder = $${paramIndex++}`;
+      params.push(query.folder);
+    }
+    if (query.mimeType) {
+      whereClause += ` AND mime_type LIKE $${paramIndex++}`;
+      params.push(`${query.mimeType}%`);
+    }
+    if (query.search) {
+      whereClause += ` AND (original_filename ILIKE $${paramIndex} OR alt_text ILIKE $${paramIndex})`;
+      params.push(`%${query.search}%`);
+      paramIndex++;
+    }
+
+    // Count total
+    const countResult = await db.query(
+      `SELECT COUNT(*) FROM media ${whereClause}`,
+      params
+    );
+    const total = parseInt(countResult.rows[0].count);
+
+    // Get files
+    params.push(query.limit, offset);
+    const result = await db.query(
+      `SELECT m.*, u.name as uploaded_by_name
+       FROM media m
+       LEFT JOIN users u ON m.uploaded_by = u.id
+       ${whereClause}
+       ORDER BY m.created_at DESC
+       LIMIT $${paramIndex++} OFFSET $${paramIndex}`,
+      params
+    );
+
+    return {
+      files: result.rows,
+      pagination: {
+        page: query.page,
+        limit: query.limit,
+        total,
+        totalPages: Math.ceil(total / query.limit),
+      },
+    };
+  });
+
+  // Get single media file
+  fastify.get('/:id', {
+    schema: {
+      tags: ['Media'],
+      summary: 'Get media file by ID',
+    },
+  }, async (request, reply) => {
+    const { id } = request.params as { id: string };
+
+    const result = await db.query(
+      `SELECT m.*, u.name as uploaded_by_name
+       FROM media m
+       LEFT JOIN users u ON m.uploaded_by = u.id
+       WHERE m.id = $1`,
+      [id]
+    );
+
+    if (result.rows.length === 0) {
+      return reply.status(404).send({ error: true, message: 'File not found' });
+    }
+
+    return { file: result.rows[0] };
+  });
+
+  // Upload media file
+  fastify.post('/upload', {
+    schema: {
+      tags: ['Media'],
+      summary: 'Upload a media file',
+      security: [{ bearerAuth: [] }],
+    },
+    preHandler: [fastify.authenticate],
+  }, async (request, reply) => {
+    const user = request.user as { id: string };
+    const data = await request.file();
+
+    if (!data) {
+      return reply.status(400).send({ error: true, message: 'No file uploaded' });
+    }
+
+    const buffer = await data.toBuffer();
+    const fileId = uuid();
+    const ext = data.filename.split('.').pop() || '';
+    const filename = `${fileId}.${ext}`;
+    const mimeType = data.mimetype;
+
+    let width: number | undefined;
+    let height: number | undefined;
+    let thumbnailUrl: string | undefined;
+
+    // Process images
+    if (mimeType.startsWith('image/')) {
+      try {
+        const metadata = await sharp(buffer).metadata();
+        width = metadata.width;
+        height = metadata.height;
+
+        // Create thumbnail
+        const thumbnail = await sharp(buffer)
+          .resize(300, 300, { fit: 'inside' })
+          .jpeg({ quality: 80 })
+          .toBuffer();
+
+        const thumbnailFilename = `thumbnails/${fileId}.jpg`;
+        await minioClient.putObject(config.minio.bucket, thumbnailFilename, thumbnail, {
+          'Content-Type': 'image/jpeg',
+        });
+        thumbnailUrl = `${config.minio.publicUrl}/${config.minio.bucket}/${thumbnailFilename}`;
+      } catch (err) {
+        fastify.log.warn('Failed to process image:', err);
+      }
+    }
+
+    // Upload original file
+    await minioClient.putObject(config.minio.bucket, filename, buffer, {
+      'Content-Type': mimeType,
+    });
+
+    const url = `${config.minio.publicUrl}/${config.minio.bucket}/${filename}`;
+
+    // Save to database
+    const result = await db.query(
+      `INSERT INTO media (id, filename, original_filename, mime_type, size_bytes, width, height, url, thumbnail_url, uploaded_by)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+       RETURNING *`,
+      [fileId, filename, data.filename, mimeType, buffer.length, width, height, url, thumbnailUrl, user.id]
+    );
+
+    return { file: result.rows[0] };
+  });
+
+  // Update media metadata
+  fastify.put('/:id', {
+    schema: {
+      tags: ['Media'],
+      summary: 'Update media file metadata',
+      security: [{ bearerAuth: [] }],
+    },
+    preHandler: [fastify.authenticate],
+  }, async (request, reply) => {
+    const { id } = request.params as { id: string };
+    const body = updateMediaSchema.parse(request.body);
+
+    const existing = await db.query('SELECT id FROM media WHERE id = $1', [id]);
+    if (existing.rows.length === 0) {
+      return reply.status(404).send({ error: true, message: 'File not found' });
+    }
+
+    const updates: string[] = [];
+    const values: any[] = [];
+    let paramIndex = 1;
+
+    if (body.altText !== undefined) {
+      updates.push(`alt_text = $${paramIndex++}`);
+      values.push(body.altText);
+    }
+    if (body.caption !== undefined) {
+      updates.push(`caption = $${paramIndex++}`);
+      values.push(body.caption);
+    }
+    if (body.folder !== undefined) {
+      updates.push(`folder = $${paramIndex++}`);
+      values.push(body.folder);
+    }
+
+    if (updates.length === 0) {
+      return reply.status(400).send({ error: true, message: 'No updates provided' });
+    }
+
+    values.push(id);
+    const result = await db.query(
+      `UPDATE media SET ${updates.join(', ')} WHERE id = $${paramIndex} RETURNING *`,
+      values
+    );
+
+    return { file: result.rows[0] };
+  });
+
+  // Delete media file
+  fastify.delete('/:id', {
+    schema: {
+      tags: ['Media'],
+      summary: 'Delete a media file',
+      security: [{ bearerAuth: [] }],
+    },
+    preHandler: [fastify.authenticate],
+  }, async (request, reply) => {
+    const { id } = request.params as { id: string };
+
+    const result = await db.query(
+      'SELECT filename FROM media WHERE id = $1',
+      [id]
+    );
+
+    if (result.rows.length === 0) {
+      return reply.status(404).send({ error: true, message: 'File not found' });
+    }
+
+    const { filename } = result.rows[0];
+
+    // Delete from MinIO
+    try {
+      await minioClient.removeObject(config.minio.bucket, filename);
+      // Try to delete thumbnail
+      await minioClient.removeObject(config.minio.bucket, `thumbnails/${id}.jpg`).catch(() => {});
+    } catch (err) {
+      fastify.log.warn('Failed to delete file from storage:', err);
+    }
+
+    // Delete from database
+    await db.query('DELETE FROM media WHERE id = $1', [id]);
+
+    return { success: true, message: 'File deleted' };
+  });
+
+  // Get folders
+  fastify.get('/folders', {
+    schema: {
+      tags: ['Media'],
+      summary: 'Get list of media folders',
+    },
+  }, async () => {
+    const result = await db.query(
+      `SELECT DISTINCT folder, COUNT(*) as count 
+       FROM media 
+       GROUP BY folder 
+       ORDER BY folder`
+    );
+
+    return { folders: result.rows };
+  });
+};

package/templates/blog/pxlr-cms/packages/api/src/modules/realtime/handler.ts

@@ -0,0 +1,228 @@
+import { SocketStream } from '@fastify/websocket';
+import { FastifyRequest } from 'fastify';
+import { redis } from '../../database/redis.js';
+import { db } from '../../database/index.js';
+import { v4 as uuid } from 'uuid';
+
+interface WebSocketMessage {
+  type: string;
+  payload: any;
+}
+
+interface ConnectedClient {
+  id: string;
+  userId?: string;
+  documentId?: string;
+  userName?: string;
+}
+
+const connectedClients = new Map<string, ConnectedClient>();
+
+export async function realtimeHandler(socket: SocketStream, request: FastifyRequest) {
+  const clientId = uuid();
+  const client: ConnectedClient = { id: clientId };
+  connectedClients.set(clientId, client);
+
+  console.log(`Client connected: ${clientId}`);
+
+  // Subscribe to Redis channels for real-time updates
+  const subscriber = redis.getSubscriber();
+  
+  const channels = ['content:created', 'content:updated', 'content:deleted', 'presence:update'];
+  
+  for (const channel of channels) {
+    await subscriber.subscribe(channel);
+  }
+
+  subscriber.on('message', (channel, message) => {
+    try {
+      const data = JSON.parse(message);
+      
+      // Only send relevant updates to this client
+      if (channel.startsWith('content:')) {
+        // If client is editing a document, send updates for that document
+        if (client.documentId && data.documentId === client.documentId) {
+          socket.send(JSON.stringify({ type: channel, payload: data }));
+        }
+      } else if (channel === 'presence:update') {
+        // Send presence updates for the same document
+        if (client.documentId && data.documentId === client.documentId) {
+          socket.send(JSON.stringify({ type: 'presence', payload: data }));
+        }
+      }
+    } catch (err) {
+      console.error('Failed to process Redis message:', err);
+    }
+  });
+
+  // Handle incoming messages
+  socket.on('message', async (rawMessage) => {
+    try {
+      const message: WebSocketMessage = JSON.parse(rawMessage.toString());
+
+      switch (message.type) {
+        case 'auth': {
+          // Authenticate client
+          const { userId, userName } = message.payload;
+          client.userId = userId;
+          client.userName = userName;
+          
+          socket.send(JSON.stringify({
+            type: 'auth:success',
+            payload: { clientId },
+          }));
+          break;
+        }
+
+        case 'join:document': {
+          // Join a document for collaborative editing
+          const { documentId } = message.payload;
+          client.documentId = documentId;
+
+          // Record active session
+          if (client.userId) {
+            await db.query(
+              `INSERT INTO active_sessions (user_id, document_id, socket_id) 
+               VALUES ($1, $2, $3)
+               ON CONFLICT (user_id, document_id) DO UPDATE SET 
+               socket_id = $3, last_active_at = CURRENT_TIMESTAMP`,
+              [client.userId, documentId, clientId]
+            );
+          }
+
+          // Get other users editing this document
+          const sessionsResult = await db.query(
+            `SELECT s.user_id, u.name, u.avatar_url, s.cursor_position
+             FROM active_sessions s
+             JOIN users u ON s.user_id = u.id
+             WHERE s.document_id = $1 AND s.socket_id != $2`,
+            [documentId, clientId]
+          );
+
+          // Notify others that this user joined
+          await redis.publish('presence:update', {
+            type: 'user:joined',
+            documentId,
+            user: {
+              id: client.userId,
+              name: client.userName,
+              clientId,
+            },
+          });
+
+          socket.send(JSON.stringify({
+            type: 'document:joined',
+            payload: {
+              documentId,
+              activeUsers: sessionsResult.rows,
+            },
+          }));
+          break;
+        }
+
+        case 'leave:document': {
+          // Leave document editing
+          if (client.documentId && client.userId) {
+            await db.query(
+              'DELETE FROM active_sessions WHERE user_id = $1 AND document_id = $2',
+              [client.userId, client.documentId]
+            );
+
+            await redis.publish('presence:update', {
+              type: 'user:left',
+              documentId: client.documentId,
+              user: {
+                id: client.userId,
+                name: client.userName,
+                clientId,
+              },
+            });
+          }
+          client.documentId = undefined;
+          break;
+        }
+
+        case 'cursor:update': {
+          // Update cursor position for collaborative editing
+          const { position } = message.payload;
+          
+          if (client.documentId && client.userId) {
+            await db.query(
+              `UPDATE active_sessions SET cursor_position = $1, last_active_at = CURRENT_TIMESTAMP
+               WHERE user_id = $2 AND document_id = $3`,
+              [position, client.userId, client.documentId]
+            );
+
+            await redis.publish('presence:update', {
+              type: 'cursor:moved',
+              documentId: client.documentId,
+              user: {
+                id: client.userId,
+                name: client.userName,
+                clientId,
+              },
+              position,
+            });
+          }
+          break;
+        }
+
+        case 'content:change': {
+          // Broadcast content changes for real-time sync
+          const { changes, documentId } = message.payload;
+          
+          await redis.publish('content:updated', {
+            documentId,
+            changes,
+            userId: client.userId,
+            clientId,
+          });
+          break;
+        }
+
+        case 'ping': {
+          socket.send(JSON.stringify({ type: 'pong', payload: { timestamp: Date.now() } }));
+          break;
+        }
+
+        default:
+          console.log('Unknown message type:', message.type);
+      }
+    } catch (err) {
+      console.error('Failed to handle WebSocket message:', err);
+      socket.send(JSON.stringify({
+        type: 'error',
+        payload: { message: 'Failed to process message' },
+      }));
+    }
+  });
+
+  // Handle disconnect
+  socket.on('close', async () => {
+    console.log(`Client disconnected: ${clientId}`);
+
+    // Clean up session
+    if (client.userId && client.documentId) {
+      await db.query(
+        'DELETE FROM active_sessions WHERE user_id = $1 AND document_id = $2',
+        [client.userId, client.documentId]
+      );
+
+      await redis.publish('presence:update', {
+        type: 'user:left',
+        documentId: client.documentId,
+        user: {
+          id: client.userId,
+          name: client.userName,
+          clientId,
+        },
+      });
+    }
+
+    connectedClients.delete(clientId);
+  });
+
+  socket.on('error', (err) => {
+    console.error('WebSocket error:', err);
+  });
+}