create-pxlr 1.0.0

package/templates/clean/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);
+  });
+}

package/templates/clean/pxlr-cms/packages/api/src/modules/schema/routes.ts

@@ -0,0 +1,284 @@
+import { FastifyPluginAsync } from 'fastify';
+import { z } from 'zod';
+import { db } from '../../database/index.js';
+import { redis } from '../../database/redis.js';
+
+// Schema field types (like Sanity)
+export type FieldType = 
+  | 'string'
+  | 'text'
+  | 'number'
+  | 'boolean'
+  | 'date'
+  | 'datetime'
+  | 'richText'
+  | 'image'
+  | 'file'
+  | 'reference'
+  | 'array'
+  | 'object'
+  | 'slug'
+  | 'url'
+  | 'email'
+  | 'color';
+
+export interface SchemaField {
+  name: string;
+  type: FieldType;
+  title?: string;
+  description?: string;
+  required?: boolean;
+  localized?: boolean;
+  hidden?: boolean;
+  readOnly?: boolean;
+  options?: Record<string, any>;
+  validation?: any[];
+  of?: SchemaField[]; // For array type
+  fields?: SchemaField[]; // For object type
+  to?: string | string[]; // For reference type
+}
+
+export interface SchemaDefinition {
+  name: string;
+  title: string;
+  description?: string;
+  icon?: string;
+  fields: SchemaField[];
+  preview?: {
+    select: Record<string, string>;
+    prepare?: string;
+  };
+}
+
+const schemaFieldSchema = z.object({
+  name: z.string().min(1),
+  type: z.string(),
+  title: z.string().optional(),
+  description: z.string().optional(),
+  required: z.boolean().optional(),
+  localized: z.boolean().optional(),
+  hidden: z.boolean().optional(),
+  readOnly: z.boolean().optional(),
+  options: z.record(z.any()).optional(),
+  validation: z.array(z.any()).optional(),
+  of: z.array(z.any()).optional(),
+  fields: z.array(z.any()).optional(),
+  to: z.union([z.string(), z.array(z.string())]).optional(),
+});
+
+const createSchemaSchema = z.object({
+  name: z.string().min(1).regex(/^[a-zA-Z][a-zA-Z0-9_]*$/, {
+    message: 'Name must start with a letter and contain only letters, numbers, and underscores (e.g. blogPost, my_page)',
+  }),
+  title: z.string().min(1),
+  description: z.string().optional(),
+  icon: z.string().optional(),
+  fields: z.array(schemaFieldSchema),
+  isSingleton: z.boolean().optional(),
+});
+
+export const schemaRoutes: FastifyPluginAsync = async (fastify) => {
+  // List all schemas
+  fastify.get('/', {
+    schema: {
+      tags: ['Schemas'],
+      summary: 'List all content schemas',
+    },
+  }, async () => {
+    // Try cache first
+    const cached = await redis.get<any[]>('schemas:all');
+    if (cached) {
+      return { schemas: cached };
+    }
+
+    const result = await db.query(
+      `SELECT id, name, title, description, icon, is_singleton, sort_order, 
+              definition, version, created_at, updated_at 
+       FROM schemas 
+       ORDER BY sort_order, title`
+    );
+
+    const schemas = result.rows.map(row => ({
+      ...row,
+      definition: row.definition,
+    }));
+
+    // Cache for 5 minutes
+    await redis.set('schemas:all', schemas, 300);
+
+    return { schemas };
+  });
+
+  // Get single schema
+  fastify.get('/:name', {
+    schema: {
+      tags: ['Schemas'],
+      summary: 'Get schema by name',
+      params: {
+        type: 'object',
+        properties: {
+          name: { type: 'string' },
+        },
+      },
+    },
+  }, async (request, reply) => {
+    const { name } = request.params as { name: string };
+
+    const result = await db.query(
+      `SELECT id, name, title, description, icon, is_singleton, 
+              definition, version, created_at, updated_at 
+       FROM schemas WHERE name = $1`,
+      [name]
+    );
+
+    if (result.rows.length === 0) {
+      return reply.status(404).send({ error: true, message: 'Schema not found' });
+    }
+
+    return { schema: result.rows[0] };
+  });
+
+  // Create schema
+  fastify.post('/', {
+    schema: {
+      tags: ['Schemas'],
+      summary: 'Create a new content schema',
+      security: [{ bearerAuth: [] }],
+    },
+    preHandler: [fastify.authenticate],
+  }, async (request, reply) => {
+    const body = createSchemaSchema.parse(request.body);
+
+    // Check if schema exists
+    const existing = await db.query(
+      'SELECT id FROM schemas WHERE name = $1',
+      [body.name]
+    );
+
+    if (existing.rows.length > 0) {
+      return reply.status(400).send({ error: true, message: 'Schema already exists' });
+    }
+
+    const definition: SchemaDefinition = {
+      name: body.name,
+      title: body.title,
+      description: body.description,
+      icon: body.icon,
+      fields: body.fields as SchemaField[],
+    };
+
+    const result = await db.query(
+      `INSERT INTO schemas (name, title, description, icon, is_singleton, definition) 
+       VALUES ($1, $2, $3, $4, $5, $6) 
+       RETURNING id, name, title, description, icon, is_singleton, definition, created_at`,
+      [body.name, body.title, body.description, body.icon, body.isSingleton || false, definition]
+    );
+
+    // Invalidate cache
+    await redis.del('schemas:all');
+
+    return { schema: result.rows[0] };
+  });
+
+  // Update schema
+  fastify.put('/:name', {
+    schema: {
+      tags: ['Schemas'],
+      summary: 'Update a content schema',
+      security: [{ bearerAuth: [] }],
+    },
+    preHandler: [fastify.authenticate],
+  }, async (request, reply) => {
+    const { name } = request.params as { name: string };
+    const body = createSchemaSchema.partial().parse(request.body);
+
+    const existing = await db.query(
+      'SELECT id, version FROM schemas WHERE name = $1',
+      [name]
+    );
+
+    if (existing.rows.length === 0) {
+      return reply.status(404).send({ error: true, message: 'Schema not found' });
+    }
+
+    const updates: string[] = [];
+    const values: any[] = [];
+    let paramIndex = 1;
+
+    if (body.title) {
+      updates.push(`title = $${paramIndex++}`);
+      values.push(body.title);
+    }
+    if (body.description !== undefined) {
+      updates.push(`description = $${paramIndex++}`);
+      values.push(body.description);
+    }
+    if (body.icon !== undefined) {
+      updates.push(`icon = $${paramIndex++}`);
+      values.push(body.icon);
+    }
+    if (body.isSingleton !== undefined) {
+      updates.push(`is_singleton = $${paramIndex++}`);
+      values.push(body.isSingleton);
+    }
+    if (body.fields) {
+      const definition: SchemaDefinition = {
+        name: body.name || name,
+        title: body.title || '',
+        description: body.description,
+        fields: body.fields as SchemaField[],
+      };
+      updates.push(`definition = $${paramIndex++}`);
+      values.push(definition);
+    }
+
+    // Increment version
+    updates.push(`version = version + 1`);
+
+    values.push(name);
+
+    const result = await db.query(
+      `UPDATE schemas SET ${updates.join(', ')} 
+       WHERE name = $${paramIndex} 
+       RETURNING *`,
+      values
+    );
+
+    // Invalidate cache
+    await redis.del('schemas:all');
+
+    return { schema: result.rows[0] };
+  });
+
+  // Delete schema
+  fastify.delete('/:name', {
+    schema: {
+      tags: ['Schemas'],
+      summary: 'Delete a content schema',
+      security: [{ bearerAuth: [] }],
+    },
+    preHandler: [fastify.authenticate],
+  }, async (request, reply) => {
+    const { name } = request.params as { name: string };
+
+    // Check if documents exist
+    const docsCount = await db.query(
+      'SELECT COUNT(*) FROM documents WHERE schema_name = $1',
+      [name]
+    );
+
+    if (parseInt(docsCount.rows[0].count) > 0) {
+      return reply.status(400).send({ 
+        error: true, 
+        message: 'Cannot delete schema with existing documents' 
+      });
+    }
+
+    await db.query('DELETE FROM schemas WHERE name = $1', [name]);
+
+    // Invalidate cache
+    await redis.del('schemas:all');
+
+    return { success: true, message: 'Schema deleted' };
+  });
+};

package/templates/clean/pxlr-cms/packages/api/src/modules/versions/routes.ts

@@ -0,0 +1,70 @@
+// Version management is integrated into content routes
+// This file exports types and utilities for versioning
+
+export interface DocumentVersion {
+  id: string;
+  documentId: string;
+  version: number;
+  data: Record<string, any>;
+  locale: string;
+  changeSummary?: string;
+  createdBy: string;
+  createdAt: Date;
+}
+
+export interface VersionDiff {
+  field: string;
+  oldValue: any;
+  newValue: any;
+  type: 'added' | 'removed' | 'changed';
+}
+
+/**
+ * Compare two versions and return the differences
+ */
+export function compareVersions(oldData: Record<string, any>, newData: Record<string, any>): VersionDiff[] {
+  const diffs: VersionDiff[] = [];
+  const allKeys = new Set([...Object.keys(oldData), ...Object.keys(newData)]);
+
+  for (const key of allKeys) {
+    const oldValue = oldData[key];
+    const newValue = newData[key];
+
+    if (oldValue === undefined && newValue !== undefined) {
+      diffs.push({ field: key, oldValue, newValue, type: 'added' });
+    } else if (oldValue !== undefined && newValue === undefined) {
+      diffs.push({ field: key, oldValue, newValue, type: 'removed' });
+    } else if (JSON.stringify(oldValue) !== JSON.stringify(newValue)) {
+      diffs.push({ field: key, oldValue, newValue, type: 'changed' });
+    }
+  }
+
+  return diffs;
+}
+
+/**
+ * Generate a human-readable summary of changes
+ */
+export function generateChangeSummary(diffs: VersionDiff[]): string {
+  if (diffs.length === 0) {
+    return 'No changes';
+  }
+
+  const parts: string[] = [];
+  
+  const added = diffs.filter(d => d.type === 'added');
+  const removed = diffs.filter(d => d.type === 'removed');
+  const changed = diffs.filter(d => d.type === 'changed');
+
+  if (added.length > 0) {
+    parts.push(`Added: ${added.map(d => d.field).join(', ')}`);
+  }
+  if (removed.length > 0) {
+    parts.push(`Removed: ${removed.map(d => d.field).join(', ')}`);
+  }
+  if (changed.length > 0) {
+    parts.push(`Changed: ${changed.map(d => d.field).join(', ')}`);
+  }
+
+  return parts.join('; ');
+}

package/templates/clean/pxlr-cms/packages/api/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"]
+    }
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/templates/clean/pxlr-cms/packages/shared/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@pxlr/shared",
+  "version": "1.0.0",
+  "description": "Shared types and utilities for PXLR CMS",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.0"
+  }
+}