@jant/core 0.3.23 → 0.3.25

package/dist/routes/pages/page.js

@@ -2,39 +2,67 @@ import { jsx as _jsx } from "hono/jsx/jsx-runtime";
 /**
  * Custom Page Route
  *
- * Catch-all route for custom pages accessible via their path field
+ * Serves pages from the pages table and posts with custom paths.
+ * This is a catch-all route mounted at "/" - must be registered last.
+ * Supports multi-level paths (e.g. /2024/my-post) for posts.
  */ import { Hono } from "hono";
-import { SinglePage as DefaultSinglePage } from "../../themes/minimal/pages/SinglePage.js";
+import { SinglePage } from "../../ui/pages/SinglePage.js";
+import { PostPage } from "../../ui/pages/PostPage.js";
 import { getNavigationData } from "../../lib/navigation.js";
 import { renderPublicPage } from "../../lib/render.js";
-import { createMediaContext, toPostViewFromPost } from "../../lib/view.js";
+import { buildMediaMap } from "../../lib/media-helpers.js";
+import { createMediaContext, toPageView, toPostView } from "../../lib/view.js";
 export const pageRoutes = new Hono();
-// Catch-all for custom page paths
-pageRoutes.get("/:path", async (c)=>{
-    const path = c.req.param("path");
-    // Look up page by path
-    const page = await c.var.services.posts.getByPath(path);
-    // Not found or not a page
-    if (!page || page.type !== "page") {
-        return c.notFound();
+// Catch-all for custom page slugs and post paths (including multi-level)
+pageRoutes.get("/*", async (c)=>{
+    const fullPath = c.req.path.slice(1); // Remove leading /
+    if (!fullPath) return c.notFound();
+    const isMultiSegment = fullPath.includes("/");
+    // Pages only have single-level slugs; skip page lookup for multi-segment paths
+    if (!isMultiSegment) {
+        const page = await c.var.services.pages.getBySlug(fullPath);
+        if (page) {
+            if (page.status === "draft") {
+                return c.notFound();
+            }
+            const navData = await getNavigationData(c);
+            const pageView = toPageView(page);
+            return renderPublicPage(c, {
+                title: `${page.title || fullPath} - ${navData.siteName}`,
+                description: page.body?.slice(0, 160),
+                navData,
+                content: /*#__PURE__*/ _jsx(SinglePage, {
+                    page: pageView
+                })
+            });
+        }
     }
-    // Don't show drafts
-    if (page.visibility === "draft") {
-        return c.notFound();
+    // Posts support multi-level paths
+    const post = await c.var.services.posts.getByPath(fullPath);
+    if (post) {
+        if (post.status === "draft") {
+            return c.notFound();
+        }
+        // Load media attachments
+        const rawMediaMap = await c.var.services.media.getByPostIds([
+            post.id
+        ]);
+        const mediaCtx = createMediaContext(c);
+        const mediaMap = buildMediaMap(rawMediaMap, mediaCtx.r2PublicUrl, mediaCtx.imageTransformUrl, mediaCtx.s3PublicUrl);
+        const postView = toPostView({
+            ...post,
+            mediaAttachments: mediaMap.get(post.id) ?? []
+        }, mediaCtx);
+        const navData = await getNavigationData(c);
+        const title = post.title || navData.siteName;
+        return renderPublicPage(c, {
+            title,
+            description: post.body?.slice(0, 160),
+            navData,
+            content: /*#__PURE__*/ _jsx(PostPage, {
+                post: postView
+            })
+        });
     }
-    const navData = await getNavigationData(c);
-    // Transform to View Model
-    const mediaCtx = createMediaContext(c);
-    const pageView = toPostViewFromPost(page, mediaCtx);
-    const components = c.var.config.theme?.components;
-    const Page = components?.SinglePage ?? DefaultSinglePage;
-    return renderPublicPage(c, {
-        title: `${page.title} - ${navData.siteName}`,
-        description: page.content?.slice(0, 160),
-        navData,
-        content: /*#__PURE__*/ _jsx(Page, {
-            page: pageView,
-            theme: components
-        })
-    });
+    return c.notFound();
 });

package/dist/routes/pages/post.js

@@ -2,7 +2,7 @@ import { jsx as _jsx } from "hono/jsx/jsx-runtime";
 /**
  * Single Post Page Route
  */ import { Hono } from "hono";
-import { PostPage as DefaultPostPage } from "../../themes/minimal/pages/PostPage.js";
+import { PostPage } from "../../ui/pages/PostPage.js";
 import * as sqid from "../../lib/sqid.js";
 import { getNavigationData } from "../../lib/navigation.js";
 import { renderPublicPage } from "../../lib/render.js";
@@ -11,20 +11,13 @@ import { createMediaContext, toPostView } from "../../lib/view.js";
 export const postRoutes = new Hono();
 postRoutes.get("/:id", async (c)=>{
     const paramId = c.req.param("id");
-    // Try to decode as sqid first
-    let id = sqid.decode(paramId);
-    // If not a valid sqid, try to find by path
-    if (!id) {
-        const post = await c.var.services.posts.getByPath(paramId);
-        if (post) {
-            id = post.id;
-        }
-    }
+    // Decode sqid to numeric ID
+    const id = sqid.decode(paramId);
     if (!id) return c.notFound();
     const post = await c.var.services.posts.getById(id);
     if (!post) return c.notFound();
     // Don't show drafts on public site
-    if (post.visibility === "draft") {
+    if (post.status === "draft") {
         return c.notFound();
     }
     // Batch load media attachments
@@ -40,15 +33,12 @@ postRoutes.get("/:id", async (c)=>{
     }, mediaCtx);
     const navData = await getNavigationData(c);
     const title = post.title || navData.siteName;
-    const components = c.var.config.theme?.components;
-    const Page = components?.PostPage ?? DefaultPostPage;
     return renderPublicPage(c, {
         title,
-        description: post.content?.slice(0, 160),
+        description: post.body?.slice(0, 160),
         navData,
-        content: /*#__PURE__*/ _jsx(Page, {
-            post: postView,
-            theme: components
+        content: /*#__PURE__*/ _jsx(PostPage, {
+            post: postView
         })
     });
 });

package/dist/routes/pages/search.js

@@ -2,7 +2,7 @@ import { jsx as _jsx } from "hono/jsx/jsx-runtime";
 /**
  * Search Page Route
  */ import { Hono } from "hono";
-import { SearchPage as DefaultSearchPage } from "../../themes/minimal/pages/SearchPage.js";
+import { SearchPage } from "../../ui/pages/SearchPage.js";
 import { getNavigationData } from "../../lib/navigation.js";
 import { renderPublicPage } from "../../lib/render.js";
 import { createMediaContext, toSearchResultViews } from "../../lib/view.js";
@@ -23,9 +23,8 @@ searchRoutes.get("/", async (c)=>{
             results = await c.var.services.search.search(query, {
                 limit: PAGE_SIZE + 1,
                 offset: (page - 1) * PAGE_SIZE,
-                visibility: [
-                    "featured",
-                    "quiet"
+                status: [
+                    "published"
                 ]
             });
             hasMore = results.length > PAGE_SIZE;
@@ -41,18 +40,15 @@ searchRoutes.get("/", async (c)=>{
     // Transform to View Models
     const mediaCtx = createMediaContext(c);
     const resultViews = toSearchResultViews(results, mediaCtx);
-    const components = c.var.config.theme?.components;
-    const Page = components?.SearchPage ?? DefaultSearchPage;
     return renderPublicPage(c, {
         title: query ? `Search: ${query} - ${navData.siteName}` : `Search - ${navData.siteName}`,
         navData,
-        content: /*#__PURE__*/ _jsx(Page, {
+        content: /*#__PURE__*/ _jsx(SearchPage, {
             query: query,
             results: resultViews,
             error: error,
             hasMore: hasMore,
-            page: page,
-            theme: components
+            page: page
         })
     });
 });

package/dist/services/collection.js

@@ -1,37 +1,21 @@
 /**
- * Collection Service
+ * Collection Service (v2)
  *
- * Manages collections and post-collection relationships
- */ import { eq, desc, and } from "drizzle-orm";
-import { collections, postCollections, posts } from "../db/schema.js";
+ * Manages collections. Posts belong to collections via posts.collection_id (1:M).
+ */ import { eq, asc, sql, desc } from "drizzle-orm";
+import { collections, posts } from "../db/schema.js";
 import { now } from "../lib/time.js";
 export function createCollectionService(db) {
     function toCollection(row) {
         return {
             id: row.id,
+            slug: row.slug,
             title: row.title,
-            path: row.path,
             description: row.description,
-            createdAt: row.createdAt,
-            updatedAt: row.updatedAt
-        };
-    }
-    function toPost(row) {
-        return {
-            id: row.id,
-            type: row.type,
-            visibility: row.visibility,
-            title: row.title,
-            path: row.path,
-            content: row.content,
-            contentHtml: row.contentHtml,
-            sourceUrl: row.sourceUrl,
-            sourceName: row.sourceName,
-            sourceDomain: row.sourceDomain,
-            replyToId: row.replyToId,
-            threadId: row.threadId,
-            deletedAt: row.deletedAt,
-            publishedAt: row.publishedAt,
+            icon: row.icon,
+            sortOrder: row.sortOrder,
+            position: row.position,
+            showDivider: row.showDivider,
             createdAt: row.createdAt,
             updatedAt: row.updatedAt
         };
@@ -41,20 +25,32 @@ export function createCollectionService(db) {
             const result = await db.select().from(collections).where(eq(collections.id, id)).limit(1);
             return result[0] ? toCollection(result[0]) : null;
         },
-        async getByPath (path) {
-            const result = await db.select().from(collections).where(eq(collections.path, path)).limit(1);
+        async getBySlug (slug) {
+            const result = await db.select().from(collections).where(eq(collections.slug, slug)).limit(1);
             return result[0] ? toCollection(result[0]) : null;
         },
         async list () {
-            const rows = await db.select().from(collections).orderBy(desc(collections.createdAt));
+            const rows = await db.select().from(collections).orderBy(asc(collections.position), desc(collections.createdAt));
             return rows.map(toCollection);
         },
         async create (data) {
             const timestamp = now();
+            let position = data.position;
+            if (position === undefined) {
+                const maxResult = await db.select({
+                    maxPos: sql`COALESCE(MAX(position), -1)`
+                }).from(collections);
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- aggregate always returns one row
+                position = maxResult[0].maxPos + 1;
+            }
             const result = await db.insert(collections).values({
+                slug: data.slug,
                 title: data.title,
-                path: data.path || null,
                 description: data.description ?? null,
+                icon: data.icon ?? null,
+                sortOrder: data.sortOrder ?? "newest",
+                position,
+                showDivider: data.showDivider ? 1 : 0,
                 createdAt: timestamp,
                 updatedAt: timestamp
             }).returning();
@@ -69,53 +65,45 @@ export function createCollectionService(db) {
                 updatedAt: timestamp
             };
             if (data.title !== undefined) updates.title = data.title;
-            if (data.path !== undefined) updates.path = data.path;
+            if (data.slug !== undefined) updates.slug = data.slug;
             if (data.description !== undefined) updates.description = data.description;
+            if (data.icon !== undefined) updates.icon = data.icon;
+            if (data.sortOrder !== undefined) updates.sortOrder = data.sortOrder;
+            if (data.position !== undefined) updates.position = data.position;
+            if (data.showDivider !== undefined) updates.showDivider = data.showDivider ? 1 : 0;
             const result = await db.update(collections).set(updates).where(eq(collections.id, id)).returning();
             return result[0] ? toCollection(result[0]) : null;
         },
         async delete (id) {
-            // Delete all post-collection relationships first
-            await db.delete(postCollections).where(eq(postCollections.collectionId, id));
+            // Clear collection_id on posts that belong to this collection
+            await db.update(posts).set({
+                collectionId: null
+            }).where(eq(posts.collectionId, id));
             const result = await db.delete(collections).where(eq(collections.id, id)).returning();
             return result.length > 0;
         },
-        async addPost (collectionId, postId) {
+        async reorder (ids) {
             const timestamp = now();
-            // Upsert the relationship
-            await db.insert(postCollections).values({
-                postId,
-                collectionId,
-                addedAt: timestamp
-            }).onConflictDoNothing();
-        },
-        async removePost (collectionId, postId) {
-            await db.delete(postCollections).where(and(eq(postCollections.collectionId, collectionId), eq(postCollections.postId, postId)));
-        },
-        async getPosts (collectionId) {
-            const rows = await db.select({
-                post: posts
-            }).from(postCollections).innerJoin(posts, eq(postCollections.postId, posts.id)).where(eq(postCollections.collectionId, collectionId)).orderBy(desc(postCollections.addedAt));
-            return rows.map((r)=>toPost(r.post));
+            for(let i = 0; i < ids.length; i++){
+                await db.update(collections).set({
+                    position: i,
+                    updatedAt: timestamp
+                })// eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- loop index guarantees element exists
+                .where(eq(collections.id, ids[i]));
+            }
         },
-        async getCollectionsForPost (postId) {
+        async getPostCounts () {
             const rows = await db.select({
-                collection: collections
-            }).from(postCollections).innerJoin(collections, eq(postCollections.collectionId, collections.id)).where(eq(postCollections.postId, postId));
-            return rows.map((r)=>toCollection(r.collection));
-        },
-        async syncPostCollections (postId, collectionIds) {
-            const current = await this.getCollectionsForPost(postId);
-            const currentIds = new Set(current.map((c)=>c.id));
-            const desiredIds = new Set(collectionIds);
-            const toAdd = collectionIds.filter((id)=>!currentIds.has(id));
-            const toRemove = current.map((c)=>c.id).filter((id)=>!desiredIds.has(id));
-            for (const collectionId of toAdd){
-                await this.addPost(collectionId, postId);
-            }
-            for (const collectionId of toRemove){
-                await this.removePost(collectionId, postId);
+                collectionId: posts.collectionId,
+                count: sql`count(*)`.as("count")
+            }).from(posts).where(sql`${posts.collectionId} IS NOT NULL AND ${posts.deletedAt} IS NULL`).groupBy(posts.collectionId);
+            const counts = new Map();
+            for (const row of rows){
+                if (row.collectionId !== null) {
+                    counts.set(row.collectionId, row.count);
+                }
             }
+            return counts;
         }
     };
 }

package/dist/services/index.js

@@ -1,22 +1,24 @@
 /**
- * Services
+ * Services (v2)
  *
  * Business logic layer
  */ import { createSettingsService } from "./settings.js";
 import { createPostService } from "./post.js";
+import { createPageService } from "./page.js";
 import { createRedirectService } from "./redirect.js";
 import { createMediaService } from "./media.js";
 import { createCollectionService } from "./collection.js";
 import { createSearchService } from "./search.js";
-import { createNavigationLinkService } from "./navigation.js";
+import { createNavItemService } from "./navigation.js";
 export function createServices(db, d1) {
     return {
         settings: createSettingsService(db),
         posts: createPostService(db),
+        pages: createPageService(db),
         redirects: createRedirectService(db),
         media: createMediaService(db),
         collections: createCollectionService(db),
         search: createSearchService(d1),
-        navigationLinks: createNavigationLinkService(db)
+        navItems: createNavItemService(db)
     };
 }

package/dist/services/navigation.js

@@ -1,16 +1,18 @@
 /**
- * Navigation Link Service
+ * Nav Item Service (v2)
  *
- * Manages navigation links displayed on public pages
+ * Manages navigation items (page links and external links)
  */ import { eq, asc, sql } from "drizzle-orm";
-import { navigationLinks } from "../db/schema.js";
+import { navItems } from "../db/schema.js";
 import { now } from "../lib/time.js";
-export function createNavigationLinkService(db) {
-    function toNavigationLink(row) {
+export function createNavItemService(db) {
+    function toNavItem(row) {
         return {
             id: row.id,
+            type: row.type,
             label: row.label,
             url: row.url,
+            pageId: row.pageId,
             position: row.position,
             createdAt: row.createdAt,
             updatedAt: row.updatedAt
@@ -18,12 +20,12 @@ export function createNavigationLinkService(db) {
     }
     return {
         async list () {
-            const rows = await db.select().from(navigationLinks).orderBy(asc(navigationLinks.position));
-            return rows.map(toNavigationLink);
+            const rows = await db.select().from(navItems).orderBy(asc(navItems.position));
+            return rows.map(toNavItem);
         },
         async getById (id) {
-            const result = await db.select().from(navigationLinks).where(eq(navigationLinks.id, id)).limit(1);
-            return result[0] ? toNavigationLink(result[0]) : null;
+            const result = await db.select().from(navItems).where(eq(navItems.id, id)).limit(1);
+            return result[0] ? toNavItem(result[0]) : null;
         },
         async create (data) {
             const timestamp = now();
@@ -31,85 +33,59 @@ export function createNavigationLinkService(db) {
             if (position === undefined) {
                 const maxResult = await db.select({
                     maxPos: sql`COALESCE(MAX(position), -1)`
-                }).from(navigationLinks);
+                }).from(navItems);
                 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- aggregate always returns one row
                 position = maxResult[0].maxPos + 1;
             }
-            const result = await db.insert(navigationLinks).values({
+            const result = await db.insert(navItems).values({
+                type: data.type,
                 label: data.label,
                 url: data.url,
+                pageId: data.pageId ?? null,
                 position,
                 createdAt: timestamp,
                 updatedAt: timestamp
             }).returning();
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- DB insert with .returning() always returns inserted row
-            return toNavigationLink(result[0]);
+            return toNavItem(result[0]);
         },
         async update (id, data) {
-            const existing = await db.select().from(navigationLinks).where(eq(navigationLinks.id, id)).limit(1);
+            const existing = await db.select().from(navItems).where(eq(navItems.id, id)).limit(1);
             if (!existing[0]) return null;
             const timestamp = now();
-            const result = await db.update(navigationLinks).set({
+            const result = await db.update(navItems).set({
+                ...data.type !== undefined && {
+                    type: data.type
+                },
                 ...data.label !== undefined && {
                     label: data.label
                 },
                 ...data.url !== undefined && {
                     url: data.url
                 },
+                ...data.pageId !== undefined && {
+                    pageId: data.pageId
+                },
                 ...data.position !== undefined && {
                     position: data.position
                 },
                 updatedAt: timestamp
-            }).where(eq(navigationLinks.id, id)).returning();
-            return result[0] ? toNavigationLink(result[0]) : null;
+            }).where(eq(navItems.id, id)).returning();
+            return result[0] ? toNavItem(result[0]) : null;
         },
         async delete (id) {
-            const result = await db.delete(navigationLinks).where(eq(navigationLinks.id, id)).returning();
+            const result = await db.delete(navItems).where(eq(navItems.id, id)).returning();
             return result.length > 0;
         },
         async reorder (ids) {
             const timestamp = now();
             for(let i = 0; i < ids.length; i++){
-                await db.update(navigationLinks).set({
+                await db.update(navItems).set({
                     position: i,
                     updatedAt: timestamp
                 })// eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- loop index guarantees element exists
-                .where(eq(navigationLinks.id, ids[i]));
-            }
-        },
-        async ensureDefaults () {
-            const existing = await db.select().from(navigationLinks).limit(1);
-            if (existing.length > 0) {
-                const rows = await db.select().from(navigationLinks).orderBy(asc(navigationLinks.position));
-                return rows.map(toNavigationLink);
-            }
-            const timestamp = now();
-            const defaults = [
-                {
-                    label: "Home",
-                    url: "/",
-                    position: 0
-                },
-                {
-                    label: "Archive",
-                    url: "/archive",
-                    position: 1
-                },
-                {
-                    label: "RSS",
-                    url: "/feed",
-                    position: 2
-                }
-            ];
-            for (const link of defaults){
-                await db.insert(navigationLinks).values({
-                    ...link,
-                    createdAt: timestamp,
-                    updatedAt: timestamp
-                });
+                .where(eq(navItems.id, ids[i]));
             }
-            const rows = await db.select().from(navigationLinks).orderBy(asc(navigationLinks.position));
-            return rows.map(toNavigationLink);
         }
     };
 }

package/dist/services/page.js

@@ -0,0 +1,84 @@
+/**
+ * Page Service
+ *
+ * CRUD operations for standalone pages (about, now, etc.)
+ */ import { eq, desc, sql } from "drizzle-orm";
+import { pages, navItems } from "../db/schema.js";
+import { now } from "../lib/time.js";
+import { render as renderMarkdown } from "../lib/markdown.js";
+export function createPageService(db) {
+    function toPage(row) {
+        return {
+            id: row.id,
+            slug: row.slug,
+            title: row.title,
+            body: row.body,
+            bodyHtml: row.bodyHtml,
+            status: row.status,
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt
+        };
+    }
+    return {
+        async getById (id) {
+            const result = await db.select().from(pages).where(eq(pages.id, id)).limit(1);
+            return result[0] ? toPage(result[0]) : null;
+        },
+        async getBySlug (slug) {
+            const result = await db.select().from(pages).where(eq(pages.slug, slug)).limit(1);
+            return result[0] ? toPage(result[0]) : null;
+        },
+        async list () {
+            const rows = await db.select().from(pages).orderBy(desc(pages.createdAt));
+            return rows.map(toPage);
+        },
+        async listNotInNav () {
+            const rows = await db.select().from(pages).where(sql`${pages.id} NOT IN (SELECT ${navItems.pageId} FROM ${navItems} WHERE ${navItems.pageId} IS NOT NULL)`).orderBy(desc(pages.createdAt));
+            return rows.map(toPage);
+        },
+        async create (data) {
+            const timestamp = now();
+            const bodyHtml = data.body ? renderMarkdown(data.body) : null;
+            const result = await db.insert(pages).values({
+                slug: data.slug,
+                title: data.title ?? null,
+                body: data.body ?? null,
+                bodyHtml,
+                status: data.status ?? "published",
+                createdAt: timestamp,
+                updatedAt: timestamp
+            }).returning();
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- DB insert with .returning() always returns inserted row
+            return toPage(result[0]);
+        },
+        async update (id, data) {
+            const existing = await this.getById(id);
+            if (!existing) return null;
+            const timestamp = now();
+            const updates = {
+                updatedAt: timestamp
+            };
+            if (data.slug !== undefined) updates.slug = data.slug;
+            if (data.title !== undefined) updates.title = data.title;
+            if (data.status !== undefined) updates.status = data.status;
+            if (data.body !== undefined) {
+                updates.body = data.body;
+                updates.bodyHtml = data.body ? renderMarkdown(data.body) : null;
+            }
+            // If slug changed, update related nav_items
+            if (data.slug !== undefined && data.slug !== existing.slug) {
+                await db.update(navItems).set({
+                    url: `/${data.slug}`,
+                    updatedAt: timestamp
+                }).where(eq(navItems.pageId, id));
+            }
+            const result = await db.update(pages).set(updates).where(eq(pages.id, id)).returning();
+            return result[0] ? toPage(result[0]) : null;
+        },
+        async delete (id) {
+            // nav_items with page_id FK have ON DELETE CASCADE, so they auto-delete
+            const result = await db.delete(pages).where(eq(pages.id, id)).returning();
+            return result.length > 0;
+        }
+    };
+}