@bernierllc/content-management-nextjs 0.0.1 → 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,363 @@
+/**
+ * Local type stubs matching the content management suite's interface contracts.
+ * These will be replaced by imports from @bernierllc/content-management-suite at merge time.
+ */
+interface ContentItem {
+    id: string;
+    type: string;
+    createdAt: string;
+    title?: string;
+    body?: string;
+    data?: Record<string, unknown>;
+    status?: string;
+    channels?: string[];
+    metadata?: Record<string, unknown>;
+    updatedAt?: string;
+    publishedAt?: string;
+    scheduledFor?: Date;
+    workflowId?: string;
+    workflowStage?: string;
+    sourceType?: string | null;
+    sourceId?: string | null;
+}
+interface CreateContentInput {
+    type: string;
+    title?: string;
+    body?: string;
+    data?: Record<string, unknown>;
+    channels?: string[];
+    metadata?: Record<string, unknown>;
+}
+interface UpdateContentInput {
+    title?: string;
+    body?: string;
+    data?: Record<string, unknown>;
+    channels?: string[];
+    metadata?: Record<string, unknown>;
+    status?: string;
+}
+interface ContentFilters {
+    type?: string;
+    status?: string;
+    page?: number;
+    limit?: number;
+}
+interface PaginatedResult<T> {
+    items: T[];
+    total: number;
+    page: number;
+    limit: number;
+    totalPages: number;
+}
+interface AIReview {
+    id: string;
+    contentId: string;
+    score: number;
+    suggestions: AIReviewSuggestion[];
+    passesThreshold: boolean;
+    rawResult: Record<string, unknown>;
+    createdAt: string;
+}
+interface AIReviewSuggestion {
+    category: string;
+    severity: 'info' | 'warning' | 'error';
+    message: string;
+    originalText?: string;
+    suggestedFix?: string;
+}
+interface SocialPost {
+    id: string;
+    contentId: string;
+    platform: string;
+    body: string;
+    status: 'draft' | 'published' | 'failed';
+    platformPostId?: string | null;
+    publishedAt?: string | null;
+    workflowId?: string;
+    workflowStage?: string;
+    createdAt: string;
+}
+interface Workflow {
+    id: string;
+    name: string;
+    stages: WorkflowStage[];
+    contentType?: string;
+    description?: string;
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface WorkflowStage {
+    id: string;
+    name: string;
+    order: number;
+    isPublishStage?: boolean;
+    allowsScheduling?: boolean;
+    description?: string;
+    permissions?: string[];
+    conditions?: StageConditions;
+}
+interface StageConditions {
+    autoAdvance?: boolean;
+    minScore?: number;
+    requiresHumanReview?: boolean;
+}
+interface User {
+    id: string;
+    name: string;
+    email: string;
+    role?: string;
+    permissions?: string[];
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface ContentTypeDefinition {
+    id: string;
+    name: string;
+    schema?: unknown;
+    defaults?: Record<string, unknown>;
+    description?: string;
+}
+interface PublishResult {
+    channelId: string;
+    success: boolean;
+    url?: string;
+    error?: string;
+}
+interface ContentPublishResult {
+    item: ContentItem;
+    results: PublishResult[];
+}
+interface IngestResult {
+    created: boolean;
+    content: ContentItem;
+}
+interface PlatformPublishResult {
+    platform: string;
+    success: boolean;
+    platformPostId?: string;
+    url?: string;
+    error?: string;
+}
+interface ContentSource {
+    id: string;
+    name: string;
+    outputTypes: string[];
+}
+interface ContentPublisher {
+    id: string;
+    name: string;
+    acceptedTypes: string[];
+}
+interface EnhancedContent {
+    original: string;
+    enhanced: string;
+    changes: Array<{
+        type: string;
+        description: string;
+    }>;
+}
+interface Suggestion {
+    category: string;
+    severity: 'info' | 'warning' | 'error';
+    message: string;
+    suggestedFix?: string;
+}
+interface EnhanceOptions {
+    tone?: string;
+    style?: string;
+    instructions?: string;
+}
+interface PlatformInfo {
+    id: string;
+    name: string;
+    acceptedTypes: string[];
+    hasPreview: boolean;
+    hasMetrics: boolean;
+}
+interface PreviewResult {
+    html?: string;
+    url?: string;
+    text?: string;
+}
+interface SocialMetrics {
+    platform: string;
+    platformPostId: string;
+    impressions?: number;
+    engagement?: number;
+    clicks?: number;
+    shares?: number;
+    raw?: Record<string, unknown>;
+}
+interface ContentNamespace {
+    list(filters?: ContentFilters): Promise<PaginatedResult<ContentItem>>;
+    get(id: string): Promise<ContentItem | null>;
+    create(input: CreateContentInput): Promise<ContentItem>;
+    update(id: string, input: UpdateContentInput): Promise<ContentItem>;
+    delete(id: string): Promise<void>;
+    publish(id: string, options?: {
+        channels?: string[];
+    }): Promise<ContentPublishResult>;
+}
+interface ContentTypesNamespace {
+    register(definition: ContentTypeDefinition): void;
+    unregister(id: string): void;
+    list(): ContentTypeDefinition[];
+    get(id: string): ContentTypeDefinition | undefined;
+}
+interface WorkflowsNamespace {
+    list(): Promise<Workflow[]>;
+    get(id: string): Promise<Workflow>;
+    create(input: Partial<Workflow>): Promise<Workflow>;
+    update(id: string, input: Partial<Workflow>): Promise<Workflow>;
+    delete(id: string): Promise<void>;
+}
+interface PublishersNamespace {
+    register(publisher: ContentPublisher): void;
+    unregister(id: string): void;
+    list(): ContentPublisher[];
+    get(id: string): ContentPublisher | undefined;
+}
+interface SourcesNamespace {
+    register(source: ContentSource): void;
+    unregister(id: string): void;
+    list(): ContentSource[];
+    get(id: string): ContentSource | undefined;
+    ingest(sourceId: string, rawPayload: unknown): Promise<IngestResult>;
+}
+interface AINamespace {
+    review(contentId: string): Promise<AIReview>;
+    generateSocialPosts(contentId: string, platforms: string[]): Promise<SocialPost[]>;
+    enhance(contentId: string, opts?: EnhanceOptions): Promise<EnhancedContent>;
+    suggest(contentId: string): Promise<Suggestion[]>;
+}
+interface SocialNamespace {
+    registerPlatform(adapter: unknown): void;
+    unregisterPlatform(id: string): void;
+    listPlatforms(): PlatformInfo[];
+    publish(contentId: string, platforms: string[]): Promise<PlatformPublishResult[]>;
+    preview(contentId: string, platform: string): Promise<PreviewResult>;
+    getMetrics(contentId: string, platform: string): Promise<SocialMetrics>;
+}
+interface UsersNamespace {
+    list(): Promise<User[]>;
+    get(id: string): Promise<User | null>;
+    create(input: Partial<User>): Promise<User>;
+    update(id: string, input: Partial<User>): Promise<User>;
+    delete(id: string): Promise<void>;
+}
+interface PermissionsNamespace {
+    check(userId: string, permission: string): Promise<boolean>;
+    grant(userId: string, permission: string): Promise<void>;
+    revoke(userId: string, permission: string): Promise<void>;
+    list(userId: string): Promise<string[]>;
+}
+interface ConfigNamespace {
+    get<T = unknown>(key: string): T | undefined;
+    set<T = unknown>(key: string, value: T): void;
+    getAll(): Record<string, unknown>;
+}
+interface PluginsNamespace {
+    register(plugin: unknown): void;
+    unregister(id: string): void;
+    list(): unknown[];
+    get(id: string): unknown | undefined;
+}
+interface ContentManagementSuite {
+    readonly content: ContentNamespace;
+    readonly contentTypes: ContentTypesNamespace;
+    readonly workflows: WorkflowsNamespace;
+    readonly publishers: PublishersNamespace;
+    readonly sources: SourcesNamespace;
+    readonly ai: AINamespace;
+    readonly social: SocialNamespace;
+    readonly users: UsersNamespace;
+    readonly permissions: PermissionsNamespace;
+    readonly config: ConfigNamespace;
+    readonly plugins: PluginsNamespace;
+    initialize(): Promise<void>;
+    dispose(): Promise<void>;
+}
+declare class ContentManagementError extends Error {
+    readonly code: string;
+    readonly context: Record<string, unknown> | undefined;
+    constructor(message: string, options?: {
+        cause?: Error;
+        code?: string;
+        context?: Record<string, unknown>;
+    });
+}
+declare class ValidationError extends ContentManagementError {
+    constructor(message: string, options?: {
+        cause?: Error;
+        code?: string;
+        context?: Record<string, unknown>;
+    });
+}
+declare class NotFoundError extends ContentManagementError {
+    constructor(message: string, options?: {
+        cause?: Error;
+        code?: string;
+        context?: Record<string, unknown>;
+    });
+}
+declare class UnauthorizedError extends ContentManagementError {
+    constructor(message: string, options?: {
+        cause?: Error;
+        code?: string;
+        context?: Record<string, unknown>;
+    });
+}
+declare class ForbiddenError extends ContentManagementError {
+    constructor(message: string, options?: {
+        cause?: Error;
+        code?: string;
+        context?: Record<string, unknown>;
+    });
+}
+declare class ConflictError extends ContentManagementError {
+    constructor(message: string, options?: {
+        cause?: Error;
+        code?: string;
+        context?: Record<string, unknown>;
+    });
+}
+declare class InternalError extends ContentManagementError {
+    constructor(message: string, options?: {
+        cause?: Error;
+        code?: string;
+        context?: Record<string, unknown>;
+    });
+}
+interface RouteHandlerOptions {
+    auth: (request: Request) => Promise<{
+        userId: string;
+    } | null>;
+    basePath?: string;
+}
+interface AuthUser {
+    userId: string;
+}
+
+interface RouteHandlers {
+    GET: (request: Request) => Promise<Response>;
+    POST: (request: Request) => Promise<Response>;
+    PUT: (request: Request) => Promise<Response>;
+    DELETE: (request: Request) => Promise<Response>;
+}
+/**
+ * Create Next.js App Router route handlers for the content management suite.
+ *
+ * Returns GET, POST, PUT, DELETE functions that internally route based on the URL path.
+ */
+declare function createContentRouteHandlers(suite: ContentManagementSuite, options: RouteHandlerOptions): RouteHandlers;
+
+/**
+ * Map error instances to HTTP status codes.
+ */
+declare function errorToStatusCode(error: unknown): number;
+/**
+ * Extract an error message suitable for HTTP responses.
+ */
+declare function errorToMessage(error: unknown): string;
+
+export { type AIReview, type AIReviewSuggestion, type AuthUser, ConflictError, type ContentFilters, type ContentItem, ContentManagementError, type ContentManagementSuite, type ContentPublishResult, type ContentPublisher, type ContentSource, type ContentTypeDefinition, type CreateContentInput, ForbiddenError, type IngestResult, InternalError, NotFoundError, type PaginatedResult, type PlatformPublishResult, type PublishResult, type RouteHandlerOptions, type RouteHandlers, type SocialPost, type StageConditions, UnauthorizedError, type UpdateContentInput, type User, ValidationError, type Workflow, type WorkflowStage, createContentRouteHandlers, errorToMessage, errorToStatusCode };

package/dist/index.js

@@ -0,0 +1,352 @@
+// src/types.ts
+var ContentManagementError = class extends Error {
+  constructor(message, options) {
+    super(message, { cause: options?.cause });
+    this.name = "ContentManagementError";
+    this.code = options?.code ?? "CONTENT_MANAGEMENT_ERROR";
+    this.context = options?.context;
+  }
+};
+var ValidationError = class extends ContentManagementError {
+  constructor(message, options) {
+    super(message, { ...options, code: options?.code ?? "VALIDATION_ERROR" });
+    this.name = "ValidationError";
+  }
+};
+var NotFoundError = class extends ContentManagementError {
+  constructor(message, options) {
+    super(message, { ...options, code: options?.code ?? "NOT_FOUND" });
+    this.name = "NotFoundError";
+  }
+};
+var UnauthorizedError = class extends ContentManagementError {
+  constructor(message, options) {
+    super(message, { ...options, code: options?.code ?? "UNAUTHORIZED" });
+    this.name = "UnauthorizedError";
+  }
+};
+var ForbiddenError = class extends ContentManagementError {
+  constructor(message, options) {
+    super(message, { ...options, code: options?.code ?? "FORBIDDEN" });
+    this.name = "ForbiddenError";
+  }
+};
+var ConflictError = class extends ContentManagementError {
+  constructor(message, options) {
+    super(message, { ...options, code: options?.code ?? "CONFLICT" });
+    this.name = "ConflictError";
+  }
+};
+var InternalError = class extends ContentManagementError {
+  constructor(message, options) {
+    super(message, { ...options, code: options?.code ?? "INTERNAL_ERROR" });
+    this.name = "InternalError";
+  }
+};
+
+// src/error-mapper.ts
+function errorToStatusCode(error) {
+  if (error instanceof ValidationError)
+    return 400;
+  if (error instanceof UnauthorizedError)
+    return 401;
+  if (error instanceof ForbiddenError)
+    return 403;
+  if (error instanceof NotFoundError)
+    return 404;
+  if (error instanceof ConflictError)
+    return 409;
+  if (error instanceof InternalError)
+    return 500;
+  return 500;
+}
+function errorToMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return "Internal server error";
+}
+
+// src/handlers/content.ts
+async function handleContentGet(suite, _user, segments, request) {
+  if (segments.length === 1) {
+    const id = segments[0];
+    const item = await suite.content.get(id);
+    if (!item) {
+      return Response.json({ error: "Content not found" }, { status: 404 });
+    }
+    return Response.json(item);
+  }
+  const url = new URL(request.url);
+  const filters = {};
+  const type = url.searchParams.get("type");
+  const status = url.searchParams.get("status");
+  const page = url.searchParams.get("page");
+  const limit = url.searchParams.get("limit");
+  if (type)
+    filters.type = type;
+  if (status)
+    filters.status = status;
+  if (page)
+    filters.page = parseInt(page, 10);
+  if (limit)
+    filters.limit = parseInt(limit, 10);
+  const result = await suite.content.list(filters);
+  return Response.json(result);
+}
+async function handleContentPost(suite, _user, segments, request) {
+  if (segments.length === 2 && segments[1] === "publish") {
+    const id = segments[0];
+    let body2 = {};
+    try {
+      body2 = await request.json();
+    } catch {
+    }
+    const channels = body2.channels;
+    const result = await suite.content.publish(id, channels ? { channels } : {});
+    return Response.json(result);
+  }
+  if (segments.length === 2 && segments[1] === "review") {
+    const id = segments[0];
+    const review = await suite.ai.review(id);
+    return Response.json(review);
+  }
+  const body = await request.json();
+  const item = await suite.content.create(body);
+  return Response.json(item, { status: 201 });
+}
+async function handleContentPut(suite, _user, segments, request) {
+  if (segments.length !== 1) {
+    return Response.json({ error: "Invalid path" }, { status: 400 });
+  }
+  const id = segments[0];
+  const body = await request.json();
+  const item = await suite.content.update(id, body);
+  return Response.json(item);
+}
+async function handleContentDelete(suite, _user, segments) {
+  if (segments.length !== 1) {
+    return Response.json({ error: "Invalid path" }, { status: 400 });
+  }
+  const id = segments[0];
+  await suite.content.delete(id);
+  return Response.json({ success: true }, { status: 200 });
+}
+
+// src/handlers/workflows.ts
+async function handleWorkflowsGet(suite, _user, segments) {
+  if (segments.length === 1) {
+    const id = segments[0];
+    const workflow = await suite.workflows.get(id);
+    return Response.json(workflow);
+  }
+  const workflows = await suite.workflows.list();
+  return Response.json(workflows);
+}
+async function handleWorkflowsPost(suite, _user, _segments, request) {
+  const body = await request.json();
+  const workflow = await suite.workflows.create(body);
+  return Response.json(workflow, { status: 201 });
+}
+async function handleWorkflowsPut(suite, _user, segments, request) {
+  if (segments.length !== 1) {
+    return Response.json({ error: "Invalid path" }, { status: 400 });
+  }
+  const id = segments[0];
+  const body = await request.json();
+  const workflow = await suite.workflows.update(id, body);
+  return Response.json(workflow);
+}
+async function handleWorkflowsDelete(suite, _user, segments) {
+  if (segments.length !== 1) {
+    return Response.json({ error: "Invalid path" }, { status: 400 });
+  }
+  const id = segments[0];
+  await suite.workflows.delete(id);
+  return Response.json({ success: true }, { status: 200 });
+}
+
+// src/handlers/sources.ts
+async function handleSourcesGet(suite, _user) {
+  const sources = suite.sources.list();
+  const result = sources.map((s) => ({
+    id: s.id,
+    name: s.name,
+    outputTypes: s.outputTypes
+  }));
+  return Response.json(result);
+}
+async function handleSourcesIngest(suite, _user, sourceId, request) {
+  const body = await request.json();
+  const result = await suite.sources.ingest(sourceId, body);
+  return Response.json(result, { status: result.created ? 201 : 200 });
+}
+
+// src/handlers/publishers.ts
+async function handlePublishersGet(suite, _user) {
+  const publishers = suite.publishers.list();
+  const result = publishers.map((p) => ({
+    id: p.id,
+    name: p.name,
+    acceptedTypes: p.acceptedTypes
+  }));
+  return Response.json(result);
+}
+
+// src/handlers/content-types.ts
+async function handleContentTypesGet(suite, _user) {
+  const types = suite.contentTypes.list();
+  const result = types.map((t) => ({
+    id: t.id,
+    name: t.name,
+    description: t.description,
+    defaults: t.defaults
+  }));
+  return Response.json(result);
+}
+
+// src/handlers/social.ts
+async function handleSocialPublish(suite, _user, contentId, request) {
+  const body = await request.json();
+  const platforms = body.platforms;
+  if (!platforms || !Array.isArray(platforms)) {
+    return Response.json(
+      { error: "platforms array is required" },
+      { status: 400 }
+    );
+  }
+  const results = await suite.social.publish(contentId, platforms);
+  return Response.json(results);
+}
+
+// src/route-handler-factory.ts
+function createContentRouteHandlers(suite, options) {
+  if (!options.auth) {
+    throw new Error(
+      "auth callback is required - content management routes must not be publicly accessible"
+    );
+  }
+  const basePath = options.basePath ?? "/api/content";
+  const normalizedBase = basePath.endsWith("/") ? basePath.slice(0, -1) : basePath;
+  const lastSlash = normalizedBase.lastIndexOf("/");
+  const apiPrefix = lastSlash > 0 ? normalizedBase.slice(0, lastSlash) : "";
+  async function withAuth(request, handler) {
+    try {
+      const user = await options.auth(request);
+      if (!user) {
+        return Response.json({ error: "Unauthorized" }, { status: 401 });
+      }
+      return await handler(user);
+    } catch (error) {
+      const status = errorToStatusCode(error);
+      const message = errorToMessage(error);
+      return Response.json({ error: message }, { status });
+    }
+  }
+  function routeSegments(url) {
+    const parsed = new URL(url);
+    const pathname = parsed.pathname;
+    if (pathname === normalizedBase || pathname.startsWith(normalizedBase + "/")) {
+      const rest = pathname.slice(normalizedBase.length);
+      const segments = rest.split("/").filter(Boolean);
+      return { resource: "content", segments };
+    }
+    if (apiPrefix) {
+      const afterPrefix = pathname.slice(apiPrefix.length);
+      const parts = afterPrefix.split("/").filter(Boolean);
+      if (parts.length >= 1 && parts[0]) {
+        const resource = parts[0];
+        const segments = parts.slice(1);
+        return { resource, segments };
+      }
+    }
+    return null;
+  }
+  const GET = async (request) => {
+    return withAuth(request, async (user) => {
+      const route = routeSegments(request.url);
+      if (!route) {
+        return Response.json({ error: "Not found" }, { status: 404 });
+      }
+      switch (route.resource) {
+        case "content":
+          return handleContentGet(suite, user, route.segments, request);
+        case "workflows":
+          return handleWorkflowsGet(suite, user, route.segments);
+        case "sources":
+          return handleSourcesGet(suite, user);
+        case "publishers":
+          return handlePublishersGet(suite, user);
+        case "content-types":
+          return handleContentTypesGet(suite, user);
+        default:
+          return Response.json({ error: "Not found" }, { status: 404 });
+      }
+    });
+  };
+  const POST = async (request) => {
+    return withAuth(request, async (user) => {
+      const route = routeSegments(request.url);
+      if (!route) {
+        return Response.json({ error: "Not found" }, { status: 404 });
+      }
+      switch (route.resource) {
+        case "content":
+          return handleContentPost(suite, user, route.segments, request);
+        case "workflows":
+          return handleWorkflowsPost(suite, user, route.segments, request);
+        case "sources":
+          if (route.segments.length === 2 && route.segments[0] === "ingest" && route.segments[1]) {
+            return handleSourcesIngest(suite, user, route.segments[1], request);
+          }
+          return Response.json({ error: "Not found" }, { status: 404 });
+        case "social":
+          if (route.segments.length === 2 && route.segments[0] && route.segments[1] === "publish") {
+            return handleSocialPublish(suite, user, route.segments[0], request);
+          }
+          return Response.json({ error: "Not found" }, { status: 404 });
+        default:
+          return Response.json({ error: "Not found" }, { status: 404 });
+      }
+    });
+  };
+  const PUT = async (request) => {
+    return withAuth(request, async (user) => {
+      const route = routeSegments(request.url);
+      if (!route) {
+        return Response.json({ error: "Not found" }, { status: 404 });
+      }
+      switch (route.resource) {
+        case "content":
+          return handleContentPut(suite, user, route.segments, request);
+        case "workflows":
+          return handleWorkflowsPut(suite, user, route.segments, request);
+        default:
+          return Response.json({ error: "Not found" }, { status: 404 });
+      }
+    });
+  };
+  const DELETE = async (request) => {
+    return withAuth(request, async (user) => {
+      const route = routeSegments(request.url);
+      if (!route) {
+        return Response.json({ error: "Not found" }, { status: 404 });
+      }
+      switch (route.resource) {
+        case "content":
+          return handleContentDelete(suite, user, route.segments);
+        case "workflows":
+          return handleWorkflowsDelete(suite, user, route.segments);
+        default:
+          return Response.json({ error: "Not found" }, { status: 404 });
+      }
+    });
+  };
+  return { GET, POST, PUT, DELETE };
+}
+export {
+  createContentRouteHandlers,
+  errorToMessage,
+  errorToStatusCode
+};
+//# sourceMappingURL=index.js.map