@bernierllc/content-management-suite 0.4.0 → 0.6.0

package/dist/server.mjs

@@ -1,1089 +0,0 @@
-#!/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