@bernierllc/content-management-suite 0.2.0

package/dist/server.mjs

@@ -0,0 +1,1089 @@
+#!/usr/bin/env node
+"use client";
+
+// src/types.ts
+import { z } from "zod";
+var ContentManagementConfigSchema = z.object({
+  // Server Configuration
+  server: z.object({
+    port: z.number().default(3e3),
+    host: z.string().default("localhost"),
+    cors: z.object({
+      origin: z.union([z.string(), z.array(z.string())]).default("*"),
+      credentials: z.boolean().default(true)
+    }).default({}),
+    security: z.object({
+      helmet: z.boolean().default(true),
+      rateLimit: z.object({
+        enabled: z.boolean().default(true),
+        windowMs: z.number().default(15 * 60 * 1e3),
+        // 15 minutes
+        max: z.number().default(100)
+        // limit each IP to 100 requests per windowMs
+      }).default({})
+    }).default({})
+  }).default({}),
+  // Database Configuration
+  database: z.object({
+    type: z.enum(["sqlite", "postgresql", "mysql", "mongodb"]).default("sqlite"),
+    url: z.string().optional(),
+    host: z.string().default("localhost"),
+    port: z.number().optional(),
+    name: z.string().default("content_management"),
+    username: z.string().optional(),
+    password: z.string().optional(),
+    ssl: z.boolean().default(false),
+    pool: z.object({
+      min: z.number().default(2),
+      max: z.number().default(10)
+    }).default({})
+  }).default({}),
+  // Content Configuration
+  content: z.object({
+    // Default editorial workflow
+    defaultWorkflow: z.object({
+      id: z.string().default("standard"),
+      name: z.string().default("Standard Workflow"),
+      description: z.string().default("Standard editorial workflow"),
+      stages: z.array(z.object({
+        id: z.string(),
+        name: z.string(),
+        order: z.number(),
+        isPublishStage: z.boolean().default(false),
+        allowsScheduling: z.boolean().default(false),
+        description: z.string().optional(),
+        permissions: z.array(z.string()).default([])
+      })).default([
+        {
+          id: "write",
+          name: "Write",
+          order: 1,
+          isPublishStage: false,
+          allowsScheduling: false,
+          description: "Write content",
+          permissions: ["content.edit"]
+        },
+        {
+          id: "publish",
+          name: "Publish",
+          order: 2,
+          isPublishStage: true,
+          allowsScheduling: true,
+          description: "Publish content",
+          permissions: ["content.publish"]
+        }
+      ]),
+      transitions: z.array(z.object({
+        id: z.string(),
+        from: z.string(),
+        to: z.string(),
+        description: z.string().optional(),
+        permissions: z.array(z.string()).default([])
+      })).default([
+        {
+          id: "write-to-publish",
+          from: "write",
+          to: "publish",
+          description: "Move from write to publish",
+          permissions: ["content.publish"]
+        }
+      ])
+    }).default({}),
+    // Content types
+    contentTypes: z.array(z.string()).default(["text", "image", "audio", "video"]),
+    // Auto-save configuration
+    autoSave: z.object({
+      enabled: z.boolean().default(true),
+      debounceMs: z.number().default(1e3),
+      maxRetries: z.number().default(3),
+      backoffMs: z.number().default(1e3)
+    }).default({}),
+    // Soft delete configuration
+    softDelete: z.object({
+      enabled: z.boolean().default(true),
+      showDeletedToUsers: z.boolean().default(false),
+      retentionDays: z.number().default(30)
+    }).default({}),
+    // File upload configuration
+    upload: z.object({
+      maxFileSize: z.number().default(104857600),
+      // 100MB
+      allowedTypes: z.array(z.string()).default([
+        "image/jpeg",
+        "image/png",
+        "image/webp",
+        "image/gif",
+        "audio/mpeg",
+        "audio/wav",
+        "audio/ogg",
+        "video/mp4",
+        "video/webm",
+        "video/ogg"
+      ]),
+      storage: z.object({
+        type: z.enum(["local", "s3", "gcs", "azure"]).default("local"),
+        path: z.string().default("./uploads"),
+        bucket: z.string().optional(),
+        region: z.string().optional(),
+        accessKey: z.string().optional(),
+        secretKey: z.string().optional()
+      }).default({})
+    }).default({})
+  }).default({}),
+  // UI Configuration
+  ui: z.object({
+    theme: z.object({
+      mode: z.enum(["light", "dark", "auto"]).default("auto"),
+      primaryColor: z.string().default("#007bff"),
+      secondaryColor: z.string().default("#6c757d"),
+      accentColor: z.string().default("#17a2b8")
+    }).default({}),
+    editor: z.object({
+      showToolbar: z.boolean().default(true),
+      showStatusBar: z.boolean().default(true),
+      showWordCount: z.boolean().default(true),
+      showCharacterCount: z.boolean().default(true),
+      autoSave: z.boolean().default(true),
+      placeholder: z.string().default("Start writing your content...")
+    }).default({}),
+    list: z.object({
+      defaultView: z.enum(["table", "list", "grid", "kanban"]).default("table"),
+      pageSize: z.number().default(20),
+      showSearch: z.boolean().default(true),
+      showFilters: z.boolean().default(true),
+      showSorting: z.boolean().default(true),
+      showPagination: z.boolean().default(true)
+    }).default({})
+  }).default({}),
+  // Integration Configuration
+  integrations: z.object({
+    neverAdmin: z.object({
+      enabled: z.boolean().default(false),
+      url: z.string().optional(),
+      apiKey: z.string().optional(),
+      syncInterval: z.number().default(3e5)
+      // 5 minutes
+    }).default({}),
+    neverHub: z.object({
+      enabled: z.boolean().default(false),
+      url: z.string().optional(),
+      apiKey: z.string().optional(),
+      packageDiscovery: z.boolean().default(true)
+    }).default({}),
+    analytics: z.object({
+      enabled: z.boolean().default(false),
+      provider: z.enum(["google", "mixpanel", "amplitude", "custom"]).optional(),
+      trackingId: z.string().optional(),
+      config: z.record(z.any()).default({})
+    }).default({})
+  }).default({}),
+  // Security Configuration
+  security: z.object({
+    jwt: z.object({
+      secret: z.string().default("your-secret-key"),
+      expiresIn: z.string().default("24h"),
+      issuer: z.string().default("content-management-suite")
+    }).default({}),
+    permissions: z.object({
+      enabled: z.boolean().default(true),
+      defaultRole: z.string().default("user"),
+      roles: z.array(z.object({
+        name: z.string(),
+        permissions: z.array(z.string()),
+        description: z.string().optional()
+      })).default([
+        {
+          name: "admin",
+          permissions: ["*"],
+          description: "Full administrative access"
+        },
+        {
+          name: "editor",
+          permissions: ["content.edit", "content.publish", "content.schedule"],
+          description: "Content editing and publishing"
+        },
+        {
+          name: "author",
+          permissions: ["content.edit"],
+          description: "Content creation and editing"
+        },
+        {
+          name: "user",
+          permissions: ["content.view"],
+          description: "Content viewing only"
+        }
+      ])
+    }).default({})
+  }).default({}),
+  // Logging Configuration
+  logging: z.object({
+    level: z.enum(["error", "warn", "info", "debug"]).default("info"),
+    format: z.enum(["json", "text"]).default("json"),
+    file: z.object({
+      enabled: z.boolean().default(true),
+      path: z.string().default("./logs"),
+      maxSize: z.string().default("10MB"),
+      maxFiles: z.number().default(5)
+    }).default({}),
+    console: z.object({
+      enabled: z.boolean().default(true),
+      colorize: z.boolean().default(true)
+    }).default({})
+  }).default({}),
+  // Performance Configuration
+  performance: z.object({
+    cache: z.object({
+      enabled: z.boolean().default(true),
+      ttl: z.number().default(300),
+      // 5 minutes
+      maxSize: z.number().default(1e3)
+    }).default({}),
+    compression: z.object({
+      enabled: z.boolean().default(true),
+      level: z.number().min(1).max(9).default(6)
+    }).default({}),
+    rateLimit: z.object({
+      enabled: z.boolean().default(true),
+      windowMs: z.number().default(15 * 60 * 1e3),
+      // 15 minutes
+      max: z.number().default(100)
+    }).default({})
+  }).default({})
+});
+var ContentManagementSuiteError = class extends Error {
+  constructor(message, code, statusCode = 500, details) {
+    super(message);
+    this.name = "ContentManagementSuiteError";
+    this.code = code;
+    this.statusCode = statusCode;
+    this.details = details;
+  }
+};
+var ContentManagementSuiteValidationError = class extends ContentManagementSuiteError {
+  constructor(message, details) {
+    super(message, "VALIDATION_ERROR", 400, details);
+    this.name = "ContentManagementSuiteValidationError";
+  }
+};
+var ContentManagementSuiteNotFoundError = class extends ContentManagementSuiteError {
+  constructor(message, details) {
+    super(message, "NOT_FOUND", 404, details);
+    this.name = "ContentManagementSuiteNotFoundError";
+  }
+};
+var ContentManagementSuiteConflictError = class extends ContentManagementSuiteError {
+  constructor(message, details) {
+    super(message, "CONFLICT", 409, details);
+    this.name = "ContentManagementSuiteConflictError";
+  }
+};
+var ContentManagementSuiteInternalError = class extends ContentManagementSuiteError {
+  constructor(message, details) {
+    super(message, "INTERNAL_ERROR", 500, details);
+    this.name = "ContentManagementSuiteInternalError";
+  }
+};
+
+// src/index.ts
+import {
+  WorkflowStepper as WorkflowStepper2,
+  StageActionButtons as StageActionButtons2,
+  WorkflowTimeline as WorkflowTimeline2,
+  WorkflowAdminConfig as WorkflowAdminConfig2
+} from "@bernierllc/content-workflow-ui";
+import { TextContentType as TextContentType2 } from "@bernierllc/content-type-text";
+import { ImageContentType as ImageContentType2 } from "@bernierllc/content-type-image";
+import { AudioContentTypeManager as AudioContentTypeManager2 } from "@bernierllc/content-type-audio";
+import { VideoContentType as VideoContentType2 } from "@bernierllc/content-type-video";
+import { ContentTypeRegistry as ContentTypeRegistry2 } from "@bernierllc/content-type-registry";
+import { EditorialWorkflowEngine, WorkflowBuilder, WorkflowTemplates, WorkflowFactory } from "@bernierllc/content-editorial-workflow";
+import { AutosaveManager } from "@bernierllc/content-autosave-manager";
+import { ContentSoftDelete } from "@bernierllc/content-soft-delete";
+
+// src/content-management-suite.ts
+import { EventEmitter } from "events";
+import express from "express";
+import cors from "cors";
+import helmet from "helmet";
+import morgan from "morgan";
+import compression from "compression";
+import { v4 as uuidv4 } from "uuid";
+import { ContentTypeRegistry } from "@bernierllc/content-type-registry";
+import { TextContentType } from "@bernierllc/content-type-text";
+import { ImageContentType } from "@bernierllc/content-type-image";
+import { AudioContentTypeManager } from "@bernierllc/content-type-audio";
+import { VideoContentType } from "@bernierllc/content-type-video";
+import {
+  WorkflowStepper,
+  StageActionButtons,
+  WorkflowTimeline,
+  WorkflowAdminConfig
+} from "@bernierllc/content-workflow-ui";
+var ContentManagementSuiteImpl = class extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    // Stub until @bernierllc/content-editor-service is published
+    this.autosaveManager = null;
+    this.softDelete = null;
+    this.workflowEngine = null;
+    // Content Types
+    this.contentTypes = /* @__PURE__ */ new Map();
+    // Plugins and Middleware
+    this.plugins = /* @__PURE__ */ new Map();
+    this.middleware = [];
+    this.hooks = /* @__PURE__ */ new Map();
+    // State
+    this.isStarted = false;
+    this.isStopped = false;
+    this.httpServer = null;
+    this.options = options;
+    this.config = this.loadConfiguration();
+    this.contentTypeRegistry = new ContentTypeRegistry();
+    this.configManager = this.createConfigManagerStub();
+    this.workflowService = this.createWorkflowServiceStub();
+    this.editorService = this.createEditorServiceStub();
+    this.workflow = {
+      stepper: WorkflowStepper,
+      actions: StageActionButtons,
+      timeline: WorkflowTimeline,
+      admin: WorkflowAdminConfig
+    };
+    this.server = express();
+    this.setupMiddleware();
+    this.setupRoutes();
+    this.editor = this.createEditorStub();
+    this.list = this.createListStub();
+    this.registerDefaultContentTypes();
+    if (options.plugins) {
+      options.plugins.forEach((plugin) => this.registerPlugin(plugin));
+    }
+  }
+  // Stub creators for services not yet published
+  createConfigManagerStub() {
+    return {
+      getConfig: () => this.config,
+      updateConfig: async (config2) => {
+        this.config = { ...this.config, ...config2 };
+      },
+      start: async () => {
+      },
+      stop: async () => {
+      }
+    };
+  }
+  createWorkflowServiceStub() {
+    return {
+      listWorkflows: async () => [],
+      getWorkflow: async (id) => ({ id, name: "Default Workflow" }),
+      createWorkflow: async (data) => ({ id: uuidv4(), ...data }),
+      updateWorkflow: async (id, data) => ({ id, ...data }),
+      deleteWorkflow: async (_id) => {
+      },
+      publishContent: async (id) => ({ id, status: "published" }),
+      scheduleContent: async (id, date) => ({ id, scheduledFor: date }),
+      unpublishContent: async (id) => ({ id, status: "draft" }),
+      start: async () => {
+      },
+      stop: async () => {
+      }
+    };
+  }
+  createEditorServiceStub() {
+    const contentStore = /* @__PURE__ */ new Map();
+    return {
+      listContent: async (_filters) => ({ items: Array.from(contentStore.values()), total: contentStore.size }),
+      getContent: async (id) => contentStore.get(id) || null,
+      createContent: async (type, data) => {
+        const content = { id: uuidv4(), type, ...data, createdAt: (/* @__PURE__ */ new Date()).toISOString() };
+        contentStore.set(content.id, content);
+        return content;
+      },
+      updateContent: async (id, data) => {
+        const existing = contentStore.get(id);
+        if (!existing)
+          throw new Error("Content not found");
+        const updated = { ...existing, ...data, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+        contentStore.set(id, updated);
+        return updated;
+      },
+      deleteContent: async (id, _soft) => {
+        contentStore.delete(id);
+      },
+      start: async () => {
+      },
+      stop: async () => {
+      }
+    };
+  }
+  // Stub for editor interface (until @bernierllc/content-editor-ui is published)
+  createEditorStub() {
+    return {
+      render: () => null,
+      getValue: () => "",
+      setValue: (_value) => {
+      },
+      focus: () => {
+      },
+      blur: () => {
+      },
+      on: (_event, _callback) => {
+      },
+      off: (_event, _callback) => {
+      }
+    };
+  }
+  // Stub for list interface (until @bernierllc/content-list-ui is published)
+  createListStub() {
+    return {
+      render: () => null,
+      getItems: () => [],
+      setItems: (_items) => {
+      },
+      getSelectedItems: () => [],
+      setSelectedItems: (_items) => {
+      },
+      on: (_event, _callback) => {
+      },
+      off: (_event, _callback) => {
+      }
+    };
+  }
+  loadConfiguration() {
+    try {
+      if (this.options.config) {
+        return ContentManagementConfigSchema.parse(this.options.config);
+      }
+      const config2 = this.configManager?.getConfig() || {};
+      return ContentManagementConfigSchema.parse(config2);
+    } catch (error) {
+      console.error("Failed to load configuration:", error);
+      return ContentManagementConfigSchema.parse({});
+    }
+  }
+  setupMiddleware() {
+    if (this.config.server.security.helmet) {
+      this.server.use(helmet());
+    }
+    this.server.use(cors(this.config.server.cors));
+    if (this.config.performance.compression.enabled) {
+      this.server.use(compression({
+        level: this.config.performance.compression.level
+      }));
+    }
+    if (this.options.logger) {
+      this.server.use(morgan("combined", {
+        stream: {
+          write: (message) => {
+            this.options.logger?.info(message.trim());
+          }
+        }
+      }));
+    }
+    this.server.use(express.json({ limit: "10mb" }));
+    this.server.use(express.urlencoded({ extended: true, limit: "10mb" }));
+    this.middleware.sort((a, b) => (a.order || 0) - (b.order || 0)).forEach((middleware) => {
+      this.server.use(middleware.handler);
+    });
+  }
+  setupRoutes() {
+    this.server.get("/health", (req, res) => {
+      res.json({
+        status: "healthy",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        version: "0.1.0",
+        uptime: process.uptime()
+      });
+    });
+    this.server.use("/api", this.createAPIRoutes());
+    this.server.use("/admin", this.createAdminRoutes());
+    this.server.use("/static", express.static("public"));
+    this.server.use(this.errorHandler.bind(this));
+  }
+  createAPIRoutes() {
+    const router = express.Router();
+    router.get("/content", this.getContentList.bind(this));
+    router.get("/content/:id", this.getContent.bind(this));
+    router.post("/content", this.createContent.bind(this));
+    router.put("/content/:id", this.updateContent.bind(this));
+    router.delete("/content/:id", this.deleteContent.bind(this));
+    router.post("/content/:id/publish", this.publishContent.bind(this));
+    router.post("/content/:id/schedule", this.scheduleContent.bind(this));
+    router.post("/content/:id/unpublish", this.unpublishContent.bind(this));
+    router.get("/workflows", this.getWorkflows.bind(this));
+    router.get("/workflows/:id", this.getWorkflow.bind(this));
+    router.post("/workflows", this.createWorkflow.bind(this));
+    router.put("/workflows/:id", this.updateWorkflow.bind(this));
+    router.delete("/workflows/:id", this.deleteWorkflow.bind(this));
+    router.get("/content-types", this.getContentTypes.bind(this));
+    router.get("/content-types/:id", this.handleGetContentType.bind(this));
+    router.post("/content-types", this.createContentType.bind(this));
+    router.put("/content-types/:id", this.updateContentType.bind(this));
+    router.delete("/content-types/:id", this.deleteContentType.bind(this));
+    router.get("/config", this.handleGetConfig.bind(this));
+    router.put("/config", this.handleUpdateConfig.bind(this));
+    router.get("/users", this.getUsers.bind(this));
+    router.get("/users/:id", this.getUser.bind(this));
+    router.post("/users", this.createUser.bind(this));
+    router.put("/users/:id", this.updateUser.bind(this));
+    router.delete("/users/:id", this.deleteUser.bind(this));
+    return router;
+  }
+  createAdminRoutes() {
+    const router = express.Router();
+    router.get("/", (req, res) => {
+      res.json({
+        message: "Content Management Suite Admin",
+        version: "0.1.0",
+        endpoints: [
+          "/workflows",
+          "/content-types",
+          "/config",
+          "/users"
+        ]
+      });
+    });
+    router.get("/workflows", this.getWorkflows.bind(this));
+    router.post("/workflows", this.createWorkflow.bind(this));
+    router.put("/workflows/:id", this.updateWorkflow.bind(this));
+    router.delete("/workflows/:id", this.deleteWorkflow.bind(this));
+    router.get("/content-types", this.getContentTypes.bind(this));
+    router.post("/content-types", this.createContentType.bind(this));
+    router.put("/content-types/:id", this.updateContentType.bind(this));
+    router.delete("/content-types/:id", this.deleteContentType.bind(this));
+    router.get("/config", this.handleGetConfig.bind(this));
+    router.put("/config", this.handleUpdateConfig.bind(this));
+    return router;
+  }
+  errorHandler(error, _req, res, _next) {
+    this.emit("error", error);
+    if (error instanceof ContentManagementSuiteError) {
+      res.status(error.statusCode).json({
+        error: {
+          code: error.code,
+          message: error.message,
+          details: error.details
+        }
+      });
+    } else {
+      res.status(500).json({
+        error: {
+          code: "INTERNAL_ERROR",
+          message: "An unexpected error occurred",
+          details: process.env.NODE_ENV === "development" ? error.message : void 0
+        }
+      });
+    }
+  }
+  registerDefaultContentTypes() {
+    this.contentTypes.set("text", TextContentType);
+    this.contentTypes.set("image", ImageContentType);
+    this.contentTypes.set("audio", AudioContentTypeManager);
+    this.contentTypes.set("video", VideoContentType);
+  }
+  // Public API Methods
+  async start() {
+    if (this.isStarted) {
+      throw new ContentManagementSuiteError("Suite is already started", "ALREADY_STARTED");
+    }
+    try {
+      await this.configManager.start();
+      await this.workflowService.start();
+      await this.editorService.start();
+      const port = this.config.server.port;
+      const host = this.config.server.host;
+      return new Promise((resolve, reject) => {
+        this.httpServer = this.server.listen(port, host, () => {
+          console.log(`Content Management Suite started on http://${host}:${port}`);
+          this.isStarted = true;
+          this.emit("started");
+          resolve();
+        });
+        this.httpServer.on("error", (err) => {
+          this.emit("error", err);
+          reject(new ContentManagementSuiteInternalError("Failed to start server", err));
+        });
+      });
+    } catch (error) {
+      this.emit("error", error);
+      throw new ContentManagementSuiteInternalError("Failed to start suite", error);
+    }
+  }
+  async stop() {
+    if (this.isStopped) {
+      throw new ContentManagementSuiteError("Suite is already stopped", "ALREADY_STOPPED");
+    }
+    try {
+      await this.configManager.stop();
+      await this.workflowService.stop();
+      await this.editorService.stop();
+      if (this.httpServer) {
+        return new Promise((resolve) => {
+          this.httpServer.close(() => {
+            console.log("Content Management Suite stopped");
+            this.isStopped = true;
+            this.emit("stopped");
+            resolve();
+          });
+        });
+      }
+      this.isStopped = true;
+    } catch (error) {
+      this.emit("error", error);
+      throw new ContentManagementSuiteInternalError("Failed to stop suite", error);
+    }
+  }
+  getConfig() {
+    return this.config;
+  }
+  async updateConfig(config2) {
+    try {
+      const newConfig = ContentManagementConfigSchema.parse({
+        ...this.config,
+        ...config2
+      });
+      this.config = newConfig;
+      await this.configManager.updateConfig(newConfig);
+      this.emit("config:updated", newConfig);
+    } catch (error) {
+      throw new ContentManagementSuiteValidationError("Invalid configuration", error);
+    }
+  }
+  registerContentType(contentType) {
+    const id = contentType?.id || contentType?.name || "unknown";
+    this.contentTypes.set(id, contentType);
+    this.emit("contentType:registered", contentType);
+  }
+  unregisterContentType(contentTypeId) {
+    if (!this.contentTypes.has(contentTypeId)) {
+      throw new ContentManagementSuiteNotFoundError("Content type not found");
+    }
+    this.contentTypes.delete(contentTypeId);
+    this.emit("contentType:unregistered", contentTypeId);
+  }
+  getContentType(contentTypeId) {
+    const contentType = this.contentTypes.get(contentTypeId);
+    if (!contentType) {
+      throw new ContentManagementSuiteNotFoundError("Content type not found");
+    }
+    return contentType;
+  }
+  listContentTypes() {
+    return Array.from(this.contentTypes.entries()).map(([id, contentType]) => ({
+      id,
+      contentType,
+      ...contentType
+    }));
+  }
+  // Plugin Management
+  registerPlugin(plugin) {
+    if (this.plugins.has(plugin.name)) {
+      throw new ContentManagementSuiteConflictError("Plugin already registered");
+    }
+    this.plugins.set(plugin.name, plugin);
+    plugin.install(this);
+    this.emit("plugin:registered", plugin);
+  }
+  unregisterPlugin(pluginName) {
+    const plugin = this.plugins.get(pluginName);
+    if (!plugin) {
+      throw new ContentManagementSuiteNotFoundError("Plugin not found");
+    }
+    plugin.uninstall(this);
+    this.plugins.delete(pluginName);
+    this.emit("plugin:unregistered", pluginName);
+  }
+  // Middleware Management
+  addMiddleware(middleware) {
+    this.middleware.push(middleware);
+    this.emit("middleware:added", middleware);
+  }
+  removeMiddleware(middlewareName) {
+    const index = this.middleware.findIndex((m) => m.name === middlewareName);
+    if (index === -1) {
+      throw new ContentManagementSuiteNotFoundError("Middleware not found");
+    }
+    this.middleware.splice(index, 1);
+    this.emit("middleware:removed", middlewareName);
+  }
+  // Hook Management
+  addHook(hook) {
+    if (!this.hooks.has(hook.name)) {
+      this.hooks.set(hook.name, []);
+    }
+    this.hooks.get(hook.name).push(hook);
+    this.hooks.get(hook.name).sort((a, b) => (a.priority || 0) - (b.priority || 0));
+    this.emit("hook:added", hook);
+  }
+  removeHook(hookName, handler) {
+    const hooks = this.hooks.get(hookName);
+    if (!hooks) {
+      throw new ContentManagementSuiteNotFoundError("Hook not found");
+    }
+    if (handler) {
+      const index = hooks.findIndex((h) => h.handler === handler);
+      if (index === -1) {
+        throw new ContentManagementSuiteNotFoundError("Hook handler not found");
+      }
+      hooks.splice(index, 1);
+    } else {
+      this.hooks.delete(hookName);
+    }
+    this.emit("hook:removed", hookName);
+  }
+  // API Route Handlers
+  async getContentList(req, res) {
+    try {
+      const { type, status, page = 1, limit = 20 } = req.query;
+      const filters = { type, status, page: parseInt(page), limit: parseInt(limit) };
+      const content = await this.editorService.listContent(filters);
+      res.json(content);
+    } catch (error) {
+      throw new ContentManagementSuiteInternalError("Failed to get content list", error);
+    }
+  }
+  async getContent(req, res) {
+    try {
+      const { id } = req.params;
+      const content = await this.editorService.getContent(id);
+      res.json(content);
+    } catch (error) {
+      throw new ContentManagementSuiteNotFoundError("Content not found", error);
+    }
+  }
+  async createContent(req, res) {
+    try {
+      const { type, data } = req.body;
+      const content = await this.editorService.createContent(type, data);
+      this.emit("content:created", content);
+      res.status(201).json(content);
+    } catch (error) {
+      throw new ContentManagementSuiteInternalError("Failed to create content", error);
+    }
+  }
+  async updateContent(req, res) {
+    try {
+      const { id } = req.params;
+      const { data } = req.body;
+      const content = await this.editorService.updateContent(id, data);
+      this.emit("content:updated", content);
+      res.json(content);
+    } catch (error) {
+      throw new ContentManagementSuiteInternalError("Failed to update content", error);
+    }
+  }
+  async deleteContent(req, res) {
+    try {
+      const { id } = req.params;
+      const { soft = true } = req.query;
+      await this.editorService.deleteContent(id, soft === "true");
+      this.emit("content:deleted", { id });
+      res.status(204).send();
+    } catch (error) {
+      throw new ContentManagementSuiteInternalError("Failed to delete content", error);
+    }
+  }
+  async publishContent(req, res) {
+    try {
+      const { id } = req.params;
+      const content = await this.workflowService.publishContent(id);
+      this.emit("content:published", content);
+      res.json(content);
+    } catch (error) {
+      throw new ContentManagementSuiteInternalError("Failed to publish content", error);
+    }
+  }
+  async scheduleContent(req, res) {
+    try {
+      const { id } = req.params;
+      const { date } = req.body;
+      const content = await this.workflowService.scheduleContent(id, new Date(date));
+      this.emit("content:scheduled", content, new Date(date));
+      res.json(content);
+    } catch (error) {
+      throw new ContentManagementSuiteInternalError("Failed to schedule content", error);
+    }
+  }
+  async unpublishContent(req, res) {
+    try {
+      const { id } = req.params;
+      const content = await this.workflowService.unpublishContent(id);
+      res.json(content);
+    } catch (error) {
+      throw new ContentManagementSuiteInternalError("Failed to unpublish content", error);
+    }
+  }
+  async getWorkflows(req, res) {
+    try {
+      const workflows = await this.workflowService.listWorkflows();
+      res.json(workflows);
+    } catch (error) {
+      throw new ContentManagementSuiteInternalError("Failed to get workflows", error);
+    }
+  }
+  async getWorkflow(req, res) {
+    try {
+      const { id } = req.params;
+      const workflow = await this.workflowService.getWorkflow(id);
+      res.json(workflow);
+    } catch (error) {
+      throw new ContentManagementSuiteNotFoundError("Workflow not found", error);
+    }
+  }
+  async createWorkflow(req, res) {
+    try {
+      const { data } = req.body;
+      const workflow = await this.workflowService.createWorkflow(data);
+      res.status(201).json(workflow);
+    } catch (error) {
+      throw new ContentManagementSuiteInternalError("Failed to create workflow", error);
+    }
+  }
+  async updateWorkflow(req, res) {
+    try {
+      const { id } = req.params;
+      const { data } = req.body;
+      const workflow = await this.workflowService.updateWorkflow(id, data);
+      res.json(workflow);
+    } catch (error) {
+      throw new ContentManagementSuiteInternalError("Failed to update workflow", error);
+    }
+  }
+  async deleteWorkflow(req, res) {
+    try {
+      const { id } = req.params;
+      await this.workflowService.deleteWorkflow(id);
+      res.status(204).send();
+    } catch (error) {
+      throw new ContentManagementSuiteInternalError("Failed to delete workflow", error);
+    }
+  }
+  async getContentTypes(req, res) {
+    try {
+      const contentTypes = this.listContentTypes();
+      res.json(contentTypes);
+    } catch (error) {
+      throw new ContentManagementSuiteInternalError("Failed to get content types", error);
+    }
+  }
+  async handleGetContentType(req, res) {
+    try {
+      const id = req.params.id;
+      if (!id) {
+        throw new ContentManagementSuiteNotFoundError("Content type ID required");
+      }
+      const contentType = this.contentTypes.get(id);
+      if (!contentType) {
+        throw new ContentManagementSuiteNotFoundError("Content type not found");
+      }
+      res.json(contentType);
+    } catch (error) {
+      throw new ContentManagementSuiteNotFoundError("Content type not found", error);
+    }
+  }
+  async createContentType(req, res) {
+    try {
+      const { data } = req.body;
+      this.registerContentType(data);
+      res.status(201).json(data);
+    } catch (error) {
+      throw new ContentManagementSuiteInternalError("Failed to create content type", error);
+    }
+  }
+  async updateContentType(req, res) {
+    try {
+      const id = req.params.id;
+      if (!id) {
+        throw new ContentManagementSuiteNotFoundError("Content type ID required");
+      }
+      const { data } = req.body;
+      this.unregisterContentType(id);
+      this.registerContentType(data);
+      res.json(data);
+    } catch (error) {
+      throw new ContentManagementSuiteInternalError("Failed to update content type", error);
+    }
+  }
+  async deleteContentType(req, res) {
+    try {
+      const id = req.params.id;
+      if (!id) {
+        throw new ContentManagementSuiteNotFoundError("Content type ID required");
+      }
+      this.unregisterContentType(id);
+      res.status(204).send();
+    } catch (error) {
+      throw new ContentManagementSuiteInternalError("Failed to delete content type", error);
+    }
+  }
+  async handleGetConfig(req, res) {
+    try {
+      res.json(this.config);
+    } catch (error) {
+      throw new ContentManagementSuiteInternalError("Failed to get config", error);
+    }
+  }
+  async handleUpdateConfig(req, res) {
+    try {
+      const { config: config2 } = req.body;
+      const newConfig = ContentManagementConfigSchema.parse({
+        ...this.config,
+        ...config2
+      });
+      this.config = newConfig;
+      await this.configManager.updateConfig(newConfig);
+      this.emit("config:updated", newConfig);
+      res.json(this.config);
+    } catch (error) {
+      throw new ContentManagementSuiteValidationError("Invalid configuration", error);
+    }
+  }
+  async getUsers(req, res) {
+    try {
+      res.json([]);
+    } catch (error) {
+      throw new ContentManagementSuiteInternalError("Failed to get users", error);
+    }
+  }
+  async getUser(req, res) {
+    try {
+      const { id } = req.params;
+      res.json({ id, name: "User" });
+    } catch (error) {
+      throw new ContentManagementSuiteNotFoundError("User not found", error);
+    }
+  }
+  async createUser(req, res) {
+    try {
+      const { data } = req.body;
+      res.status(201).json({ id: uuidv4(), ...data });
+    } catch (error) {
+      throw new ContentManagementSuiteInternalError("Failed to create user", error);
+    }
+  }
+  async updateUser(req, res) {
+    try {
+      const { id } = req.params;
+      const { data } = req.body;
+      res.json({ id, ...data });
+    } catch (error) {
+      throw new ContentManagementSuiteInternalError("Failed to update user", error);
+    }
+  }
+  async deleteUser(req, res) {
+    try {
+      const { id: _id } = req.params;
+      res.status(204).send();
+    } catch (error) {
+      throw new ContentManagementSuiteInternalError("Failed to delete user", error);
+    }
+  }
+};
+function createContentManagementSuite(options = {}) {
+  return new ContentManagementSuiteImpl(options);
+}
+
+// src/server.ts
+import { config } from "dotenv";
+config();
+async function main() {
+  try {
+    console.log("Starting Content Management Suite...");
+    const suite = createContentManagementSuite({
+      config: {
+        server: {
+          port: parseInt(process.env.CONTENT_MANAGEMENT_PORT || "3000"),
+          host: process.env.CONTENT_MANAGEMENT_HOST || "localhost",
+          cors: {
+            origin: process.env.CONTENT_MANAGEMENT_CORS_ORIGIN || "*",
+            credentials: true
+          },
+          security: {
+            helmet: true,
+            rateLimit: {
+              enabled: true,
+              windowMs: 15 * 60 * 1e3,
+              max: 100
+            }
+          }
+        },
+        database: {
+          type: process.env.CONTENT_MANAGEMENT_DATABASE_TYPE || "sqlite",
+          url: process.env.CONTENT_MANAGEMENT_DATABASE_URL,
+          host: process.env.CONTENT_MANAGEMENT_DATABASE_HOST || "localhost",
+          name: process.env.CONTENT_MANAGEMENT_DATABASE_NAME || "content_management",
+          ssl: process.env.CONTENT_MANAGEMENT_DATABASE_SSL === "true",
+          pool: {
+            min: 2,
+            max: 10
+          }
+        },
+        security: {
+          jwt: {
+            secret: process.env.CONTENT_MANAGEMENT_JWT_SECRET || "your-secret-key",
+            expiresIn: process.env.CONTENT_MANAGEMENT_JWT_EXPIRES_IN || "24h",
+            issuer: "content-management-suite"
+          },
+          permissions: {
+            enabled: true,
+            defaultRole: "user",
+            roles: [
+              { name: "admin", permissions: ["*"], description: "Full administrative access" },
+              { name: "editor", permissions: ["content.edit", "content.publish", "content.schedule"], description: "Content editing and publishing" },
+              { name: "author", permissions: ["content.edit"], description: "Content creation and editing" },
+              { name: "user", permissions: ["content.view"], description: "Content viewing only" }
+            ]
+          }
+        },
+        integrations: {
+          neverAdmin: {
+            enabled: process.env.CONTENT_MANAGEMENT_NEVERADMIN_ENABLED === "true",
+            url: process.env.CONTENT_MANAGEMENT_NEVERADMIN_URL,
+            apiKey: process.env.CONTENT_MANAGEMENT_NEVERADMIN_API_KEY,
+            syncInterval: 3e5
+          },
+          neverHub: {
+            enabled: process.env.CONTENT_MANAGEMENT_NEVERHUB_ENABLED === "true",
+            url: process.env.CONTENT_MANAGEMENT_NEVERHUB_URL,
+            apiKey: process.env.CONTENT_MANAGEMENT_NEVERHUB_API_KEY,
+            packageDiscovery: true
+          },
+          analytics: {
+            enabled: false,
+            config: {}
+          }
+        }
+      }
+    });
+    process.on("SIGINT", async () => {
+      console.log("\nReceived SIGINT, shutting down gracefully...");
+      try {
+        await suite.stop();
+        console.log("Suite stopped successfully");
+        process.exit(0);
+      } catch (error) {
+        console.error("Error during shutdown:", error);
+        process.exit(1);
+      }
+    });
+    process.on("SIGTERM", async () => {
+      console.log("\nReceived SIGTERM, shutting down gracefully...");
+      try {
+        await suite.stop();
+        console.log("Suite stopped successfully");
+        process.exit(0);
+      } catch (error) {
+        console.error("Error during shutdown:", error);
+        process.exit(1);
+      }
+    });
+    await suite.start();
+    console.log("Content Management Suite is running");
+    console.log(`Server: http://${process.env.CONTENT_MANAGEMENT_HOST || "localhost"}:${process.env.CONTENT_MANAGEMENT_PORT || "3000"}`);
+    console.log("Press Ctrl+C to stop");
+  } catch (error) {
+    console.error("Failed to start Content Management Suite:", error);
+    process.exit(1);
+  }
+}
+main();
+//# sourceMappingURL=server.mjs.map