@jant/core 0.0.1

package/src/routes/pages/post.tsx

@@ -0,0 +1,81 @@
+/**
+ * Single Post Page Route
+ */
+
+import { Hono } from "hono";
+import { useLingui } from "../../i18n/index.js";
+import type { Bindings, Post } from "../../types.js";
+import type { AppVariables } from "../../app.js";
+import { BaseLayout } from "../../theme/layouts/index.js";
+import * as sqid from "../../lib/sqid.js";
+import * as time from "../../lib/time.js";
+
+type Env = { Bindings: Bindings; Variables: AppVariables };
+
+export const postRoutes = new Hono<Env>();
+
+function PostContent({ post }: { post: Post }) {
+  const { t } = useLingui();
+
+  return (
+    <div class="container py-8">
+      <article class="h-entry">
+        {post.title && <h1 class="p-name text-2xl font-semibold mb-4">{post.title}</h1>}
+
+        <div
+          class="e-content prose"
+          dangerouslySetInnerHTML={{ __html: post.contentHtml || "" }}
+        />
+
+        <footer class="mt-6 pt-4 border-t text-sm text-muted-foreground">
+          <time class="dt-published" datetime={time.toISOString(post.publishedAt)}>
+            {time.formatDate(post.publishedAt)}
+          </time>
+          <a href={`/p/${sqid.encode(post.id)}`} class="u-url ml-4">
+            {t({ message: "Permalink", comment: "@context: Link to permanent URL of post" })}
+          </a>
+        </footer>
+      </article>
+
+      <nav class="mt-8">
+        <a href="/" class="text-sm hover:underline">
+          {t({ message: "← Back to home", comment: "@context: Navigation link" })}
+        </a>
+      </nav>
+    </div>
+  );
+}
+
+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;
+    }
+  }
+
+  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") {
+    return c.notFound();
+  }
+
+  const siteName = (await c.var.services.settings.get("SITE_NAME")) ?? "Jant";
+  const title = post.title || siteName;
+
+  return c.html(
+    <BaseLayout title={title} description={post.content?.slice(0, 160)} c={c}>
+      <PostContent post={post} />
+    </BaseLayout>
+  );
+});

package/src/routes/pages/search.tsx

@@ -0,0 +1,162 @@
+/**
+ * Search Page Route
+ */
+
+import { Hono } from "hono";
+import { useLingui } from "../../i18n/index.js";
+import type { Bindings } from "../../types.js";
+import type { AppVariables } from "../../app.js";
+import type { SearchResult } from "../../services/search.js";
+import { BaseLayout } from "../../theme/layouts/index.js";
+import { PagePagination } from "../../theme/components/index.js";
+import * as sqid from "../../lib/sqid.js";
+import * as time from "../../lib/time.js";
+
+type Env = { Bindings: Bindings; Variables: AppVariables };
+
+const PAGE_SIZE = 10;
+
+export const searchRoutes = new Hono<Env>();
+
+function SearchContent({
+  query,
+  results,
+  error,
+  hasMore,
+  page,
+}: {
+  query: string;
+  results: SearchResult[];
+  error: string | null;
+  hasMore: boolean;
+  page: number;
+}) {
+  const { t } = useLingui();
+  const searchTitle = t({ message: "Search", comment: "@context: Search page title" });
+
+  return (
+    <div class="container py-8 max-w-2xl">
+      <h1 class="text-2xl font-semibold mb-6">{searchTitle}</h1>
+
+      {/* Search form */}
+      <form method="get" action="/search" class="mb-8">
+        <div class="flex gap-2">
+          <input
+            type="search"
+            name="q"
+            class="input flex-1"
+            placeholder={t({ message: "Search posts...", comment: "@context: Search input placeholder" })}
+            value={query}
+            autofocus
+          />
+          <button type="submit" class="btn">
+            {t({ message: "Search", comment: "@context: Search submit button" })}
+          </button>
+        </div>
+      </form>
+
+      {/* Error */}
+      {error && (
+        <div class="p-4 rounded-lg bg-destructive/10 text-destructive mb-6">
+          {error}
+        </div>
+      )}
+
+      {/* Results */}
+      {query && !error && (
+        <div>
+          <p class="text-sm text-muted-foreground mb-4">
+            {results.length === 0
+              ? t({ message: "No results found.", comment: "@context: Search empty results" })
+              : results.length === 1
+                ? t({ message: "Found 1 result", comment: "@context: Search results count - single" })
+                : t({ message: "Found {count} results", comment: "@context: Search results count - multiple", values: { count: String(results.length) } })}
+          </p>
+
+          {results.length > 0 && (
+            <>
+              <div class="flex flex-col gap-4">
+                {results.map((result) => (
+                  <article key={result.post.id} class="p-4 rounded-lg border hover:border-primary">
+                    <a href={`/p/${sqid.encode(result.post.id)}`} class="block">
+                      <h2 class="font-medium hover:underline">
+                        {result.post.title ||
+                          result.post.content?.slice(0, 60) ||
+                          `Post #${result.post.id}`}
+                      </h2>
+
+                      {result.snippet && (
+                        <p
+                          class="text-sm text-muted-foreground mt-2 line-clamp-2"
+                          dangerouslySetInnerHTML={{ __html: result.snippet }}
+                        />
+                      )}
+
+                      <footer class="flex items-center gap-2 mt-2 text-xs text-muted-foreground">
+                        <span class="badge-outline">{result.post.type}</span>
+                        <time datetime={time.toISOString(result.post.publishedAt)}>
+                          {time.formatDate(result.post.publishedAt)}
+                        </time>
+                      </footer>
+                    </a>
+                  </article>
+                ))}
+              </div>
+
+              <PagePagination
+                baseUrl={`/search?q=${encodeURIComponent(query)}`}
+                currentPage={page}
+                hasMore={hasMore}
+              />
+            </>
+          )}
+        </div>
+      )}
+
+      <nav class="mt-8 pt-6 border-t">
+        <a href="/" class="text-sm hover:underline">
+          ← {t({ message: "Back to home", comment: "@context: Navigation link back to home page" })}
+        </a>
+      </nav>
+    </div>
+  );
+}
+
+searchRoutes.get("/", async (c) => {
+  const query = c.req.query("q") || "";
+  const pageParam = c.req.query("page");
+  const page = pageParam ? Math.max(1, parseInt(pageParam, 10) || 1) : 1;
+
+  const siteName = (await c.var.services.settings.get("SITE_NAME")) ?? "Jant";
+
+  // Only search if there's a query
+  let results: Awaited<ReturnType<typeof c.var.services.search.search>> = [];
+  let error: string | null = null;
+  let hasMore = false;
+
+  if (query.trim()) {
+    try {
+      // Fetch one extra to check for more
+      results = await c.var.services.search.search(query, {
+        limit: PAGE_SIZE + 1,
+        offset: (page - 1) * PAGE_SIZE,
+        visibility: ["featured", "quiet"],
+      });
+
+      hasMore = results.length > PAGE_SIZE;
+      if (hasMore) {
+        results = results.slice(0, PAGE_SIZE);
+      }
+    } catch (err) {
+      // eslint-disable-next-line no-console -- Error logging is intentional
+      console.error("Search error:", err);
+      error = "Search failed. Please try again.";
+    }
+  }
+
+  return c.html(
+    <BaseLayout title={query ? `Search: ${query} - ${siteName}` : `Search - ${siteName}`} c={c}>
+      <SearchContent query={query} results={results} error={error} hasMore={hasMore} page={page} />
+    </BaseLayout>
+  );
+});

package/src/services/collection.ts

@@ -0,0 +1,180 @@
+/**
+ * Collection Service
+ *
+ * Manages collections and post-collection relationships
+ */
+
+import { eq, desc, and } from "drizzle-orm";
+import type { Database } from "../db/index.js";
+import { collections, postCollections, posts } from "../db/schema.js";
+import { now } from "../lib/time.js";
+import type { Collection, Post } from "../types.js";
+
+export interface CollectionService {
+  getById(id: number): Promise<Collection | null>;
+  getByPath(path: string): Promise<Collection | null>;
+  list(): Promise<Collection[]>;
+  create(data: CreateCollectionData): Promise<Collection>;
+  update(id: number, data: UpdateCollectionData): Promise<Collection | null>;
+  delete(id: number): Promise<boolean>;
+  addPost(collectionId: number, postId: number): Promise<void>;
+  removePost(collectionId: number, postId: number): Promise<void>;
+  getPosts(collectionId: number): Promise<Post[]>;
+  getCollectionsForPost(postId: number): Promise<Collection[]>;
+}
+
+export interface CreateCollectionData {
+  title: string;
+  path?: string;
+  description?: string;
+}
+
+export interface UpdateCollectionData {
+  title?: string;
+  path?: string | null;
+  description?: string;
+}
+
+export function createCollectionService(db: Database): CollectionService {
+  function toCollection(row: typeof collections.$inferSelect): Collection {
+    return {
+      id: row.id,
+      title: row.title,
+      path: row.path,
+      description: row.description,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt,
+    };
+  }
+
+  function toPost(row: typeof posts.$inferSelect): Post {
+    return {
+      id: row.id,
+      type: row.type as Post["type"],
+      visibility: row.visibility as Post["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,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt,
+    };
+  }
+
+  return {
+    async getById(id) {
+      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);
+      return result[0] ? toCollection(result[0]) : null;
+    },
+
+    async list() {
+      const rows = await db.select().from(collections).orderBy(desc(collections.createdAt));
+      return rows.map(toCollection);
+    },
+
+    async create(data) {
+      const timestamp = now();
+
+      const result = await db
+        .insert(collections)
+        .values({
+          title: data.title,
+          path: data.path || null,
+          description: data.description ?? null,
+          createdAt: timestamp,
+          updatedAt: timestamp,
+        })
+        .returning();
+
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- DB insert with .returning() always returns inserted row
+      return toCollection(result[0]!);
+    },
+
+    async update(id, data) {
+      const existing = await this.getById(id);
+      if (!existing) return null;
+
+      const timestamp = now();
+      const updates: Partial<typeof collections.$inferInsert> = { updatedAt: timestamp };
+
+      if (data.title !== undefined) updates.title = data.title;
+      if (data.path !== undefined) updates.path = data.path;
+      if (data.description !== undefined) updates.description = data.description;
+
+      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));
+
+      const result = await db.delete(collections).where(eq(collections.id, id)).returning();
+      return result.length > 0;
+    },
+
+    async addPost(collectionId, postId) {
+      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));
+    },
+
+    async getCollectionsForPost(postId) {
+      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));
+    },
+  };
+}

package/src/services/index.ts

@@ -0,0 +1,40 @@
+/**
+ * Services
+ *
+ * Business logic layer
+ */
+
+import type { Database } from "../db/index.js";
+import { createSettingsService, type SettingsService } from "./settings.js";
+import { createPostService, type PostService } from "./post.js";
+import { createRedirectService, type RedirectService } from "./redirect.js";
+import { createMediaService, type MediaService } from "./media.js";
+import { createCollectionService, type CollectionService } from "./collection.js";
+import { createSearchService, type SearchService } from "./search.js";
+
+export interface Services {
+  settings: SettingsService;
+  posts: PostService;
+  redirects: RedirectService;
+  media: MediaService;
+  collections: CollectionService;
+  search: SearchService;
+}
+
+export function createServices(db: Database, d1: D1Database): Services {
+  return {
+    settings: createSettingsService(db),
+    posts: createPostService(db),
+    redirects: createRedirectService(db),
+    media: createMediaService(db),
+    collections: createCollectionService(db),
+    search: createSearchService(d1),
+  };
+}
+
+export type { SettingsService } from "./settings.js";
+export type { PostService, PostFilters } from "./post.js";
+export type { RedirectService } from "./redirect.js";
+export type { MediaService } from "./media.js";
+export type { CollectionService } from "./collection.js";
+export type { SearchService, SearchResult, SearchOptions } from "./search.js";

package/src/services/media.ts

@@ -0,0 +1,97 @@
+/**
+ * Media Service
+ *
+ * Handles media upload and management with R2 storage
+ */
+
+import { eq, desc } from "drizzle-orm";
+import { uuidv7 } from "uuidv7";
+import type { Database } from "../db/index.js";
+import { media } from "../db/schema.js";
+import { now } from "../lib/time.js";
+import type { Media } from "../types.js";
+
+export interface MediaService {
+  getById(id: string): Promise<Media | null>;
+  list(limit?: number): Promise<Media[]>;
+  create(data: CreateMediaData): Promise<Media>;
+  delete(id: string): Promise<boolean>;
+  getByR2Key(r2Key: string): Promise<Media | null>;
+}
+
+export interface CreateMediaData {
+  postId?: number;
+  filename: string;
+  originalName: string;
+  mimeType: string;
+  size: number;
+  r2Key: string;
+  width?: number;
+  height?: number;
+  alt?: string;
+}
+
+export function createMediaService(db: Database): MediaService {
+  function toMedia(row: typeof media.$inferSelect): Media {
+    return {
+      id: row.id,
+      postId: row.postId,
+      filename: row.filename,
+      originalName: row.originalName,
+      mimeType: row.mimeType,
+      size: row.size,
+      r2Key: row.r2Key,
+      width: row.width,
+      height: row.height,
+      alt: row.alt,
+      createdAt: row.createdAt,
+    };
+  }
+
+  return {
+    async getById(id) {
+      const result = await db.select().from(media).where(eq(media.id, id)).limit(1);
+      return result[0] ? toMedia(result[0]) : null;
+    },
+
+    async getByR2Key(r2Key) {
+      const result = await db.select().from(media).where(eq(media.r2Key, r2Key)).limit(1);
+      return result[0] ? toMedia(result[0]) : null;
+    },
+
+    async list(limit = 100) {
+      const rows = await db.select().from(media).orderBy(desc(media.createdAt)).limit(limit);
+      return rows.map(toMedia);
+    },
+
+    async create(data) {
+      const id = uuidv7();
+      const timestamp = now();
+
+      const result = await db
+        .insert(media)
+        .values({
+          id,
+          postId: data.postId ?? null,
+          filename: data.filename,
+          originalName: data.originalName,
+          mimeType: data.mimeType,
+          size: data.size,
+          r2Key: data.r2Key,
+          width: data.width ?? null,
+          height: data.height ?? null,
+          alt: data.alt ?? null,
+          createdAt: timestamp,
+        })
+        .returning();
+
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- DB insert with .returning() always returns inserted row
+      return toMedia(result[0]!);
+    },
+
+    async delete(id) {
+      const result = await db.delete(media).where(eq(media.id, id)).returning();
+      return result.length > 0;
+    },
+  };
+}