create-pxlr 1.0.0

package/templates/blog/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/blog/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/blog/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/blog/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"
+  }
+}

package/templates/blog/pxlr-cms/packages/shared/src/types/index.ts

@@ -0,0 +1,139 @@
+// Schema field types
+export type FieldType =
+  | 'string'
+  | 'text'
+  | 'number'
+  | 'boolean'
+  | 'date'
+  | 'datetime'
+  | 'richText'
+  | 'image'
+  | 'file'
+  | 'reference'
+  | 'array'
+  | 'object'
+  | 'slug'
+  | 'url'
+  | 'email'
+  | 'color';
+
+// Schema field definition
+export interface SchemaField {
+  name: string;
+  type: FieldType;
+  title?: string;
+  description?: string;
+  required?: boolean;
+  localized?: boolean;
+  hidden?: boolean;
+  readOnly?: boolean;
+  options?: Record<string, any>;
+  validation?: ValidationRule[];
+  of?: SchemaField[];
+  fields?: SchemaField[];
+  to?: string | string[];
+}
+
+// Validation rules
+export interface ValidationRule {
+  type: 'required' | 'min' | 'max' | 'regex' | 'custom';
+  value?: any;
+  message?: string;
+}
+
+// Schema definition
+export interface SchemaDefinition {
+  name: string;
+  title: string;
+  description?: string;
+  icon?: string;
+  fields: SchemaField[];
+  isSingleton?: boolean;
+  preview?: {
+    select: Record<string, string>;
+    prepare?: string;
+  };
+}
+
+// Document
+export interface Document {
+  id: string;
+  schemaName: string;
+  data: Record<string, any>;
+  locale: string;
+  status: 'draft' | 'published' | 'archived';
+  publishedAt?: string;
+  createdBy: string;
+  updatedBy: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+// Document version
+export interface DocumentVersion {
+  id: string;
+  documentId: string;
+  version: number;
+  data: Record<string, any>;
+  locale: string;
+  changeSummary?: string;
+  createdBy: string;
+  createdAt: string;
+}
+
+// Media file
+export interface MediaFile {
+  id: string;
+  filename: string;
+  originalFilename: string;
+  mimeType: string;
+  sizeBytes: number;
+  width?: number;
+  height?: number;
+  url: string;
+  thumbnailUrl?: string;
+  altText?: string;
+  caption?: string;
+  metadata?: Record<string, any>;
+  folder: string;
+  uploadedBy: string;
+  createdAt: string;
+}
+
+// User
+export interface User {
+  id: string;
+  email: string;
+  name: string;
+  role: 'admin' | 'editor' | 'viewer';
+  avatarUrl?: string;
+  isActive: boolean;
+  lastLoginAt?: string;
+  createdAt: string;
+}
+
+// Locale
+export interface Locale {
+  code: string;
+  name: string;
+  nativeName?: string;
+  isDefault: boolean;
+  isActive: boolean;
+}
+
+// API Response types
+export interface ApiResponse<T> {
+  data?: T;
+  error?: boolean;
+  message?: string;
+}
+
+export interface PaginatedResponse<T> {
+  items: T[];
+  pagination: {
+    page: number;
+    limit: number;
+    total: number;
+    totalPages: number;
+  };
+}

package/templates/blog/pxlr-cms/packages/shared/tsconfig.json

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