@jant/core 0.3.7 → 0.3.9

package/dist/routes/api/posts.js

@@ -4,12 +4,13 @@
 import * as sqid from "../../lib/sqid.js";
 import { CreatePostSchema, UpdatePostSchema, validateMediaForPostType } from "../../lib/schemas.js";
 import { requireAuthApi } from "../../middleware/auth.js";
-import { getMediaUrl, getImageUrl } from "../../lib/image.js";
+import { getMediaUrl, getImageUrl, getPublicUrlForProvider } from "../../lib/image.js";
 export const postsApiRoutes = new Hono();
 /**
  * Converts a Media record to a MediaAttachment API response shape.
- */ function toMediaAttachment(m, r2PublicUrl, imageTransformUrl) {
-    const url = getMediaUrl(m.id, m.r2Key, r2PublicUrl);
+ */ function toMediaAttachment(m, r2PublicUrl, imageTransformUrl, s3PublicUrl) {
+    const publicUrl = getPublicUrlForProvider(m.provider, r2PublicUrl, s3PublicUrl);
+    const url = getMediaUrl(m.id, m.storageKey, publicUrl);
     const previewUrl = getImageUrl(url, imageTransformUrl, {
         width: 400,
         quality: 80,
@@ -50,11 +51,12 @@ postsApiRoutes.get("/", async (c)=>{
     const mediaMap = await c.var.services.media.getByPostIds(postIds);
     const r2PublicUrl = c.env.R2_PUBLIC_URL;
     const imageTransformUrl = c.env.IMAGE_TRANSFORM_URL;
+    const s3PublicUrl = c.env.S3_PUBLIC_URL;
     return c.json({
         posts: posts.map((p)=>({
                 ...p,
                 sqid: sqid.encode(p.id),
-                mediaAttachments: (mediaMap.get(p.id) ?? []).map((m)=>toMediaAttachment(m, r2PublicUrl, imageTransformUrl))
+                mediaAttachments: (mediaMap.get(p.id) ?? []).map((m)=>toMediaAttachment(m, r2PublicUrl, imageTransformUrl, s3PublicUrl))
             })),
         nextCursor: posts.length === limit ? sqid.encode(posts[posts.length - 1]?.id ?? 0) : null
     });
@@ -72,10 +74,11 @@ postsApiRoutes.get("/:id", async (c)=>{
     const mediaList = await c.var.services.media.getByPostId(post.id);
     const r2PublicUrl = c.env.R2_PUBLIC_URL;
     const imageTransformUrl = c.env.IMAGE_TRANSFORM_URL;
+    const s3PublicUrl = c.env.S3_PUBLIC_URL;
     return c.json({
         ...post,
         sqid: sqid.encode(post.id),
-        mediaAttachments: mediaList.map((m)=>toMediaAttachment(m, r2PublicUrl, imageTransformUrl))
+        mediaAttachments: mediaList.map((m)=>toMediaAttachment(m, r2PublicUrl, imageTransformUrl, s3PublicUrl))
     });
 });
 // Create post (requires auth)
@@ -126,10 +129,11 @@ postsApiRoutes.post("/", requireAuthApi(), async (c)=>{
     const mediaList = await c.var.services.media.getByPostId(post.id);
     const r2PublicUrl = c.env.R2_PUBLIC_URL;
     const imageTransformUrl = c.env.IMAGE_TRANSFORM_URL;
+    const s3PublicUrl = c.env.S3_PUBLIC_URL;
     return c.json({
         ...post,
         sqid: sqid.encode(post.id),
-        mediaAttachments: mediaList.map((m)=>toMediaAttachment(m, r2PublicUrl, imageTransformUrl))
+        mediaAttachments: mediaList.map((m)=>toMediaAttachment(m, r2PublicUrl, imageTransformUrl, s3PublicUrl))
     }, 201);
 });
 // Update post (requires auth)
@@ -195,10 +199,11 @@ postsApiRoutes.put("/:id", requireAuthApi(), async (c)=>{
     const mediaList = await c.var.services.media.getByPostId(post.id);
     const r2PublicUrl = c.env.R2_PUBLIC_URL;
     const imageTransformUrl = c.env.IMAGE_TRANSFORM_URL;
+    const s3PublicUrl = c.env.S3_PUBLIC_URL;
     return c.json({
         ...post,
         sqid: sqid.encode(post.id),
-        mediaAttachments: mediaList.map((m)=>toMediaAttachment(m, r2PublicUrl, imageTransformUrl))
+        mediaAttachments: mediaList.map((m)=>toMediaAttachment(m, r2PublicUrl, imageTransformUrl, s3PublicUrl))
     });
 });
 // Delete post (requires auth)

package/dist/routes/api/timeline.js

@@ -0,0 +1,116 @@
+import { jsx as _jsx } from "hono/jsx/jsx-runtime";
+/**
+ * Timeline API Routes
+ *
+ * Provides load-more functionality for the timeline feed via SSE.
+ */ import { Hono } from "hono";
+import { sse } from "../../lib/sse.js";
+import { buildMediaMap } from "../../lib/media-helpers.js";
+import { TimelineItem } from "../../theme/components/timeline/TimelineItem.js";
+import { ThreadPreview } from "../../theme/components/timeline/ThreadPreview.js";
+const PAGE_SIZE = 20;
+export const timelineApiRoutes = new Hono();
+timelineApiRoutes.get("/", async (c)=>{
+    const cursorParam = c.req.query("cursor");
+    const cursor = cursorParam ? parseInt(cursorParam, 10) : undefined;
+    if (!cursor || isNaN(cursor)) {
+        return c.json({
+            error: "cursor parameter required"
+        }, 400);
+    }
+    // Fetch one extra to determine if there are more
+    const posts = await c.var.services.posts.list({
+        visibility: [
+            "featured",
+            "quiet"
+        ],
+        excludeReplies: true,
+        excludeTypes: [
+            "page"
+        ],
+        limit: PAGE_SIZE + 1,
+        cursor
+    });
+    const hasMore = posts.length > PAGE_SIZE;
+    const displayPosts = hasMore ? posts.slice(0, PAGE_SIZE) : posts;
+    if (displayPosts.length === 0) {
+        return sse(c, async (stream)=>{
+            stream.remove("#load-more-container");
+        });
+    }
+    // Build media map
+    const postIds = displayPosts.map((p)=>p.id);
+    const rawMediaMap = await c.var.services.media.getByPostIds(postIds);
+    const r2PublicUrl = c.env.R2_PUBLIC_URL;
+    const imageTransformUrl = c.env.IMAGE_TRANSFORM_URL;
+    const s3PublicUrl = c.env.S3_PUBLIC_URL;
+    const mediaMap = buildMediaMap(rawMediaMap, r2PublicUrl, imageTransformUrl, s3PublicUrl);
+    // Get reply counts to identify thread roots
+    const replyCounts = await c.var.services.posts.getReplyCounts(postIds);
+    const threadRootIds = postIds.filter((id)=>(replyCounts.get(id) ?? 0) > 0);
+    // Get thread previews
+    const threadPreviews = await c.var.services.posts.getThreadPreviews(threadRootIds, 3);
+    // Load media for preview replies
+    const previewReplyIds = [];
+    for (const replies of threadPreviews.values()){
+        for (const reply of replies){
+            previewReplyIds.push(reply.id);
+        }
+    }
+    const previewMediaMap = previewReplyIds.length > 0 ? buildMediaMap(await c.var.services.media.getByPostIds(previewReplyIds), r2PublicUrl, imageTransformUrl, s3PublicUrl) : new Map();
+    // Assemble timeline items
+    const items = displayPosts.map((post)=>{
+        const postWithMedia = {
+            ...post,
+            mediaAttachments: mediaMap.get(post.id) ?? []
+        };
+        const replyCount = replyCounts.get(post.id) ?? 0;
+        const previewReplies = threadPreviews.get(post.id);
+        if (replyCount > 0 && previewReplies) {
+            return {
+                post: postWithMedia,
+                threadPreview: {
+                    replies: previewReplies.map((r)=>({
+                            ...r,
+                            mediaAttachments: previewMediaMap.get(r.id) ?? []
+                        })),
+                    totalReplyCount: replyCount
+                }
+            };
+        }
+        return {
+            post: postWithMedia
+        };
+    });
+    // Render items to HTML
+    const itemsHtml = items.map((item)=>{
+        if (item.threadPreview) {
+            return /*#__PURE__*/ _jsx(ThreadPreview, {
+                rootPost: item.post,
+                previewReplies: item.threadPreview.replies,
+                totalReplyCount: item.threadPreview.totalReplyCount
+            });
+        }
+        return /*#__PURE__*/ _jsx(TimelineItem, {
+            item: item
+        });
+    }).map((jsx)=>jsx.toString()).join("");
+    // Determine next cursor
+    const lastPost = displayPosts[displayPosts.length - 1];
+    const nextCursor = hasMore && lastPost ? lastPost.id : undefined;
+    // Build load-more button HTML
+    const loadMoreHtml = nextCursor ? `<div id="load-more-container" class="mt-6 text-center"><button class="btn btn-outline" data-on:click="@get('/api/timeline?cursor=${nextCursor}')">Load more</button></div>` : "";
+    return sse(c, async (stream)=>{
+        // Append new items to the feed
+        stream.patchElements(itemsHtml, {
+            mode: "append",
+            selector: "#timeline-feed"
+        });
+        // Replace or remove the load-more container
+        if (loadMoreHtml) {
+            stream.patchElements(loadMoreHtml);
+        } else {
+            stream.remove("#load-more-container");
+        }
+    });
+});

package/dist/routes/api/upload.js

@@ -5,16 +5,17 @@
  * Supports both JSON and SSE (Datastar) responses.
  */ import { Hono } from "hono";
 import { html } from "hono/html";
+import { uuidv7 } from "uuidv7";
 import { requireAuthApi } from "../../middleware/auth.js";
-import { getMediaUrl, getImageUrl } from "../../lib/image.js";
+import { getMediaUrl, getImageUrl, getPublicUrlForProvider } from "../../lib/image.js";
 import { sse, dsSignals } from "../../lib/sse.js";
 export const uploadApiRoutes = new Hono();
 // Require auth for all upload routes
 uploadApiRoutes.use("*", requireAuthApi());
 /**
  * Render a media card HTML string for SSE response
- */ function renderMediaCard(media, r2PublicUrl, imageTransformUrl) {
-    const fullUrl = getMediaUrl(media.id, media.r2Key, r2PublicUrl);
+ */ function renderMediaCard(media, publicUrl, imageTransformUrl) {
+    const fullUrl = getMediaUrl(media.id, media.storageKey, publicUrl);
     const thumbnailUrl = getImageUrl(fullUrl, imageTransformUrl, {
         width: 300,
         quality: 80,
@@ -86,14 +87,15 @@ function formatSize(bytes) {
 }
 // Upload a file
 uploadApiRoutes.post("/", async (c)=>{
-    if (!c.env.R2) {
+    const storage = c.var.storage;
+    if (!storage) {
         if (wantsSSE(c)) {
             return dsSignals({
-                _uploadError: "R2 storage not configured"
+                _uploadError: "Storage not configured"
             });
         }
         return c.json({
-            error: "R2 storage not configured"
+            error: "Storage not configured"
         }, 500);
     }
     const formData = await c.req.formData();
@@ -138,30 +140,34 @@ uploadApiRoutes.post("/", async (c)=>{
             error: "File too large (max 10MB)"
         }, 400);
     }
-    // Generate unique filename
+    // Generate unique filename using UUIDv7
     const ext = file.name.split(".").pop() || "bin";
-    const timestamp = Date.now();
-    const random = Math.random().toString(36).substring(2, 8);
-    const filename = `${timestamp}-${random}.${ext}`;
-    const r2Key = `uploads/${filename}`;
+    const id = uuidv7();
+    const date = new Date();
+    const year = date.getUTCFullYear();
+    const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+    const filename = `${id}.${ext}`;
+    const storageKey = `media/${year}/${month}/${filename}`;
     try {
-        // Upload to R2
-        await c.env.R2.put(r2Key, file.stream(), {
-            httpMetadata: {
-                contentType: file.type
-            }
+        // Upload to storage
+        await storage.put(storageKey, file.stream(), {
+            contentType: file.type
         });
         // Save to database
         const media = await c.var.services.media.create({
+            id,
             filename,
             originalName: file.name,
             mimeType: file.type,
             size: file.size,
-            r2Key
+            storageKey,
+            provider: c.env.STORAGE_DRIVER || "r2"
         });
         // SSE response for Datastar
         if (wantsSSE(c)) {
-            const cardHtml = renderMediaCard(media, c.env.R2_PUBLIC_URL, c.env.IMAGE_TRANSFORM_URL);
+            const provider = c.env.STORAGE_DRIVER || "r2";
+            const mediaPublicUrl = getPublicUrlForProvider(provider, c.env.R2_PUBLIC_URL, c.env.S3_PUBLIC_URL);
+            const cardHtml = renderMediaCard(media, mediaPublicUrl, c.env.IMAGE_TRANSFORM_URL);
             return sse(c, async (stream)=>{
                 // Replace placeholder with real media card
                 await stream.patchElements(cardHtml, {
@@ -172,7 +178,9 @@ uploadApiRoutes.post("/", async (c)=>{
             });
         }
         // JSON response for API clients
-        const publicUrl = getMediaUrl(media.id, r2Key, c.env.R2_PUBLIC_URL);
+        const provider = c.env.STORAGE_DRIVER || "r2";
+        const mediaPublicUrl = getPublicUrlForProvider(provider, c.env.R2_PUBLIC_URL, c.env.S3_PUBLIC_URL);
+        const publicUrl = getMediaUrl(media.id, storageKey, mediaPublicUrl);
         return c.json({
             id: media.id,
             filename: media.filename,
@@ -198,11 +206,13 @@ uploadApiRoutes.post("/", async (c)=>{
 uploadApiRoutes.get("/", async (c)=>{
     const limit = parseInt(c.req.query("limit") ?? "50", 10);
     const mediaList = await c.var.services.media.list(limit);
+    const r2PublicUrl = c.env.R2_PUBLIC_URL;
+    const s3PublicUrl = c.env.S3_PUBLIC_URL;
     return c.json({
         media: mediaList.map((m)=>({
                 id: m.id,
                 filename: m.filename,
-                url: getMediaUrl(m.id, m.r2Key, c.env.R2_PUBLIC_URL),
+                url: getMediaUrl(m.id, m.storageKey, getPublicUrlForProvider(m.provider, r2PublicUrl, s3PublicUrl)),
                 mimeType: m.mimeType,
                 size: m.size,
                 createdAt: m.createdAt
@@ -218,13 +228,14 @@ uploadApiRoutes.delete("/:id", async (c)=>{
             error: "Not found"
         }, 404);
     }
-    // Delete from R2
-    if (c.env.R2) {
+    // Delete from storage
+    const storage = c.var.storage;
+    if (storage) {
         try {
-            await c.env.R2.delete(media.r2Key);
+            await storage.delete(media.storageKey);
         } catch (err) {
             // eslint-disable-next-line no-console -- Error logging is intentional
-            console.error("R2 delete error:", err);
+            console.error("Storage delete error:", err);
         }
     }
     // Delete from database

package/dist/routes/dash/media.js

@@ -10,7 +10,7 @@ import { useLingui as $_useLingui } from "@jant/core/i18n";
 import { DashLayout } from "../../theme/layouts/index.js";
 import { EmptyState, DangerZone } from "../../theme/components/index.js";
 import * as time from "../../lib/time.js";
-import { getMediaUrl, getImageUrl } from "../../lib/image.js";
+import { getMediaUrl, getImageUrl, getPublicUrlForProvider } from "../../lib/image.js";
 import { dsRedirect } from "../../lib/sse.js";
 export const mediaRoutes = new Hono();
 /**
@@ -22,8 +22,9 @@ export const mediaRoutes = new Hono();
 }
 /**
  * Media card component for the grid
- */ function MediaCard({ media, r2PublicUrl, imageTransformUrl }) {
-    const fullUrl = getMediaUrl(media.id, media.r2Key, r2PublicUrl);
+ */ function MediaCard({ media, r2PublicUrl, imageTransformUrl, s3PublicUrl }) {
+    const publicUrl = getPublicUrlForProvider(media.provider, r2PublicUrl, s3PublicUrl);
+    const fullUrl = getMediaUrl(media.id, media.storageKey, publicUrl);
     const thumbnailUrl = getImageUrl(fullUrl, imageTransformUrl, {
         width: 300,
         quality: 80,
@@ -73,7 +74,7 @@ export const mediaRoutes = new Hono();
  * Media list page content
  *
  * Upload is handled by media-upload.ts (client module) + Datastar @post for SSE.
- */ function MediaListContent({ mediaList, r2PublicUrl, imageTransformUrl }) {
+ */ function MediaListContent({ mediaList, r2PublicUrl, imageTransformUrl, s3PublicUrl }) {
     const { i18n: $__i18n, _: $__ } = $_useLingui();
     const processingText = $__i18n._({
         id: "k1ifdL",
@@ -161,7 +162,8 @@ export const mediaRoutes = new Hono();
                     children: mediaList.map((m)=>/*#__PURE__*/ _jsx(MediaCard, {
                             media: m,
                             r2PublicUrl: r2PublicUrl,
-                            imageTransformUrl: imageTransformUrl
+                            imageTransformUrl: imageTransformUrl,
+                            s3PublicUrl: s3PublicUrl
                         }, m.id))
                 })
             }),
@@ -181,9 +183,10 @@ export const mediaRoutes = new Hono();
 }
 /**
  * View single media content
- */ function ViewMediaContent({ media, r2PublicUrl, imageTransformUrl }) {
+ */ function ViewMediaContent({ media, r2PublicUrl, imageTransformUrl, s3PublicUrl }) {
     const { i18n: $__i18n, _: $__ } = $_useLingui();
-    const url = getMediaUrl(media.id, media.r2Key, r2PublicUrl);
+    const publicUrl = getPublicUrlForProvider(media.provider, r2PublicUrl, s3PublicUrl);
+    const url = getMediaUrl(media.id, media.storageKey, publicUrl);
     const thumbnailUrl = getImageUrl(url, imageTransformUrl, {
         width: 600,
         quality: 85,
@@ -386,6 +389,7 @@ mediaRoutes.get("/", async (c)=>{
     const siteName = await getSiteName(c);
     const r2PublicUrl = c.env.R2_PUBLIC_URL;
     const imageTransformUrl = c.env.IMAGE_TRANSFORM_URL;
+    const s3PublicUrl = c.env.S3_PUBLIC_URL;
     return c.html(/*#__PURE__*/ _jsx(DashLayout, {
         c: c,
         title: "Media",
@@ -394,7 +398,8 @@ mediaRoutes.get("/", async (c)=>{
         children: /*#__PURE__*/ _jsx(MediaListContent, {
             mediaList: mediaList,
             r2PublicUrl: r2PublicUrl,
-            imageTransformUrl: imageTransformUrl
+            imageTransformUrl: imageTransformUrl,
+            s3PublicUrl: s3PublicUrl
         })
     }));
 });
@@ -404,6 +409,7 @@ mediaRoutes.get("/picker", async (c)=>{
     const mediaList = await c.var.services.media.list(100);
     const r2PublicUrl = c.env.R2_PUBLIC_URL;
     const imageTransformUrl = c.env.IMAGE_TRANSFORM_URL;
+    const s3PublicUrl = c.env.S3_PUBLIC_URL;
     if (mediaList.length === 0) {
         return c.html(/*#__PURE__*/ _jsx("p", {
             class: "text-muted-foreground text-sm col-span-4",
@@ -412,7 +418,8 @@ mediaRoutes.get("/picker", async (c)=>{
     }
     return c.html(/*#__PURE__*/ _jsx(_Fragment, {
         children: mediaList.filter((m)=>m.mimeType.startsWith("image/")).map((m)=>{
-            const url = getMediaUrl(m.id, m.r2Key, r2PublicUrl);
+            const pUrl = getPublicUrlForProvider(m.provider, r2PublicUrl, s3PublicUrl);
+            const url = getMediaUrl(m.id, m.storageKey, pUrl);
             const thumbUrl = getImageUrl(url, imageTransformUrl, {
                 width: 150,
                 quality: 80,
@@ -444,6 +451,7 @@ mediaRoutes.get("/:id", async (c)=>{
     const siteName = await getSiteName(c);
     const r2PublicUrl = c.env.R2_PUBLIC_URL;
     const imageTransformUrl = c.env.IMAGE_TRANSFORM_URL;
+    const s3PublicUrl = c.env.S3_PUBLIC_URL;
     return c.html(/*#__PURE__*/ _jsx(DashLayout, {
         c: c,
         title: media.originalName,
@@ -452,7 +460,8 @@ mediaRoutes.get("/:id", async (c)=>{
         children: /*#__PURE__*/ _jsx(ViewMediaContent, {
             media: media,
             r2PublicUrl: r2PublicUrl,
-            imageTransformUrl: imageTransformUrl
+            imageTransformUrl: imageTransformUrl,
+            s3PublicUrl: s3PublicUrl
         })
     }));
 });
@@ -461,13 +470,14 @@ mediaRoutes.post("/:id/delete", async (c)=>{
     const id = c.req.param("id");
     const media = await c.var.services.media.getById(id);
     if (!media) return c.notFound();
-    // Delete from R2
-    if (c.env.R2) {
+    // Delete from storage
+    const storage = c.var.storage;
+    if (storage) {
         try {
-            await c.env.R2.delete(media.r2Key);
+            await storage.delete(media.storageKey);
         } catch (err) {
             // eslint-disable-next-line no-console -- Error logging is intentional
-            console.error("R2 delete error:", err);
+            console.error("Storage delete error:", err);
         }
     }
     // Delete from database