@valentinkolb/filegate 2.4.0 → 2.5.2

package/src/handlers/indexHandler.ts

@@ -1,107 +0,0 @@
-import { Hono } from "hono";
-import { describeRoute } from "hono-openapi";
-import { join } from "node:path";
-import { jsonResponse, requiresAuth } from "../lib/openapi";
-import { v } from "../lib/validator";
-import {
-  RescanResponseSchema,
-  IndexStatsSchema,
-  BulkResolveBodySchema,
-  BulkResolveResponseSchema,
-  ErrorSchema,
-} from "../schemas";
-import { config } from "../config";
-import { bulkResolve, getIndexStats } from "../lib/index";
-import { scanAll } from "../lib/scanner";
-
-const app = new Hono();
-
-app.post(
-  "/rescan",
-  describeRoute({
-    tags: ["Index"],
-    summary: "Rescan file index",
-    ...requiresAuth,
-    responses: {
-      200: jsonResponse(RescanResponseSchema, "Rescan completed"),
-      400: jsonResponse(ErrorSchema, "Bad request"),
-      500: jsonResponse(ErrorSchema, "Internal error"),
-    },
-  }),
-  async (c) => {
-    if (!config.indexEnabled) {
-      return c.json({ error: "index disabled" }, 400);
-    }
-
-    try {
-      const result = await scanAll();
-      return c.json(result);
-    } catch (err) {
-      console.error("[Filegate] Index rescan failed:", err);
-      return c.json({ error: "rescan failed" }, 500);
-    }
-  },
-);
-
-app.get(
-  "/stats",
-  describeRoute({
-    tags: ["Index"],
-    summary: "Get index stats",
-    ...requiresAuth,
-    responses: {
-      200: jsonResponse(IndexStatsSchema, "Index stats"),
-      400: jsonResponse(ErrorSchema, "Bad request"),
-      500: jsonResponse(ErrorSchema, "Internal error"),
-    },
-  }),
-  async (c) => {
-    if (!config.indexEnabled) {
-      return c.json({ error: "index disabled" }, 400);
-    }
-
-    try {
-      const stats = await getIndexStats();
-      return c.json(stats);
-    } catch (err) {
-      console.error("[Filegate] Index stats failed:", err);
-      return c.json({ error: "stats failed" }, 500);
-    }
-  },
-);
-
-app.post(
-  "/resolve",
-  describeRoute({
-    tags: ["Index"],
-    summary: "Resolve file IDs to paths",
-    ...requiresAuth,
-    responses: {
-      200: jsonResponse(BulkResolveResponseSchema, "Resolved paths"),
-      400: jsonResponse(ErrorSchema, "Bad request"),
-      500: jsonResponse(ErrorSchema, "Internal error"),
-    },
-  }),
-  v("json", BulkResolveBodySchema),
-  async (c) => {
-    if (!config.indexEnabled) {
-      return c.json({ error: "index disabled" }, 400);
-    }
-
-    try {
-      const { ids } = c.req.valid("json");
-      const resolved = await bulkResolve(ids);
-      const response: Record<string, string | null> = {};
-      for (const id of ids) {
-        const entry = resolved[id];
-        response[id] = entry ? join(entry.basePath, entry.relPath) : null;
-      }
-      return c.json(response);
-    } catch (err) {
-      console.error("[Filegate] Index resolve failed:", err);
-      return c.json({ error: "resolve failed" }, 500);
-    }
-  },
-);
-
-export default app;

package/src/handlers/search.ts

@@ -1,144 +0,0 @@
-import { Hono } from "hono";
-import { describeRoute } from "hono-openapi";
-import { Glob } from "bun";
-import { stat } from "node:fs/promises";
-import { join, basename, relative } from "node:path";
-import { validatePath } from "../lib/path";
-import { jsonResponse, requiresAuth } from "../lib/openapi";
-import { v } from "../lib/validator";
-import {
-  SearchResponseSchema,
-  ErrorSchema,
-  SearchQuerySchema,
-  countRecursiveWildcards,
-  type FileInfo,
-  type SearchResult,
-} from "../schemas";
-import { config } from "../config";
-import { enrichFileInfoBatch } from "../lib/index";
-
-const app = new Hono();
-
-const getFileInfo = async (fullPath: string, basePath: string): Promise<FileInfo | null> => {
-  try {
-    const s = await stat(fullPath);
-    const name = basename(fullPath);
-    const file = Bun.file(fullPath);
-
-    return {
-      name,
-      path: relative(basePath, fullPath),
-      type: s.isDirectory() ? "directory" : "file",
-      size: s.isDirectory() ? 0 : s.size,
-      mtime: s.mtime.toISOString(),
-      isHidden: name.startsWith("."),
-      mimeType: s.isDirectory() ? undefined : file.type,
-    };
-  } catch {
-    return null;
-  }
-};
-
-const searchInPath = async (
-  basePath: string,
-  pattern: string,
-  showHidden: boolean,
-  limit: number,
-  includeFiles: boolean,
-  includeDirectories: boolean,
-): Promise<SearchResult> => {
-  const glob = new Glob(pattern);
-  const files: FileInfo[] = [];
-  let hasMore = false;
-
-  // If we need directories, we must set onlyFiles: false
-  const onlyFiles = includeFiles && !includeDirectories;
-
-  for await (const match of glob.scan({ cwd: basePath, dot: showHidden, onlyFiles })) {
-    if (!showHidden && basename(match).startsWith(".")) continue;
-
-    if (files.length >= limit) {
-      hasMore = true;
-      break;
-    }
-
-    const info = await getFileInfo(join(basePath, match), basePath);
-    if (!info) continue;
-
-    // Filter based on type
-    if (info.type === "file" && !includeFiles) continue;
-    if (info.type === "directory" && !includeDirectories) continue;
-
-    files.push(info);
-  }
-
-  return { basePath, files, total: files.length, hasMore };
-};
-
-app.get(
-  "/search",
-  describeRoute({
-    tags: ["Search"],
-    summary: "Search files with glob pattern",
-    description: "Search multiple paths in parallel using glob patterns",
-    ...requiresAuth,
-    responses: {
-      200: jsonResponse(SearchResponseSchema, "Search results"),
-      400: jsonResponse(ErrorSchema, "Bad request"),
-      403: jsonResponse(ErrorSchema, "Forbidden"),
-      404: jsonResponse(ErrorSchema, "Not found"),
-    },
-  }),
-  v("query", SearchQuerySchema),
-  async (c) => {
-    const { paths: pathsParam, pattern, showHidden, limit: limitParam, files, directories } = c.req.valid("query");
-
-    // At least one of files or directories must be true
-    if (!files && !directories) {
-      return c.json({ error: "at least one of 'files' or 'directories' must be true" }, 400);
-    }
-
-    // Validate recursive wildcard count
-    const wildcardCount = countRecursiveWildcards(pattern);
-    if (wildcardCount > config.searchMaxRecursiveWildcards) {
-      return c.json(
-        { error: `too many recursive wildcards: ${wildcardCount} (max ${config.searchMaxRecursiveWildcards})` },
-        400,
-      );
-    }
-
-    const limit = Math.min(limitParam ?? config.searchMaxResults, config.searchMaxResults);
-    const paths = pathsParam
-      .split(",")
-      .map((p) => p.trim())
-      .filter(Boolean);
-    const validPaths: string[] = [];
-
-    for (const p of paths) {
-      const result = await validatePath(p, { allowBasePath: true });
-      if (!result.ok) return c.json({ error: result.error }, result.status);
-
-      const s = await stat(result.realPath).catch(() => null);
-      if (!s) return c.json({ error: `path not found: ${p}` }, 404);
-      if (!s.isDirectory()) return c.json({ error: `not a directory: ${p}` }, 400);
-
-      validPaths.push(result.realPath);
-    }
-
-    const results = await Promise.all(
-      validPaths.map((p) => searchInPath(p, pattern, showHidden, limit, files, directories)),
-    );
-
-    if (config.indexEnabled) {
-      for (const result of results) {
-        result.files = await enrichFileInfoBatch(result.files, result.basePath);
-      }
-    }
-
-    const totalFiles = results.reduce((sum, r) => sum + r.total, 0);
-
-    return c.json({ results, totalFiles });
-  },
-);
-
-export default app;

package/src/handlers/thumbnail.ts

@@ -1,174 +0,0 @@
-import { Hono } from "hono";
-import { describeRoute } from "hono-openapi";
-import { stat } from "node:fs/promises";
-import { join } from "node:path";
-import sharp from "sharp";
-import { validatePath } from "../lib/path";
-import { jsonResponse, requiresAuth } from "../lib/openapi";
-import { v } from "../lib/validator";
-import { ImageThumbnailQuerySchema, ErrorSchema } from "../schemas";
-import { config } from "../config";
-import { resolveId } from "../lib/index";
-
-const app = new Hono();
-
-// Generate ETag from path, mtime, and thumbnail parameters
-const generateETag = (path: string, mtime: Date, params: string): string => {
-  const hasher = new Bun.CryptoHasher("sha256");
-  hasher.update(`${path}:${mtime.getTime()}:${params}`);
-  return `"${hasher.digest("hex").slice(0, 16)}"`;
-};
-
-// Supported image MIME types
-const SUPPORTED_IMAGE_TYPES = new Set([
-  "image/jpeg",
-  "image/png",
-  "image/webp",
-  "image/avif",
-  "image/tiff",
-  "image/gif",
-  "image/svg+xml",
-]);
-
-// Format to MIME type mapping
-const FORMAT_MIME: Record<string, string> = {
-  webp: "image/webp",
-  jpeg: "image/jpeg",
-  png: "image/png",
-  avif: "image/avif",
-};
-
-const resolveQueryPath = async (
-  path: string | undefined,
-  id: string | undefined,
-): Promise<{ ok: true; path: string } | { ok: false; status: 400 | 404; error: string }> => {
-  if (id) {
-    if (!config.indexEnabled) {
-      return { ok: false, status: 400, error: "index disabled" };
-    }
-    const resolved = await resolveId(id);
-    if (!resolved) return { ok: false, status: 404, error: "not found" };
-    return { ok: true, path: join(resolved.basePath, resolved.relPath) };
-  }
-
-  if (!path) {
-    return { ok: false, status: 400, error: "path or id required" };
-  }
-
-  return { ok: true, path };
-};
-
-// GET /thumbnail/image - Generate image thumbnail
-app.get(
-  "/image",
-  describeRoute({
-    tags: ["Thumbnail"],
-    summary: "Generate image thumbnail",
-    description:
-      "Generate a thumbnail from an image file on-the-fly using Sharp. " +
-      "Supports JPEG, PNG, WebP, AVIF, TIFF, GIF, and SVG input formats.",
-    ...requiresAuth,
-    responses: {
-      200: {
-        description: "Thumbnail image",
-        content: {
-          "image/webp": { schema: { type: "string", format: "binary" } },
-          "image/jpeg": { schema: { type: "string", format: "binary" } },
-          "image/png": { schema: { type: "string", format: "binary" } },
-          "image/avif": { schema: { type: "string", format: "binary" } },
-        },
-      },
-      400: jsonResponse(ErrorSchema, "Invalid parameters or not an image"),
-      403: jsonResponse(ErrorSchema, "Forbidden"),
-      404: jsonResponse(ErrorSchema, "Not found"),
-    },
-  }),
-  v("query", ImageThumbnailQuerySchema),
-  async (c) => {
-    const { path, id, width, height, fit, position, format, quality } = c.req.valid("query");
-
-    const resolved = await resolveQueryPath(path, id);
-    if (!resolved.ok) return c.json({ error: resolved.error }, resolved.status);
-
-    // Validate path
-    const result = await validatePath(resolved.path);
-    if (!result.ok) return c.json({ error: result.error }, result.status);
-
-    // Check if file exists and is a file
-    const file = Bun.file(result.realPath);
-    if (!(await file.exists())) {
-      return c.json({ error: "file not found" }, 404);
-    }
-
-    // Check MIME type
-    if (!SUPPORTED_IMAGE_TYPES.has(file.type)) {
-      return c.json(
-        { error: `unsupported image type: ${file.type}. Supported: ${[...SUPPORTED_IMAGE_TYPES].join(", ")}` },
-        400,
-      );
-    }
-
-    // Get file stats for Last-Modified and ETag
-    const fileStat = await stat(result.realPath);
-    const lastModified = fileStat.mtime;
-    const paramsKey = `${width}x${height}:${fit}:${position}:${format}:${quality}`;
-    const etag = generateETag(result.realPath, lastModified, paramsKey);
-
-    // Check If-None-Match (ETag)
-    const ifNoneMatch = c.req.header("If-None-Match");
-    if (ifNoneMatch === etag) {
-      return new Response(null, { status: 304 });
-    }
-
-    // Check If-Modified-Since
-    const ifModifiedSince = c.req.header("If-Modified-Since");
-    if (ifModifiedSince) {
-      const clientDate = new Date(ifModifiedSince);
-      if (lastModified <= clientDate) {
-        return new Response(null, { status: 304 });
-      }
-    }
-
-    try {
-      // Read file and process with Sharp
-      const buffer = await file.arrayBuffer();
-
-      let pipeline = sharp(Buffer.from(buffer)).resize(width, height, {
-        fit,
-        position,
-      });
-
-      // Apply format and quality
-      switch (format) {
-        case "webp":
-          pipeline = pipeline.webp({ quality });
-          break;
-        case "jpeg":
-          pipeline = pipeline.jpeg({ quality });
-          break;
-        case "png":
-          pipeline = pipeline.png({ quality });
-          break;
-        case "avif":
-          pipeline = pipeline.avif({ quality });
-          break;
-      }
-
-      const thumbnail = await pipeline.toBuffer();
-
-      return new Response(thumbnail, {
-        headers: {
-          "Content-Type": FORMAT_MIME[format],
-          "Cache-Control": "public, max-age=31536000, immutable",
-          "Last-Modified": lastModified.toUTCString(),
-          ETag: etag,
-        },
-      });
-    } catch (err) {
-      console.error("[Filegate] Thumbnail error:", err);
-      return c.json({ error: "failed to generate thumbnail" }, 500);
-    }
-  },
-);
-
-export default app;