@arch-cadre/blog-module 1.0.7 → 1.0.8

package/dist/actions/index.d.ts

@@ -1,5 +1,5 @@
 import type { z } from "zod";
-import { commentSchema, postSchema } from "../lib/validation";
+import { commentSchema, postSchema } from "../lib/validation.js";
 export declare function createPost(data: z.infer<typeof postSchema>): Promise<{
     success: boolean;
     error?: undefined;
@@ -7,10 +7,43 @@ export declare function createPost(data: z.infer<typeof postSchema>): Promise<{
     success: boolean;
     error: any;
 }>;
-export declare function getPosts(): Promise<any>;
-export declare function getPostBySlug(slug: string): Promise<any>;
-export declare function getPostById(id: string): Promise<any>;
-export declare function getComments(postId: string): Promise<any>;
+export declare function getPosts(): Promise<{
+    id: string;
+    title: string;
+    slug: string;
+    content: string;
+    createdAt: Date;
+    author: {
+        name: string;
+    };
+}[]>;
+export declare function getPostBySlug(slug: string): Promise<{
+    id: string;
+    title: string;
+    slug: string;
+    content: string;
+    createdAt: Date;
+    author: {
+        name: string;
+    };
+}>;
+export declare function getPostById(id: string): Promise<{
+    id: string;
+    title: string;
+    slug: string;
+    content: string;
+    authorId: string;
+    createdAt: Date;
+}>;
+export declare function getComments(postId: string): Promise<{
+    id: string;
+    content: string;
+    createdAt: Date;
+    author: {
+        name: string;
+        image: string | null;
+    };
+}[]>;
 export declare function createComment(data: z.infer<typeof commentSchema>): Promise<{
     success: boolean;
     error?: undefined;

package/dist/actions/index.js

@@ -0,0 +1,149 @@
+"use server";
+import { db, getCurrentSession, userTable } from "@arch-cadre/core/server";
+import { desc, eq } from "drizzle-orm";
+import { revalidatePath } from "next/cache";
+import { commentSchema, postSchema } from "../lib/validation.js";
+import { commentsTable, postsTable } from "../schema.js";
+// --- Posts ---
+export async function createPost(data) {
+    try {
+        const { user } = await getCurrentSession();
+        if (!user)
+            throw new Error("Unauthorized");
+        const validated = postSchema.parse(data);
+        await db.insert(postsTable).values({
+            ...validated,
+            authorId: user.id,
+        });
+        revalidatePath("/blog");
+        return { success: true };
+    }
+    catch (error) {
+        console.error("[BlogModule:Actions] createPost failed:", error);
+        return { success: false, error: error.message };
+    }
+}
+export async function getPosts() {
+    try {
+        return await db
+            .select({
+            id: postsTable.id,
+            title: postsTable.title,
+            slug: postsTable.slug,
+            content: postsTable.content,
+            createdAt: postsTable.createdAt,
+            author: {
+                name: userTable.name,
+            },
+        })
+            .from(postsTable)
+            .innerJoin(userTable, eq(postsTable.authorId, userTable.id))
+            .orderBy(desc(postsTable.createdAt));
+    }
+    catch (error) {
+        console.error("[BlogModule:Actions] getPosts failed:", error);
+        throw error;
+    }
+}
+export async function getPostBySlug(slug) {
+    try {
+        const [post] = await db
+            .select({
+            id: postsTable.id,
+            title: postsTable.title,
+            slug: postsTable.slug,
+            content: postsTable.content,
+            createdAt: postsTable.createdAt,
+            author: {
+                name: userTable.name,
+            },
+        })
+            .from(postsTable)
+            .innerJoin(userTable, eq(postsTable.authorId, userTable.id))
+            .where(eq(postsTable.slug, slug));
+        return post || null;
+    }
+    catch (error) {
+        console.error("[BlogModule:Actions] getPostBySlug failed:", error);
+        throw error;
+    }
+}
+export async function getPostById(id) {
+    try {
+        const [post] = await db
+            .select()
+            .from(postsTable)
+            .where(eq(postsTable.id, id));
+        return post || null;
+    }
+    catch (error) {
+        console.error("[BlogModule:Actions] getPostById failed:", error);
+        throw error;
+    }
+}
+// --- Comments ---
+export async function getComments(postId) {
+    try {
+        return await db
+            .select({
+            id: commentsTable.id,
+            content: commentsTable.content,
+            createdAt: commentsTable.createdAt,
+            author: {
+                name: userTable.name,
+                image: userTable.image,
+            },
+        })
+            .from(commentsTable)
+            .innerJoin(userTable, eq(commentsTable.authorId, userTable.id))
+            .where(eq(commentsTable.postId, postId))
+            .orderBy(desc(commentsTable.createdAt));
+    }
+    catch (error) {
+        console.error("[BlogModule:Actions] getComments failed:", error);
+        throw error;
+    }
+}
+export async function createComment(data) {
+    try {
+        const { user } = await getCurrentSession();
+        if (!user)
+            throw new Error("Must be logged in to comment");
+        const validated = commentSchema.parse(data);
+        await db.insert(commentsTable).values({
+            content: validated.content,
+            postId: validated.postId,
+            authorId: user.id,
+        });
+        revalidatePath(`/blog`);
+        return { success: true };
+    }
+    catch (error) {
+        console.error("[BlogModule:Actions] createComment failed:", error);
+        return { success: false, error: error.message };
+    }
+}
+export async function deletePost(id) {
+    try {
+        await db.delete(postsTable).where(eq(postsTable.id, id));
+        revalidatePath("/blog");
+        return { success: true };
+    }
+    catch (error) {
+        console.error("[BlogModule:Actions] deletePost failed:", error);
+        return { success: false, error: error.message };
+    }
+}
+export async function updatePost(id, data) {
+    try {
+        const validated = postSchema.parse(data);
+        await db.update(postsTable).set(validated).where(eq(postsTable.id, id));
+        revalidatePath("/blog");
+        revalidatePath(`/blog/${validated.slug}`);
+        return { success: true };
+    }
+    catch (error) {
+        console.error("[BlogModule:Actions] updatePost failed:", error);
+        return { success: false, error: error.message };
+    }
+}

package/dist/components/BlogStatsWidget.d.ts

@@ -1,2 +1 @@
-import * as React from "react";
-export default function BlogStatsWidget(): Promise<React.JSX.Element>;
+export default function BlogStatsWidget(): Promise<import("react/jsx-runtime").JSX.Element>;

package/dist/components/BlogStatsWidget.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { db } from "@arch-cadre/core/server";
+import { getTranslation } from "@arch-cadre/intl/server";
+import { Card, CardContent, CardHeader, CardTitle } from "@arch-cadre/ui";
+import { sql } from "drizzle-orm";
+import { FileText, MessageSquare } from "lucide-react";
+import { commentsTable, postsTable } from "../schema.js";
+export default async function BlogStatsWidget() {
+    const { t } = await getTranslation();
+    const [postsCount] = await db
+        .select({ count: sql `count(*)` })
+        .from(postsTable);
+    const [commentsCount] = await db
+        .select({ count: sql `count(*)` })
+        .from(commentsTable);
+    return (_jsxs("div", { className: "grid gap-4 md:grid-cols-2 lg:grid-cols-2", children: [_jsxs(Card, { children: [_jsxs(CardHeader, { className: "flex flex-row items-center justify-between space-y-0 pb-2", children: [_jsx(CardTitle, { className: "text-sm font-medium", children: t("Total Posts") }), _jsx(FileText, { className: "h-4 w-4 text-muted-foreground" })] }), _jsx(CardContent, { children: _jsx("div", { className: "text-2xl font-bold", children: postsCount?.count || 0 }) })] }), _jsxs(Card, { children: [_jsxs(CardHeader, { className: "flex flex-row items-center justify-between space-y-0 pb-2", children: [_jsx(CardTitle, { className: "text-sm font-medium", children: t("Total Comments") }), _jsx(MessageSquare, { className: "h-4 w-4 text-muted-foreground" })] }), _jsx(CardContent, { children: _jsx("div", { className: "text-2xl font-bold", children: commentsCount?.count || 0 }) })] })] }));
+}

package/dist/components/RecentCommentsWidget.d.ts

@@ -1,2 +1 @@
-import * as React from "react";
-export default function RecentCommentsWidget(): Promise<React.JSX.Element>;
+export default function RecentCommentsWidget(): Promise<import("react/jsx-runtime").JSX.Element>;

package/dist/components/RecentCommentsWidget.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { db, userTable } from "@arch-cadre/core/server";
+import { getTranslation } from "@arch-cadre/intl/server";
+import { Avatar, AvatarFallback, AvatarImage, Card, CardContent, CardDescription, CardHeader, CardTitle, } from "@arch-cadre/ui";
+import { desc, eq } from "drizzle-orm";
+import { commentsTable } from "../schema.js";
+export default async function RecentCommentsWidget() {
+    const { t } = await getTranslation();
+    const comments = await db
+        .select({
+        id: commentsTable.id,
+        content: commentsTable.content,
+        createdAt: commentsTable.createdAt,
+        author: {
+            name: userTable.name,
+            image: userTable.image,
+        },
+    })
+        .from(commentsTable)
+        .leftJoin(userTable, eq(commentsTable.authorId, userTable.id))
+        .orderBy(desc(commentsTable.createdAt))
+        .limit(5);
+    return (_jsxs(Card, { children: [_jsxs(CardHeader, { children: [_jsx(CardTitle, { children: t("Recent Comments") }), _jsx(CardDescription, { children: t("What readers are saying about your posts.") })] }), _jsxs(CardContent, { className: "grid gap-8", children: [comments.map((comment) => (_jsxs("div", { className: "flex items-center gap-4", children: [_jsxs(Avatar, { className: "h-9 w-9", children: [_jsx(AvatarImage, { src: comment.author?.image || "", alt: "Avatar" }), _jsx(AvatarFallback, { children: comment.author?.name?.substring(0, 2).toUpperCase() || "CM" })] }), _jsxs("div", { className: "grid gap-1", children: [_jsx("p", { className: "text-sm font-medium leading-none line-clamp-1", children: comment.content }), _jsxs("p", { className: "text-sm text-muted-foreground", children: [comment.author?.name || t("Anonymous"), " \u2022", " ", new Date(comment.createdAt).toLocaleDateString()] })] })] }, comment.id))), comments.length === 0 && (_jsx("div", { className: "text-center py-4 text-muted-foreground", children: t("No comments yet.") }))] })] }));
+}

package/dist/components/RecentPostsWidget.d.ts

@@ -1,2 +1 @@
-import * as React from "react";
-export default function RecentPostsWidget(): Promise<React.JSX.Element>;
+export default function RecentPostsWidget(): Promise<import("react/jsx-runtime").JSX.Element>;

package/dist/components/RecentPostsWidget.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { db, userTable } from "@arch-cadre/core/server";
+import { getTranslation } from "@arch-cadre/intl/server";
+import { Avatar, AvatarFallback, AvatarImage, Card, CardContent, CardDescription, CardHeader, CardTitle, } from "@arch-cadre/ui";
+import { desc, eq } from "drizzle-orm";
+import { postsTable } from "../schema.js";
+export default async function RecentPostsWidget() {
+    const { t } = await getTranslation();
+    const posts = await db
+        .select({
+        id: postsTable.id,
+        title: postsTable.title,
+        createdAt: postsTable.createdAt,
+        author: {
+            name: userTable.name,
+            image: userTable.image,
+        },
+    })
+        .from(postsTable)
+        .leftJoin(userTable, eq(postsTable.authorId, userTable.id))
+        .orderBy(desc(postsTable.createdAt))
+        .limit(5);
+    return (_jsxs(Card, { children: [_jsxs(CardHeader, { children: [_jsx(CardTitle, { children: t("Recent Posts") }), _jsx(CardDescription, { children: t("The latest articles published on your blog.") })] }), _jsxs(CardContent, { className: "grid gap-8", children: [posts.map((post) => (_jsxs("div", { className: "flex items-center gap-4", children: [_jsxs(Avatar, { className: "h-9 w-9", children: [_jsx(AvatarImage, { src: post.author?.image || "", alt: "Avatar" }), _jsx(AvatarFallback, { children: post.author?.name?.substring(0, 2).toUpperCase() || "AU" })] }), _jsxs("div", { className: "grid gap-1", children: [_jsx("p", { className: "text-sm font-medium leading-none", children: post.title }), _jsx("p", { className: "text-sm text-muted-foreground", children: new Date(post.createdAt).toLocaleDateString() })] })] }, post.id))), posts.length === 0 && (_jsx("div", { className: "text-center py-4 text-muted-foreground", children: t("No posts found.") }))] })] }));
+}

package/dist/components/ui/button.d.ts

@@ -3,7 +3,7 @@ import * as React from "react";
 declare const buttonVariants: (props?: ({
     variant?: "link" | "default" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
     size?: "default" | "sm" | "lg" | "icon" | null | undefined;
-} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
 export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
     asChild?: boolean;
 }

package/dist/components/ui/button.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Slot } from "@radix-ui/react-slot";
+import { cva } from "class-variance-authority";
+import * as React from "react";
+import { cn } from "../../lib/utils.js";
+const buttonVariants = cva("inline-flex items-center justify-center whitespace-nowrap rounded-md text-sm font-medium transition-colors focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:pointer-events-none disabled:opacity-50", {
+    variants: {
+        variant: {
+            default: "bg-primary text-primary-foreground shadow hover:bg-primary/90",
+            destructive: "bg-destructive text-destructive-foreground shadow-sm hover:bg-destructive/90",
+            outline: "border border-input bg-background shadow-sm hover:bg-accent hover:text-accent-foreground",
+            secondary: "bg-secondary text-secondary-foreground shadow-sm hover:bg-secondary/80",
+            ghost: "hover:bg-accent hover:text-accent-foreground",
+            link: "text-primary underline-offset-4 hover:underline",
+        },
+        size: {
+            default: "h-9 px-4 py-2",
+            sm: "h-8 rounded-md px-3 text-xs",
+            lg: "h-10 rounded-md px-8",
+            icon: "size-9",
+        },
+    },
+    defaultVariants: {
+        variant: "default",
+        size: "default",
+    },
+});
+const Button = React.forwardRef(({ className, variant, size, asChild = false, ...props }, ref) => {
+    const Comp = asChild ? Slot : "button";
+    return (_jsx(Comp, { className: cn(buttonVariants({ variant, size, className })), ref: ref, ...props }));
+});
+Button.displayName = "Button";
+export { Button, buttonVariants };

package/dist/components/ui/card.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from "react";
+import { cn } from "../../lib/utils.js";
+const Card = React.forwardRef(({ className, ...props }, ref) => (_jsx("div", { ref: ref, className: cn("rounded-xl border bg-card text-card-foreground shadow", className), ...props })));
+Card.displayName = "Card";
+const CardHeader = React.forwardRef(({ className, ...props }, ref) => (_jsx("div", { ref: ref, className: cn("flex flex-col space-y-1.5 p-6", className), ...props })));
+CardHeader.displayName = "CardHeader";
+const CardTitle = React.forwardRef(({ className, ...props }, ref) => (_jsx("div", { ref: ref, className: cn("font-semibold leading-none tracking-tight", className), ...props })));
+CardTitle.displayName = "CardTitle";
+const CardContent = React.forwardRef(({ className, ...props }, ref) => (_jsx("div", { ref: ref, className: cn("p-6 pt-0", className), ...props })));
+CardContent.displayName = "CardContent";
+export { Card, CardHeader, CardTitle, CardContent };

package/dist/components/ui/input.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from "react";
+import { cn } from "../../lib/utils.js";
+const Input = React.forwardRef(({ className, type, ...props }, ref) => {
+    return (_jsx("input", { type: type, className: cn("flex h-9 w-full rounded-md border border-input bg-transparent px-3 py-1 text-sm shadow-sm transition-colors file:border-0 file:bg-transparent file:text-sm file:font-medium placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:cursor-not-allowed disabled:opacity-50", className), ref: ref, ...props }));
+});
+Input.displayName = "Input";
+export { Input };

package/dist/components/ui/table.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from "react";
+import { cn } from "../../lib/utils.js";
+const Table = React.forwardRef(({ className, ...props }, ref) => (_jsx("div", { className: "relative w-full overflow-auto", children: _jsx("table", { ref: ref, className: cn("w-full caption-bottom text-sm", className), ...props }) })));
+Table.displayName = "Table";
+const TableHeader = React.forwardRef(({ className, ...props }, ref) => (_jsx("thead", { ref: ref, className: cn("[&_tr]:border-b", className), ...props })));
+TableHeader.displayName = "TableHeader";
+const TableBody = React.forwardRef(({ className, ...props }, ref) => (_jsx("tbody", { ref: ref, className: cn("[&_tr:last-child]:border-0", className), ...props })));
+TableBody.displayName = "TableBody";
+const TableRow = React.forwardRef(({ className, ...props }, ref) => (_jsx("tr", { ref: ref, className: cn("border-b transition-colors hover:bg-muted/50 data-[state=selected]:bg-muted", className), ...props })));
+TableRow.displayName = "TableRow";
+const TableHead = React.forwardRef(({ className, ...props }, ref) => (_jsx("th", { ref: ref, className: cn("h-10 px-2 text-left align-middle font-medium text-muted-foreground [&:has([role=checkbox])]:pr-0 [&>[role=checkbox]]:translate-y-[2px]", className), ...props })));
+TableHead.displayName = "TableHead";
+const TableCell = React.forwardRef(({ className, ...props }, ref) => (_jsx("td", { ref: ref, className: cn("p-2 align-middle [&:has([role=checkbox])]:pr-0 [&>[role=checkbox]]:translate-y-[2px]", className), ...props })));
+TableCell.displayName = "TableCell";
+export { Table, TableHeader, TableBody, TableHead, TableRow, TableCell };

package/dist/components/ui/textarea.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from "react";
+import { cn } from "../../lib/utils.js";
+const Textarea = React.forwardRef(({ className, ...props }, ref) => {
+    return (_jsx("textarea", { className: cn("flex min-h-[60px] w-full rounded-md border border-input bg-transparent px-3 py-2 text-sm shadow-sm placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:cursor-not-allowed disabled:opacity-50", className), ref: ref, ...props }));
+});
+Textarea.displayName = "Textarea";
+export { Textarea };

package/dist/index.js

@@ -0,0 +1,98 @@
+import { assignPermissionToRole, createPermission, db, getRoles, permissionsTable, } from "@arch-cadre/core/server";
+import { inArray, sql } from "drizzle-orm";
+import manifest from "../manifest.json" with { type: "json" };
+import BlogStatsWidget from "./components/BlogStatsWidget.js";
+import RecentCommentsWidget from "./components/RecentCommentsWidget.js";
+import RecentPostsWidget from "./components/RecentPostsWidget.js";
+import { navigation } from "./navigation.js";
+import { privateRoutes, publicRoutes } from "./routes.js";
+const BLOG_PERMISSIONS = [
+    { name: "post:create", description: "Allow creating blog posts" },
+    { name: "post:update", description: "Allow updating blog posts" },
+    { name: "post:delete", description: "Allow deleting blog posts" },
+    { name: "comment:create", description: "Allow creating comments" },
+    { name: "comment:update", description: "Allow updating comments" },
+    { name: "comment:delete", description: "Allow deleting comments" },
+];
+// --- Module Definition ---
+const blogModule = {
+    manifest: manifest,
+    init: async () => {
+        console.log("[BlogModule] ready.");
+    },
+    widgets: [
+        {
+            id: "blog-stats",
+            name: "Blog Stats",
+            area: "dashboard-stats",
+            component: BlogStatsWidget,
+            priority: 20,
+        },
+        {
+            id: "recent-posts",
+            name: "Recent Posts",
+            area: "dashboard-main",
+            component: RecentPostsWidget,
+            priority: 20,
+        },
+        {
+            id: "recent-comments",
+            name: "Recent Comments",
+            area: "dashboard-main",
+            component: RecentCommentsWidget,
+            priority: 30,
+        },
+    ],
+    onEnable: async () => {
+        console.log("[BlogModule] enabling and registering permissions...");
+        try {
+            // 1. Create permissions
+            for (const perm of BLOG_PERMISSIONS) {
+                await createPermission(perm.name, perm.description);
+            }
+            // 2. Assign to admin role
+            const roles = await getRoles();
+            const adminRole = roles.find((r) => r.name === "admin");
+            if (adminRole) {
+                const blogPermNames = BLOG_PERMISSIONS.map((p) => p.name);
+                const blogPerms = await db
+                    .select()
+                    .from(permissionsTable)
+                    .where(inArray(permissionsTable.name, blogPermNames));
+                for (const p of blogPerms) {
+                    await assignPermissionToRole(adminRole.id, p.id);
+                }
+                console.log("[BlogModule] Permissions assigned to admin role.");
+            }
+        }
+        catch (error) {
+            console.error("[BlogModule] Error during permission registration:", error);
+        }
+        console.log("[BlogModule] enabled.");
+    },
+    onDisable: async () => {
+        console.log("[Blog] onDisable: Cleaning up tables and permissions...");
+        try {
+            // 1. Remove permissions (cascades to role-permission mappings)
+            const blogPermNames = BLOG_PERMISSIONS.map((p) => p.name);
+            await db
+                .delete(permissionsTable)
+                .where(inArray(permissionsTable.name, blogPermNames));
+            console.log("[BlogModule] Permissions and mappings removed.");
+            // 2. Drop tables
+            const tables = ["blog_posts", "blog_comments"];
+            for (const table of tables) {
+                await db.execute(sql.raw(`DROP TABLE IF EXISTS ${table} CASCADE`));
+            }
+        }
+        catch (e) {
+            console.error("[Blog] onDisable Error:", e);
+        }
+    },
+    routes: {
+        public: publicRoutes,
+        private: privateRoutes,
+    },
+    navigation: navigation,
+};
+export default blogModule;

package/dist/lib/{utils.mjs → utils.js}

@@ -1,5 +1,5 @@
 import { clsx } from "clsx";
 import { twMerge } from "tailwind-merge";
 export function cn(...inputs) {
-  return twMerge(clsx(inputs));
+    return twMerge(clsx(inputs));
 }

package/dist/lib/validation.d.ts

@@ -5,12 +5,12 @@ export declare const postSchema: z.ZodObject<{
     slug: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     title: string;
-    content: string;
     slug: string;
+    content: string;
 }, {
     title: string;
-    content: string;
     slug: string;
+    content: string;
 }>;
 export declare const commentSchema: z.ZodObject<{
     content: z.ZodString;

package/dist/lib/validation.js

@@ -0,0 +1,11 @@
+import { z } from "zod";
+// --- Validation Schemas ---
+export const postSchema = z.object({
+    title: z.string().min(3, "Title must be at least 3 characters"),
+    content: z.string().min(10, "Content must be at least 10 characters"),
+    slug: z.string().min(3, "Slug is required"),
+});
+export const commentSchema = z.object({
+    content: z.string().min(2, "Comment is too short"),
+    postId: z.string().uuid(),
+});

package/dist/navigation.js

@@ -0,0 +1,21 @@
+import { i18n } from "@arch-cadre/intl";
+export const navigation = {
+    public: [
+        {
+            title: i18n("Blog"),
+            url: "/blog",
+            icon: "solar:pen-2-broken",
+        },
+    ],
+    admin: {
+        [i18n("CMS")]: [
+            {
+                title: i18n("Blog Manager"),
+                url: "/blog",
+                icon: "solar:posts-carousel-vertical-broken",
+                roles: ["admin"],
+                permissions: ["post:create", "post:update", "post:delete"],
+            },
+        ],
+    },
+};

package/dist/routes.js

@@ -0,0 +1,55 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { getCurrentSession } from "@arch-cadre/core/server";
+import { getComments, getPostById, getPostBySlug, getPosts } from "./actions/index.js";
+import { BlogAdminPage, BlogListPage, CreatePostForm, EditPostForm, PostDetailPage, } from "./ui/views.js";
+export const publicRoutes = [
+    {
+        path: "/blog",
+        component: async () => {
+            const posts = await getPosts();
+            return _jsx(BlogListPage, { posts: posts });
+        },
+        auth: false,
+    },
+    {
+        path: "/blog/:slug",
+        component: async ({ params }) => {
+            const { slug } = await params;
+            const post = await getPostBySlug(slug);
+            const comments = post ? await getComments(post.id) : [];
+            const session = await getCurrentSession();
+            return (_jsx(PostDetailPage, { post: post, comments: comments, currentUser: session?.user }));
+        },
+        auth: false,
+    },
+];
+export const privateRoutes = [
+    {
+        path: "/blog",
+        component: async () => {
+            const posts = await getPosts();
+            return _jsx(BlogAdminPage, { posts: posts });
+        },
+        auth: true,
+        roles: ["admin"],
+        permissions: ["post:create", "post:update", "post:delete"],
+    },
+    {
+        path: "/blog/new",
+        component: CreatePostForm,
+        auth: true,
+        roles: ["admin"],
+        permissions: ["post:create"],
+    },
+    {
+        path: "/blog/edit/:id",
+        component: async ({ params }) => {
+            const { id } = await params;
+            const post = await getPostById(id);
+            return _jsx(EditPostForm, { post: post });
+        },
+        auth: true,
+        roles: ["admin"],
+        permissions: ["post:update"],
+    },
+];

package/dist/schema.js

@@ -0,0 +1,60 @@
+import { userTable } from "@arch-cadre/core";
+import { defineRelations } from "drizzle-orm";
+import { pgTable, text, timestamp } from "drizzle-orm/pg-core";
+export const postsTable = pgTable("blog_posts", {
+    id: text("id")
+        .primaryKey()
+        .$defaultFn(() => crypto.randomUUID()),
+    title: text("title").notNull(),
+    slug: text("slug").unique().notNull(),
+    content: text("content").notNull(),
+    authorId: text("author_id")
+        .references(() => userTable.id, { onDelete: "cascade" })
+        .notNull(),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+});
+export const commentsTable = pgTable("blog_comments", {
+    id: text("id")
+        .primaryKey()
+        .$defaultFn(() => crypto.randomUUID()),
+    postId: text("post_id")
+        .references(() => postsTable.id, { onDelete: "cascade" })
+        .notNull(),
+    authorId: text("author_id")
+        .references(() => userTable.id, { onDelete: "cascade" })
+        .notNull(),
+    content: text("content").notNull(),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+});
+export const blogSchema = {
+    postsTable,
+    commentsTable,
+};
+export const relations = defineRelations({
+    user: userTable,
+    post: postsTable,
+    comment: commentsTable,
+}, (r) => ({
+    user: {
+        posts: r.many.post({
+            from: r.user.id,
+            to: r.post.authorId,
+        }),
+        comments: r.many.comment({
+            from: r.user.id,
+            to: r.comment.authorId,
+        }),
+    },
+    post: {
+        comments: r.many.comment({
+            from: r.post.id,
+            to: r.comment.postId,
+        }),
+    },
+    comment: {
+        post: r.one.post({
+            from: r.comment.postId,
+            to: r.post.id,
+        }),
+    },
+}));