pxlr-cms 1.0.0

package/templates/clean/pxlr-cms/packages/api/src/database/init.sql

@@ -0,0 +1,178 @@
+-- PXLR CMS Database Schema
+-- PostgreSQL initialization script
+
+-- Enable UUID extension
+CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
+CREATE EXTENSION IF NOT EXISTS "pgcrypto";
+
+-- Users table
+CREATE TABLE IF NOT EXISTS users (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    email VARCHAR(255) UNIQUE NOT NULL,
+    password_hash VARCHAR(255) NOT NULL,
+    name VARCHAR(255),
+    role VARCHAR(50) DEFAULT 'editor' CHECK (role IN ('admin', 'editor', 'viewer')),
+    avatar_url TEXT,
+    is_active BOOLEAN DEFAULT true,
+    last_login_at TIMESTAMP WITH TIME ZONE,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Schema definitions table
+CREATE TABLE IF NOT EXISTS schemas (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    name VARCHAR(255) UNIQUE NOT NULL,
+    title VARCHAR(255) NOT NULL,
+    description TEXT,
+    definition JSONB NOT NULL,
+    icon VARCHAR(50),
+    is_singleton BOOLEAN DEFAULT false,
+    sort_order INTEGER DEFAULT 0,
+    version INTEGER DEFAULT 1,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Documents table (main content storage)
+CREATE TABLE IF NOT EXISTS documents (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    schema_name VARCHAR(255) NOT NULL REFERENCES schemas(name) ON DELETE RESTRICT,
+    data JSONB NOT NULL DEFAULT '{}',
+    locale VARCHAR(10) DEFAULT 'en',
+    status VARCHAR(50) DEFAULT 'draft' CHECK (status IN ('draft', 'published', 'archived')),
+    published_at TIMESTAMP WITH TIME ZONE,
+    created_by UUID REFERENCES users(id),
+    updated_by UUID REFERENCES users(id),
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Document versions table (for version history)
+CREATE TABLE IF NOT EXISTS document_versions (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    document_id UUID NOT NULL REFERENCES documents(id) ON DELETE CASCADE,
+    version INTEGER NOT NULL,
+    data JSONB NOT NULL,
+    locale VARCHAR(10) DEFAULT 'en',
+    change_summary TEXT,
+    created_by UUID REFERENCES users(id),
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+    UNIQUE(document_id, version, locale)
+);
+
+-- Media files table
+CREATE TABLE IF NOT EXISTS media (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    filename VARCHAR(255) NOT NULL,
+    original_filename VARCHAR(255) NOT NULL,
+    mime_type VARCHAR(100) NOT NULL,
+    size_bytes BIGINT NOT NULL,
+    width INTEGER,
+    height INTEGER,
+    url TEXT NOT NULL,
+    thumbnail_url TEXT,
+    alt_text TEXT,
+    caption TEXT,
+    metadata JSONB DEFAULT '{}',
+    folder VARCHAR(255) DEFAULT '/',
+    uploaded_by UUID REFERENCES users(id),
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Locales table
+CREATE TABLE IF NOT EXISTS locales (
+    code VARCHAR(10) PRIMARY KEY,
+    name VARCHAR(100) NOT NULL,
+    native_name VARCHAR(100),
+    is_default BOOLEAN DEFAULT false,
+    is_active BOOLEAN DEFAULT true,
+    sort_order INTEGER DEFAULT 0,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Sessions table (for real-time collaboration)
+CREATE TABLE IF NOT EXISTS active_sessions (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    document_id UUID REFERENCES documents(id) ON DELETE CASCADE,
+    socket_id VARCHAR(255),
+    cursor_position JSONB,
+    last_active_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+);
+
+-- API Keys table (for external access)
+CREATE TABLE IF NOT EXISTS api_keys (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    name VARCHAR(255) NOT NULL,
+    key_hash VARCHAR(255) UNIQUE NOT NULL,
+    permissions JSONB DEFAULT '["read"]',
+    last_used_at TIMESTAMP WITH TIME ZONE,
+    expires_at TIMESTAMP WITH TIME ZONE,
+    is_active BOOLEAN DEFAULT true,
+    created_by UUID REFERENCES users(id),
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Webhooks table
+CREATE TABLE IF NOT EXISTS webhooks (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    name VARCHAR(255) NOT NULL,
+    url TEXT NOT NULL,
+    events JSONB NOT NULL DEFAULT '[]',
+    secret VARCHAR(255),
+    is_active BOOLEAN DEFAULT true,
+    last_triggered_at TIMESTAMP WITH TIME ZONE,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Indexes for performance
+CREATE INDEX IF NOT EXISTS idx_documents_schema ON documents(schema_name);
+CREATE INDEX IF NOT EXISTS idx_documents_status ON documents(status);
+CREATE INDEX IF NOT EXISTS idx_documents_locale ON documents(locale);
+CREATE INDEX IF NOT EXISTS idx_documents_created_at ON documents(created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_documents_data_gin ON documents USING GIN(data);
+CREATE INDEX IF NOT EXISTS idx_document_versions_document ON document_versions(document_id);
+CREATE INDEX IF NOT EXISTS idx_media_folder ON media(folder);
+CREATE INDEX IF NOT EXISTS idx_media_mime ON media(mime_type);
+CREATE INDEX IF NOT EXISTS idx_active_sessions_document ON active_sessions(document_id);
+CREATE INDEX IF NOT EXISTS idx_active_sessions_user ON active_sessions(user_id);
+
+-- Trigger function for updated_at
+CREATE OR REPLACE FUNCTION update_updated_at_column()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.updated_at = CURRENT_TIMESTAMP;
+    RETURN NEW;
+END;
+$$ language 'plpgsql';
+
+-- Apply updated_at trigger to tables
+CREATE TRIGGER update_users_updated_at BEFORE UPDATE ON users
+    FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();
+
+CREATE TRIGGER update_schemas_updated_at BEFORE UPDATE ON schemas
+    FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();
+
+CREATE TRIGGER update_documents_updated_at BEFORE UPDATE ON documents
+    FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();
+
+CREATE TRIGGER update_media_updated_at BEFORE UPDATE ON media
+    FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();
+
+CREATE TRIGGER update_webhooks_updated_at BEFORE UPDATE ON webhooks
+    FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();
+
+-- Insert default locale
+INSERT INTO locales (code, name, native_name, is_default, is_active, sort_order) VALUES
+    ('en', 'English', 'English', true, true, 0),
+    ('ru', 'Russian', 'Русский', false, true, 1)
+ON CONFLICT (code) DO NOTHING;
+
+-- Insert default admin user (password: admin123)
+INSERT INTO users (email, password_hash, name, role) VALUES
+    ('admin@pxlr.local', crypt('admin123', gen_salt('bf')), 'Administrator', 'admin')
+ON CONFLICT (email) DO NOTHING;

package/templates/clean/pxlr-cms/packages/api/src/database/redis.ts

@@ -0,0 +1,95 @@
+import Redis from 'ioredis';
+import { config } from '../config.js';
+
+class RedisClient {
+  private client: Redis | null = null;
+  private subscriber: Redis | null = null;
+
+  async connect() {
+    this.client = new Redis(config.redisUrl, {
+      maxRetriesPerRequest: 3,
+      retryStrategy: (times) => {
+        if (times > 3) {
+          return null;
+        }
+        return Math.min(times * 100, 3000);
+      },
+    });
+
+    this.subscriber = new Redis(config.redisUrl);
+
+    // Wait for connection
+    await new Promise<void>((resolve, reject) => {
+      this.client!.once('ready', resolve);
+      this.client!.once('error', reject);
+    });
+  }
+
+  async disconnect() {
+    if (this.client) {
+      await this.client.quit();
+      this.client = null;
+    }
+    if (this.subscriber) {
+      await this.subscriber.quit();
+      this.subscriber = null;
+    }
+  }
+
+  getClient(): Redis {
+    if (!this.client) {
+      throw new Error('Redis not connected');
+    }
+    return this.client;
+  }
+
+  getSubscriber(): Redis {
+    if (!this.subscriber) {
+      throw new Error('Redis subscriber not connected');
+    }
+    return this.subscriber;
+  }
+
+  // Cache helpers
+  async get<T>(key: string): Promise<T | null> {
+    const value = await this.getClient().get(key);
+    if (!value) return null;
+    return JSON.parse(value) as T;
+  }
+
+  async set(key: string, value: any, ttlSeconds?: number): Promise<void> {
+    const serialized = JSON.stringify(value);
+    if (ttlSeconds) {
+      await this.getClient().setex(key, ttlSeconds, serialized);
+    } else {
+      await this.getClient().set(key, serialized);
+    }
+  }
+
+  async del(key: string): Promise<void> {
+    await this.getClient().del(key);
+  }
+
+  async invalidatePattern(pattern: string): Promise<void> {
+    const keys = await this.getClient().keys(pattern);
+    if (keys.length > 0) {
+      await this.getClient().del(...keys);
+    }
+  }
+
+  // Pub/Sub for real-time
+  async publish(channel: string, message: any): Promise<void> {
+    await this.getClient().publish(channel, JSON.stringify(message));
+  }
+
+  async subscribe(channel: string, callback: (message: any) => void): Promise<void> {
+    await this.getSubscriber().subscribe(channel);
+    this.getSubscriber().on('message', (ch, msg) => {
+      if (ch === channel) {
+        callback(JSON.parse(msg));
+      }
+    });
+  }
+}
+
+export const redis = new RedisClient();

package/templates/clean/pxlr-cms/packages/api/src/index.ts

@@ -0,0 +1,157 @@
+import Fastify from 'fastify';
+import cors from '@fastify/cors';
+import helmet from '@fastify/helmet';
+import jwt from '@fastify/jwt';
+import multipart from '@fastify/multipart';
+import rateLimit from '@fastify/rate-limit';
+import websocket from '@fastify/websocket';
+import swagger from '@fastify/swagger';
+import swaggerUi from '@fastify/swagger-ui';
+
+import { config } from './config.js';
+import { db } from './database/index.js';
+import { redis } from './database/redis.js';
+import { authRoutes } from './modules/auth/routes.js';
+import { contentRoutes } from './modules/content/routes.js';
+import { schemaRoutes } from './modules/schema/routes.js';
+import { mediaRoutes } from './modules/media/routes.js';
+import { realtimeHandler } from './modules/realtime/handler.js';
+
+const fastify = Fastify({
+  logger: {
+    level: config.isDev ? 'info' : 'warn',
+  },
+});
+
+async function bootstrap() {
+  // Register plugins
+  await fastify.register(cors, {
+    origin: config.isDev ? true : config.corsOrigins,
+    credentials: true,
+  });
+
+  await fastify.register(helmet, {
+    contentSecurityPolicy: false,
+  });
+
+  await fastify.register(jwt, {
+    secret: config.jwtSecret,
+    sign: {
+      expiresIn: config.jwtExpiresIn,
+    },
+  });
+
+  // Add authenticate decorator
+  fastify.decorate('authenticate', async (request: any, reply: any) => {
+    try {
+      await request.jwtVerify();
+    } catch (err) {
+      reply.status(401).send({ error: true, message: 'Unauthorized' });
+    }
+  });
+
+  await fastify.register(multipart, {
+    limits: {
+      fileSize: 100 * 1024 * 1024, // 100MB
+    },
+  });
+
+  await fastify.register(rateLimit, {
+    max: 100,
+    timeWindow: '1 minute',
+  });
+
+  await fastify.register(websocket);
+
+  // Swagger documentation
+  await fastify.register(swagger, {
+    openapi: {
+      info: {
+        title: 'PXLR CMS API',
+        description: 'Headless CMS API Documentation',
+        version: '1.0.0',
+      },
+      servers: [
+        {
+          url: `http://localhost:${config.port}`,
+          description: 'Development server',
+        },
+      ],
+      components: {
+        securitySchemes: {
+          bearerAuth: {
+            type: 'http',
+            scheme: 'bearer',
+            bearerFormat: 'JWT',
+          },
+        },
+      },
+    },
+  });
+
+  await fastify.register(swaggerUi, {
+    routePrefix: '/docs',
+    uiConfig: {
+      docExpansion: 'list',
+      deepLinking: false,
+    },
+  });
+
+  // Health check
+  fastify.get('/health', async () => {
+    return { status: 'ok', timestamp: new Date().toISOString() };
+  });
+
+  // Register routes
+  await fastify.register(authRoutes, { prefix: '/auth' });
+  await fastify.register(schemaRoutes, { prefix: '/schemas' });
+  await fastify.register(contentRoutes, { prefix: '/content' });
+  await fastify.register(mediaRoutes, { prefix: '/media' });
+
+  // WebSocket for real-time collaboration
+  fastify.get('/ws', { websocket: true }, realtimeHandler);
+
+  // Global error handler
+  fastify.setErrorHandler((error, request, reply) => {
+    fastify.log.error(error);
+    
+    const statusCode = error.statusCode || 500;
+    const message = config.isDev ? error.message : 'Internal Server Error';
+    
+    reply.status(statusCode).send({
+      error: true,
+      message,
+      statusCode,
+    });
+  });
+
+  // Start server
+  try {
+    await db.connect();
+    fastify.log.info('Database connected');
+
+    await redis.connect();
+    fastify.log.info('Redis connected');
+
+    await fastify.listen({ port: config.port, host: '0.0.0.0' });
+    fastify.log.info(`PXLR CMS API running on port ${config.port}`);
+    fastify.log.info(`API Documentation: http://localhost:${config.port}/docs`);
+  } catch (err) {
+    fastify.log.error(err);
+    process.exit(1);
+  }
+}
+
+// Graceful shutdown
+const signals = ['SIGINT', 'SIGTERM'];
+signals.forEach((signal) => {
+  process.on(signal, async () => {
+    console.log(`\nReceived ${signal}, shutting down gracefully...`);
+    await fastify.close();
+    await db.disconnect();
+    await redis.disconnect();
+    process.exit(0);
+  });
+});
+
+bootstrap();

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

@@ -0,0 +1,256 @@
+import { FastifyPluginAsync } from 'fastify';
+import bcrypt from 'bcryptjs';
+import { z } from 'zod';
+import { db } from '../../database/index.js';
+
+const loginSchema = z.object({
+  email: z.string().email(),
+  password: z.string().min(6),
+});
+
+const registerSchema = z.object({
+  email: z.string().email(),
+  password: z.string().min(6),
+  name: z.string().min(2),
+});
+
+export const authRoutes: FastifyPluginAsync = async (fastify) => {
+  // Login
+  fastify.post('/login', {
+    schema: {
+      tags: ['Auth'],
+      summary: 'Login to PXLR CMS',
+      body: {
+        type: 'object',
+        required: ['email', 'password'],
+        properties: {
+          email: { type: 'string', format: 'email' },
+          password: { type: 'string', minLength: 6 },
+        },
+      },
+      response: {
+        200: {
+          type: 'object',
+          properties: {
+            token: { type: 'string' },
+            user: {
+              type: 'object',
+              properties: {
+                id: { type: 'string' },
+                email: { type: 'string' },
+                name: { type: 'string' },
+                role: { type: 'string' },
+              },
+            },
+          },
+        },
+      },
+    },
+  }, async (request, reply) => {
+    const body = loginSchema.parse(request.body);
+
+    const result = await db.query(
+      `SELECT id, email, password_hash, name, role, is_active 
+       FROM users WHERE email = $1`,
+      [body.email]
+    );
+
+    const user = result.rows[0];
+
+    if (!user || !user.is_active) {
+      return reply.status(401).send({ error: true, message: 'Invalid credentials' });
+    }
+
+    const validPassword = await bcrypt.compare(body.password, user.password_hash);
+    if (!validPassword) {
+      return reply.status(401).send({ error: true, message: 'Invalid credentials' });
+    }
+
+    // Update last login
+    await db.query(
+      'UPDATE users SET last_login_at = CURRENT_TIMESTAMP WHERE id = $1',
+      [user.id]
+    );
+
+    const token = fastify.jwt.sign({
+      id: user.id,
+      email: user.email,
+      role: user.role,
+    });
+
+    return {
+      token,
+      user: {
+        id: user.id,
+        email: user.email,
+        name: user.name,
+        role: user.role,
+      },
+    };
+  });
+
+  // Register (admin only in production)
+  fastify.post('/register', {
+    schema: {
+      tags: ['Auth'],
+      summary: 'Register a new user',
+      body: {
+        type: 'object',
+        required: ['email', 'password', 'name'],
+        properties: {
+          email: { type: 'string', format: 'email' },
+          password: { type: 'string', minLength: 6 },
+          name: { type: 'string', minLength: 2 },
+        },
+      },
+    },
+  }, async (request, reply) => {
+    const body = registerSchema.parse(request.body);
+
+    // Check if user exists
+    const existing = await db.query(
+      'SELECT id FROM users WHERE email = $1',
+      [body.email]
+    );
+
+    if (existing.rows.length > 0) {
+      return reply.status(400).send({ error: true, message: 'Email already registered' });
+    }
+
+    const passwordHash = await bcrypt.hash(body.password, 12);
+
+    const result = await db.query(
+      `INSERT INTO users (email, password_hash, name, role) 
+       VALUES ($1, $2, $3, 'editor') 
+       RETURNING id, email, name, role`,
+      [body.email, passwordHash, body.name]
+    );
+
+    const user = result.rows[0];
+
+    const token = fastify.jwt.sign({
+      id: user.id,
+      email: user.email,
+      role: user.role,
+    });
+
+    return {
+      token,
+      user: {
+        id: user.id,
+        email: user.email,
+        name: user.name,
+        role: user.role,
+      },
+    };
+  });
+
+  // Get current user
+  fastify.get('/me', {
+    schema: {
+      tags: ['Auth'],
+      summary: 'Get current user',
+      security: [{ bearerAuth: [] }],
+    },
+    preHandler: [fastify.authenticate],
+  }, async (request) => {
+    const user = request.user as { id: string };
+
+    const result = await db.query(
+      `SELECT id, email, name, role, avatar_url, created_at 
+       FROM users WHERE id = $1`,
+      [user.id]
+    );
+
+    return { user: result.rows[0] };
+  });
+
+  // Logout (invalidate token - for future implementation with token blacklist)
+  fastify.post('/logout', {
+    schema: {
+      tags: ['Auth'],
+      summary: 'Logout current user',
+      security: [{ bearerAuth: [] }],
+    },
+    preHandler: [fastify.authenticate],
+  }, async () => {
+    return { success: true, message: 'Logged out successfully' };
+  });
+
+  // Update profile
+  fastify.put('/profile', {
+    schema: {
+      tags: ['Auth'],
+      summary: 'Update user profile',
+      security: [{ bearerAuth: [] }],
+    },
+    preHandler: [fastify.authenticate],
+  }, async (request, reply) => {
+    const user = request.user as { id: string };
+    const body = z.object({
+      name: z.string().min(2),
+    }).parse(request.body);
+
+    const result = await db.query(
+      `UPDATE users SET name = $1, updated_at = CURRENT_TIMESTAMP 
+       WHERE id = $2 
+       RETURNING id, email, name, role, avatar_url`,
+      [body.name, user.id]
+    );
+
+    if (result.rows.length === 0) {
+      return reply.status(404).send({ error: true, message: 'User not found' });
+    }
+
+    return { user: result.rows[0] };
+  });
+
+  // Change password
+  fastify.put('/password', {
+    schema: {
+      tags: ['Auth'],
+      summary: 'Change user password',
+      security: [{ bearerAuth: [] }],
+    },
+    preHandler: [fastify.authenticate],
+  }, async (request, reply) => {
+    const user = request.user as { id: string };
+    const body = z.object({
+      currentPassword: z.string().min(6),
+      newPassword: z.string().min(6),
+    }).parse(request.body);
+
+    // Get current password hash
+    const result = await db.query(
+      'SELECT password_hash FROM users WHERE id = $1',
+      [user.id]
+    );
+
+    if (result.rows.length === 0) {
+      return reply.status(404).send({ error: true, message: 'User not found' });
+    }
+
+    // Verify current password
+    const validPassword = await bcrypt.compare(body.currentPassword, result.rows[0].password_hash);
+    if (!validPassword) {
+      return reply.status(400).send({ error: true, message: 'Current password is incorrect' });
+    }
+
+    // Hash new password and update
+    const newPasswordHash = await bcrypt.hash(body.newPassword, 12);
+    await db.query(
+      'UPDATE users SET password_hash = $1, updated_at = CURRENT_TIMESTAMP WHERE id = $2',
+      [newPasswordHash, user.id]
+    );
+
+    return { success: true, message: 'Password changed successfully' };
+  });
+
+};
+
+// Type augmentation for Fastify
+declare module 'fastify' {
+  interface FastifyInstance {
+    authenticate: any;
+  }
+}