@bernierllc/content-management-suite 0.4.2 → 0.6.0

package/dist/server.js

@@ -1,1102 +0,0 @@
-#!/usr/bin/env node
-"use client";
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-// src/types.ts
-var import_zod = require("zod");
-var ContentManagementConfigSchema = import_zod.z.object({
-  // Server Configuration
-  server: import_zod.z.object({
-    port: import_zod.z.number().default(3e3),
-    host: import_zod.z.string().default("localhost"),
-    cors: import_zod.z.object({
-      origin: import_zod.z.union([import_zod.z.string(), import_zod.z.array(import_zod.z.string())]).default("*"),
-      credentials: import_zod.z.boolean().default(true)
-    }).default({}),
-    security: import_zod.z.object({
-      helmet: import_zod.z.boolean().default(true),
-      rateLimit: import_zod.z.object({
-        enabled: import_zod.z.boolean().default(true),
-        windowMs: import_zod.z.number().default(15 * 60 * 1e3),
-        // 15 minutes
-        max: import_zod.z.number().default(100)
-        // limit each IP to 100 requests per windowMs
-      }).default({})
-    }).default({})
-  }).default({}),
-  // Database Configuration
-  database: import_zod.z.object({
-    type: import_zod.z.enum(["sqlite", "postgresql", "mysql", "mongodb"]).default("sqlite"),
-    url: import_zod.z.string().optional(),
-    host: import_zod.z.string().default("localhost"),
-    port: import_zod.z.number().optional(),
-    name: import_zod.z.string().default("content_management"),
-    username: import_zod.z.string().optional(),
-    password: import_zod.z.string().optional(),
-    ssl: import_zod.z.boolean().default(false),
-    pool: import_zod.z.object({
-      min: import_zod.z.number().default(2),
-      max: import_zod.z.number().default(10)
-    }).default({})
-  }).default({}),
-  // Content Configuration
-  content: import_zod.z.object({
-    // Default editorial workflow
-    defaultWorkflow: import_zod.z.object({
-      id: import_zod.z.string().default("standard"),
-      name: import_zod.z.string().default("Standard Workflow"),
-      description: import_zod.z.string().default("Standard editorial workflow"),
-      stages: import_zod.z.array(import_zod.z.object({
-        id: import_zod.z.string(),
-        name: import_zod.z.string(),
-        order: import_zod.z.number(),
-        isPublishStage: import_zod.z.boolean().default(false),
-        allowsScheduling: import_zod.z.boolean().default(false),
-        description: import_zod.z.string().optional(),
-        permissions: import_zod.z.array(import_zod.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: import_zod.z.array(import_zod.z.object({
-        id: import_zod.z.string(),
-        from: import_zod.z.string(),
-        to: import_zod.z.string(),
-        description: import_zod.z.string().optional(),
-        permissions: import_zod.z.array(import_zod.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: import_zod.z.array(import_zod.z.string()).default(["text", "image", "audio", "video"]),
-    // Auto-save configuration
-    autoSave: import_zod.z.object({
-      enabled: import_zod.z.boolean().default(true),
-      debounceMs: import_zod.z.number().default(1e3),
-      maxRetries: import_zod.z.number().default(3),
-      backoffMs: import_zod.z.number().default(1e3)
-    }).default({}),
-    // Soft delete configuration
-    softDelete: import_zod.z.object({
-      enabled: import_zod.z.boolean().default(true),
-      showDeletedToUsers: import_zod.z.boolean().default(false),
-      retentionDays: import_zod.z.number().default(30)
-    }).default({}),
-    // File upload configuration
-    upload: import_zod.z.object({
-      maxFileSize: import_zod.z.number().default(104857600),
-      // 100MB
-      allowedTypes: import_zod.z.array(import_zod.z.string()).default([
-        "image/jpeg",
-        "image/png",
-        "image/webp",
-        "image/gif",
-        "audio/mpeg",
-        "audio/wav",
-        "audio/ogg",
-        "video/mp4",
-        "video/webm",
-        "video/ogg"
-      ]),
-      storage: import_zod.z.object({
-        type: import_zod.z.enum(["local", "s3", "gcs", "azure"]).default("local"),
-        path: import_zod.z.string().default("./uploads"),
-        bucket: import_zod.z.string().optional(),
-        region: import_zod.z.string().optional(),
-        accessKey: import_zod.z.string().optional(),
-        secretKey: import_zod.z.string().optional()
-      }).default({})
-    }).default({})
-  }).default({}),
-  // UI Configuration
-  ui: import_zod.z.object({
-    theme: import_zod.z.object({
-      mode: import_zod.z.enum(["light", "dark", "auto"]).default("auto"),
-      primaryColor: import_zod.z.string().default("#007bff"),
-      secondaryColor: import_zod.z.string().default("#6c757d"),
-      accentColor: import_zod.z.string().default("#17a2b8")
-    }).default({}),
-    editor: import_zod.z.object({
-      showToolbar: import_zod.z.boolean().default(true),
-      showStatusBar: import_zod.z.boolean().default(true),
-      showWordCount: import_zod.z.boolean().default(true),
-      showCharacterCount: import_zod.z.boolean().default(true),
-      autoSave: import_zod.z.boolean().default(true),
-      placeholder: import_zod.z.string().default("Start writing your content...")
-    }).default({}),
-    list: import_zod.z.object({
-      defaultView: import_zod.z.enum(["table", "list", "grid", "kanban"]).default("table"),
-      pageSize: import_zod.z.number().default(20),
-      showSearch: import_zod.z.boolean().default(true),
-      showFilters: import_zod.z.boolean().default(true),
-      showSorting: import_zod.z.boolean().default(true),
-      showPagination: import_zod.z.boolean().default(true)
-    }).default({})
-  }).default({}),
-  // Integration Configuration
-  integrations: import_zod.z.object({
-    neverAdmin: import_zod.z.object({
-      enabled: import_zod.z.boolean().default(false),
-      url: import_zod.z.string().optional(),
-      apiKey: import_zod.z.string().optional(),
-      syncInterval: import_zod.z.number().default(3e5)
-      // 5 minutes
-    }).default({}),
-    neverHub: import_zod.z.object({
-      enabled: import_zod.z.boolean().default(false),
-      url: import_zod.z.string().optional(),
-      apiKey: import_zod.z.string().optional(),
-      packageDiscovery: import_zod.z.boolean().default(true)
-    }).default({}),
-    analytics: import_zod.z.object({
-      enabled: import_zod.z.boolean().default(false),
-      provider: import_zod.z.enum(["google", "mixpanel", "amplitude", "custom"]).optional(),
-      trackingId: import_zod.z.string().optional(),
-      config: import_zod.z.record(import_zod.z.any()).default({})
-    }).default({})
-  }).default({}),
-  // Security Configuration
-  security: import_zod.z.object({
-    jwt: import_zod.z.object({
-      secret: import_zod.z.string().default("your-secret-key"),
-      expiresIn: import_zod.z.string().default("24h"),
-      issuer: import_zod.z.string().default("content-management-suite")
-    }).default({}),
-    permissions: import_zod.z.object({
-      enabled: import_zod.z.boolean().default(true),
-      defaultRole: import_zod.z.string().default("user"),
-      roles: import_zod.z.array(import_zod.z.object({
-        name: import_zod.z.string(),
-        permissions: import_zod.z.array(import_zod.z.string()),
-        description: import_zod.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: import_zod.z.object({
-    level: import_zod.z.enum(["error", "warn", "info", "debug"]).default("info"),
-    format: import_zod.z.enum(["json", "text"]).default("json"),
-    file: import_zod.z.object({
-      enabled: import_zod.z.boolean().default(true),
-      path: import_zod.z.string().default("./logs"),
-      maxSize: import_zod.z.string().default("10MB"),
-      maxFiles: import_zod.z.number().default(5)
-    }).default({}),
-    console: import_zod.z.object({
-      enabled: import_zod.z.boolean().default(true),
-      colorize: import_zod.z.boolean().default(true)
-    }).default({})
-  }).default({}),
-  // Performance Configuration
-  performance: import_zod.z.object({
-    cache: import_zod.z.object({
-      enabled: import_zod.z.boolean().default(true),
-      ttl: import_zod.z.number().default(300),
-      // 5 minutes
-      maxSize: import_zod.z.number().default(1e3)
-    }).default({}),
-    compression: import_zod.z.object({
-      enabled: import_zod.z.boolean().default(true),
-      level: import_zod.z.number().min(1).max(9).default(6)
-    }).default({}),
-    rateLimit: import_zod.z.object({
-      enabled: import_zod.z.boolean().default(true),
-      windowMs: import_zod.z.number().default(15 * 60 * 1e3),
-      // 15 minutes
-      max: import_zod.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
-var import_content_workflow_ui2 = require("@bernierllc/content-workflow-ui");
-var import_content_type_text2 = require("@bernierllc/content-type-text");
-var import_content_type_image2 = require("@bernierllc/content-type-image");
-var import_content_type_audio2 = require("@bernierllc/content-type-audio");
-var import_content_type_video2 = require("@bernierllc/content-type-video");
-var import_content_type_registry2 = require("@bernierllc/content-type-registry");
-var import_content_editorial_workflow = require("@bernierllc/content-editorial-workflow");
-var import_content_autosave_manager = require("@bernierllc/content-autosave-manager");
-var import_content_soft_delete = require("@bernierllc/content-soft-delete");
-
-// src/content-management-suite.ts
-var import_events = require("events");
-var import_express = __toESM(require("express"));
-var import_cors = __toESM(require("cors"));
-var import_helmet = __toESM(require("helmet"));
-var import_morgan = __toESM(require("morgan"));
-var import_compression = __toESM(require("compression"));
-var import_uuid = require("uuid");
-var import_content_type_registry = require("@bernierllc/content-type-registry");
-var import_content_type_text = require("@bernierllc/content-type-text");
-var import_content_type_image = require("@bernierllc/content-type-image");
-var import_content_type_audio = require("@bernierllc/content-type-audio");
-var import_content_type_video = require("@bernierllc/content-type-video");
-var import_content_workflow_ui = require("@bernierllc/content-workflow-ui");
-var ContentManagementSuiteImpl = class extends import_events.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 import_content_type_registry.ContentTypeRegistry();
-    this.configManager = this.createConfigManagerStub();
-    this.workflowService = this.createWorkflowServiceStub();
-    this.editorService = this.createEditorServiceStub();
-    this.workflow = {
-      stepper: import_content_workflow_ui.WorkflowStepper,
-      actions: import_content_workflow_ui.StageActionButtons,
-      timeline: import_content_workflow_ui.WorkflowTimeline,
-      admin: import_content_workflow_ui.WorkflowAdminConfig
-    };
-    this.server = (0, import_express.default)();
-    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: (0, import_uuid.v4)(), ...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: (0, import_uuid.v4)(), 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((0, import_helmet.default)());
-    }
-    this.server.use((0, import_cors.default)(this.config.server.cors));
-    if (this.config.performance.compression.enabled) {
-      this.server.use((0, import_compression.default)({
-        level: this.config.performance.compression.level
-      }));
-    }
-    if (this.options.logger) {
-      this.server.use((0, import_morgan.default)("combined", {
-        stream: {
-          write: (message) => {
-            this.options.logger?.info(message.trim());
-          }
-        }
-      }));
-    }
-    this.server.use(import_express.default.json({ limit: "10mb" }));
-    this.server.use(import_express.default.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", import_express.default.static("public"));
-    this.server.use(this.errorHandler.bind(this));
-  }
-  createAPIRoutes() {
-    const router = import_express.default.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 = import_express.default.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", import_content_type_text.TextContentType);
-    this.contentTypes.set("image", import_content_type_image.ImageContentType);
-    this.contentTypes.set("audio", import_content_type_audio.AudioContentTypeManager);
-    this.contentTypes.set("video", import_content_type_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: (0, import_uuid.v4)(), ...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
-var import_dotenv = require("dotenv");
-(0, import_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.js.map