@jant/core 0.3.35 → 0.3.37

package/src/services/index.ts

@@ -7,8 +7,8 @@
 import type { Database } from "../db/index.js";
 import { createSettingsService, type SettingsService } from "./settings.js";
 import { createPostService, type PostService } from "./post.js";
-import { createPageService, type PageService } from "./page.js";
-import { createRedirectService, type RedirectService } from "./redirect.js";
+import { createCustomUrlService, type CustomUrlService } from "./custom-url.js";
+import { createPathService, type PathService } from "./path.js";
 import { createMediaService, type MediaService } from "./media.js";
 import {
   createCollectionService,
@@ -17,48 +17,55 @@ import {
 import { createSearchService, type SearchService } from "./search.js";
 import { createNavItemService, type NavItemService } from "./navigation.js";
 import { createAuthService, type AuthService } from "./auth.js";
-import {
-  createPathRegistryService,
-  type PathRegistryService,
-} from "./path-registry.js";
+import { createApiTokenService, type ApiTokenService } from "./api-token.js";
 
 export interface Services {
   settings: SettingsService;
+  paths: PathService;
   posts: PostService;
-  pages: PageService;
-  redirects: RedirectService;
+  customUrls: CustomUrlService;
   media: MediaService;
   collections: CollectionService;
   search: SearchService;
   navItems: NavItemService;
   auth: AuthService;
-  pathRegistry: PathRegistryService;
+  apiTokens: ApiTokenService;
 }
 
-export function createServices(db: Database, d1: D1Database): Services {
+export function createServices(
+  db: Database,
+  d1: D1Database,
+  config?: { slugIdLength?: number },
+): Services {
   const settings = createSettingsService(db);
-  const pathRegistry = createPathRegistryService(db);
+  const paths = createPathService(db);
   return {
     settings,
-    pathRegistry,
-    posts: createPostService(db, pathRegistry),
-    pages: createPageService(db, pathRegistry),
-    redirects: createRedirectService(db, pathRegistry),
+    paths,
+    posts: createPostService(
+      db,
+      {
+        slugIdLength: config?.slugIdLength ?? 5,
+      },
+      paths,
+    ),
+    customUrls: createCustomUrlService(db, paths),
     media: createMediaService(db),
-    collections: createCollectionService(db),
+    collections: createCollectionService(db, paths),
     search: createSearchService(d1),
     navItems: createNavItemService(db),
     auth: createAuthService(db, settings),
+    apiTokens: createApiTokenService(db),
   };
 }
 
 export type { SettingsService } from "./settings.js";
+export type { PathService } from "./path.js";
 export type { PostService, PostFilters, PostDeleteDeps } from "./post.js";
-export type { PageService, PageFilters } from "./page.js";
-export type { RedirectService } from "./redirect.js";
+export type { CustomUrlService } from "./custom-url.js";
 export type { MediaService, MediaFilters } from "./media.js";
 export type { CollectionService } from "./collection.js";
 export type { SearchService, SearchResult, SearchOptions } from "./search.js";
 export type { NavItemService } from "./navigation.js";
 export type { AuthService } from "./auth.js";
-export type { PathRegistryService, OwnerType } from "./path-registry.js";
+export type { ApiTokenService } from "./api-token.js";

package/src/services/media.ts

@@ -5,15 +5,19 @@
  */
 
 import { eq, desc, inArray, asc, sql, and } from "drizzle-orm";
+import { generateKeyBetween } from "fractional-indexing";
 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 { StorageDriver } from "../lib/storage.js";
-import type { Media } from "../types.js";
+import { toMediaKind } from "../lib/upload.js";
+import type { Media, MediaKind } from "../types.js";
 import { MAX_MEDIA_ATTACHMENTS } from "../types.js";
 import { ValidationError } from "../lib/errors.js";
 
+const DEFAULT_MEDIA_POSITION = "a0";
+
 export interface MediaFilters {
   limit?: number;
   /** Filter by MIME type prefix, e.g. "image/" */
@@ -23,8 +27,8 @@ export interface MediaFilters {
 export interface MediaService {
   getById(id: string): Promise<Media | null>;
   getByIds(ids: string[]): Promise<Media[]>;
-  getByPostId(postId: number): Promise<Media[]>;
-  getByPostIds(postIds: number[]): Promise<Map<number, Media[]>>;
+  getByPostId(postId: string): Promise<Media[]>;
+  getByPostIds(postIds: string[]): Promise<Map<string, Media[]>>;
   list(filters?: MediaFilters): Promise<Media[]>;
   create(data: CreateMediaData): Promise<Media>;
   /**
@@ -50,15 +54,15 @@ export interface MediaService {
    * @param storage - Optional storage driver; when provided the files are deleted from storage
    */
   deleteByIds(ids: string[], storage?: StorageDriver | null): Promise<void>;
-  getByStorageKey(storageKey: string): Promise<Media | null>;
-  attachToPost(postId: number, mediaIds: string[]): Promise<void>;
-  detachFromPost(postId: number): Promise<void>;
+  getByStorageKey(storageKey: string, provider: string): Promise<Media | null>;
+  attachToPost(postId: string, mediaIds: string[]): Promise<void>;
+  detachFromPost(postId: string): Promise<void>;
   updateAlt(id: string, alt: string): Promise<void>;
 }
 
 export interface CreateMediaData {
   id?: string;
-  postId?: number;
+  postId?: string;
   filename: string;
   originalName: string;
   mimeType: string;
@@ -68,11 +72,38 @@ export interface CreateMediaData {
   width?: number;
   height?: number;
   alt?: string;
-  position?: number;
+  position?: string;
   blurhash?: string;
+  waveform?: string;
+  posterKey?: string;
+  summary?: string;
+  chars?: number;
+  mediaKind?: MediaKind;
 }
 
 export function createMediaService(db: Database): MediaService {
+  async function getLastPosition(postId: string): Promise<string | null> {
+    const rows = await db
+      .select({ position: media.position })
+      .from(media)
+      .where(eq(media.postId, postId))
+      .orderBy(sql`${media.position} DESC`)
+      .limit(1);
+    return rows[0]?.position ?? null;
+  }
+
+  function buildSequentialPositions(count: number): string[] {
+    const positions: string[] = [];
+    let previous: string | null = null;
+
+    for (let i = 0; i < count; i += 1) {
+      previous = generateKeyBetween(previous, null);
+      positions.push(previous);
+    }
+
+    return positions;
+  }
+
   function toMedia(row: typeof media.$inferSelect): Media {
     return {
       id: row.id,
@@ -88,7 +119,13 @@ export function createMediaService(db: Database): MediaService {
       alt: row.alt,
       position: row.position,
       blurhash: row.blurhash,
+      waveform: row.waveform,
+      posterKey: row.posterKey,
+      summary: row.summary,
+      chars: row.chars,
+      mediaKind: row.mediaKind as MediaKind,
       createdAt: row.createdAt,
+      updatedAt: row.updatedAt,
     };
   }
 
@@ -118,7 +155,7 @@ export function createMediaService(db: Database): MediaService {
     },
 
     async getByPostIds(postIds) {
-      const result = new Map<number, Media[]>();
+      const result = new Map<string, Media[]>();
       if (postIds.length === 0) return result;
 
       const rows = await db
@@ -141,11 +178,13 @@ export function createMediaService(db: Database): MediaService {
       return result;
     },
 
-    async getByStorageKey(storageKey) {
+    async getByStorageKey(storageKey, provider) {
       const result = await db
         .select()
         .from(media)
-        .where(eq(media.storageKey, storageKey))
+        .where(
+          and(eq(media.storageKey, storageKey), eq(media.provider, provider)),
+        )
         .limit(1);
       return result[0] ? toMedia(result[0]) : null;
     },
@@ -185,6 +224,11 @@ export function createMediaService(db: Database): MediaService {
     async create(data) {
       const id = data.id ?? uuidv7();
       const timestamp = now();
+      const mediaKind = data.mediaKind ?? toMediaKind(data.mimeType);
+      const lastPosition =
+        data.position === undefined && data.postId
+          ? await getLastPosition(data.postId)
+          : null;
 
       const result = await db
         .insert(media)
@@ -200,9 +244,19 @@ export function createMediaService(db: Database): MediaService {
           width: data.width ?? null,
           height: data.height ?? null,
           alt: data.alt ?? null,
-          position: data.position ?? 0,
+          position:
+            data.position ??
+            (data.postId
+              ? generateKeyBetween(lastPosition, null)
+              : DEFAULT_MEDIA_POSITION),
           blurhash: data.blurhash ?? null,
+          waveform: data.waveform ?? null,
+          posterKey: data.posterKey ?? null,
+          summary: data.summary ?? null,
+          chars: data.chars ?? null,
+          mediaKind,
           createdAt: timestamp,
+          updatedAt: timestamp,
         })
         .returning();
 
@@ -211,9 +265,14 @@ export function createMediaService(db: Database): MediaService {
     },
 
     async attachToPost(postId, mediaIds) {
+      const timestamp = now();
       const clearQuery = db
         .update(media)
-        .set({ postId: null, position: 0 })
+        .set({
+          postId: null,
+          position: DEFAULT_MEDIA_POSITION,
+          updatedAt: timestamp,
+        })
         .where(eq(media.postId, postId));
 
       const validIds = mediaIds.filter((id): id is string => Boolean(id));
@@ -223,13 +282,20 @@ export function createMediaService(db: Database): MediaService {
         return;
       }
 
+      const positions = buildSequentialPositions(validIds.length);
+
       // Clear existing + re-attach atomically
-      const attachQueries = validIds.map((mediaId, i) =>
-        db
+      const attachQueries = validIds.map((mediaId, i) => {
+        const position = positions[i];
+        if (!position) {
+          throw new Error("Failed to assign a media position");
+        }
+
+        return db
           .update(media)
-          .set({ postId, position: i })
-          .where(eq(media.id, mediaId)),
-      );
+          .set({ postId, position, updatedAt: timestamp })
+          .where(eq(media.id, mediaId));
+      });
       await db.batch([clearQuery, ...attachQueries] as [
         typeof clearQuery,
         ...(typeof attachQueries)[number][],
@@ -239,12 +305,15 @@ export function createMediaService(db: Database): MediaService {
     async detachFromPost(postId) {
       await db
         .update(media)
-        .set({ postId: null, position: 0 })
+        .set({ postId: null, position: DEFAULT_MEDIA_POSITION })
         .where(eq(media.postId, postId));
     },
 
     async updateAlt(id, alt) {
-      await db.update(media).set({ alt }).where(eq(media.id, id));
+      await db
+        .update(media)
+        .set({ alt, updatedAt: now() })
+        .where(eq(media.id, id));
     },
 
     async delete(id, storage) {
@@ -256,6 +325,12 @@ export function createMediaService(db: Database): MediaService {
           // eslint-disable-next-line no-console -- Error logging is intentional
           console.error("Storage delete error:", err);
         });
+        if (record.posterKey) {
+          await storage.delete(record.posterKey).catch((err) => {
+            // eslint-disable-next-line no-console -- Error logging is intentional
+            console.error("Storage delete poster error:", err);
+          });
+        }
       }
 
       await db.delete(media).where(eq(media.id, id));
@@ -267,9 +342,12 @@ export function createMediaService(db: Database): MediaService {
 
       if (storage) {
         const records = await this.getByIds(ids);
+        const keys = records.flatMap((r) =>
+          r.posterKey ? [r.storageKey, r.posterKey] : [r.storageKey],
+        );
         await Promise.all(
-          records.map((r) =>
-            storage.delete(r.storageKey).catch((err) => {
+          keys.map((key) =>
+            storage.delete(key).catch((err) => {
               // eslint-disable-next-line no-console -- Error logging is intentional
               console.error("Storage delete error:", err);
             }),

package/src/services/navigation.ts

@@ -1,10 +1,13 @@
 /**
  * Nav Item Service (v2)
  *
- * Manages navigation items (page links and external links)
+ * Manages navigation items (external links and system links)
+ * with fractional indexing for efficient reordering.
  */
 
 import { eq, asc, sql } from "drizzle-orm";
+import { generateKeyBetween } from "fractional-indexing";
+import { uuidv7 } from "uuidv7";
 import type { Database } from "../db/index.js";
 import { navItems } from "../db/schema.js";
 import { now } from "../lib/time.js";
@@ -15,14 +18,37 @@ import type {
   UpdateNavItem,
 } from "../types.js";
 
+const POSITION_RETRY_ATTEMPTS = 5;
+
+function isUniqueConstraintError(err: unknown): boolean {
+  let current: unknown = err;
+  while (current) {
+    const msg = String(current);
+    if (
+      msg.includes("UNIQUE constraint") ||
+      msg.includes("SQLITE_CONSTRAINT")
+    ) {
+      return true;
+    }
+    current =
+      current instanceof Error && current.cause !== current
+        ? current.cause
+        : undefined;
+  }
+  return false;
+}
+
 export interface NavItemService {
   list(): Promise<NavItem[]>;
-  getById(id: number): Promise<NavItem | null>;
+  getById(id: string): Promise<NavItem | null>;
   create(data: CreateNavItem): Promise<NavItem>;
-  update(id: number, data: UpdateNavItem): Promise<NavItem | null>;
-  delete(id: number): Promise<boolean>;
-  deleteByPageId(pageId: number): Promise<boolean>;
-  reorder(ids: number[]): Promise<void>;
+  update(id: string, data: UpdateNavItem): Promise<NavItem | null>;
+  delete(id: string): Promise<boolean>;
+  move(
+    id: string,
+    afterId: string | null,
+    beforeId: string | null,
+  ): Promise<NavItem | null>;
 }
 
 export function createNavItemService(db: Database): NavItemService {
@@ -32,13 +58,63 @@ export function createNavItemService(db: Database): NavItemService {
       type: row.type as NavItemType,
       label: row.label,
       url: row.url,
-      pageId: row.pageId,
       position: row.position,
       createdAt: row.createdAt,
       updatedAt: row.updatedAt,
     };
   }
 
+  async function getLastPosition(): Promise<string | null> {
+    const rows = await db
+      .select({ position: navItems.position })
+      .from(navItems)
+      .orderBy(sql`${navItems.position} DESC`)
+      .limit(1);
+    return rows[0]?.position ?? null;
+  }
+
+  async function listOrderedPositions(excludeId?: string) {
+    const rows = await db
+      .select({ id: navItems.id, position: navItems.position })
+      .from(navItems)
+      .orderBy(asc(navItems.position));
+    return excludeId ? rows.filter((row) => row.id !== excludeId) : rows;
+  }
+
+  async function getAppendPosition(): Promise<string> {
+    const lastPos = await getLastPosition();
+    return generateKeyBetween(lastPos, null);
+  }
+
+  async function getMovePosition(
+    id: string,
+    afterId: string | null,
+    beforeId: string | null,
+  ): Promise<string> {
+    const rows = await listOrderedPositions(id);
+    const afterIndex = afterId
+      ? rows.findIndex((row) => row.id === afterId)
+      : -1;
+    if (afterIndex >= 0) {
+      return generateKeyBetween(
+        rows[afterIndex]?.position ?? null,
+        rows[afterIndex + 1]?.position ?? null,
+      );
+    }
+
+    const beforeIndex = beforeId
+      ? rows.findIndex((row) => row.id === beforeId)
+      : -1;
+    if (beforeIndex >= 0) {
+      return generateKeyBetween(
+        rows[beforeIndex - 1]?.position ?? null,
+        rows[beforeIndex]?.position ?? null,
+      );
+    }
+
+    return generateKeyBetween(rows.at(-1)?.position ?? null, null);
+  }
+
   return {
     async list() {
       const rows = await db
@@ -58,32 +134,55 @@ export function createNavItemService(db: Database): NavItemService {
     },
 
     async create(data) {
+      const id = uuidv7();
       const timestamp = now();
 
-      let position = data.position;
-      if (position === undefined) {
-        const maxResult = await db
-          .select({ maxPos: sql<number>`COALESCE(MAX(position), -1)` })
-          .from(navItems);
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- aggregate always returns one row
-        position = maxResult[0]!.maxPos + 1;
+      if (data.position !== undefined) {
+        const result = await db
+          .insert(navItems)
+          .values({
+            id,
+            type: data.type,
+            label: data.label,
+            url: data.url,
+            position: data.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 toNavItem(result[0]!);
       }
 
-      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();
+      for (let attempt = 0; attempt < POSITION_RETRY_ATTEMPTS; attempt += 1) {
+        try {
+          const result = await db
+            .insert(navItems)
+            .values({
+              id,
+              type: data.type,
+              label: data.label,
+              url: data.url,
+              position: await getAppendPosition(),
+              createdAt: timestamp,
+              updatedAt: timestamp,
+            })
+            .returning();
 
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- DB insert with .returning() always returns inserted row
-      return toNavItem(result[0]!);
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- DB insert with .returning() always returns inserted row
+          return toNavItem(result[0]!);
+        } catch (err) {
+          if (
+            !isUniqueConstraintError(err) ||
+            attempt === POSITION_RETRY_ATTEMPTS - 1
+          ) {
+            throw err;
+          }
+        }
+      }
+
+      throw new Error("Failed to assign a unique nav item position");
     },
 
     async update(id, data) {
@@ -101,7 +200,6 @@ export function createNavItemService(db: Database): NavItemService {
           ...(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,
         })
@@ -119,26 +217,39 @@ export function createNavItemService(db: Database): NavItemService {
       return result.length > 0;
     },
 
-    async deleteByPageId(pageId) {
-      const result = await db
-        .delete(navItems)
-        .where(eq(navItems.pageId, pageId))
-        .returning();
-      return result.length > 0;
-    },
+    async move(id, afterId, beforeId) {
+      // Look up the item
+      const items = await db
+        .select()
+        .from(navItems)
+        .where(eq(navItems.id, id))
+        .limit(1);
+      if (!items[0]) return null;
 
-    async reorder(ids) {
-      if (ids.length === 0) return;
       const timestamp = now();
-      const queries = ids.map((id, i) =>
-        db
-          .update(navItems)
-          .set({ position: i, updatedAt: timestamp })
-          .where(eq(navItems.id, id)),
-      );
-      await db.batch(
-        queries as [(typeof queries)[number], ...(typeof queries)[number][]],
-      );
+      for (let attempt = 0; attempt < POSITION_RETRY_ATTEMPTS; attempt += 1) {
+        try {
+          const result = await db
+            .update(navItems)
+            .set({
+              position: await getMovePosition(id, afterId, beforeId),
+              updatedAt: timestamp,
+            })
+            .where(eq(navItems.id, id))
+            .returning();
+
+          return result[0] ? toNavItem(result[0]) : null;
+        } catch (err) {
+          if (
+            !isUniqueConstraintError(err) ||
+            attempt === POSITION_RETRY_ATTEMPTS - 1
+          ) {
+            throw err;
+          }
+        }
+      }
+
+      throw new Error("Failed to assign a unique nav item position");
     },
   };
 }